diff options
Diffstat (limited to 'core')
19 files changed, 561 insertions, 562 deletions
diff --git a/core/src/main/kotlin/Formats/StructuredFormatService.kt b/core/src/main/kotlin/Formats/StructuredFormatService.kt index 324f156a..941ee899 100644 --- a/core/src/main/kotlin/Formats/StructuredFormatService.kt +++ b/core/src/main/kotlin/Formats/StructuredFormatService.kt @@ -103,7 +103,7 @@ abstract class StructuredFormatService(locationService: LocationService, } fun locationHref(from: Location, to: DocumentationNode): String { - val topLevelPage = to.references(DocumentationReference.Kind.TopLevelPage).singleOrNull()?.to + val topLevelPage = to.references(RefKind.TopLevelPage).singleOrNull()?.to if (topLevelPage != null) { return from.relativePathTo(locationService.location(topLevelPage), to.name) } @@ -137,7 +137,7 @@ abstract class StructuredFormatService(locationService: LocationService, } // All items have exactly the same documentation, so we can use any item to render it val item = items.first() - item.details(DocumentationNode.Kind.OverloadGroupNote).forEach { + item.details(NodeKind.OverloadGroupNote).forEach { to.append(formatText(location, it.content)) } to.append(formatText(location, item.content.summary)) @@ -147,7 +147,7 @@ abstract class StructuredFormatService(locationService: LocationService, } private fun DocumentationNode.isModuleOrPackage(): Boolean = - kind == DocumentationNode.Kind.Module || kind == DocumentationNode.Kind.Package + kind == NodeKind.Module || kind == NodeKind.Package protected open fun appendAsSignature(to: StringBuilder, node: ContentNode, block: () -> Unit) { block() @@ -198,8 +198,8 @@ abstract class StructuredFormatService(locationService: LocationService, private fun DocumentationNode.appendDeprecation(location: Location, to: StringBuilder) { if (deprecation != null) { - val deprecationParameter = deprecation!!.details(DocumentationNode.Kind.Parameter).firstOrNull() - val deprecationValue = deprecationParameter?.details(DocumentationNode.Kind.Value)?.firstOrNull() + val deprecationParameter = deprecation!!.details(NodeKind.Parameter).firstOrNull() + val deprecationValue = deprecationParameter?.details(NodeKind.Value)?.firstOrNull() if (deprecationValue != null) { to.append(formatStrong("Deprecated:")).append(" ") appendLine(to, formatText(deprecationValue.name.removeSurrounding("\""))) @@ -215,7 +215,7 @@ abstract class StructuredFormatService(locationService: LocationService, } private fun DocumentationNode.appendSourceLink(to: StringBuilder) { - val sourceUrl = details(DocumentationNode.Kind.SourceUrl).firstOrNull() + val sourceUrl = details(NodeKind.SourceUrl).firstOrNull() if (sourceUrl != null) { to.append(" ") appendLine(to, formatLink("(source)", sourceUrl.name)) @@ -227,7 +227,7 @@ abstract class StructuredFormatService(locationService: LocationService, fun appendLocation(location: Location, to: StringBuilder, nodes: Iterable<DocumentationNode>) { val singleNode = nodes.singleOrNull() if (singleNode != null && singleNode.isModuleOrPackage()) { - if (singleNode.kind == DocumentationNode.Kind.Package) { + if (singleNode.kind == NodeKind.Package) { appendHeader(to, "Package " + formatText(singleNode.name), 2) } to.append(formatText(location, singleNode.content)) @@ -307,51 +307,51 @@ abstract class StructuredFormatService(locationService: LocationService, for ((breadcrumbs, items) in breakdownByLocation) { appendLine(to, breadcrumbs) appendLine(to) - appendLocation(location, to, items.filter { it.kind != DocumentationNode.Kind.ExternalClass }) + appendLocation(location, to, items.filter { it.kind != NodeKind.ExternalClass }) } for (node in nodes) { - if (node.kind == DocumentationNode.Kind.ExternalClass) { + if (node.kind == NodeKind.ExternalClass) { appendSection(location, "Extensions for ${node.name}", node.members, node, to) continue } - appendSection(location, "Packages", node.members(DocumentationNode.Kind.Package), node, to) - appendSection(location, "Types", node.members.filter { it.kind in DocumentationNode.Kind.classLike }, node, to) - appendSection(location, "Extensions for External Classes", node.members(DocumentationNode.Kind.ExternalClass), node, to) - appendSection(location, "Enum Values", node.members(DocumentationNode.Kind.EnumItem), node, to) - appendSection(location, "Constructors", node.members(DocumentationNode.Kind.Constructor), node, to) - appendSection(location, "Properties", node.members(DocumentationNode.Kind.Property), node, to) - appendSection(location, "Inherited Properties", node.inheritedMembers(DocumentationNode.Kind.Property), node, to) - appendSection(location, "Functions", node.members(DocumentationNode.Kind.Function), node, to) - appendSection(location, "Inherited Functions", node.inheritedMembers(DocumentationNode.Kind.Function), node, to) - appendSection(location, "Companion Object Properties", node.members(DocumentationNode.Kind.CompanionObjectProperty), node, to) - appendSection(location, "Companion Object Functions", node.members(DocumentationNode.Kind.CompanionObjectFunction), node, to) + appendSection(location, "Packages", node.members(NodeKind.Package), node, to) + appendSection(location, "Types", node.members.filter { it.kind in NodeKind.classLike }, node, to) + appendSection(location, "Extensions for External Classes", node.members(NodeKind.ExternalClass), node, to) + appendSection(location, "Enum Values", node.members(NodeKind.EnumItem), node, to) + appendSection(location, "Constructors", node.members(NodeKind.Constructor), node, to) + appendSection(location, "Properties", node.members(NodeKind.Property), node, to) + appendSection(location, "Inherited Properties", node.inheritedMembers(NodeKind.Property), node, to) + appendSection(location, "Functions", node.members(NodeKind.Function), node, to) + appendSection(location, "Inherited Functions", node.inheritedMembers(NodeKind.Function), node, to) + appendSection(location, "Companion Object Properties", node.members(NodeKind.CompanionObjectProperty), node, to) + appendSection(location, "Companion Object Functions", node.members(NodeKind.CompanionObjectFunction), node, to) appendSection(location, "Other members", node.members.filter { it.kind !in setOf( - DocumentationNode.Kind.Class, - DocumentationNode.Kind.Interface, - DocumentationNode.Kind.Enum, - DocumentationNode.Kind.Object, - DocumentationNode.Kind.AnnotationClass, - DocumentationNode.Kind.Constructor, - DocumentationNode.Kind.Property, - DocumentationNode.Kind.Package, - DocumentationNode.Kind.Function, - DocumentationNode.Kind.CompanionObjectProperty, - DocumentationNode.Kind.CompanionObjectFunction, - DocumentationNode.Kind.ExternalClass, - DocumentationNode.Kind.EnumItem + NodeKind.Class, + NodeKind.Interface, + NodeKind.Enum, + NodeKind.Object, + NodeKind.AnnotationClass, + NodeKind.Constructor, + NodeKind.Property, + NodeKind.Package, + NodeKind.Function, + NodeKind.CompanionObjectProperty, + NodeKind.CompanionObjectFunction, + NodeKind.ExternalClass, + NodeKind.EnumItem ) }, node, to) val allExtensions = collectAllExtensions(node) - appendSection(location, "Extension Properties", allExtensions.filter { it.kind == DocumentationNode.Kind.Property }, node, to) - appendSection(location, "Extension Functions", allExtensions.filter { it.kind == DocumentationNode.Kind.Function }, node, to) - appendSection(location, "Companion Object Extension Properties", allExtensions.filter { it.kind == DocumentationNode.Kind.CompanionObjectProperty }, node, to) - appendSection(location, "Companion Object Extension Functions", allExtensions.filter { it.kind == DocumentationNode.Kind.CompanionObjectFunction }, node, to) + appendSection(location, "Extension Properties", allExtensions.filter { it.kind == NodeKind.Property }, node, to) + appendSection(location, "Extension Functions", allExtensions.filter { it.kind == NodeKind.Function }, node, to) + appendSection(location, "Companion Object Extension Properties", allExtensions.filter { it.kind == NodeKind.CompanionObjectProperty }, node, to) + appendSection(location, "Companion Object Extension Functions", allExtensions.filter { it.kind == NodeKind.CompanionObjectFunction }, node, to) appendSection(location, "Inheritors", - node.inheritors.filter { it.kind != DocumentationNode.Kind.EnumItem }, node, to) + node.inheritors.filter { it.kind != NodeKind.EnumItem }, node, to) appendSection(location, "Links", node.links, node, to) } @@ -364,7 +364,7 @@ abstract class StructuredFormatService(locationService: LocationService, fun collect(node: DocumentationNode) { if (!visited.add(node)) return result.addAll(node.extensions) - node.references(DocumentationReference.Kind.Superclass).forEach { collect(it.to) } + node.references(RefKind.Superclass).forEach { collect(it.to) } } collect(node) diff --git a/core/src/main/kotlin/Java/JavaPsiDocumentationBuilder.kt b/core/src/main/kotlin/Java/JavaPsiDocumentationBuilder.kt index 3c9875cd..c16e66c6 100644 --- a/core/src/main/kotlin/Java/JavaPsiDocumentationBuilder.kt +++ b/core/src/main/kotlin/Java/JavaPsiDocumentationBuilder.kt @@ -2,7 +2,6 @@ package org.jetbrains.dokka import com.google.inject.Inject import com.intellij.psi.* -import org.jetbrains.dokka.DocumentationNode.Kind fun getSignature(element: PsiElement?) = when(element) { is PsiClass -> element.qualifiedName @@ -69,11 +68,11 @@ class JavaPsiDocumentationBuilder : JavaDocumentationBuilder { fun link(node: DocumentationNode, element: PsiElement?) { val qualifiedName = getSignature(element) if (qualifiedName != null) { - refGraph.link(node, qualifiedName, DocumentationReference.Kind.Link) + refGraph.link(node, qualifiedName, RefKind.Link) } } - fun link(element: PsiElement?, node: DocumentationNode, kind: DocumentationReference.Kind) { + fun link(element: PsiElement?, node: DocumentationNode, kind: RefKind) { val qualifiedName = getSignature(element) if (qualifiedName != null) { refGraph.link(qualifiedName, node, kind) @@ -81,7 +80,7 @@ class JavaPsiDocumentationBuilder : JavaDocumentationBuilder { } fun nodeForElement(element: PsiNamedElement, - kind: Kind, + kind: NodeKind, name: String = element.name ?: "<anonymous>"): DocumentationNode { val (docComment, deprecatedContent) = docParser.parseDocumentation(element) val node = DocumentationNode(name, docComment, kind) @@ -92,17 +91,17 @@ class JavaPsiDocumentationBuilder : JavaDocumentationBuilder { modifierList.annotations.filter { !ignoreAnnotation(it) }.forEach { val annotation = it.build() node.append(annotation, - if (it.qualifiedName == "java.lang.Deprecated") DocumentationReference.Kind.Deprecation else DocumentationReference.Kind.Annotation) + if (it.qualifiedName == "java.lang.Deprecated") RefKind.Deprecation else RefKind.Annotation) } } } if (deprecatedContent != null) { - val deprecationNode = DocumentationNode("", deprecatedContent, Kind.Modifier) - node.append(deprecationNode, DocumentationReference.Kind.Deprecation) + val deprecationNode = DocumentationNode("", deprecatedContent, NodeKind.Modifier) + node.append(deprecationNode, RefKind.Deprecation) } if (element is PsiDocCommentOwner && element.isDeprecated && node.deprecation == null) { - val deprecationNode = DocumentationNode("", Content.of(ContentText("Deprecated")), Kind.Modifier) - node.append(deprecationNode, DocumentationReference.Kind.Deprecation) + val deprecationNode = DocumentationNode("", Content.of(ContentText("Deprecated")), NodeKind.Modifier) + node.append(deprecationNode, RefKind.Deprecation) } return node } @@ -113,7 +112,7 @@ class JavaPsiDocumentationBuilder : JavaDocumentationBuilder { } fun <T : Any> DocumentationNode.appendChildren(elements: Array<T>, - kind: DocumentationReference.Kind = DocumentationReference.Kind.Member, + kind: RefKind = RefKind.Member, buildFn: T.() -> DocumentationNode) { elements.forEach { if (!skipElement(it)) { @@ -132,24 +131,24 @@ class JavaPsiDocumentationBuilder : JavaDocumentationBuilder { element is PsiDocCommentOwner && element.docComment?.let { it.findTagByName("suppress") != null } ?: false fun <T : Any> DocumentationNode.appendMembers(elements: Array<T>, buildFn: T.() -> DocumentationNode) = - appendChildren(elements, DocumentationReference.Kind.Member, buildFn) + appendChildren(elements, RefKind.Member, buildFn) fun <T : Any> DocumentationNode.appendDetails(elements: Array<T>, buildFn: T.() -> DocumentationNode) = - appendChildren(elements, DocumentationReference.Kind.Detail, buildFn) + appendChildren(elements, RefKind.Detail, buildFn) fun PsiClass.build(): DocumentationNode { val kind = when { - isInterface -> DocumentationNode.Kind.Interface - isEnum -> DocumentationNode.Kind.Enum - isAnnotationType -> DocumentationNode.Kind.AnnotationClass - else -> DocumentationNode.Kind.Class + isInterface -> NodeKind.Interface + isEnum -> NodeKind.Enum + isAnnotationType -> NodeKind.AnnotationClass + else -> NodeKind.Class } val node = nodeForElement(this, kind) superTypes.filter { !ignoreSupertype(it) }.forEach { - node.appendType(it, Kind.Supertype) + node.appendType(it, NodeKind.Supertype) val superClass = it.resolve() if (superClass != null) { - link(superClass, node, DocumentationReference.Kind.Inheritor) + link(superClass, node, RefKind.Inheritor) } } node.appendDetails(typeParameters) { build() } @@ -180,9 +179,9 @@ class JavaPsiDocumentationBuilder : JavaDocumentationBuilder { return node } - private fun PsiField.nodeKind(): Kind = when { - this is PsiEnumConstant -> Kind.EnumItem - else -> Kind.Field + private fun PsiField.nodeKind(): NodeKind = when { + this is PsiEnumConstant -> NodeKind.EnumItem + else -> NodeKind.Field } fun PsiMethod.build(): DocumentationNode { @@ -198,24 +197,24 @@ class JavaPsiDocumentationBuilder : JavaDocumentationBuilder { return node } - private fun PsiMethod.nodeKind(): Kind = when { - isConstructor -> Kind.Constructor - else -> Kind.Function + private fun PsiMethod.nodeKind(): NodeKind = when { + isConstructor -> NodeKind.Constructor + else -> NodeKind.Function } fun PsiParameter.build(): DocumentationNode { - val node = nodeForElement(this, Kind.Parameter) + val node = nodeForElement(this, NodeKind.Parameter) node.appendType(type) if (type is PsiEllipsisType) { - node.appendTextNode("vararg", Kind.Modifier, DocumentationReference.Kind.Detail) + node.appendTextNode("vararg", NodeKind.Modifier, RefKind.Detail) } return node } fun PsiTypeParameter.build(): DocumentationNode { - val node = nodeForElement(this, Kind.TypeParameter) - extendsListTypes.forEach { node.appendType(it, Kind.UpperBound) } - implementsListTypes.forEach { node.appendType(it, Kind.UpperBound) } + val node = nodeForElement(this, NodeKind.TypeParameter) + extendsListTypes.forEach { node.appendType(it, NodeKind.UpperBound) } + implementsListTypes.forEach { node.appendType(it, NodeKind.UpperBound) } return node } @@ -224,42 +223,42 @@ class JavaPsiDocumentationBuilder : JavaDocumentationBuilder { PsiModifier.MODIFIERS.forEach { if (modifierList.hasExplicitModifier(it)) { - appendTextNode(it, Kind.Modifier) + appendTextNode(it, NodeKind.Modifier) } } } - fun DocumentationNode.appendType(psiType: PsiType?, kind: DocumentationNode.Kind = DocumentationNode.Kind.Type) { + fun DocumentationNode.appendType(psiType: PsiType?, kind: NodeKind = NodeKind.Type) { if (psiType == null) { return } - append(psiType.build(kind), DocumentationReference.Kind.Detail) + append(psiType.build(kind), RefKind.Detail) } - fun PsiType.build(kind: DocumentationNode.Kind = DocumentationNode.Kind.Type): DocumentationNode { + fun PsiType.build(kind: NodeKind = NodeKind.Type): DocumentationNode { val name = mapTypeName(this) val node = DocumentationNode(name, Content.Empty, kind) if (this is PsiClassType) { - node.appendDetails(parameters) { build(Kind.Type) } + node.appendDetails(parameters) { build(NodeKind.Type) } link(node, resolve()) } if (this is PsiArrayType && this !is PsiEllipsisType) { - node.append(componentType.build(Kind.Type), DocumentationReference.Kind.Detail) + node.append(componentType.build(NodeKind.Type), RefKind.Detail) } return node } fun PsiAnnotation.build(): DocumentationNode { - val node = DocumentationNode(nameReferenceElement?.text ?: "<?>", Content.Empty, DocumentationNode.Kind.Annotation) + val node = DocumentationNode(nameReferenceElement?.text ?: "<?>", Content.Empty, NodeKind.Annotation) parameterList.attributes.forEach { - val parameter = DocumentationNode(it.name ?: "value", Content.Empty, DocumentationNode.Kind.Parameter) + val parameter = DocumentationNode(it.name ?: "value", Content.Empty, NodeKind.Parameter) val value = it.value if (value != null) { val valueText = (value as? PsiLiteralExpression)?.value as? String ?: value.text - val valueNode = DocumentationNode(valueText, Content.Empty, DocumentationNode.Kind.Value) - parameter.append(valueNode, DocumentationReference.Kind.Detail) + val valueNode = DocumentationNode(valueText, Content.Empty, NodeKind.Value) + parameter.append(valueNode, RefKind.Detail) } - node.append(parameter, DocumentationReference.Kind.Detail) + node.append(parameter, RefKind.Detail) } return node } diff --git a/core/src/main/kotlin/Kotlin/DescriptorDocumentationParser.kt b/core/src/main/kotlin/Kotlin/DescriptorDocumentationParser.kt index b7705ec9..3a5769c9 100644 --- a/core/src/main/kotlin/Kotlin/DescriptorDocumentationParser.kt +++ b/core/src/main/kotlin/Kotlin/DescriptorDocumentationParser.kt @@ -112,8 +112,8 @@ class DescriptorDocumentationParser val parseResult = JavadocParser(refGraph).parseDocumentation(psi as PsiNamedElement) return parseResult.content to { node -> parseResult.deprecatedContent?.let { - val deprecationNode = DocumentationNode("", it, DocumentationNode.Kind.Modifier) - node.append(deprecationNode, DocumentationReference.Kind.Deprecation) + val deprecationNode = DocumentationNode("", it, NodeKind.Modifier) + node.append(deprecationNode, RefKind.Deprecation) } } } diff --git a/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt b/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt index d6db3d59..5deb6177 100644 --- a/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt +++ b/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt @@ -3,7 +3,6 @@ package org.jetbrains.dokka import com.google.inject.Inject import com.intellij.openapi.util.text.StringUtil import com.intellij.psi.PsiJavaFile -import org.jetbrains.dokka.DocumentationNode.Kind import org.jetbrains.dokka.Kotlin.DescriptorDocumentationParser import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.descriptors.* @@ -70,11 +69,11 @@ class DocumentationBuilder KtTokens.OPEN_KEYWORD, KtTokens.FINAL_KEYWORD, KtTokens.ABSTRACT_KEYWORD, KtTokens.SEALED_KEYWORD, KtTokens.OVERRIDE_KEYWORD) - fun link(node: DocumentationNode, descriptor: DeclarationDescriptor, kind: DocumentationReference.Kind) { + fun link(node: DocumentationNode, descriptor: DeclarationDescriptor, kind: RefKind) { refGraph.link(node, descriptor.signature(), kind) } - fun link(fromDescriptor: DeclarationDescriptor?, toDescriptor: DeclarationDescriptor?, kind: DocumentationReference.Kind) { + fun link(fromDescriptor: DeclarationDescriptor?, toDescriptor: DeclarationDescriptor?, kind: RefKind) { if (fromDescriptor != null && toDescriptor != null) { refGraph.link(fromDescriptor.signature(), toDescriptor.signature(), kind) } @@ -84,8 +83,8 @@ class DocumentationBuilder refGraph.register(descriptor.signature(), node) } - fun <T> nodeForDescriptor(descriptor: T, kind: Kind): DocumentationNode where T : DeclarationDescriptor, T : Named { - val (doc, callback) = descriptorDocumentationParser.parseDocumentationAndDetails(descriptor, kind == Kind.Parameter) + fun <T> nodeForDescriptor(descriptor: T, kind: NodeKind): DocumentationNode where T : DeclarationDescriptor, T : Named { + val (doc, callback) = descriptorDocumentationParser.parseDocumentationAndDetails(descriptor, kind == NodeKind.Parameter) val node = DocumentationNode(descriptor.name.asString(), doc, kind).withModifiers(descriptor) callback(node) return node @@ -110,22 +109,22 @@ class DocumentationBuilder } } val modifier = modality.name.toLowerCase() - appendTextNode(modifier, DocumentationNode.Kind.Modifier) + appendTextNode(modifier, NodeKind.Modifier) } fun DocumentationNode.appendVisibility(descriptor: DeclarationDescriptorWithVisibility) { val modifier = descriptor.visibility.normalize().displayName - appendTextNode(modifier, DocumentationNode.Kind.Modifier) + appendTextNode(modifier, NodeKind.Modifier) } fun DocumentationNode.appendSupertypes(descriptor: ClassDescriptor) { val superTypes = descriptor.typeConstructor.supertypes for (superType in superTypes) { if (!ignoreSupertype(superType)) { - appendType(superType, DocumentationNode.Kind.Supertype) + appendType(superType, NodeKind.Supertype) val superclass = superType?.constructor?.declarationDescriptor - link(superclass, descriptor, DocumentationReference.Kind.Inheritor) - link(descriptor, superclass, DocumentationReference.Kind.Superclass) + link(superclass, descriptor, RefKind.Inheritor) + link(descriptor, superclass, RefKind.Superclass) } } } @@ -139,16 +138,16 @@ class DocumentationBuilder return false } - fun DocumentationNode.appendProjection(projection: TypeProjection, kind: DocumentationNode.Kind = DocumentationNode.Kind.Type) { + fun DocumentationNode.appendProjection(projection: TypeProjection, kind: NodeKind = NodeKind.Type) { if (projection.isStarProjection) { - appendTextNode("*", Kind.Type) + appendTextNode("*", NodeKind.Type) } else { appendType(projection.type, kind, projection.projectionKind.label) } } - fun DocumentationNode.appendType(kotlinType: KotlinType?, kind: DocumentationNode.Kind = DocumentationNode.Kind.Type, prefix: String = "") { + fun DocumentationNode.appendType(kotlinType: KotlinType?, kind: NodeKind = NodeKind.Type, prefix: String = "") { if (kotlinType == null) return val classifierDescriptor = kotlinType.constructor.declarationDescriptor @@ -167,17 +166,17 @@ class DocumentationBuilder } val node = DocumentationNode(name, Content.Empty, kind) if (prefix != "") { - node.appendTextNode(prefix, Kind.Modifier) + node.appendTextNode(prefix, NodeKind.Modifier) } if (kotlinType.isMarkedNullable) { - node.appendTextNode("?", Kind.NullabilityModifier) + node.appendTextNode("?", NodeKind.NullabilityModifier) } if (classifierDescriptor != null) { link(node, classifierDescriptor, - if (classifierDescriptor.isBoringBuiltinClass()) DocumentationReference.Kind.HiddenLink else DocumentationReference.Kind.Link) + if (classifierDescriptor.isBoringBuiltinClass()) RefKind.HiddenLink else RefKind.Link) } - append(node, DocumentationReference.Kind.Detail) + append(node, RefKind.Detail) node.appendAnnotations(kotlinType) for (typeArgument in kotlinType.arguments) { node.appendProjection(typeArgument) @@ -192,7 +191,7 @@ class DocumentationBuilder val annotationNode = it.build() if (annotationNode != null) { append(annotationNode, - if (annotationNode.isDeprecation()) DocumentationReference.Kind.Deprecation else DocumentationReference.Kind.Annotation) + if (annotationNode.isDeprecation()) RefKind.Deprecation else RefKind.Annotation) } } } @@ -201,7 +200,7 @@ class DocumentationBuilder val psi = (descriptor as DeclarationDescriptorWithSource).source.getPsi() as? KtModifierListOwner ?: return KtTokens.MODIFIER_KEYWORDS_ARRAY.filter { it !in knownModifiers }.forEach { if (psi.hasModifier(it)) { - appendTextNode(it.value, Kind.Modifier) + appendTextNode(it.value, NodeKind.Modifier) } } } @@ -212,7 +211,7 @@ class DocumentationBuilder appendSourceLink(sourceElement.getPsi(), options.sourceLinks) } - fun DocumentationNode.appendChild(descriptor: DeclarationDescriptor, kind: DocumentationReference.Kind): DocumentationNode? { + fun DocumentationNode.appendChild(descriptor: DeclarationDescriptor, kind: RefKind): DocumentationNode? { // do not include generated code if (descriptor is CallableMemberDescriptor && descriptor.kind != CallableMemberDescriptor.Kind.DECLARATION) return null @@ -238,22 +237,22 @@ class DocumentationBuilder if (descriptor is CallableMemberDescriptor && descriptor.kind == CallableMemberDescriptor.Kind.FAKE_OVERRIDE) { val baseDescriptor = descriptor.overriddenDescriptors.firstOrNull() if (baseDescriptor != null) { - link(this, baseDescriptor, DocumentationReference.Kind.InheritedMember) + link(this, baseDescriptor, RefKind.InheritedMember) } null } else { val descriptorToUse = if (descriptor is ConstructorDescriptor) descriptor else descriptor.original - appendChild(descriptorToUse, DocumentationReference.Kind.Member) + appendChild(descriptorToUse, RefKind.Member) } } return nodes.filterNotNull() } - fun DocumentationNode.appendInPageChildren(descriptors: Iterable<DeclarationDescriptor>, kind: DocumentationReference.Kind) { + fun DocumentationNode.appendInPageChildren(descriptors: Iterable<DeclarationDescriptor>, kind: RefKind) { descriptors.forEach { descriptor -> val node = appendChild(descriptor, kind) - node?.addReferenceTo(this, DocumentationReference.Kind.TopLevelPage) + node?.addReferenceTo(this, RefKind.TopLevelPage) } } @@ -285,17 +284,17 @@ class DocumentationBuilder fun ClassDescriptor.build(): DocumentationNode { val kind = when (kind) { - ClassKind.OBJECT -> Kind.Object - ClassKind.INTERFACE -> Kind.Interface - ClassKind.ENUM_CLASS -> Kind.Enum - ClassKind.ANNOTATION_CLASS -> Kind.AnnotationClass - ClassKind.ENUM_ENTRY -> Kind.EnumItem - else -> Kind.Class + ClassKind.OBJECT -> NodeKind.Object + ClassKind.INTERFACE -> NodeKind.Interface + ClassKind.ENUM_CLASS -> NodeKind.Enum + ClassKind.ANNOTATION_CLASS -> NodeKind.AnnotationClass + ClassKind.ENUM_ENTRY -> NodeKind.EnumItem + else -> NodeKind.Class } val node = nodeForDescriptor(this, kind) node.appendSupertypes(this) if (getKind() != ClassKind.OBJECT && getKind() != ClassKind.ENUM_ENTRY) { - node.appendInPageChildren(typeConstructor.parameters, DocumentationReference.Kind.Detail) + node.appendInPageChildren(typeConstructor.parameters, RefKind.Detail) val constructorsToDocument = if (getKind() == ClassKind.ENUM_CLASS) constructors.filter { it.valueParameters.size > 0 } else @@ -305,7 +304,7 @@ class DocumentationBuilder val members = defaultType.memberScope.getContributedDescriptors().filter { it != companionObjectDescriptor } node.appendMembers(members) node.appendMembers(staticScope.getContributedDescriptors()).forEach { - it.appendTextNode("static", Kind.Modifier) + it.appendTextNode("static", NodeKind.Modifier) } val companionObjectDescriptor = companionObjectDescriptor if (companionObjectDescriptor != null) { @@ -319,8 +318,8 @@ class DocumentationBuilder } fun ConstructorDescriptor.build(): DocumentationNode { - val node = nodeForDescriptor(this, Kind.Constructor) - node.appendInPageChildren(valueParameters, DocumentationReference.Kind.Detail) + val node = nodeForDescriptor(this, NodeKind.Constructor) + node.appendInPageChildren(valueParameters, RefKind.Detail) register(this, node) return node } @@ -339,11 +338,11 @@ class DocumentationBuilder logger.warn("Found an unresolved type in ${signatureWithSourceLocation()}") } - val node = nodeForDescriptor(this, if (inCompanionObject()) Kind.CompanionObjectFunction else Kind.Function) + val node = nodeForDescriptor(this, if (inCompanionObject()) NodeKind.CompanionObjectFunction else NodeKind.Function) - node.appendInPageChildren(typeParameters, DocumentationReference.Kind.Detail) - extensionReceiverParameter?.let { node.appendChild(it, DocumentationReference.Kind.Detail) } - node.appendInPageChildren(valueParameters, DocumentationReference.Kind.Detail) + node.appendInPageChildren(typeParameters, RefKind.Detail) + extensionReceiverParameter?.let { node.appendChild(it, RefKind.Detail) } + node.appendInPageChildren(valueParameters, RefKind.Detail) node.appendType(returnType) node.appendAnnotations(this) node.appendModifiers(this) @@ -360,7 +359,7 @@ class DocumentationBuilder fun addOverrideLink(baseClassFunction: CallableMemberDescriptor, overridingFunction: CallableMemberDescriptor) { val source = baseClassFunction.original.source.getPsi() if (source != null) { - link(overridingFunction, baseClassFunction, DocumentationReference.Kind.Override) + link(overridingFunction, baseClassFunction, RefKind.Override) } else { baseClassFunction.overriddenDescriptors.forEach { addOverrideLink(it, overridingFunction) @@ -369,15 +368,15 @@ class DocumentationBuilder } fun PropertyDescriptor.build(): DocumentationNode { - val node = nodeForDescriptor(this, if (inCompanionObject()) Kind.CompanionObjectProperty else Kind.Property) - node.appendInPageChildren(typeParameters, DocumentationReference.Kind.Detail) - extensionReceiverParameter?.let { node.appendChild(it, DocumentationReference.Kind.Detail) } + val node = nodeForDescriptor(this, if (inCompanionObject()) NodeKind.CompanionObjectProperty else NodeKind.Property) + node.appendInPageChildren(typeParameters, RefKind.Detail) + extensionReceiverParameter?.let { node.appendChild(it, RefKind.Detail) } node.appendType(returnType) node.appendAnnotations(this) node.appendModifiers(this) node.appendSourceLink(source) if (isVar) { - node.appendTextNode("var", DocumentationNode.Kind.Modifier) + node.appendTextNode("var", NodeKind.Modifier) } getter?.let { if (!it.isDefault) { @@ -413,21 +412,21 @@ class DocumentationBuilder } fun ValueParameterDescriptor.build(): DocumentationNode { - val node = nodeForDescriptor(this, Kind.Parameter) + val node = nodeForDescriptor(this, NodeKind.Parameter) node.appendType(varargElementType ?: type) if (declaresDefaultValue()) { val psi = source.getPsi() as? KtParameter if (psi != null) { val defaultValueText = psi.defaultValue?.text if (defaultValueText != null) { - node.appendTextNode(defaultValueText, Kind.Value) + node.appendTextNode(defaultValueText, NodeKind.Value) } } } node.appendAnnotations(this) node.appendModifiers(this) - if (varargElementType != null && node.details(Kind.Modifier).none { it.name == "vararg" }) { - node.appendTextNode("vararg", Kind.Modifier) + if (varargElementType != null && node.details(NodeKind.Modifier).none { it.name == "vararg" }) { + node.appendTextNode("vararg", NodeKind.Modifier) } register(this, node) return node @@ -438,25 +437,25 @@ class DocumentationBuilder val name = name.asString() val prefix = variance.label - val node = DocumentationNode(name, doc, DocumentationNode.Kind.TypeParameter) + val node = DocumentationNode(name, doc, NodeKind.TypeParameter) if (prefix != "") { - node.appendTextNode(prefix, Kind.Modifier) + node.appendTextNode(prefix, NodeKind.Modifier) } if (isReified) { - node.appendTextNode("reified", Kind.Modifier) + node.appendTextNode("reified", NodeKind.Modifier) } for (constraint in upperBounds) { if (KotlinBuiltIns.isDefaultBound(constraint)) { continue } - node.appendType(constraint, Kind.UpperBound) + node.appendType(constraint, NodeKind.UpperBound) } for (constraint in lowerBounds) { if (KotlinBuiltIns.isNothing(constraint)) continue - node.appendType(constraint, Kind.LowerBound) + node.appendType(constraint, NodeKind.LowerBound) } return node } @@ -468,9 +467,9 @@ class DocumentationBuilder } link(receiverClass, containingDeclaration, - DocumentationReference.Kind.Extension) + RefKind.Extension) - val node = DocumentationNode(name.asString(), Content.Empty, Kind.Receiver) + val node = DocumentationNode(name.asString(), Content.Empty, NodeKind.Receiver) node.appendType(type) return node } @@ -480,14 +479,14 @@ class DocumentationBuilder if (annotationClass == null || ErrorUtils.isError(annotationClass)) { return null } - val node = DocumentationNode(annotationClass.name.asString(), Content.Empty, DocumentationNode.Kind.Annotation) + val node = DocumentationNode(annotationClass.name.asString(), Content.Empty, NodeKind.Annotation) val arguments = allValueArguments.toList().sortedBy { it.first.index } arguments.forEach { val valueNode = it.second.toDocumentationNode() if (valueNode != null) { - val paramNode = DocumentationNode(it.first.name.asString(), Content.Empty, DocumentationNode.Kind.Parameter) - paramNode.append(valueNode, DocumentationReference.Kind.Detail) - node.append(paramNode, DocumentationReference.Kind.Detail) + val paramNode = DocumentationNode(it.first.name.asString(), Content.Empty, NodeKind.Parameter) + paramNode.append(valueNode, RefKind.Detail) + node.append(paramNode, RefKind.Detail) } } return node @@ -506,7 +505,7 @@ class DocumentationBuilder value.containingDeclaration.name.asString() + "." + value.name.asString() else -> value.toString() }.let { valueString -> - DocumentationNode(valueString, Content.Empty, DocumentationNode.Kind.Value) + DocumentationNode(valueString, Content.Empty, NodeKind.Value) } } } @@ -521,7 +520,7 @@ class KotlinPackageDocumentationBuilder : PackageDocumentationBuilder { with(documentationBuilder) { if (descriptor.isDocumented()) { val parent = packageNode.getParentForPackageMember(descriptor, externalClassNodes) - parent.appendChild(descriptor, DocumentationReference.Kind.Member) + parent.appendChild(descriptor, RefKind.Member) } } } @@ -545,7 +544,7 @@ class KotlinJavaDocumentationBuilder } else { with(documentationBuilder) { - packageNode.appendChild(descriptor, DocumentationReference.Kind.Member) + packageNode.appendChild(descriptor, RefKind.Member) } } } @@ -580,8 +579,8 @@ fun DocumentationNode.getParentForPackageMember(descriptor: DeclarationDescripto !ErrorUtils.isError(extensionClassDescriptor)) { val fqName = DescriptorUtils.getFqNameSafe(extensionClassDescriptor) return externalClassNodes.getOrPut(fqName, { - val newNode = DocumentationNode(fqName.asString(), Content.Empty, Kind.ExternalClass) - append(newNode, DocumentationReference.Kind.Member) + val newNode = DocumentationNode(fqName.asString(), Content.Empty, NodeKind.ExternalClass) + append(newNode, RefKind.Member) newNode }) } diff --git a/core/src/main/kotlin/Kotlin/KotlinLanguageService.kt b/core/src/main/kotlin/Kotlin/KotlinLanguageService.kt index c0c101bf..80f91646 100644 --- a/core/src/main/kotlin/Kotlin/KotlinLanguageService.kt +++ b/core/src/main/kotlin/Kotlin/KotlinLanguageService.kt @@ -11,22 +11,22 @@ class KotlinLanguageService : LanguageService { override fun render(node: DocumentationNode, renderMode: RenderMode): ContentNode { return content { when (node.kind) { - DocumentationNode.Kind.Package -> if (renderMode == RenderMode.FULL) renderPackage(node) - in DocumentationNode.Kind.classLike -> renderClass(node, renderMode) - - DocumentationNode.Kind.EnumItem, - DocumentationNode.Kind.ExternalClass -> if (renderMode == RenderMode.FULL) identifier(node.name) - - DocumentationNode.Kind.TypeParameter -> renderTypeParameter(node, renderMode) - DocumentationNode.Kind.Type, - DocumentationNode.Kind.UpperBound -> renderType(node, renderMode) - - DocumentationNode.Kind.Modifier -> renderModifier(node) - DocumentationNode.Kind.Constructor, - DocumentationNode.Kind.Function, - DocumentationNode.Kind.CompanionObjectFunction -> renderFunction(node, renderMode) - DocumentationNode.Kind.Property, - DocumentationNode.Kind.CompanionObjectProperty -> renderProperty(node, renderMode) + NodeKind.Package -> if (renderMode == RenderMode.FULL) renderPackage(node) + in NodeKind.classLike -> renderClass(node, renderMode) + + NodeKind.EnumItem, + NodeKind.ExternalClass -> if (renderMode == RenderMode.FULL) identifier(node.name) + + NodeKind.TypeParameter -> renderTypeParameter(node, renderMode) + NodeKind.Type, + NodeKind.UpperBound -> renderType(node, renderMode) + + NodeKind.Modifier -> renderModifier(node) + NodeKind.Constructor, + NodeKind.Function, + NodeKind.CompanionObjectFunction -> renderFunction(node, renderMode) + NodeKind.Property, + NodeKind.CompanionObjectProperty -> renderProperty(node, renderMode) else -> identifier(node.name) } } @@ -34,7 +34,7 @@ class KotlinLanguageService : LanguageService { override fun renderName(node: DocumentationNode): String { return when (node.kind) { - DocumentationNode.Kind.Constructor -> node.owner!!.name + NodeKind.Constructor -> node.owner!!.name else -> node.name } } @@ -42,10 +42,10 @@ class KotlinLanguageService : LanguageService { override fun summarizeSignatures(nodes: List<DocumentationNode>): ContentNode? { if (nodes.size < 2) return null val receiverKind = nodes.getReceiverKind() ?: return null - val functionWithTypeParameter = nodes.firstOrNull { it.details(DocumentationNode.Kind.TypeParameter).any() } ?: return null + val functionWithTypeParameter = nodes.firstOrNull { it.details(NodeKind.TypeParameter).any() } ?: return null return content { - val typeParameter = functionWithTypeParameter.details(DocumentationNode.Kind.TypeParameter).first() - if (functionWithTypeParameter.kind == DocumentationNode.Kind.Function) { + val typeParameter = functionWithTypeParameter.details(NodeKind.TypeParameter).first() + if (functionWithTypeParameter.kind == NodeKind.Function) { renderFunction(functionWithTypeParameter, RenderMode.SUMMARY, SummarizingMapper(receiverKind, typeParameter.name)) } else { @@ -63,9 +63,9 @@ class KotlinLanguageService : LanguageService { } private fun DocumentationNode.getReceiverQName(): String? { - if (kind != DocumentationNode.Kind.Function && kind != DocumentationNode.Kind.Property) return null - val receiver = details(DocumentationNode.Kind.Receiver).singleOrNull() ?: return null - return receiver.detail(DocumentationNode.Kind.Type).qualifiedNameFromType() + if (kind != NodeKind.Function && kind != NodeKind.Property) return null + val receiver = details(NodeKind.Receiver).singleOrNull() ?: return null + return receiver.detail(NodeKind.Type).qualifiedNameFromType() } companion object { @@ -142,7 +142,7 @@ class KotlinLanguageService : LanguageService { } private fun ContentBlock.renderType(node: DocumentationNode, renderMode: RenderMode) { - var typeArguments = node.details(DocumentationNode.Kind.Type) + var typeArguments = node.details(NodeKind.Type) if (node.name == "Function${typeArguments.count() - 1}") { // lambda val isExtension = node.annotations.any { it.name == "ExtensionFunctionType" } @@ -174,7 +174,7 @@ class KotlinLanguageService : LanguageService { } symbol(">") } - val nullabilityModifier = node.details(DocumentationNode.Kind.NullabilityModifier).singleOrNull() + val nullabilityModifier = node.details(NodeKind.NullabilityModifier).singleOrNull() if (nullabilityModifier != null) { symbol(nullabilityModifier.name) } @@ -200,7 +200,7 @@ class KotlinLanguageService : LanguageService { identifier(node.name) - val constraints = node.details(DocumentationNode.Kind.UpperBound) + val constraints = node.details(NodeKind.UpperBound) if (constraints.any()) { nbsp() symbol(":") @@ -218,9 +218,9 @@ class KotlinLanguageService : LanguageService { identifier(node.name, IdentifierKind.ParameterName) symbol(":") nbsp() - val parameterType = node.detail(DocumentationNode.Kind.Type) + val parameterType = node.detail(NodeKind.Type) renderType(parameterType, renderMode) - val valueNode = node.details(DocumentationNode.Kind.Value).firstOrNull() + val valueNode = node.details(NodeKind.Value).firstOrNull() if (valueNode != null) { nbsp() symbol("=") @@ -230,7 +230,7 @@ class KotlinLanguageService : LanguageService { } private fun ContentBlock.renderTypeParametersForNode(node: DocumentationNode, renderMode: RenderMode) { - val typeParameters = node.details(DocumentationNode.Kind.TypeParameter) + val typeParameters = node.details(NodeKind.TypeParameter) if (typeParameters.any()) { symbol("<") renderList(typeParameters) { @@ -241,7 +241,7 @@ class KotlinLanguageService : LanguageService { } private fun ContentBlock.renderSupertypesForNode(node: DocumentationNode, renderMode: RenderMode) { - val supertypes = node.details(DocumentationNode.Kind.Supertype) + val supertypes = node.details(NodeKind.Supertype) if (supertypes.any()) { nbsp() symbol(":") @@ -256,9 +256,9 @@ class KotlinLanguageService : LanguageService { private fun ContentBlock.renderModifiersForNode(node: DocumentationNode, renderMode: RenderMode, nowrap: Boolean = false) { - val modifiers = node.details(DocumentationNode.Kind.Modifier) + val modifiers = node.details(NodeKind.Modifier) for (it in modifiers) { - if (node.kind == org.jetbrains.dokka.DocumentationNode.Kind.Interface && it.name == "abstract") + if (node.kind == org.jetbrains.dokka.NodeKind.Interface && it.name == "abstract") continue if (renderMode == RenderMode.SUMMARY && it.name in fullOnlyModifiers) { continue @@ -275,11 +275,11 @@ class KotlinLanguageService : LanguageService { private fun ContentBlock.renderAnnotation(node: DocumentationNode) { identifier("@" + node.name, IdentifierKind.AnnotationName) - val parameters = node.details(DocumentationNode.Kind.Parameter) + val parameters = node.details(NodeKind.Parameter) if (!parameters.isEmpty()) { symbol("(") renderList(parameters) { - text(it.detail(DocumentationNode.Kind.Value).name) + text(it.detail(NodeKind.Value).name) } symbol(")") } @@ -292,12 +292,12 @@ class KotlinLanguageService : LanguageService { } renderModifiersForNode(node, renderMode) when (node.kind) { - DocumentationNode.Kind.Class, - DocumentationNode.Kind.AnnotationClass, - DocumentationNode.Kind.Enum -> keyword("class ") - DocumentationNode.Kind.Interface -> keyword("interface ") - DocumentationNode.Kind.EnumItem -> keyword("enum val ") - DocumentationNode.Kind.Object -> keyword("object ") + NodeKind.Class, + NodeKind.AnnotationClass, + NodeKind.Enum -> keyword("class ") + NodeKind.Interface -> keyword("interface ") + NodeKind.EnumItem -> keyword("enum val ") + NodeKind.Object -> keyword("object ") else -> throw IllegalArgumentException("Node $node is not a class-like object") } @@ -314,23 +314,23 @@ class KotlinLanguageService : LanguageService { } renderModifiersForNode(node, renderMode) when (node.kind) { - DocumentationNode.Kind.Constructor -> identifier(node.owner!!.name) - DocumentationNode.Kind.Function, - DocumentationNode.Kind.CompanionObjectFunction -> keyword("fun ") + NodeKind.Constructor -> identifier(node.owner!!.name) + NodeKind.Function, + NodeKind.CompanionObjectFunction -> keyword("fun ") else -> throw IllegalArgumentException("Node $node is not a function-like object") } renderTypeParametersForNode(node, renderMode) - if (node.details(DocumentationNode.Kind.TypeParameter).any()) { + if (node.details(NodeKind.TypeParameter).any()) { text(" ") } renderReceiver(node, renderMode, signatureMapper) - if (node.kind != org.jetbrains.dokka.DocumentationNode.Kind.Constructor) + if (node.kind != org.jetbrains.dokka.NodeKind.Constructor) identifierOrDeprecated(node) symbol("(") - val parameters = node.details(DocumentationNode.Kind.Parameter) + val parameters = node.details(NodeKind.Parameter) renderList(parameters) { indentedSoftLineBreak() renderParameter(it, renderMode) @@ -341,7 +341,7 @@ class KotlinLanguageService : LanguageService { } symbol(")") symbol(": ") - renderType(node.detail(DocumentationNode.Kind.Type), renderMode) + renderType(node.detail(NodeKind.Type), renderMode) } else { symbol(")") @@ -349,24 +349,24 @@ class KotlinLanguageService : LanguageService { } private fun ContentBlock.renderReceiver(node: DocumentationNode, renderMode: RenderMode, signatureMapper: SignatureMapper?) { - val receiver = node.details(DocumentationNode.Kind.Receiver).singleOrNull() + val receiver = node.details(NodeKind.Receiver).singleOrNull() if (receiver != null) { if (signatureMapper != null) { signatureMapper.renderReceiver(receiver, this) } else { - renderType(receiver.detail(DocumentationNode.Kind.Type), renderMode) + renderType(receiver.detail(NodeKind.Type), renderMode) } symbol(".") } } private fun needReturnType(node: DocumentationNode) = when(node.kind) { - DocumentationNode.Kind.Constructor -> false + NodeKind.Constructor -> false else -> !node.isUnitReturnType() } fun DocumentationNode.isUnitReturnType(): Boolean = - detail(DocumentationNode.Kind.Type).hiddenLinks.firstOrNull()?.qualifiedName() == "kotlin.Unit" + detail(NodeKind.Type).hiddenLinks.firstOrNull()?.qualifiedName() == "kotlin.Unit" private fun ContentBlock.renderProperty(node: DocumentationNode, renderMode: RenderMode, @@ -376,12 +376,12 @@ class KotlinLanguageService : LanguageService { } renderModifiersForNode(node, renderMode) when (node.kind) { - DocumentationNode.Kind.Property, - DocumentationNode.Kind.CompanionObjectProperty -> keyword("${node.getPropertyKeyword()} ") + NodeKind.Property, + NodeKind.CompanionObjectProperty -> keyword("${node.getPropertyKeyword()} ") else -> throw IllegalArgumentException("Node $node is not a property") } renderTypeParametersForNode(node, renderMode) - if (node.details(DocumentationNode.Kind.TypeParameter).any()) { + if (node.details(NodeKind.TypeParameter).any()) { text(" ") } @@ -389,11 +389,11 @@ class KotlinLanguageService : LanguageService { identifierOrDeprecated(node) symbol(": ") - renderType(node.detail(DocumentationNode.Kind.Type), renderMode) + renderType(node.detail(NodeKind.Type), renderMode) } fun DocumentationNode.getPropertyKeyword() = - if (details(DocumentationNode.Kind.Modifier).any { it.name == "var" }) "var" else "val" + if (details(NodeKind.Modifier).any { it.name == "var" }) "var" else "val" fun ContentBlock.identifierOrDeprecated(node: DocumentationNode) { if (node.deprecation != null) { diff --git a/core/src/main/kotlin/Languages/JavaLanguageService.kt b/core/src/main/kotlin/Languages/JavaLanguageService.kt index 8be9f13e..d6f9ade5 100644 --- a/core/src/main/kotlin/Languages/JavaLanguageService.kt +++ b/core/src/main/kotlin/Languages/JavaLanguageService.kt @@ -1,6 +1,5 @@ package org.jetbrains.dokka -import org.jetbrains.dokka.DocumentationNode.Kind import org.jetbrains.dokka.LanguageService.RenderMode /** @@ -9,23 +8,23 @@ import org.jetbrains.dokka.LanguageService.RenderMode class JavaLanguageService : LanguageService { override fun render(node: DocumentationNode, renderMode: RenderMode): ContentNode { return ContentText(when (node.kind) { - Kind.Package -> renderPackage(node) - in Kind.classLike -> renderClass(node) + NodeKind.Package -> renderPackage(node) + in NodeKind.classLike -> renderClass(node) - Kind.TypeParameter -> renderTypeParameter(node) - Kind.Type, - Kind.UpperBound -> renderType(node) + NodeKind.TypeParameter -> renderTypeParameter(node) + NodeKind.Type, + NodeKind.UpperBound -> renderType(node) - Kind.Constructor, - Kind.Function -> renderFunction(node) - Kind.Property -> renderProperty(node) + NodeKind.Constructor, + NodeKind.Function -> renderFunction(node) + NodeKind.Property -> renderProperty(node) else -> "${node.kind}: ${node.name}" }) } override fun renderName(node: DocumentationNode): String { return when (node.kind) { - Kind.Constructor -> node.owner!!.name + NodeKind.Constructor -> node.owner!!.name else -> node.name } } @@ -45,13 +44,13 @@ class JavaLanguageService : LanguageService { } fun getArrayElementType(node: DocumentationNode): DocumentationNode? = when (node.name) { - "Array" -> node.details(Kind.Type).singleOrNull()?.let { et -> getArrayElementType(et) ?: et } ?: DocumentationNode("Object", node.content, DocumentationNode.Kind.ExternalClass) - "IntArray", "LongArray", "ShortArray", "ByteArray", "CharArray", "DoubleArray", "FloatArray", "BooleanArray" -> DocumentationNode(node.name.removeSuffix("Array").toLowerCase(), node.content, DocumentationNode.Kind.Type) + "Array" -> node.details(NodeKind.Type).singleOrNull()?.let { et -> getArrayElementType(et) ?: et } ?: DocumentationNode("Object", node.content, NodeKind.ExternalClass) + "IntArray", "LongArray", "ShortArray", "ByteArray", "CharArray", "DoubleArray", "FloatArray", "BooleanArray" -> DocumentationNode(node.name.removeSuffix("Array").toLowerCase(), node.content, NodeKind.Type) else -> null } fun getArrayDimension(node: DocumentationNode): Int = when (node.name) { - "Array" -> 1 + (node.details(DocumentationNode.Kind.Type).singleOrNull()?.let { getArrayDimension(it) } ?: 0) + "Array" -> 1 + (node.details(NodeKind.Type).singleOrNull()?.let { getArrayDimension(it) } ?: 0) "IntArray", "LongArray", "ShortArray", "ByteArray", "CharArray", "DoubleArray", "FloatArray", "BooleanArray" -> 1 else -> 0 } @@ -71,7 +70,7 @@ class JavaLanguageService : LanguageService { } private fun renderTypeParameter(node: DocumentationNode): String { - val constraints = node.details(Kind.UpperBound) + val constraints = node.details(NodeKind.UpperBound) return if (constraints.none()) node.name else { @@ -80,12 +79,12 @@ class JavaLanguageService : LanguageService { } private fun renderParameter(node: DocumentationNode): String { - return "${renderType(node.detail(Kind.Type))} ${node.name}" + return "${renderType(node.detail(NodeKind.Type))} ${node.name}" } private fun renderTypeParametersForNode(node: DocumentationNode): String { return StringBuilder().apply { - val typeParameters = node.details(Kind.TypeParameter) + val typeParameters = node.details(NodeKind.TypeParameter) if (typeParameters.any()) { append("<") append(typeParameters.map { renderTypeParameter(it) }.joinToString()) @@ -95,7 +94,7 @@ class JavaLanguageService : LanguageService { } private fun renderModifiersForNode(node: DocumentationNode): String { - val modifiers = node.details(Kind.Modifier).map { renderModifier(it) }.filter { it != "" } + val modifiers = node.details(NodeKind.Modifier).map { renderModifier(it) }.filter { it != "" } if (modifiers.none()) return "" return modifiers.joinToString(" ", postfix = " ") @@ -104,11 +103,11 @@ class JavaLanguageService : LanguageService { private fun renderClass(node: DocumentationNode): String { return StringBuilder().apply { when (node.kind) { - Kind.Class -> append("class ") - Kind.Interface -> append("interface ") - Kind.Enum -> append("enum ") - Kind.EnumItem -> append("enum value ") - Kind.Object -> append("class ") + NodeKind.Class -> append("class ") + NodeKind.Interface -> append("interface ") + NodeKind.Enum -> append("enum ") + NodeKind.EnumItem -> append("enum value ") + NodeKind.Object -> append("class ") else -> throw IllegalArgumentException("Node $node is not a class-like object") } @@ -120,22 +119,22 @@ class JavaLanguageService : LanguageService { private fun renderFunction(node: DocumentationNode): String { return StringBuilder().apply { when (node.kind) { - Kind.Constructor -> append(node.owner?.name) - Kind.Function -> { + NodeKind.Constructor -> append(node.owner?.name) + NodeKind.Function -> { append(renderTypeParametersForNode(node)) - append(renderType(node.detail(Kind.Type))) + append(renderType(node.detail(NodeKind.Type))) append(" ") append(node.name) } else -> throw IllegalArgumentException("Node $node is not a function-like object") } - val receiver = node.details(Kind.Receiver).singleOrNull() + val receiver = node.details(NodeKind.Receiver).singleOrNull() append("(") if (receiver != null) - (listOf(receiver) + node.details(Kind.Parameter)).map { renderParameter(it) }.joinTo(this) + (listOf(receiver) + node.details(NodeKind.Parameter)).map { renderParameter(it) }.joinTo(this) else - node.details(Kind.Parameter).map { renderParameter(it) }.joinTo(this) + node.details(NodeKind.Parameter).map { renderParameter(it) }.joinTo(this) append(")") }.toString() @@ -144,19 +143,19 @@ class JavaLanguageService : LanguageService { private fun renderProperty(node: DocumentationNode): String { return StringBuilder().apply { when (node.kind) { - Kind.Property -> append("val ") + NodeKind.Property -> append("val ") else -> throw IllegalArgumentException("Node $node is not a property") } append(renderTypeParametersForNode(node)) - val receiver = node.details(Kind.Receiver).singleOrNull() + val receiver = node.details(NodeKind.Receiver).singleOrNull() if (receiver != null) { - append(renderType(receiver.detail(Kind.Type))) + append(renderType(receiver.detail(NodeKind.Type))) append(".") } append(node.name) append(": ") - append(renderType(node.detail(Kind.Type))) + append(renderType(node.detail(NodeKind.Type))) }.toString() } }
\ No newline at end of file diff --git a/core/src/main/kotlin/Model/DocumentationNode.kt b/core/src/main/kotlin/Model/DocumentationNode.kt index 35933aee..ba3edc24 100644 --- a/core/src/main/kotlin/Model/DocumentationNode.kt +++ b/core/src/main/kotlin/Model/DocumentationNode.kt @@ -2,9 +2,61 @@ package org.jetbrains.dokka import java.util.* +enum class NodeKind { + Unknown, + + Package, + Class, + Interface, + Enum, + AnnotationClass, + EnumItem, + Object, + + Constructor, + Function, + Property, + Field, + + CompanionObjectProperty, + CompanionObjectFunction, + + Parameter, + Receiver, + TypeParameter, + Type, + Supertype, + UpperBound, + LowerBound, + Exception, + + Modifier, + NullabilityModifier, + + Module, + + ExternalClass, + Annotation, + + Value, + + SourceUrl, + SourcePosition, + + /** + * A note which is rendered once on a page documenting a group of overloaded functions. + * Needs to be generated equally on all overloads. + */ + OverloadGroupNote; + + companion object { + val classLike = setOf(Class, Interface, Enum, AnnotationClass, Object) + } +} + open class DocumentationNode(val name: String, content: Content, - val kind: DocumentationNode.Kind) { + val kind: NodeKind) { private val references = LinkedHashSet<DocumentationReference>() @@ -14,30 +66,30 @@ open class DocumentationNode(val name: String, val summary: ContentNode get() = content.summary val owner: DocumentationNode? - get() = references(DocumentationReference.Kind.Owner).singleOrNull()?.to + get() = references(RefKind.Owner).singleOrNull()?.to val details: List<DocumentationNode> - get() = references(DocumentationReference.Kind.Detail).map { it.to } + get() = references(RefKind.Detail).map { it.to } val members: List<DocumentationNode> - get() = references(DocumentationReference.Kind.Member).map { it.to } + get() = references(RefKind.Member).map { it.to } val inheritedMembers: List<DocumentationNode> - get() = references(DocumentationReference.Kind.InheritedMember).map { it.to } + get() = references(RefKind.InheritedMember).map { it.to } val extensions: List<DocumentationNode> - get() = references(DocumentationReference.Kind.Extension).map { it.to } + get() = references(RefKind.Extension).map { it.to } val inheritors: List<DocumentationNode> - get() = references(DocumentationReference.Kind.Inheritor).map { it.to } + get() = references(RefKind.Inheritor).map { it.to } val overrides: List<DocumentationNode> - get() = references(DocumentationReference.Kind.Override).map { it.to } + get() = references(RefKind.Override).map { it.to } val links: List<DocumentationNode> - get() = references(DocumentationReference.Kind.Link).map { it.to } + get() = references(RefKind.Link).map { it.to } val hiddenLinks: List<DocumentationNode> - get() = references(DocumentationReference.Kind.HiddenLink).map { it.to } + get() = references(RefKind.HiddenLink).map { it.to } val annotations: List<DocumentationNode> - get() = references(DocumentationReference.Kind.Annotation).map { it.to } + get() = references(RefKind.Annotation).map { it.to } val deprecation: DocumentationNode? - get() = references(DocumentationReference.Kind.Deprecation).singleOrNull()?.to + get() = references(RefKind.Deprecation).singleOrNull()?.to // TODO: Should we allow node mutation? Model merge will copy by ref, so references are transparent, which could nice - fun addReferenceTo(to: DocumentationNode, kind: DocumentationReference.Kind) { + fun addReferenceTo(to: DocumentationNode, kind: RefKind) { references.add(DocumentationReference(this, to, kind)) } @@ -52,77 +104,25 @@ open class DocumentationNode(val name: String, (content as MutableContent).body() } - fun details(kind: DocumentationNode.Kind): List<DocumentationNode> = details.filter { it.kind == kind } - fun members(kind: DocumentationNode.Kind): List<DocumentationNode> = members.filter { it.kind == kind } - fun inheritedMembers(kind: DocumentationNode.Kind): List<DocumentationNode> = inheritedMembers.filter { it.kind == kind } - fun links(kind: DocumentationNode.Kind): List<DocumentationNode> = links.filter { it.kind == kind } + fun details(kind: NodeKind): List<DocumentationNode> = details.filter { it.kind == kind } + fun members(kind: NodeKind): List<DocumentationNode> = members.filter { it.kind == kind } + fun inheritedMembers(kind: NodeKind): List<DocumentationNode> = inheritedMembers.filter { it.kind == kind } + fun links(kind: NodeKind): List<DocumentationNode> = links.filter { it.kind == kind } - fun detail(kind: DocumentationNode.Kind): DocumentationNode = details.filter { it.kind == kind }.single() - fun member(kind: DocumentationNode.Kind): DocumentationNode = members.filter { it.kind == kind }.single() - fun link(kind: DocumentationNode.Kind): DocumentationNode = links.filter { it.kind == kind }.single() + fun detail(kind: NodeKind): DocumentationNode = details.filter { it.kind == kind }.single() + fun member(kind: NodeKind): DocumentationNode = members.filter { it.kind == kind }.single() + fun link(kind: NodeKind): DocumentationNode = links.filter { it.kind == kind }.single() - fun references(kind: DocumentationReference.Kind): List<DocumentationReference> = references.filter { it.kind == kind } + fun references(kind: RefKind): List<DocumentationReference> = references.filter { it.kind == kind } fun allReferences(): Set<DocumentationReference> = references override fun toString(): String { return "$kind:$name" } - - enum class Kind { - Unknown, - - Package, - Class, - Interface, - Enum, - AnnotationClass, - EnumItem, - Object, - - Constructor, - Function, - Property, - Field, - - CompanionObjectProperty, - CompanionObjectFunction, - - Parameter, - Receiver, - TypeParameter, - Type, - Supertype, - UpperBound, - LowerBound, - Exception, - - Modifier, - NullabilityModifier, - - Module, - - ExternalClass, - Annotation, - - Value, - - SourceUrl, - SourcePosition, - - /** - * A note which is rendered once on a page documenting a group of overloaded functions. - * Needs to be generated equally on all overloads. - */ - OverloadGroupNote; - - companion object { - val classLike = setOf(Class, Interface, Enum, AnnotationClass, Object) - } - } } class DocumentationModule(name: String, content: Content = Content.Empty) - : DocumentationNode(name, content, DocumentationNode.Kind.Module) { + : DocumentationNode(name, content, NodeKind.Module) { } val DocumentationNode.path: List<DocumentationNode> @@ -132,30 +132,30 @@ val DocumentationNode.path: List<DocumentationNode> } fun DocumentationNode.findOrCreatePackageNode(packageName: String, packageContent: Map<String, Content>): DocumentationNode { - val existingNode = members(DocumentationNode.Kind.Package).firstOrNull { it.name == packageName } + val existingNode = members(NodeKind.Package).firstOrNull { it.name == packageName } if (existingNode != null) { return existingNode } val newNode = DocumentationNode(packageName, packageContent.getOrElse(packageName) { Content.Empty }, - DocumentationNode.Kind.Package) - append(newNode, DocumentationReference.Kind.Member) + NodeKind.Package) + append(newNode, RefKind.Member) return newNode } -fun DocumentationNode.append(child: DocumentationNode, kind: DocumentationReference.Kind) { +fun DocumentationNode.append(child: DocumentationNode, kind: RefKind) { addReferenceTo(child, kind) when (kind) { - DocumentationReference.Kind.Detail -> child.addReferenceTo(this, DocumentationReference.Kind.Owner) - DocumentationReference.Kind.Member -> child.addReferenceTo(this, DocumentationReference.Kind.Owner) - DocumentationReference.Kind.Owner -> child.addReferenceTo(this, DocumentationReference.Kind.Member) + RefKind.Detail -> child.addReferenceTo(this, RefKind.Owner) + RefKind.Member -> child.addReferenceTo(this, RefKind.Owner) + RefKind.Owner -> child.addReferenceTo(this, RefKind.Member) else -> { /* Do not add any links back for other types */ } } } fun DocumentationNode.appendTextNode(text: String, - kind: DocumentationNode.Kind, - refKind: DocumentationReference.Kind = DocumentationReference.Kind.Detail) { + kind: NodeKind, + refKind: RefKind = RefKind.Detail) { append(DocumentationNode(text, Content.Empty, kind), refKind) } diff --git a/core/src/main/kotlin/Model/DocumentationReference.kt b/core/src/main/kotlin/Model/DocumentationReference.kt index 99a1f434..6db6d303 100644 --- a/core/src/main/kotlin/Model/DocumentationReference.kt +++ b/core/src/main/kotlin/Model/DocumentationReference.kt @@ -2,27 +2,28 @@ package org.jetbrains.dokka import com.google.inject.Singleton -data class DocumentationReference(val from: DocumentationNode, val to: DocumentationNode, val kind: DocumentationReference.Kind) { - enum class Kind { - Owner, - Member, - InheritedMember, - Detail, - Link, - HiddenLink, - Extension, - Inheritor, - Superclass, - Override, - Annotation, - Deprecation, - TopLevelPage - } +enum class RefKind { + Owner, + Member, + InheritedMember, + Detail, + Link, + HiddenLink, + Extension, + Inheritor, + Superclass, + Override, + Annotation, + Deprecation, + TopLevelPage +} + +data class DocumentationReference(val from: DocumentationNode, val to: DocumentationNode, val kind: RefKind) { } class PendingDocumentationReference(val lazyNodeFrom: () -> DocumentationNode?, val lazyNodeTo: () -> DocumentationNode?, - val kind: DocumentationReference.Kind) { + val kind: RefKind) { fun resolve() { val fromNode = lazyNodeFrom() val toNode = lazyNodeTo() @@ -41,15 +42,15 @@ class NodeReferenceGraph() { nodeMap.put(signature, node) } - fun link(fromNode: DocumentationNode, toSignature: String, kind: DocumentationReference.Kind) { + fun link(fromNode: DocumentationNode, toSignature: String, kind: RefKind) { references.add(PendingDocumentationReference({ -> fromNode}, { -> nodeMap[toSignature]}, kind)) } - fun link(fromSignature: String, toNode: DocumentationNode, kind: DocumentationReference.Kind) { + fun link(fromSignature: String, toNode: DocumentationNode, kind: RefKind) { references.add(PendingDocumentationReference({ -> nodeMap[fromSignature]}, { -> toNode}, kind)) } - fun link(fromSignature: String, toSignature: String, kind: DocumentationReference.Kind) { + fun link(fromSignature: String, toSignature: String, kind: RefKind) { references.add(PendingDocumentationReference({ -> nodeMap[fromSignature]}, { -> nodeMap[toSignature]}, kind)) } diff --git a/core/src/main/kotlin/Model/SourceLinks.kt b/core/src/main/kotlin/Model/SourceLinks.kt index 956bfe4b..99bb8f60 100644 --- a/core/src/main/kotlin/Model/SourceLinks.kt +++ b/core/src/main/kotlin/Model/SourceLinks.kt @@ -1,10 +1,10 @@ package org.jetbrains.dokka -import com.intellij.psi.PsiElement -import java.io.File import com.intellij.psi.PsiDocumentManager +import com.intellij.psi.PsiElement import com.intellij.psi.PsiNameIdentifierOwner import org.jetbrains.kotlin.psi.psiUtil.startOffset +import java.io.File class SourceLinkDefinition(val path: String, val url: String, val lineSuffix: String?) @@ -22,12 +22,12 @@ fun DocumentationNode.appendSourceLink(psi: PsiElement?, sourceLinks: List<Sourc url += linkDef.lineSuffix + line.toString() } } - append(DocumentationNode(url, Content.Empty, DocumentationNode.Kind.SourceUrl), - DocumentationReference.Kind.Detail); + append(DocumentationNode(url, Content.Empty, NodeKind.SourceUrl), + RefKind.Detail); } if (target != null) { - append(DocumentationNode(target.sourcePosition(), Content.Empty, DocumentationNode.Kind.SourcePosition), DocumentationReference.Kind.Detail) + append(DocumentationNode(target.sourcePosition(), Content.Empty, NodeKind.SourcePosition), RefKind.Detail) } } diff --git a/core/src/main/kotlin/javadoc/docbase.kt b/core/src/main/kotlin/javadoc/docbase.kt index a0caca94..25733464 100644 --- a/core/src/main/kotlin/javadoc/docbase.kt +++ b/core/src/main/kotlin/javadoc/docbase.kt @@ -34,17 +34,17 @@ open class DocumentationNodeBareAdapter(override val node: DocumentationNode) : override fun getRawCommentText(): String = rawCommentText_ ?: "" override fun isError(): Boolean = false - override fun isException(): Boolean = node.kind == DocumentationNode.Kind.Exception - override fun isEnumConstant(): Boolean = node.kind == DocumentationNode.Kind.EnumItem - override fun isEnum(): Boolean = node.kind == DocumentationNode.Kind.Enum - override fun isMethod(): Boolean = node.kind == DocumentationNode.Kind.Function - override fun isInterface(): Boolean = node.kind == DocumentationNode.Kind.Interface - override fun isField(): Boolean = node.kind == DocumentationNode.Kind.Field - override fun isClass(): Boolean = node.kind == DocumentationNode.Kind.Class - override fun isAnnotationType(): Boolean = node.kind == DocumentationNode.Kind.AnnotationClass - override fun isConstructor(): Boolean = node.kind == DocumentationNode.Kind.Constructor - override fun isOrdinaryClass(): Boolean = node.kind == DocumentationNode.Kind.Class - override fun isAnnotationTypeElement(): Boolean = node.kind == DocumentationNode.Kind.Annotation + override fun isException(): Boolean = node.kind == NodeKind.Exception + override fun isEnumConstant(): Boolean = node.kind == NodeKind.EnumItem + override fun isEnum(): Boolean = node.kind == NodeKind.Enum + override fun isMethod(): Boolean = node.kind == NodeKind.Function + override fun isInterface(): Boolean = node.kind == NodeKind.Interface + override fun isField(): Boolean = node.kind == NodeKind.Field + override fun isClass(): Boolean = node.kind == NodeKind.Class + override fun isAnnotationType(): Boolean = node.kind == NodeKind.AnnotationClass + override fun isConstructor(): Boolean = node.kind == NodeKind.Constructor + override fun isOrdinaryClass(): Boolean = node.kind == NodeKind.Class + override fun isAnnotationTypeElement(): Boolean = node.kind == NodeKind.Annotation override fun compareTo(other: Any?): Int = when (other) { !is DocumentationNodeAdapter -> 1 @@ -54,7 +54,7 @@ open class DocumentationNodeBareAdapter(override val node: DocumentationNode) : override fun equals(other: Any?): Boolean = node.qualifiedName() == (other as? DocumentationNodeAdapter)?.node?.qualifiedName() override fun hashCode(): Int = node.name.hashCode() - override fun isIncluded(): Boolean = node.kind != DocumentationNode.Kind.ExternalClass + override fun isIncluded(): Boolean = node.kind != NodeKind.ExternalClass } @@ -89,7 +89,7 @@ private fun <T> nodeAnnotations(self: T): List<AnnotationDescAdapter> where T : = 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(DocumentationNode.Kind.Modifier).any { it.name == name } +private fun DocumentationNode.hasModifier(name: String) = details(NodeKind.Modifier).any { it.name == name } class PackageAdapter(module: ModuleNodeAdapter, node: DocumentationNode) : DocumentationNodeAdapter(module, node), PackageDoc { @@ -99,12 +99,12 @@ class PackageAdapter(module: ModuleNodeAdapter, node: DocumentationNode) : Docum allClasses.get(className)?.let { ClassDocumentationNodeAdapter(module, it) } override fun annotationTypes(): Array<out AnnotationTypeDoc> = emptyArray() - override fun annotations(): Array<out AnnotationDesc> = node.members(DocumentationNode.Kind.AnnotationClass).map { AnnotationDescAdapter(module, it) }.toTypedArray() - override fun exceptions(): Array<out ClassDoc> = node.members(DocumentationNode.Kind.Exception).map { ClassDocumentationNodeAdapter(module, it) }.toTypedArray() - override fun ordinaryClasses(): Array<out ClassDoc> = node.members(DocumentationNode.Kind.Class).map { ClassDocumentationNodeAdapter(module, it) }.toTypedArray() - override fun interfaces(): Array<out ClassDoc> = node.members(DocumentationNode.Kind.Interface).map { ClassDocumentationNodeAdapter(module, it) }.toTypedArray() + override fun annotations(): Array<out AnnotationDesc> = node.members(NodeKind.AnnotationClass).map { AnnotationDescAdapter(module, it) }.toTypedArray() + override fun exceptions(): Array<out ClassDoc> = node.members(NodeKind.Exception).map { ClassDocumentationNodeAdapter(module, it) }.toTypedArray() + override fun ordinaryClasses(): Array<out ClassDoc> = node.members(NodeKind.Class).map { ClassDocumentationNodeAdapter(module, it) }.toTypedArray() + override fun interfaces(): Array<out ClassDoc> = node.members(NodeKind.Interface).map { ClassDocumentationNodeAdapter(module, it) }.toTypedArray() override fun errors(): Array<out ClassDoc> = emptyArray() - override fun enums(): Array<out ClassDoc> = node.members(DocumentationNode.Kind.Enum).map { ClassDocumentationNodeAdapter(module, it) }.toTypedArray() + override fun enums(): Array<out ClassDoc> = node.members(NodeKind.Enum).map { ClassDocumentationNodeAdapter(module, it) }.toTypedArray() override fun allClasses(filter: Boolean): Array<out ClassDoc> = allClasses.values.map { ClassDocumentationNodeAdapter(module, it) }.toTypedArray() override fun allClasses(): Array<out ClassDoc> = allClasses(true) @@ -126,7 +126,7 @@ class ProgramElementAdapter(module: ModuleNodeAdapter, node: DocumentationNode) override fun isPackagePrivate(): Boolean = false override fun isStatic(): Boolean = node.hasModifier("static") override fun modifierSpecifier(): Int = Modifier.PUBLIC + if (isStatic) Modifier.STATIC else 0 - override fun qualifiedName(): String? = if (node.kind == DocumentationNode.Kind.Type) node.qualifiedNameFromType() else node.qualifiedName() + override fun qualifiedName(): String? = if (node.kind == NodeKind.Type) node.qualifiedNameFromType() else node.qualifiedName() override fun annotations(): Array<out AnnotationDesc>? = nodeAnnotations(this).toTypedArray() override fun modifiers(): String? = "public ${if (isStatic) "static" else ""}".trim() override fun isProtected(): Boolean = false @@ -134,13 +134,13 @@ class ProgramElementAdapter(module: ModuleNodeAdapter, node: DocumentationNode) override fun isFinal(): Boolean = node.hasModifier("final") override fun containingPackage(): PackageDoc? { - if (node.kind == DocumentationNode.Kind.Type) { + if (node.kind == NodeKind.Type) { return null } var owner: DocumentationNode? = node while (owner != null) { - if (owner.kind == DocumentationNode.Kind.Package) { + if (owner.kind == NodeKind.Package) { return PackageAdapter(module, owner) } owner = owner.owner @@ -150,16 +150,16 @@ class ProgramElementAdapter(module: ModuleNodeAdapter, node: DocumentationNode) } override fun containingClass(): ClassDoc? { - if (node.kind == DocumentationNode.Kind.Type) { + if (node.kind == NodeKind.Type) { return null } var owner = node.owner while (owner != null) { when (owner.kind) { - DocumentationNode.Kind.Class, - DocumentationNode.Kind.Interface, - DocumentationNode.Kind.Enum -> return ClassDocumentationNodeAdapter(module, owner) + NodeKind.Class, + NodeKind.Interface, + NodeKind.Enum -> return ClassDocumentationNodeAdapter(module, owner) else -> owner = owner.owner } } @@ -184,9 +184,9 @@ open class TypeAdapter(override val module: ModuleNodeAdapter, override val node override fun asClassDoc(): ClassDoc? = if (isPrimitive) null else elementType?.asClassDoc() ?: when (node.kind) { - in DocumentationNode.Kind.classLike, - DocumentationNode.Kind.ExternalClass, - DocumentationNode.Kind.Exception -> module.classNamed(qualifiedTypeName()) ?: ClassDocumentationNodeAdapter(module, node) + in NodeKind.classLike, + NodeKind.ExternalClass, + NodeKind.Exception -> module.classNamed(qualifiedTypeName()) ?: ClassDocumentationNodeAdapter(module, node) else -> when { node.links.isNotEmpty() -> TypeAdapter(module, node.links.first()).asClassDoc() @@ -194,12 +194,12 @@ open class TypeAdapter(override val module: ModuleNodeAdapter, override val node } } - override fun asTypeVariable(): TypeVariable? = if (node.kind == DocumentationNode.Kind.TypeParameter) TypeVariableAdapter(module, node) else null + override fun asTypeVariable(): TypeVariable? = if (node.kind == NodeKind.TypeParameter) TypeVariableAdapter(module, node) else null override fun asParameterizedType(): ParameterizedType? = - if (node.details(DocumentationNode.Kind.Type).isNotEmpty()) ParameterizedTypeAdapter(module, node) + if (node.details(NodeKind.Type).isNotEmpty()) ParameterizedTypeAdapter(module, node) else null // TODO it should ignore dimensions - override fun asAnnotationTypeDoc(): AnnotationTypeDoc? = if (node.kind == DocumentationNode.Kind.AnnotationClass) AnnotationTypeDocAdapter(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 override fun getElementType(): Type? = javaLanguageService.getArrayElementType(node)?.let { et -> TypeAdapter(module, et) } override fun asWildcardType(): WildcardType? = null @@ -215,26 +215,26 @@ class AnnotatedTypeAdapter(module: ModuleNodeAdapter, node: DocumentationNode) : } class WildcardTypeAdapter(module: ModuleNodeAdapter, node: DocumentationNode) : TypeAdapter(module, node), WildcardType { - override fun extendsBounds(): Array<out Type> = node.details(DocumentationNode.Kind.UpperBound).map { TypeAdapter(module, it) }.toTypedArray() - override fun superBounds(): Array<out Type> = node.details(DocumentationNode.Kind.LowerBound).map { TypeAdapter(module, it) }.toTypedArray() + override fun extendsBounds(): Array<out Type> = node.details(NodeKind.UpperBound).map { TypeAdapter(module, it) }.toTypedArray() + override fun superBounds(): Array<out Type> = node.details(NodeKind.LowerBound).map { TypeAdapter(module, it) }.toTypedArray() } class TypeVariableAdapter(module: ModuleNodeAdapter, node: DocumentationNode) : TypeAdapter(module, node), TypeVariable { override fun owner(): ProgramElementDoc = node.owner!!.let<DocumentationNode, ProgramElementDoc> { owner -> when (owner.kind) { - DocumentationNode.Kind.Function, - DocumentationNode.Kind.Constructor -> ExecutableMemberAdapter(module, owner) + NodeKind.Function, + NodeKind.Constructor -> ExecutableMemberAdapter(module, owner) - DocumentationNode.Kind.Class, - DocumentationNode.Kind.Interface, - DocumentationNode.Kind.Enum -> ClassDocumentationNodeAdapter(module, owner) + NodeKind.Class, + NodeKind.Interface, + NodeKind.Enum -> ClassDocumentationNodeAdapter(module, owner) else -> ProgramElementAdapter(module, node.owner!!) } } - override fun bounds(): Array<out Type>? = node.details(DocumentationNode.Kind.UpperBound).map { TypeAdapter(module, it) }.toTypedArray() - override fun annotations(): Array<out AnnotationDesc>? = node.members(DocumentationNode.Kind.Annotation).map { AnnotationDescAdapter(module, it) }.toTypedArray() + override fun bounds(): Array<out Type>? = node.details(NodeKind.UpperBound).map { TypeAdapter(module, it) }.toTypedArray() + override fun annotations(): Array<out AnnotationDesc>? = node.members(NodeKind.Annotation).map { AnnotationDescAdapter(module, it) }.toTypedArray() override fun qualifiedTypeName(): String = node.name override fun simpleTypeName(): String = node.name @@ -247,32 +247,32 @@ class TypeVariableAdapter(module: ModuleNodeAdapter, node: DocumentationNode) : } class ParameterizedTypeAdapter(module: ModuleNodeAdapter, node: DocumentationNode) : TypeAdapter(module, node), ParameterizedType { - override fun typeArguments(): Array<out Type> = node.details(DocumentationNode.Kind.Type).map { TypeVariableAdapter(module, it) }.toTypedArray() + 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 == DocumentationNode.Kind.Class || it.kind == DocumentationNode.Kind.ExternalClass } + .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 == DocumentationNode.Kind.Interface } + .filter { it.kind == NodeKind.Interface } .map { ClassDocumentationNodeAdapter(module, it) } .toTypedArray() override fun containingType(): Type? = when (node.owner?.kind) { - DocumentationNode.Kind.Package -> null - DocumentationNode.Kind.Class, - DocumentationNode.Kind.Interface, - DocumentationNode.Kind.Object, - DocumentationNode.Kind.Enum -> ClassDocumentationNodeAdapter(module, node.owner!!) + NodeKind.Package -> null + NodeKind.Class, + NodeKind.Interface, + NodeKind.Object, + NodeKind.Enum -> ClassDocumentationNodeAdapter(module, node.owner!!) else -> null } } class ParameterAdapter(module: ModuleNodeAdapter, node: DocumentationNode) : DocumentationNodeAdapter(module, node), Parameter { - override fun typeName(): String? = JavaLanguageService().renderType(node.detail(DocumentationNode.Kind.Type)) - override fun type(): Type? = TypeAdapter(module, node.detail(DocumentationNode.Kind.Type)) + override fun typeName(): String? = JavaLanguageService().renderType(node.detail(NodeKind.Type)) + override fun type(): Type? = TypeAdapter(module, node.detail(NodeKind.Type)) override fun annotations(): Array<out AnnotationDesc> = nodeAnnotations(this).toTypedArray() } @@ -288,10 +288,10 @@ class ReceiverParameterAdapter(module: ModuleNodeAdapter, val receiverType: Docu } } -fun classOf(fqName: String, kind: DocumentationNode.Kind = DocumentationNode.Kind.Class) = DocumentationNode(fqName.substringAfterLast(".", fqName), Content.Empty, kind).let { node -> +fun classOf(fqName: String, kind: NodeKind = NodeKind.Class) = DocumentationNode(fqName.substringAfterLast(".", fqName), Content.Empty, kind).let { node -> val pkg = fqName.substringBeforeLast(".", "") if (pkg.isNotEmpty()) { - node.append(DocumentationNode(pkg, Content.Empty, DocumentationNode.Kind.Package), DocumentationReference.Kind.Owner) + node.append(DocumentationNode(pkg, Content.Empty, NodeKind.Package), RefKind.Owner) } node @@ -308,37 +308,37 @@ open class ExecutableMemberAdapter(module: ModuleNodeAdapter, node: Documentatio .filter { it.tag == "Exceptions" } .map { it.subjectName } .filterNotNull() - .map { ThrowsTagAdapter(this, ClassDocumentationNodeAdapter(module, classOf(it, DocumentationNode.Kind.Exception))) } + .map { ThrowsTagAdapter(this, ClassDocumentationNodeAdapter(module, classOf(it, NodeKind.Exception))) } .toTypedArray() - override fun isVarArgs(): Boolean = node.details(DocumentationNode.Kind.Parameter).any { false } // TODO + override fun isVarArgs(): Boolean = node.details(NodeKind.Parameter).any { false } // TODO override fun isSynchronized(): Boolean = node.annotations.any { it.name == "synchronized" } - override fun paramTags(): Array<out ParamTag> = node.details(DocumentationNode.Kind.Parameter) + override fun paramTags(): Array<out ParamTag> = node.details(NodeKind.Parameter) .filter { it.content.summary !is ContentEmpty || it.content.description !is ContentEmpty || it.content.sections.isNotEmpty() } .map { ParamTagAdapter(module, this, it.name, false, it.content.children) } .toTypedArray() override fun thrownExceptionTypes(): Array<out Type> = emptyArray() override fun receiverType(): Type? = receiverNode()?.let { receiver -> TypeAdapter(module, receiver) } - override fun flatSignature(): String = node.details(DocumentationNode.Kind.Parameter).map { JavaLanguageService().renderType(it) }.joinToString(", ", "(", ")") - override fun signature(): String = node.details(DocumentationNode.Kind.Parameter).map { JavaLanguageService().renderType(it) }.joinToString(", ", "(", ")") // TODO it should be FQ types + override fun flatSignature(): String = node.details(NodeKind.Parameter).map { JavaLanguageService().renderType(it) }.joinToString(", ", "(", ")") + 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(DocumentationNode.Kind.Parameter).map { ParameterAdapter(module, it) } + + node.details(NodeKind.Parameter).map { ParameterAdapter(module, it) } ).toTypedArray() - override fun typeParameters(): Array<out TypeVariable> = node.details(DocumentationNode.Kind.TypeParameter).map { TypeVariableAdapter(module, it) }.toTypedArray() + override fun typeParameters(): Array<out TypeVariable> = node.details(NodeKind.TypeParameter).map { TypeVariableAdapter(module, it) }.toTypedArray() - override fun typeParamTags(): Array<out ParamTag> = node.details(DocumentationNode.Kind.TypeParameter).filter { it.content.summary !is ContentEmpty || it.content.description !is ContentEmpty || it.content.sections.isNotEmpty() }.map { + override fun typeParamTags(): Array<out ParamTag> = node.details(NodeKind.TypeParameter).filter { it.content.summary !is ContentEmpty || it.content.description !is ContentEmpty || it.content.sections.isNotEmpty() }.map { ParamTagAdapter(module, this, it.name, true, it.content.children) }.toTypedArray() - private fun receiverNode() = node.details(DocumentationNode.Kind.Receiver).let { receivers -> + private fun receiverNode() = node.details(NodeKind.Receiver).let { receivers -> when { - receivers.isNotEmpty() -> receivers.single().detail(DocumentationNode.Kind.Type) + receivers.isNotEmpty() -> receivers.single().detail(NodeKind.Type) else -> null } } @@ -360,16 +360,16 @@ class MethodAdapter(module: ModuleNodeAdapter, node: DocumentationNode) : Docume override fun isDefault(): Boolean = false - override fun returnType(): Type = TypeAdapter(module, node.detail(DocumentationNode.Kind.Type)) + override fun returnType(): Type = TypeAdapter(module, node.detail(NodeKind.Type)) } class FieldAdapter(module: ModuleNodeAdapter, node: DocumentationNode) : DocumentationNodeAdapter(module, node), ProgramElementDoc by ProgramElementAdapter(module, node), FieldDoc { override fun isSynthetic(): Boolean = false - override fun constantValueExpression(): String? = node.details(DocumentationNode.Kind.Value).firstOrNull()?.let { it.name } + override fun constantValueExpression(): String? = node.details(NodeKind.Value).firstOrNull()?.let { it.name } override fun constantValue(): Any? = constantValueExpression() - override fun type(): Type = TypeAdapter(module, node.detail(DocumentationNode.Kind.Type)) + override fun type(): Type = TypeAdapter(module, node.detail(NodeKind.Type)) override fun isTransient(): Boolean = node.hasAnnotation(Transient::class) override fun serialFieldTags(): Array<out SerialFieldTag> = emptyArray() @@ -384,48 +384,48 @@ open class ClassDocumentationNodeAdapter(module: ModuleNodeAdapter, val classNod override fun name(): String { val parent = classNode.owner - if (parent?.kind in DocumentationNode.Kind.classLike) { + if (parent?.kind in NodeKind.classLike) { return parent!!.name + "." + classNode.name } return classNode.name } - override fun constructors(filter: Boolean): Array<out ConstructorDoc> = classNode.members(DocumentationNode.Kind.Constructor).map { ConstructorAdapter(module, it) }.toTypedArray() + override fun constructors(filter: Boolean): Array<out ConstructorDoc> = classNode.members(NodeKind.Constructor).map { ConstructorAdapter(module, it) }.toTypedArray() override fun constructors(): Array<out ConstructorDoc> = constructors(true) override fun importedPackages(): Array<out PackageDoc> = emptyArray() override fun importedClasses(): Array<out ClassDoc>? = emptyArray() - override fun typeParameters(): Array<out TypeVariable> = classNode.details(DocumentationNode.Kind.TypeParameter).map { TypeVariableAdapter(module, it) }.toTypedArray() - override fun asTypeVariable(): TypeVariable? = if (classNode.kind == DocumentationNode.Kind.Class) TypeVariableAdapter(module, classNode) else null + override fun typeParameters(): Array<out TypeVariable> = classNode.details(NodeKind.TypeParameter).map { TypeVariableAdapter(module, it) }.toTypedArray() + override fun asTypeVariable(): TypeVariable? = if (classNode.kind == NodeKind.Class) TypeVariableAdapter(module, classNode) else null override fun isExternalizable(): Boolean = interfaces().any { it.qualifiedName() == "java.io.Externalizable" } override fun definesSerializableFields(): Boolean = false - override fun methods(filter: Boolean): Array<out MethodDoc> = classNode.members(DocumentationNode.Kind.Function).map { MethodAdapter(module, it) }.toTypedArray() // TODO include get/set methods + override fun methods(filter: Boolean): Array<out MethodDoc> = classNode.members(NodeKind.Function).map { MethodAdapter(module, it) }.toTypedArray() // TODO include get/set methods override fun methods(): Array<out MethodDoc> = methods(true) - override fun enumConstants(): Array<out FieldDoc>? = classNode.members(DocumentationNode.Kind.EnumItem).map { FieldAdapter(module, it) }.toTypedArray() - override fun isAbstract(): Boolean = classNode.details(DocumentationNode.Kind.Modifier).any { it.name == "abstract" } + 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 == DocumentationNode.Kind.Interface } + .filter { it.kind == NodeKind.Interface } .map { ClassDocumentationNodeAdapter(module, it) } .toTypedArray() override fun interfaces(): Array<out ClassDoc> = classNode.lookupSuperClasses(module) - .filter { it.kind == DocumentationNode.Kind.Interface } + .filter { it.kind == NodeKind.Interface } .map { ClassDocumentationNodeAdapter(module, it) } .toTypedArray() - override fun typeParamTags(): Array<out ParamTag> = (classNode.details(DocumentationNode.Kind.TypeParameter).filter { it.content.summary !is ContentEmpty || it.content.description !is ContentEmpty || it.content.sections.isNotEmpty() }.map { + override fun typeParamTags(): Array<out ParamTag> = (classNode.details(NodeKind.TypeParameter).filter { it.content.summary !is ContentEmpty || it.content.description !is ContentEmpty || it.content.sections.isNotEmpty() }.map { ParamTagAdapter(module, this, it.name, true, it.content.children) } + classNode.content.sections.filter { it.subjectName in typeParameters().map { it.simpleTypeName() } }.map { ParamTagAdapter(module, this, it.subjectName ?: "?", true, it.children) }).toTypedArray() override fun fields(): Array<out FieldDoc> = fields(true) - override fun fields(filter: Boolean): Array<out FieldDoc> = classNode.members(DocumentationNode.Kind.Field).map { FieldAdapter(module, it) }.toTypedArray() + override fun fields(filter: Boolean): Array<out FieldDoc> = classNode.members(NodeKind.Field).map { FieldAdapter(module, it) }.toTypedArray() override fun findClass(className: String?): ClassDoc? = null // TODO !!! override fun serializableFields(): Array<out FieldDoc> = emptyArray() - override fun superclassType(): Type? = classNode.lookupSuperClasses(module).singleOrNull { it.kind == DocumentationNode.Kind.Class }?.let { ClassDocumentationNodeAdapter(module, it) } + override fun superclassType(): Type? = classNode.lookupSuperClasses(module).singleOrNull { it.kind == NodeKind.Class }?.let { ClassDocumentationNodeAdapter(module, it) } override fun serializationMethods(): Array<out MethodDoc> = emptyArray() // TODO - override fun superclass(): ClassDoc? = classNode.lookupSuperClasses(module).singleOrNull { it.kind == DocumentationNode.Kind.Class }?.let { ClassDocumentationNodeAdapter(module, it) } + override fun superclass(): ClassDoc? = classNode.lookupSuperClasses(module).singleOrNull { it.kind == NodeKind.Class }?.let { ClassDocumentationNodeAdapter(module, it) } override fun isSerializable(): Boolean = false // TODO override fun subclassOf(cd: ClassDoc?): Boolean { if (cd == null) { @@ -445,18 +445,18 @@ open class ClassDocumentationNodeAdapter(module: ModuleNodeAdapter, val classNod } visitedTypes.add(fqName) - types.addAll(type.details(DocumentationNode.Kind.Supertype).filter { it.qualifiedName() !in visitedTypes }) + types.addAll(type.details(NodeKind.Supertype).filter { it.qualifiedName() !in visitedTypes }) } return false } - override fun innerClasses(): Array<out ClassDoc> = classNode.members(DocumentationNode.Kind.Class).map { ClassDocumentationNodeAdapter(module, it) }.toTypedArray() + override fun innerClasses(): Array<out ClassDoc> = classNode.members(NodeKind.Class).map { ClassDocumentationNodeAdapter(module, it) }.toTypedArray() override fun innerClasses(filter: Boolean): Array<out ClassDoc> = innerClasses() } fun DocumentationNode.lookupSuperClasses(module: ModuleNodeAdapter) = - details(DocumentationNode.Kind.Supertype) + details(NodeKind.Supertype) .map { it.links.firstOrNull() } .map { module.allTypes[it?.qualifiedName()] } .filterNotNull() @@ -465,7 +465,7 @@ fun List<DocumentationNode>.collectAllTypesRecursively(): Map<String, Documentat val result = hashMapOf<String, DocumentationNode>() fun DocumentationNode.collectTypesRecursively() { - val classLikeMembers = DocumentationNode.Kind.classLike.flatMap { members(it) } + val classLikeMembers = NodeKind.classLike.flatMap { members(it) } classLikeMembers.forEach { result.put(it.qualifiedName(), it) it.collectTypesRecursively() @@ -477,8 +477,8 @@ fun List<DocumentationNode>.collectAllTypesRecursively(): Map<String, Documentat } class ModuleNodeAdapter(val module: DocumentationModule, val reporter: DocErrorReporter, val outputPath: String) : DocumentationNodeBareAdapter(module), DocErrorReporter by reporter, RootDoc { - val allPackages = module.members(DocumentationNode.Kind.Package).toMapBy { it.name } - val allTypes = module.members(DocumentationNode.Kind.Package).collectAllTypesRecursively() + val allPackages = module.members(NodeKind.Package).toMapBy { it.name } + val allTypes = module.members(NodeKind.Package).collectAllTypesRecursively() override fun packageNamed(name: String?): PackageDoc? = allPackages[name]?.let { PackageAdapter(this, it) } @@ -492,7 +492,7 @@ class ModuleNodeAdapter(val module: DocumentationModule, val reporter: DocErrorR arrayOf("-keywords") ) - override fun specifiedPackages(): Array<out PackageDoc>? = module.members(DocumentationNode.Kind.Package).map { PackageAdapter(this, it) }.toTypedArray() + 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) } diff --git a/core/src/main/kotlin/javadoc/source-position.kt b/core/src/main/kotlin/javadoc/source-position.kt index 0e4c6e3c..6125f968 100644 --- a/core/src/main/kotlin/javadoc/source-position.kt +++ b/core/src/main/kotlin/javadoc/source-position.kt @@ -2,12 +2,13 @@ package org.jetbrains.dokka.javadoc import com.sun.javadoc.SourcePosition import org.jetbrains.dokka.DocumentationNode +import org.jetbrains.dokka.NodeKind import java.io.File class SourcePositionAdapter(val docNode: DocumentationNode) : SourcePosition { private val sourcePositionParts: List<String> by lazy { - docNode.details(DocumentationNode.Kind.SourcePosition).firstOrNull()?.name?.split(":") ?: emptyList() + docNode.details(NodeKind.SourcePosition).firstOrNull()?.name?.split(":") ?: emptyList() } override fun file(): File? = if (sourcePositionParts.isEmpty()) null else File(sourcePositionParts[0]) diff --git a/core/src/main/kotlin/javadoc/tags.kt b/core/src/main/kotlin/javadoc/tags.kt index 5872dbaa..aab5ecf1 100644 --- a/core/src/main/kotlin/javadoc/tags.kt +++ b/core/src/main/kotlin/javadoc/tags.kt @@ -176,9 +176,9 @@ private fun buildInlineTags(module: ModuleNodeAdapter, holder: Doc, node: Conten is ContentNodeLink -> { val target = node.node when (target?.kind) { - DocumentationNode.Kind.Function -> result.add(SeeMethodTagAdapter(holder, MethodAdapter(module, node.node!!), node)) + NodeKind.Function -> result.add(SeeMethodTagAdapter(holder, MethodAdapter(module, node.node!!), node)) - in DocumentationNode.Kind.classLike -> result.add(SeeClassTagAdapter(holder, ClassDocumentationNodeAdapter(module, node.node!!), node)) + in NodeKind.classLike -> result.add(SeeClassTagAdapter(holder, ClassDocumentationNodeAdapter(module, node.node!!), node)) else -> buildInlineTags(module, holder, node.children, result) } diff --git a/core/src/test/kotlin/model/ClassTest.kt b/core/src/test/kotlin/model/ClassTest.kt index 981791c4..0a824f1c 100644 --- a/core/src/test/kotlin/model/ClassTest.kt +++ b/core/src/test/kotlin/model/ClassTest.kt @@ -1,8 +1,8 @@ package org.jetbrains.dokka.tests import org.jetbrains.dokka.Content -import org.jetbrains.dokka.DocumentationNode -import org.jetbrains.dokka.DocumentationReference +import org.jetbrains.dokka.NodeKind +import org.jetbrains.dokka.RefKind import org.junit.Test import kotlin.test.assertEquals import kotlin.test.assertTrue @@ -11,7 +11,7 @@ public class ClassTest { @Test fun emptyClass() { verifyModel("testdata/classes/emptyClass.kt") { model -> with(model.members.single().members.single()) { - assertEquals(DocumentationNode.Kind.Class, kind) + assertEquals(NodeKind.Class, kind) assertEquals("Klass", name) assertEquals(Content.Empty, content) assertEquals("<init>", members.single().name) @@ -23,7 +23,7 @@ public class ClassTest { @Test fun emptyObject() { verifyModel("testdata/classes/emptyObject.kt") { model -> with(model.members.single().members.single()) { - assertEquals(DocumentationNode.Kind.Object, kind) + assertEquals(NodeKind.Object, kind) assertEquals("Obj", name) assertEquals(Content.Empty, content) assertTrue(members.none()) @@ -35,7 +35,7 @@ public class ClassTest { @Test fun classWithConstructor() { verifyModel("testdata/classes/classWithConstructor.kt") { model -> with (model.members.single().members.single()) { - assertEquals(DocumentationNode.Kind.Class, kind) + assertEquals(NodeKind.Class, kind) assertEquals("Klass", name) assertEquals(Content.Empty, content) assertTrue(links.none()) @@ -44,12 +44,12 @@ public class ClassTest { with(members.elementAt(0)) { assertEquals("<init>", name) assertEquals(Content.Empty, content) - assertEquals(DocumentationNode.Kind.Constructor, kind) + assertEquals(NodeKind.Constructor, kind) assertEquals(2, details.count()) assertEquals("public", details.elementAt(0).name) with(details.elementAt(1)) { assertEquals("name", name) - assertEquals(DocumentationNode.Kind.Parameter, kind) + assertEquals(NodeKind.Parameter, kind) assertEquals(Content.Empty, content) assertEquals("String", details.single().name) assertTrue(links.none()) @@ -65,7 +65,7 @@ public class ClassTest { @Test fun classWithFunction() { verifyModel("testdata/classes/classWithFunction.kt") { model -> with(model.members.single().members.single()) { - assertEquals(DocumentationNode.Kind.Class, kind) + assertEquals(NodeKind.Class, kind) assertEquals("Klass", name) assertEquals(Content.Empty, content) assertTrue(links.none()) @@ -74,7 +74,7 @@ public class ClassTest { with(members.elementAt(0)) { assertEquals("<init>", name) assertEquals(Content.Empty, content) - assertEquals(DocumentationNode.Kind.Constructor, kind) + assertEquals(NodeKind.Constructor, kind) assertEquals(1, details.count()) assertEquals("public", details.elementAt(0).name) assertTrue(links.none()) @@ -83,8 +83,8 @@ public class ClassTest { with(members.elementAt(1)) { assertEquals("fn", name) assertEquals(Content.Empty, content) - assertEquals(DocumentationNode.Kind.Function, kind) - assertEquals("Unit", detail(DocumentationNode.Kind.Type).name) + assertEquals(NodeKind.Function, kind) + assertEquals("Unit", detail(NodeKind.Type).name) assertTrue(links.none()) assertTrue(members.none()) } @@ -95,7 +95,7 @@ public class ClassTest { @Test fun classWithProperty() { verifyModel("testdata/classes/classWithProperty.kt") { model -> with(model.members.single().members.single()) { - assertEquals(DocumentationNode.Kind.Class, kind) + assertEquals(NodeKind.Class, kind) assertEquals("Klass", name) assertEquals(Content.Empty, content) assertTrue(links.none()) @@ -104,7 +104,7 @@ public class ClassTest { with(members.elementAt(0)) { assertEquals("<init>", name) assertEquals(Content.Empty, content) - assertEquals(DocumentationNode.Kind.Constructor, kind) + assertEquals(NodeKind.Constructor, kind) assertEquals(1, details.count()) assertEquals("public", details.elementAt(0).name) assertTrue(members.none()) @@ -113,8 +113,8 @@ public class ClassTest { with(members.elementAt(1)) { assertEquals("name", name) assertEquals(Content.Empty, content) - assertEquals(DocumentationNode.Kind.Property, kind) - assertEquals("String", detail(DocumentationNode.Kind.Type).name) + assertEquals(NodeKind.Property, kind) + assertEquals("String", detail(NodeKind.Type).name) assertTrue(members.none()) assertTrue(links.none()) } @@ -125,7 +125,7 @@ public class ClassTest { @Test fun classWithCompanionObject() { verifyModel("testdata/classes/classWithCompanionObject.kt") { model -> with(model.members.single().members.single()) { - assertEquals(DocumentationNode.Kind.Class, kind) + assertEquals(NodeKind.Class, kind) assertEquals("Klass", name) assertEquals(Content.Empty, content) assertTrue(links.none()) @@ -137,13 +137,13 @@ public class ClassTest { } with(members.elementAt(1)) { assertEquals("x", name) - assertEquals(DocumentationNode.Kind.CompanionObjectProperty, kind) + assertEquals(NodeKind.CompanionObjectProperty, kind) assertTrue(members.none()) assertTrue(links.none()) } with(members.elementAt(2)) { assertEquals("foo", name) - assertEquals(DocumentationNode.Kind.CompanionObjectFunction, kind) + assertEquals(NodeKind.CompanionObjectFunction, kind) assertTrue(members.none()) assertTrue(links.none()) } @@ -157,21 +157,21 @@ public class ClassTest { with(cls.annotations[0]) { assertEquals("Strictfp", name) assertEquals(Content.Empty, content) - assertEquals(DocumentationNode.Kind.Annotation, kind) + assertEquals(NodeKind.Annotation, kind) } } } @Test fun dataClass() { verifyPackageMember("testdata/classes/dataClass.kt") { cls -> - val modifiers = cls.details(DocumentationNode.Kind.Modifier).map { it.name } + val modifiers = cls.details(NodeKind.Modifier).map { it.name } assertTrue("data" in modifiers) } } @Test fun sealedClass() { verifyPackageMember("testdata/classes/sealedClass.kt") { cls -> - val modifiers = cls.details(DocumentationNode.Kind.Modifier).map { it.name } + val modifiers = cls.details(NodeKind.Modifier).map { it.name } assertEquals(1, modifiers.count { it == "sealed" }) } } @@ -182,13 +182,13 @@ public class ClassTest { with(deprecation!!) { assertEquals("Deprecated", name) assertEquals(Content.Empty, content) - assertEquals(DocumentationNode.Kind.Annotation, kind) + assertEquals(NodeKind.Annotation, kind) assertEquals(1, details.count()) with(details[0]) { - assertEquals(DocumentationNode.Kind.Parameter, kind) + assertEquals(NodeKind.Parameter, kind) assertEquals(1, details.count()) with(details[0]) { - assertEquals(DocumentationNode.Kind.Value, kind) + assertEquals(NodeKind.Value, kind) assertEquals("\"should no longer be used\"", name) } } @@ -204,12 +204,12 @@ public class ClassTest { with(annotations[0]) { assertEquals("Retention", name) assertEquals(Content.Empty, content) - assertEquals(DocumentationNode.Kind.Annotation, kind) + assertEquals(NodeKind.Annotation, kind) with(details[0]) { - assertEquals(DocumentationNode.Kind.Parameter, kind) + assertEquals(NodeKind.Parameter, kind) assertEquals(1, details.count()) with(details[0]) { - assertEquals(DocumentationNode.Kind.Value, kind) + assertEquals(NodeKind.Value, kind) assertEquals("RetentionPolicy.SOURCE", name) } } @@ -221,11 +221,11 @@ public class ClassTest { @Test fun notOpenClass() { verifyModel("testdata/classes/notOpenClass.kt") { model -> with(model.members.single().members.first { it.name == "D"}.members.first { it.name == "f" }) { - val modifiers = details(DocumentationNode.Kind.Modifier) + val modifiers = details(NodeKind.Modifier) assertEquals(2, modifiers.size) assertEquals("final", modifiers[1].name) - val overrideReferences = references(DocumentationReference.Kind.Override) + val overrideReferences = references(RefKind.Override) assertEquals(1, overrideReferences.size) } } @@ -234,11 +234,11 @@ public class ClassTest { @Test fun indirectOverride() { verifyModel("testdata/classes/indirectOverride.kt") { model -> with(model.members.single().members.first { it.name == "E"}.members.first { it.name == "foo" }) { - val modifiers = details(DocumentationNode.Kind.Modifier) + val modifiers = details(NodeKind.Modifier) assertEquals(2, modifiers.size) assertEquals("final", modifiers[1].name) - val overrideReferences = references(DocumentationReference.Kind.Override) + val overrideReferences = references(RefKind.Override) assertEquals(1, overrideReferences.size) } } @@ -247,7 +247,7 @@ public class ClassTest { @Test fun innerClass() { verifyPackageMember("testdata/classes/innerClass.kt") { cls -> val innerClass = cls.members.single { it.name == "D" } - val modifiers = innerClass.details(DocumentationNode.Kind.Modifier) + val modifiers = innerClass.details(NodeKind.Modifier) assertEquals(3, modifiers.size) assertEquals("inner", modifiers[2].name) } @@ -257,16 +257,16 @@ public class ClassTest { verifyModel("testdata/classes/companionObjectExtension.kt") { model -> val pkg = model.members.single() val cls = pkg.members.single { it.name == "Foo" } - val extensions = cls.extensions.filter { it.kind == DocumentationNode.Kind.CompanionObjectProperty } + val extensions = cls.extensions.filter { it.kind == NodeKind.CompanionObjectProperty } assertEquals(1, extensions.size) } } @Test fun secondaryConstructor() { verifyPackageMember("testdata/classes/secondaryConstructor.kt") { cls -> - val constructors = cls.members(DocumentationNode.Kind.Constructor) + val constructors = cls.members(NodeKind.Constructor) assertEquals(2, constructors.size) - with (constructors.first { it.details(DocumentationNode.Kind.Parameter).size == 1}) { + with (constructors.first { it.details(NodeKind.Parameter).size == 1}) { assertEquals("<init>", name) assertEquals("This is a secondary constructor.", summary.toTestString()) } diff --git a/core/src/test/kotlin/model/FunctionTest.kt b/core/src/test/kotlin/model/FunctionTest.kt index 83fd8223..0a65b640 100644 --- a/core/src/test/kotlin/model/FunctionTest.kt +++ b/core/src/test/kotlin/model/FunctionTest.kt @@ -1,7 +1,7 @@ package org.jetbrains.dokka.tests import org.jetbrains.dokka.Content -import org.jetbrains.dokka.DocumentationNode +import org.jetbrains.dokka.NodeKind import org.junit.Test import kotlin.test.assertEquals import kotlin.test.assertTrue @@ -11,9 +11,9 @@ public class FunctionTest { verifyModel("testdata/functions/function.kt") { model -> with(model.members.single().members.single()) { assertEquals("fn", name) - assertEquals(DocumentationNode.Kind.Function, kind) + assertEquals(NodeKind.Function, kind) assertEquals("Function fn", content.summary.toTestString()) - assertEquals("Unit", detail(DocumentationNode.Kind.Type).name) + assertEquals("Unit", detail(NodeKind.Type).name) assertTrue(members.none()) assertTrue(links.none()) } @@ -24,17 +24,17 @@ public class FunctionTest { verifyModel("testdata/functions/functionWithReceiver.kt") { model -> with(model.members.single().members.single()) { assertEquals("kotlin.String", name) - assertEquals(DocumentationNode.Kind.ExternalClass, kind) + assertEquals(NodeKind.ExternalClass, kind) assertEquals(2, members.count()) with(members[0]) { assertEquals("fn", name) - assertEquals(DocumentationNode.Kind.Function, kind) + assertEquals(NodeKind.Function, kind) assertEquals("Function with receiver", content.summary.toTestString()) assertEquals("public", details.elementAt(0).name) assertEquals("final", details.elementAt(1).name) with(details.elementAt(2)) { assertEquals("<this>", name) - assertEquals(DocumentationNode.Kind.Receiver, kind) + assertEquals(NodeKind.Receiver, kind) assertEquals(Content.Empty, content) assertEquals("String", details.single().name) assertTrue(members.none()) @@ -46,7 +46,7 @@ public class FunctionTest { } with(members[1]) { assertEquals("fn", name) - assertEquals(DocumentationNode.Kind.Function, kind) + assertEquals(NodeKind.Function, kind) } } } @@ -56,14 +56,14 @@ public class FunctionTest { verifyModel("testdata/functions/genericFunction.kt") { model -> with(model.members.single().members.single()) { assertEquals("generic", name) - assertEquals(DocumentationNode.Kind.Function, kind) + assertEquals(NodeKind.Function, kind) assertEquals("generic function", content.summary.toTestString()) assertEquals("private", details.elementAt(0).name) assertEquals("final", details.elementAt(1).name) with(details.elementAt(2)) { assertEquals("T", name) - assertEquals(DocumentationNode.Kind.TypeParameter, kind) + assertEquals(NodeKind.TypeParameter, kind) assertEquals(Content.Empty, content) assertTrue(details.none()) assertTrue(members.none()) @@ -80,18 +80,18 @@ public class FunctionTest { verifyModel("testdata/functions/genericFunctionWithConstraints.kt") { model -> with(model.members.single().members.single()) { assertEquals("generic", name) - assertEquals(DocumentationNode.Kind.Function, kind) + assertEquals(NodeKind.Function, kind) assertEquals("generic function", content.summary.toTestString()) assertEquals("public", details.elementAt(0).name) assertEquals("final", details.elementAt(1).name) with(details.elementAt(2)) { assertEquals("T", name) - assertEquals(DocumentationNode.Kind.TypeParameter, kind) + assertEquals(NodeKind.TypeParameter, kind) assertEquals(Content.Empty, content) with(details.single()) { assertEquals("R", name) - assertEquals(DocumentationNode.Kind.UpperBound, kind) + assertEquals(NodeKind.UpperBound, kind) assertEquals(Content.Empty, content) assertTrue(details.none()) assertTrue(members.none()) @@ -102,7 +102,7 @@ public class FunctionTest { } with(details.elementAt(3)) { assertEquals("R", name) - assertEquals(DocumentationNode.Kind.TypeParameter, kind) + assertEquals(NodeKind.TypeParameter, kind) assertEquals(Content.Empty, content) assertTrue(members.none()) assertTrue(links.none()) @@ -119,7 +119,7 @@ public class FunctionTest { verifyModel("testdata/functions/functionWithParams.kt") { model -> with(model.members.single().members.single()) { assertEquals("function", name) - assertEquals(DocumentationNode.Kind.Function, kind) + assertEquals(NodeKind.Function, kind) assertEquals("Multiline", content.summary.toTestString()) assertEquals("""Function Documentation""", content.description.toTestString()) @@ -128,7 +128,7 @@ Documentation""", content.description.toTestString()) assertEquals("final", details.elementAt(1).name) with(details.elementAt(2)) { assertEquals("x", name) - assertEquals(DocumentationNode.Kind.Parameter, kind) + assertEquals(NodeKind.Parameter, kind) assertEquals("parameter", content.summary.toTestString()) assertEquals("Int", details.single().name) assertTrue(members.none()) @@ -147,7 +147,7 @@ Documentation""", content.description.toTestString()) with(func.annotations[0]) { assertEquals("Strictfp", name) assertEquals(Content.Empty, content) - assertEquals(DocumentationNode.Kind.Annotation, kind) + assertEquals(NodeKind.Annotation, kind) } } } @@ -160,7 +160,7 @@ Documentation""", content.description.toTestString()) @Test fun inlineFunction() { verifyPackageMember("testdata/functions/inlineFunction.kt") { func -> - val modifiers = func.details(DocumentationNode.Kind.Modifier).map { it.name } + val modifiers = func.details(NodeKind.Modifier).map { it.name } assertTrue("inline" in modifiers) } } @@ -173,7 +173,7 @@ Documentation""", content.description.toTestString()) with(annotations[0]) { assertEquals("Fancy", name) assertEquals(Content.Empty, content) - assertEquals(DocumentationNode.Kind.Annotation, kind) + assertEquals(NodeKind.Annotation, kind) } } } @@ -183,7 +183,7 @@ Documentation""", content.description.toTestString()) @Test fun functionWithNoinlineParam() { verifyPackageMember("testdata/functions/functionWithNoinlineParam.kt") { func -> with(func.details.elementAt(2)) { - val modifiers = details(DocumentationNode.Kind.Modifier).map { it.name } + val modifiers = details(NodeKind.Modifier).map { it.name } assertTrue("noinline" in modifiers) } } @@ -196,13 +196,13 @@ Documentation""", content.description.toTestString()) with(annotations[0]) { assertEquals("Fancy", name) assertEquals(Content.Empty, content) - assertEquals(DocumentationNode.Kind.Annotation, kind) + assertEquals(NodeKind.Annotation, kind) assertEquals(1, details.count()) with(details[0]) { - assertEquals(DocumentationNode.Kind.Parameter, kind) + assertEquals(NodeKind.Parameter, kind) assertEquals(1, details.count()) with(details[0]) { - assertEquals(DocumentationNode.Kind.Value, kind) + assertEquals(NodeKind.Value, kind) assertEquals("1", name) } } @@ -215,7 +215,7 @@ Documentation""", content.description.toTestString()) verifyModel("testdata/functions/functionWithDefaultParameter.kt") { model -> with(model.members.single().members.single()) { with(details.elementAt(2)) { - val value = details(DocumentationNode.Kind.Value) + val value = details(NodeKind.Value) assertEquals(1, value.count()) with(value[0]) { assertEquals("\"\"", name) diff --git a/core/src/test/kotlin/model/JavaTest.kt b/core/src/test/kotlin/model/JavaTest.kt index 903260d3..3d6f2e75 100644 --- a/core/src/test/kotlin/model/JavaTest.kt +++ b/core/src/test/kotlin/model/JavaTest.kt @@ -1,7 +1,7 @@ package org.jetbrains.dokka.tests -import org.jetbrains.dokka.DocumentationNode -import org.jetbrains.dokka.DocumentationReference +import org.jetbrains.dokka.NodeKind +import org.jetbrains.dokka.RefKind import org.junit.Test import kotlin.test.assertEquals import kotlin.test.assertFalse @@ -11,8 +11,8 @@ public class JavaTest { @Test fun function() { verifyJavaPackageMember("testdata/java/member.java") { cls -> assertEquals("Test", cls.name) - assertEquals(DocumentationNode.Kind.Class, cls.kind) - with(cls.members(DocumentationNode.Kind.Function).single()) { + assertEquals(NodeKind.Class, cls.kind) + with(cls.members(NodeKind.Function).single()) { assertEquals("fn", name) assertEquals("Summary for Function", content.summary.toTestString().trimEnd()) assertEquals(3, content.sections.size) @@ -30,16 +30,16 @@ public class JavaTest { assertEquals("Author", tag) assertEquals("yole", toTestString()) } - assertEquals("Unit", detail(DocumentationNode.Kind.Type).name) + assertEquals("Unit", detail(NodeKind.Type).name) assertTrue(members.none()) assertTrue(links.none()) with(details.first { it.name == "name" }) { - assertEquals(DocumentationNode.Kind.Parameter, kind) - assertEquals("String", detail(DocumentationNode.Kind.Type).name) + assertEquals(NodeKind.Parameter, kind) + assertEquals("String", detail(NodeKind.Type).name) } with(details.first { it.name == "value" }) { - assertEquals(DocumentationNode.Kind.Parameter, kind) - assertEquals("Int", detail(DocumentationNode.Kind.Type).name) + assertEquals(NodeKind.Parameter, kind) + assertEquals("Int", detail(NodeKind.Type).name) } } } @@ -47,7 +47,7 @@ public class JavaTest { @Test fun memberWithModifiers() { verifyJavaPackageMember("testdata/java/memberWithModifiers.java") { cls -> - val modifiers = cls.details(DocumentationNode.Kind.Modifier).map { it.name } + val modifiers = cls.details(NodeKind.Modifier).map { it.name } assertTrue("abstract" in modifiers) with(cls.members.single { it.name == "fn" }) { assertEquals("protected", details[0].name) @@ -60,7 +60,7 @@ public class JavaTest { @Test fun superClass() { verifyJavaPackageMember("testdata/java/superClass.java") { cls -> - val superTypes = cls.details(DocumentationNode.Kind.Supertype) + val superTypes = cls.details(NodeKind.Supertype) assertEquals(2, superTypes.size) assertEquals("Exception", superTypes[0].name) assertEquals("Cloneable", superTypes[1].name) @@ -69,12 +69,12 @@ public class JavaTest { @Test fun arrayType() { verifyJavaPackageMember("testdata/java/arrayType.java") { cls -> - with(cls.members(DocumentationNode.Kind.Function).single()) { - val type = detail(DocumentationNode.Kind.Type) + with(cls.members(NodeKind.Function).single()) { + val type = detail(NodeKind.Type) assertEquals("Array", type.name) - assertEquals("String", type.detail(DocumentationNode.Kind.Type).name) - with(details(DocumentationNode.Kind.Parameter).single()) { - val parameterType = detail(DocumentationNode.Kind.Type) + assertEquals("String", type.detail(NodeKind.Type).name) + with(details(NodeKind.Parameter).single()) { + val parameterType = detail(NodeKind.Type) assertEquals("IntArray", parameterType.name) } } @@ -83,16 +83,16 @@ public class JavaTest { @Test fun typeParameter() { verifyJavaPackageMember("testdata/java/typeParameter.java") { cls -> - val typeParameters = cls.details(DocumentationNode.Kind.TypeParameter) + val typeParameters = cls.details(NodeKind.TypeParameter) with(typeParameters.single()) { assertEquals("T", name) - with(detail(DocumentationNode.Kind.UpperBound)) { + with(detail(NodeKind.UpperBound)) { assertEquals("Comparable", name) - assertEquals("T", detail(DocumentationNode.Kind.Type).name) + assertEquals("T", detail(NodeKind.Type).name) } } - with(cls.members(DocumentationNode.Kind.Function).single()) { - val methodTypeParameters = details(DocumentationNode.Kind.TypeParameter) + with(cls.members(NodeKind.Function).single()) { + val methodTypeParameters = details(NodeKind.TypeParameter) with(methodTypeParameters.single()) { assertEquals("E", name) } @@ -102,7 +102,7 @@ public class JavaTest { @Test fun constructors() { verifyJavaPackageMember("testdata/java/constructors.java") { cls -> - val constructors = cls.members(DocumentationNode.Kind.Constructor) + val constructors = cls.members(NodeKind.Constructor) assertEquals(2, constructors.size) with(constructors[0]) { assertEquals("<init>", name) @@ -112,39 +112,39 @@ public class JavaTest { @Test fun innerClass() { verifyJavaPackageMember("testdata/java/innerClass.java") { cls -> - val innerClass = cls.members(DocumentationNode.Kind.Class).single() + val innerClass = cls.members(NodeKind.Class).single() assertEquals("D", innerClass.name) } } @Test fun varargs() { verifyJavaPackageMember("testdata/java/varargs.java") { cls -> - val fn = cls.members(DocumentationNode.Kind.Function).single() - val param = fn.detail(DocumentationNode.Kind.Parameter) - assertEquals("vararg", param.details(DocumentationNode.Kind.Modifier).first().name) - val psiType = param.detail(DocumentationNode.Kind.Type) + val fn = cls.members(NodeKind.Function).single() + val param = fn.detail(NodeKind.Parameter) + assertEquals("vararg", param.details(NodeKind.Modifier).first().name) + val psiType = param.detail(NodeKind.Type) assertEquals("String", psiType.name) - assertTrue(psiType.details(DocumentationNode.Kind.Type).isEmpty()) + assertTrue(psiType.details(NodeKind.Type).isEmpty()) } } @Test fun fields() { verifyJavaPackageMember("testdata/java/field.java") { cls -> - val i = cls.members(DocumentationNode.Kind.Property).single { it.name == "i" } - assertEquals("Int", i.detail(DocumentationNode.Kind.Type).name) - assertTrue("var" in i.details(DocumentationNode.Kind.Modifier).map { it.name }) - - val s = cls.members(DocumentationNode.Kind.Property).single { it.name == "s" } - assertEquals("String", s.detail(DocumentationNode.Kind.Type).name) - assertFalse("var" in s.details(DocumentationNode.Kind.Modifier).map { it.name }) - assertTrue("static" in s.details(DocumentationNode.Kind.Modifier).map { it.name }) + val i = cls.members(NodeKind.Property).single { it.name == "i" } + assertEquals("Int", i.detail(NodeKind.Type).name) + assertTrue("var" in i.details(NodeKind.Modifier).map { it.name }) + + val s = cls.members(NodeKind.Property).single { it.name == "s" } + assertEquals("String", s.detail(NodeKind.Type).name) + assertFalse("var" in s.details(NodeKind.Modifier).map { it.name }) + assertTrue("static" in s.details(NodeKind.Modifier).map { it.name }) } } @Test fun staticMethod() { verifyJavaPackageMember("testdata/java/staticMethod.java") { cls -> - val m = cls.members(DocumentationNode.Kind.Function).single { it.name == "foo" } - assertTrue("static" in m.details(DocumentationNode.Kind.Modifier).map { it.name }) + val m = cls.members(NodeKind.Function).single { it.name == "foo" } + assertTrue("static" in m.details(NodeKind.Modifier).map { it.name }) } } @@ -154,10 +154,10 @@ public class JavaTest { with(cls.annotations[0]) { assertEquals(1, details.count()) with(details[0]) { - assertEquals(DocumentationNode.Kind.Parameter, kind) + assertEquals(NodeKind.Parameter, kind) assertEquals(1, details.count()) with(details[0]) { - assertEquals(DocumentationNode.Kind.Value, kind) + assertEquals(NodeKind.Value, kind) assertEquals("[AnnotationTarget.FIELD, AnnotationTarget.CLASS, AnnotationTarget.FILE, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER]", name) } } @@ -167,30 +167,30 @@ public class JavaTest { @Test fun deprecation() { verifyJavaPackageMember("testdata/java/deprecation.java") { cls -> - val fn = cls.members(DocumentationNode.Kind.Function).single() + val fn = cls.members(NodeKind.Function).single() assertEquals("This should no longer be used", fn.deprecation!!.content.toTestString()) } } @Test fun javaLangObject() { verifyJavaPackageMember("testdata/java/javaLangObject.java") { cls -> - val fn = cls.members(DocumentationNode.Kind.Function).single() - assertEquals("Any", fn.detail(DocumentationNode.Kind.Type).name) + val fn = cls.members(NodeKind.Function).single() + assertEquals("Any", fn.detail(NodeKind.Type).name) } } @Test fun enumValues() { verifyJavaPackageMember("testdata/java/enumValues.java") { cls -> - val superTypes = cls.details(DocumentationNode.Kind.Supertype) + val superTypes = cls.details(NodeKind.Supertype) assertEquals(0, superTypes.size) - assertEquals(1, cls.members(DocumentationNode.Kind.EnumItem).size) + assertEquals(1, cls.members(NodeKind.EnumItem).size) } } @Test fun inheritorLinks() { verifyJavaPackageMember("testdata/java/inheritorLinks.java") { cls -> val fooClass = cls.members.single { it.name == "Foo" } - val inheritors = fooClass.references(DocumentationReference.Kind.Inheritor) + val inheritors = fooClass.references(RefKind.Inheritor) assertEquals(1, inheritors.size) } } diff --git a/core/src/test/kotlin/model/KotlinAsJavaTest.kt b/core/src/test/kotlin/model/KotlinAsJavaTest.kt index b439d399..fab307f3 100644 --- a/core/src/test/kotlin/model/KotlinAsJavaTest.kt +++ b/core/src/test/kotlin/model/KotlinAsJavaTest.kt @@ -1,7 +1,7 @@ package org.jetbrains.dokka.tests import org.jetbrains.dokka.DocumentationModule -import org.jetbrains.dokka.DocumentationNode +import org.jetbrains.dokka.NodeKind import org.junit.Test import kotlin.test.assertEquals @@ -11,11 +11,11 @@ class KotlinAsJavaTest { val pkg = model.members.single() val facadeClass = pkg.members.single { it.name == "FunctionKt" } - assertEquals(DocumentationNode.Kind.Class, facadeClass.kind) + assertEquals(NodeKind.Class, facadeClass.kind) val fn = facadeClass.members.single() assertEquals("fn", fn.name) - assertEquals(DocumentationNode.Kind.Function, fn.kind) + assertEquals(NodeKind.Function, fn.kind) } } @@ -23,7 +23,7 @@ class KotlinAsJavaTest { verifyModelAsJava("testdata/comments/oneLineDoc.kt") { model -> val facadeClass = model.members.single().members.single { it.name == "OneLineDocKt" } val getter = facadeClass.members.single { it.name == "getProperty" } - assertEquals(DocumentationNode.Kind.Function, getter.kind) + assertEquals(NodeKind.Function, getter.kind) assertEquals("doc", getter.content.summary.toTestString()) } } diff --git a/core/src/test/kotlin/model/LinkTest.kt b/core/src/test/kotlin/model/LinkTest.kt index c30e1c10..3db1b90f 100644 --- a/core/src/test/kotlin/model/LinkTest.kt +++ b/core/src/test/kotlin/model/LinkTest.kt @@ -9,7 +9,7 @@ public class LinkTest { verifyModel("testdata/links/linkToSelf.kt") { model -> with(model.members.single().members.single()) { assertEquals("Foo", name) - assertEquals(DocumentationNode.Kind.Class, kind) + assertEquals(NodeKind.Class, kind) assertEquals("This is link to [Foo -> Class:Foo]", content.summary.toTestString()) } } @@ -19,7 +19,7 @@ public class LinkTest { verifyModel("testdata/links/linkToMember.kt") { model -> with(model.members.single().members.single()) { assertEquals("Foo", name) - assertEquals(DocumentationNode.Kind.Class, kind) + assertEquals(NodeKind.Class, kind) assertEquals("This is link to [member -> Function:member]", content.summary.toTestString()) } } @@ -29,7 +29,7 @@ public class LinkTest { verifyModel("testdata/links/linkToQualifiedMember.kt") { model -> with(model.members.single().members.single()) { assertEquals("Foo", name) - assertEquals(DocumentationNode.Kind.Class, kind) + assertEquals(NodeKind.Class, kind) assertEquals("This is link to [Foo.member -> Function:member]", content.summary.toTestString()) } } @@ -39,7 +39,7 @@ public class LinkTest { verifyModel("testdata/links/linkToParam.kt") { model -> with(model.members.single().members.single()) { assertEquals("Foo", name) - assertEquals(DocumentationNode.Kind.Function, kind) + assertEquals(NodeKind.Function, kind) assertEquals("This is link to [param -> Parameter:param]", content.summary.toTestString()) } } diff --git a/core/src/test/kotlin/model/PackageTest.kt b/core/src/test/kotlin/model/PackageTest.kt index aa5a059a..edb5d989 100644 --- a/core/src/test/kotlin/model/PackageTest.kt +++ b/core/src/test/kotlin/model/PackageTest.kt @@ -1,7 +1,7 @@ package org.jetbrains.dokka.tests import org.jetbrains.dokka.Content -import org.jetbrains.dokka.DocumentationNode +import org.jetbrains.dokka.NodeKind import org.jetbrains.kotlin.config.KotlinSourceRoot import org.junit.Test import kotlin.test.assertEquals @@ -11,7 +11,7 @@ public class PackageTest { @Test fun rootPackage() { verifyModel("testdata/packages/rootPackage.kt") { model -> with(model.members.single()) { - assertEquals(DocumentationNode.Kind.Package, kind) + assertEquals(NodeKind.Package, kind) assertEquals("", name) assertEquals(Content.Empty, content) assertTrue(details.none()) @@ -24,7 +24,7 @@ public class PackageTest { @Test fun simpleNamePackage() { verifyModel("testdata/packages/simpleNamePackage.kt") { model -> with(model.members.single()) { - assertEquals(DocumentationNode.Kind.Package, kind) + assertEquals(NodeKind.Package, kind) assertEquals("simple", name) assertEquals(Content.Empty, content) assertTrue(details.none()) @@ -37,7 +37,7 @@ public class PackageTest { @Test fun dottedNamePackage() { verifyModel("testdata/packages/dottedNamePackage.kt") { model -> with(model.members.single()) { - assertEquals(DocumentationNode.Kind.Package, kind) + assertEquals(NodeKind.Package, kind) assertEquals("dot.name", name) assertEquals(Content.Empty, content) assertTrue(details.none()) @@ -52,7 +52,7 @@ public class PackageTest { KotlinSourceRoot("testdata/packages/simpleNamePackage.kt")) { model -> assertEquals(2, model.members.count()) with(model.members.single { it.name == "simple" }) { - assertEquals(DocumentationNode.Kind.Package, kind) + assertEquals(NodeKind.Package, kind) assertEquals("simple", name) assertEquals(Content.Empty, content) assertTrue(details.none()) @@ -60,7 +60,7 @@ public class PackageTest { assertTrue(links.none()) } with(model.members.single { it.name == "dot.name" }) { - assertEquals(DocumentationNode.Kind.Package, kind) + assertEquals(NodeKind.Package, kind) assertEquals(Content.Empty, content) assertTrue(details.none()) assertTrue(members.none()) @@ -74,7 +74,7 @@ public class PackageTest { KotlinSourceRoot("testdata/packages/simpleNamePackage2.kt")) { model -> assertEquals(1, model.members.count()) with(model.members.elementAt(0)) { - assertEquals(DocumentationNode.Kind.Package, kind) + assertEquals(NodeKind.Package, kind) assertEquals("simple", name) assertEquals(Content.Empty, content) assertTrue(details.none()) diff --git a/core/src/test/kotlin/model/PropertyTest.kt b/core/src/test/kotlin/model/PropertyTest.kt index 716aac54..a049979d 100644 --- a/core/src/test/kotlin/model/PropertyTest.kt +++ b/core/src/test/kotlin/model/PropertyTest.kt @@ -1,8 +1,8 @@ package org.jetbrains.dokka.tests import org.jetbrains.dokka.Content -import org.jetbrains.dokka.DocumentationNode -import org.jetbrains.dokka.DocumentationReference +import org.jetbrains.dokka.NodeKind +import org.jetbrains.dokka.RefKind import org.junit.Test import kotlin.test.assertEquals import kotlin.test.assertTrue @@ -12,9 +12,9 @@ public class PropertyTest { verifyModel("testdata/properties/valueProperty.kt") { model -> with(model.members.single().members.single()) { assertEquals("property", name) - assertEquals(DocumentationNode.Kind.Property, kind) + assertEquals(NodeKind.Property, kind) assertEquals(Content.Empty, content) - assertEquals("String", detail(DocumentationNode.Kind.Type).name) + assertEquals("String", detail(NodeKind.Type).name) assertTrue(members.none()) assertTrue(links.none()) } @@ -25,9 +25,9 @@ public class PropertyTest { verifyModel("testdata/properties/variableProperty.kt") { model -> with(model.members.single().members.single()) { assertEquals("property", name) - assertEquals(DocumentationNode.Kind.Property, kind) + assertEquals(NodeKind.Property, kind) assertEquals(Content.Empty, content) - assertEquals("String", detail(DocumentationNode.Kind.Type).name) + assertEquals("String", detail(NodeKind.Type).name) assertTrue(members.none()) assertTrue(links.none()) } @@ -38,9 +38,9 @@ public class PropertyTest { verifyModel("testdata/properties/valuePropertyWithGetter.kt") { model -> with(model.members.single().members.single()) { assertEquals("property", name) - assertEquals(DocumentationNode.Kind.Property, kind) + assertEquals(NodeKind.Property, kind) assertEquals(Content.Empty, content) - assertEquals("String", detail(DocumentationNode.Kind.Type).name) + assertEquals("String", detail(NodeKind.Type).name) assertTrue(links.none()) assertTrue(members.none()) } @@ -51,10 +51,10 @@ public class PropertyTest { verifyModel("testdata/properties/variablePropertyWithAccessors.kt") { model -> with(model.members.single().members.single()) { assertEquals("property", name) - assertEquals(DocumentationNode.Kind.Property, kind) + assertEquals(NodeKind.Property, kind) assertEquals(Content.Empty, content) - assertEquals("String", detail(DocumentationNode.Kind.Type).name) - val modifiers = details(DocumentationNode.Kind.Modifier).map { it.name } + assertEquals("String", detail(NodeKind.Type).name) + val modifiers = details(NodeKind.Modifier).map { it.name } assertTrue("final" in modifiers) assertTrue("public" in modifiers) assertTrue("var" in modifiers) @@ -71,7 +71,7 @@ public class PropertyTest { with(annotations[0]) { assertEquals("Volatile", name) assertEquals(Content.Empty, content) - assertEquals(DocumentationNode.Kind.Annotation, kind) + assertEquals(NodeKind.Annotation, kind) } } } @@ -81,10 +81,10 @@ public class PropertyTest { verifyModel("testdata/properties/propertyWithReceiver.kt") { model -> with(model.members.single().members.single()) { assertEquals("kotlin.String", name) - assertEquals(DocumentationNode.Kind.ExternalClass, kind) + assertEquals(NodeKind.ExternalClass, kind) with(members.single()) { assertEquals("foobar", name) - assertEquals(DocumentationNode.Kind.Property, kind) + assertEquals(NodeKind.Property, kind) } } } @@ -94,7 +94,7 @@ public class PropertyTest { verifyModel("testdata/properties/propertyOverride.kt") { model -> with(model.members.single().members.single { it.name == "Bar" }.members.single { it.name == "xyzzy"}) { assertEquals("xyzzy", name) - val override = references(DocumentationReference.Kind.Override).single().to + val override = references(RefKind.Override).single().to assertEquals("xyzzy", override.name) assertEquals("Foo", override.owner!!.name) } |