diff options
20 files changed, 236 insertions, 169 deletions
diff --git a/core/src/main/kotlin/model/Documentable.kt b/core/src/main/kotlin/model/Documentable.kt index b808e09c..a7dd0919 100644 --- a/core/src/main/kotlin/model/Documentable.kt +++ b/core/src/main/kotlin/model/Documentable.kt @@ -367,23 +367,6 @@ enum class FunctionModifiers { NONE, FUNCTION, EXTENSION } -enum class ExtraModifiers { - STATIC, INLINE, INFIX, SUSPEND, REIFIED, CROSSINLINE, NOINLINE, - OVERRIDE, DATA, CONST, EXTERNAL, INNER, LATEINIT, OPERATOR, TAILREC, VARARG, - NATIVE, SYNCHRONIZED, STRICTFP, TRANSIENT, VOLATILE, TRANSITIVE; - - companion object { - val kotlinOnlyModifiers = setOf( - INLINE, INFIX, EXTERNAL, SUSPEND, REIFIED, CROSSINLINE, NOINLINE, OVERRIDE, DATA, CONST, INNER, LATEINIT, OPERATOR, - TAILREC, VARARG - ) - - val javaOnlyModifiers = setOf( - STATIC, NATIVE, SYNCHRONIZED, STRICTFP, TRANSIENT, VOLATILE, TRANSITIVE - ) - } -} - private fun String.shorten(maxLength: Int) = lineSequence().first().let { if (it.length != length || it.length > maxLength) it.take(maxLength - 3) + "..." else it } diff --git a/core/src/main/kotlin/model/aditionalExtras.kt b/core/src/main/kotlin/model/aditionalExtras.kt index 05b88f48..2b9d481f 100644 --- a/core/src/main/kotlin/model/aditionalExtras.kt +++ b/core/src/main/kotlin/model/aditionalExtras.kt @@ -39,11 +39,11 @@ class Annotations(val content: List<Annotation>) : ExtraProperty<Documentable> { } sealed class AnnotationParameterValue -class AnnotationValue(val annotation: Annotations.Annotation) : AnnotationParameterValue() -class ArrayValue(val value: List<AnnotationParameterValue>) : AnnotationParameterValue() -class EnumValue(val enumName: String, val enumDri: DRI) : AnnotationParameterValue() -class ClassValue(val className: String, val classDRI: DRI) : AnnotationParameterValue() // TODO Investigate if KtClassValue can be parameter of annotation -class StringValue(val value: String) : AnnotationParameterValue() +data class AnnotationValue(val annotation: Annotations.Annotation) : AnnotationParameterValue() +data class ArrayValue(val value: List<AnnotationParameterValue>) : AnnotationParameterValue() +data class EnumValue(val enumName: String, val enumDri: DRI) : AnnotationParameterValue() +data class ClassValue(val className: String, val classDRI: DRI) : AnnotationParameterValue() +data class StringValue(val value: String) : AnnotationParameterValue() object PrimaryConstructorExtra : ExtraProperty<DFunction>, ExtraProperty.Key<DFunction, PrimaryConstructorExtra> { diff --git a/core/src/main/kotlin/model/extraModifiers.kt b/core/src/main/kotlin/model/extraModifiers.kt new file mode 100644 index 00000000..093ce62a --- /dev/null +++ b/core/src/main/kotlin/model/extraModifiers.kt @@ -0,0 +1,60 @@ +package org.jetbrains.dokka.model + +sealed class ExtraModifiers(val name: String) { + + sealed class KotlinOnlyModifiers(name: String) : ExtraModifiers(name) { + object Inline : KotlinOnlyModifiers("inline") + object Infix : KotlinOnlyModifiers("infix") + object External : KotlinOnlyModifiers("external") + object Suspend : KotlinOnlyModifiers("suspend") + object Reified : KotlinOnlyModifiers("reified") + object CrossInline : KotlinOnlyModifiers("crossinline") + object NoInline : KotlinOnlyModifiers("noinline") + object Override : KotlinOnlyModifiers("override") + object Data : KotlinOnlyModifiers("data") + object Const : KotlinOnlyModifiers("const") + object Inner : KotlinOnlyModifiers("inner") + object LateInit : KotlinOnlyModifiers("lateinit") + object Operator : KotlinOnlyModifiers("operator") + object TailRec : KotlinOnlyModifiers("tailrec") + object VarArg : KotlinOnlyModifiers("vararg") + } + + sealed class JavaOnlyModifiers(name: String) : ExtraModifiers(name) { + object Static : JavaOnlyModifiers("static") + object Native : JavaOnlyModifiers("native") + object Synchronized : JavaOnlyModifiers("synchronized") + object StrictFP : JavaOnlyModifiers("strictfp") + object Transient : JavaOnlyModifiers("transient") + object Volatile : JavaOnlyModifiers("volatile") + object Transitive : JavaOnlyModifiers("transitive") + } + + companion object { + fun valueOf(str: String) = when(str) { + "inline" -> KotlinOnlyModifiers.Inline + "infix" -> KotlinOnlyModifiers.Infix + "external" -> KotlinOnlyModifiers.External + "suspend" -> KotlinOnlyModifiers.Suspend + "reified" -> KotlinOnlyModifiers.Reified + "crossinline" -> KotlinOnlyModifiers.CrossInline + "noinline" -> KotlinOnlyModifiers.NoInline + "override" -> KotlinOnlyModifiers.Override + "data" -> KotlinOnlyModifiers.Data + "const" -> KotlinOnlyModifiers.Const + "inner" -> KotlinOnlyModifiers.Inner + "lateinit" -> KotlinOnlyModifiers.LateInit + "operator" -> KotlinOnlyModifiers.Operator + "tailrec" -> KotlinOnlyModifiers.TailRec + "vararg" -> KotlinOnlyModifiers.VarArg + "static" -> JavaOnlyModifiers.Static + "native" -> JavaOnlyModifiers.Native + "synchronized" -> JavaOnlyModifiers.Synchronized + "strictfp" -> JavaOnlyModifiers.StrictFP + "transient" -> JavaOnlyModifiers.Transient + "volatile" -> JavaOnlyModifiers.Volatile + "transitive" -> JavaOnlyModifiers.Transitive + else -> throw IllegalArgumentException("There is no Extra Modifier for given name $str") + } + } +}
\ No newline at end of file diff --git a/plugins/base/src/main/kotlin/signatures/JvmSingatureUtils.kt b/plugins/base/src/main/kotlin/signatures/JvmSignatureUtils.kt index dde553b9..0ae72109 100644 --- a/plugins/base/src/main/kotlin/signatures/JvmSingatureUtils.kt +++ b/plugins/base/src/main/kotlin/signatures/JvmSignatureUtils.kt @@ -1,11 +1,10 @@ package org.jetbrains.dokka.base.signatures -import javaslang.Tuple2 import org.jetbrains.dokka.base.translators.documentables.PageContentBuilder import org.jetbrains.dokka.model.* import org.jetbrains.dokka.model.properties.WithExtraProperties -interface JvmSingatureUtils { +interface JvmSignatureUtils { fun PageContentBuilder.DocumentableContentBuilder.annotationsBlock(d: Documentable) @@ -20,7 +19,7 @@ interface JvmSingatureUtils { extra[Annotations]?.content ?: emptyList() private fun Annotations.Annotation.toSignatureString(): String = - "@${this.dri.classNames}(${this.params.entries.joinToString { it.key + "=" + it.value }})" + "@" + this.dri.classNames + "(" + this.params.entries.joinToString { it.key + "=" + it.value } + ")" private fun PageContentBuilder.DocumentableContentBuilder.annotations( d: Documentable, @@ -45,15 +44,10 @@ interface JvmSingatureUtils { } } ?: Unit - fun <T : Documentable> WithExtraProperties<T>.modifiersWithFilter( - filter: Set<ExtraModifiers> = ExtraModifiers.values().toSet() - ): Set<ExtraModifiers> = - extra[AdditionalModifiers]?.content?.filter { it in filter }?.toSet() ?: emptySet() - fun PageContentBuilder.DocumentableContentBuilder.toSignatureString( a: Annotations.Annotation, renderAtStrategy: AtStrategy, - listBrackets: Tuple2<Char, Char>, + listBrackets: Pair<Char, Char>, classExtension: String ) { when (renderAtStrategy) { @@ -78,17 +72,17 @@ interface JvmSingatureUtils { private fun PageContentBuilder.DocumentableContentBuilder.valueToSignature( a: AnnotationParameterValue, renderAtStrategy: AtStrategy, - listBrackets: Tuple2<Char, Char>, + listBrackets: Pair<Char, Char>, classExtension: String ): Unit = when (a) { is AnnotationValue -> toSignatureString(a.annotation, renderAtStrategy, listBrackets, classExtension) is ArrayValue -> { - text(listBrackets._1.toString()) + text(listBrackets.first.toString()) a.value.forEachIndexed { i, it -> valueToSignature(it, renderAtStrategy, listBrackets, classExtension) if (i != a.value.size - 1) text(", ") } - text(listBrackets._2.toString()) + text(listBrackets.second.toString()) } is EnumValue -> link(a.enumName, a.enumDri) is ClassValue -> link(a.className + classExtension, a.classDRI) @@ -99,7 +93,7 @@ interface JvmSingatureUtils { d: Documentable, ignored: Set<Annotations.Annotation>, renderAtStrategy: AtStrategy, - listBrackets: Tuple2<Char, Char>, + listBrackets: Pair<Char, Char>, classExtension: String ) { annotations(d, ignored) { @@ -113,7 +107,7 @@ interface JvmSingatureUtils { d: Documentable, ignored: Set<Annotations.Annotation>, renderAtStrategy: AtStrategy, - listBrackets: Tuple2<Char, Char>, + listBrackets: Pair<Char, Char>, classExtension: String ) { annotations(d, ignored) { diff --git a/plugins/base/src/main/kotlin/signatures/KotlinSignatureProvider.kt b/plugins/base/src/main/kotlin/signatures/KotlinSignatureProvider.kt index 4c689abc..33c82458 100644 --- a/plugins/base/src/main/kotlin/signatures/KotlinSignatureProvider.kt +++ b/plugins/base/src/main/kotlin/signatures/KotlinSignatureProvider.kt @@ -6,7 +6,6 @@ import org.jetbrains.dokka.links.* import org.jetbrains.dokka.model.* import org.jetbrains.dokka.model.Nullable import org.jetbrains.dokka.model.TypeConstructor -import org.jetbrains.dokka.model.properties.ExtraProperty import org.jetbrains.dokka.model.properties.WithExtraProperties import org.jetbrains.dokka.pages.ContentKind import org.jetbrains.dokka.pages.ContentNode @@ -15,7 +14,7 @@ import org.jetbrains.dokka.utilities.DokkaLogger import kotlin.text.Typography.nbsp class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLogger) : SignatureProvider, - JvmSingatureUtils by KotlinSignatureUtils { + JvmSignatureUtils by KotlinSignatureUtils { private val contentBuilder = PageContentBuilder(ctcc, this, logger) private val ignoredVisibilities = setOf(JavaVisibility.Public, KotlinVisibility.Public) @@ -69,7 +68,7 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog if (c is DClass) { platformText(c.modifier, sourceSets) { if (it !in ignoredModifiers) - if (c.extra[AdditionalModifiers]?.content?.contains(ExtraModifiers.DATA) == true) "" + if (c.extra[AdditionalModifiers]?.content?.contains(ExtraModifiers.KotlinOnlyModifiers.Data) == true) "" else (if (it is JavaModifier.Empty) KotlinModifier.Open else it).let { it.name + " " } else "" diff --git a/plugins/base/src/main/kotlin/signatures/KotlinSignatureUtils.kt b/plugins/base/src/main/kotlin/signatures/KotlinSignatureUtils.kt index 3ce4be0a..48cfe304 100644 --- a/plugins/base/src/main/kotlin/signatures/KotlinSignatureUtils.kt +++ b/plugins/base/src/main/kotlin/signatures/KotlinSignatureUtils.kt @@ -1,16 +1,15 @@ package org.jetbrains.dokka.base.signatures -import javaslang.Tuple2 import org.jetbrains.dokka.base.translators.documentables.PageContentBuilder +import org.jetbrains.dokka.model.AdditionalModifiers import org.jetbrains.dokka.model.Documentable import org.jetbrains.dokka.model.ExtraModifiers -import org.jetbrains.dokka.model.ExtraModifiers.Companion.kotlinOnlyModifiers import org.jetbrains.dokka.model.properties.WithExtraProperties -object KotlinSignatureUtils : JvmSingatureUtils { +object KotlinSignatureUtils : JvmSignatureUtils { private val strategy = OnlyOnce - private val listBrackets = Tuple2('[', ']') + private val listBrackets = Pair('[', ']') private val classExtension = "::class" override fun PageContentBuilder.DocumentableContentBuilder.annotationsBlock(d: Documentable) = @@ -20,5 +19,5 @@ object KotlinSignatureUtils : JvmSingatureUtils { annotationsInlineWithIgnored(d, emptySet(), strategy, listBrackets, classExtension) override fun <T : Documentable> WithExtraProperties<T>.modifiers() = - modifiersWithFilter(kotlinOnlyModifiers) + extra[AdditionalModifiers]?.content?.filterIsInstance<ExtraModifiers.KotlinOnlyModifiers>()?.toSet() ?: emptySet() }
\ No newline at end of file diff --git a/plugins/base/src/main/kotlin/signatures/SignatureProvider.kt b/plugins/base/src/main/kotlin/signatures/SignatureProvider.kt index 7d7995b7..c04b6ecf 100644 --- a/plugins/base/src/main/kotlin/signatures/SignatureProvider.kt +++ b/plugins/base/src/main/kotlin/signatures/SignatureProvider.kt @@ -1,11 +1,7 @@ package org.jetbrains.dokka.base.signatures -import javaslang.Tuple2 -import org.jetbrains.dokka.base.translators.documentables.PageContentBuilder import org.jetbrains.dokka.model.* -import org.jetbrains.dokka.model.properties.WithExtraProperties import org.jetbrains.dokka.pages.ContentNode -import org.jetbrains.dokka.pages.TextStyle interface SignatureProvider { fun signature(documentable: Documentable): ContentNode diff --git a/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt b/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt index c24a3384..65b83200 100644 --- a/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt +++ b/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt @@ -46,7 +46,7 @@ import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.kotlin.types.TypeProjection import org.jetbrains.kotlin.utils.addToStdlib.safeAs import java.nio.file.Paths -import java.lang.IllegalArgumentException +import kotlin.IllegalArgumentException import kotlin.reflect.jvm.internal.impl.resolve.constants.KClassValue object DefaultDescriptorToDocumentableTranslator : SourceToDocumentableTranslator { @@ -546,9 +546,7 @@ private class DokkaDescriptorVisitor( is TypeParameterDescriptor -> OtherParameter( declarationDRI = DRI.from(ctor.containingDeclaration), name = ctor.name.asString() - ).let { - if (isMarkedNullable) Nullable(it) else it - } + ) else -> TypeConstructor( DRI.from(constructor.declarationDescriptor!!), // TODO: remove '!!' arguments.map { it.toProjection() }, @@ -556,6 +554,8 @@ private class DokkaDescriptorVisitor( else if (isFunctionType) FunctionModifiers.FUNCTION else FunctionModifiers.NONE ) + }.let { + if (isMarkedNullable) Nullable(it) else it } } @@ -593,43 +593,43 @@ private class DokkaDescriptorVisitor( DescriptorDocumentableSource(this).toSourceSetDependent() private fun FunctionDescriptor.additionalExtras() = listOfNotNull( - ExtraModifiers.INFIX.takeIf { isInfix }, - ExtraModifiers.INLINE.takeIf { isInline }, - ExtraModifiers.SUSPEND.takeIf { isSuspend }, - ExtraModifiers.OPERATOR.takeIf { isOperator }, - ExtraModifiers.STATIC.takeIf { isJvmStaticInObjectOrClassOrInterface() }, - ExtraModifiers.TAILREC.takeIf { isTailrec }, - ExtraModifiers.EXTERNAL.takeIf { isExternal }, - ExtraModifiers.OVERRIDE.takeIf { DescriptorUtils.isOverride(this) } + ExtraModifiers.KotlinOnlyModifiers.Infix.takeIf { isInfix }, + ExtraModifiers.KotlinOnlyModifiers.Inline.takeIf { isInline }, + ExtraModifiers.KotlinOnlyModifiers.Suspend.takeIf { isSuspend }, + ExtraModifiers.KotlinOnlyModifiers.Operator.takeIf { isOperator }, + ExtraModifiers.JavaOnlyModifiers.Static.takeIf { isJvmStaticInObjectOrClassOrInterface() }, + ExtraModifiers.KotlinOnlyModifiers.TailRec.takeIf { isTailrec }, + ExtraModifiers.KotlinOnlyModifiers.External.takeIf { isExternal }, + ExtraModifiers.KotlinOnlyModifiers.Override.takeIf { DescriptorUtils.isOverride(this) } ).toProperty() private fun ClassDescriptor.additionalExtras() = listOfNotNull( - ExtraModifiers.INLINE.takeIf { isInline }, - ExtraModifiers.EXTERNAL.takeIf { isExternal }, - ExtraModifiers.INNER.takeIf { isInner }, - ExtraModifiers.DATA.takeIf { isData } + ExtraModifiers.KotlinOnlyModifiers.Inline.takeIf { isInline }, + ExtraModifiers.KotlinOnlyModifiers.External.takeIf { isExternal }, + ExtraModifiers.KotlinOnlyModifiers.Inner.takeIf { isInner }, + ExtraModifiers.KotlinOnlyModifiers.Data.takeIf { isData } ).toProperty() private fun ValueParameterDescriptor.additionalExtras() = listOfNotNull( - ExtraModifiers.NOINLINE.takeIf { isNoinline }, - ExtraModifiers.CROSSINLINE.takeIf { isCrossinline }, - ExtraModifiers.CONST.takeIf { isConst }, - ExtraModifiers.LATEINIT.takeIf { isLateInit }, - ExtraModifiers.VARARG.takeIf { isVararg } + ExtraModifiers.KotlinOnlyModifiers.NoInline.takeIf { isNoinline }, + ExtraModifiers.KotlinOnlyModifiers.CrossInline.takeIf { isCrossinline }, + ExtraModifiers.KotlinOnlyModifiers.Const.takeIf { isConst }, + ExtraModifiers.KotlinOnlyModifiers.LateInit.takeIf { isLateInit }, + ExtraModifiers.KotlinOnlyModifiers.VarArg.takeIf { isVararg } ).toProperty() private fun TypeParameterDescriptor.additionalExtras() = listOfNotNull( - ExtraModifiers.REIFIED.takeIf { isReified } + ExtraModifiers.KotlinOnlyModifiers.Reified.takeIf { isReified } ).toProperty() private fun PropertyDescriptor.additionalExtras() = listOfNotNull( - ExtraModifiers.CONST.takeIf { isConst }, - ExtraModifiers.LATEINIT.takeIf { isLateInit }, - ExtraModifiers.STATIC.takeIf { isJvmStaticInObjectOrClassOrInterface() }, - ExtraModifiers.EXTERNAL.takeIf { isExternal }, - ExtraModifiers.OVERRIDE.takeIf { DescriptorUtils.isOverride(this) } + ExtraModifiers.KotlinOnlyModifiers.Const.takeIf { isConst }, + ExtraModifiers.KotlinOnlyModifiers.LateInit.takeIf { isLateInit }, + ExtraModifiers.JavaOnlyModifiers.Static.takeIf { isJvmStaticInObjectOrClassOrInterface() }, + ExtraModifiers.KotlinOnlyModifiers.External.takeIf { isExternal }, + ExtraModifiers.KotlinOnlyModifiers.Override.takeIf { DescriptorUtils.isOverride(this) } ) private fun List<ExtraModifiers>.toProperty() = @@ -640,11 +640,12 @@ private class DokkaDescriptorVisitor( private fun Annotated.getListOfAnnotations() = annotations.map { it.toAnnotation() } private fun ConstantValue<*>.toValue(): AnnotationParameterValue = when (this) { - is ConstantsAnnotationValue -> AnnotationValue(value.let { it.toAnnotation() }) + is ConstantsAnnotationValue -> AnnotationValue(value.toAnnotation()) is ConstantsArrayValue -> ArrayValue(value.map { it.toValue() }) is ConstantsEnumValue -> EnumValue( - enumEntryName.identifier, - enumClassId.let { DRI(it.packageFqName.asString(), it.relativeClassName.asString()) }) + fullEnumEntryName(), + DRI(enumClassId.packageFqName.asString(), fullEnumEntryName()) + ) is ConstantsKtClassValue -> when(value) { is NormalClass -> (value as NormalClass).value.classId.let { ClassValue( @@ -672,7 +673,7 @@ private class DokkaDescriptorVisitor( private fun FieldDescriptor.getAnnotationsAsExtraModifiers() = getAnnotations().content.mapNotNull { try { - ExtraModifiers.valueOf(it.dri.classNames?.toUpperCase() ?: "") + ExtraModifiers.valueOf(it.dri.classNames?.toLowerCase() ?: "") } catch (e: IllegalArgumentException) { null } @@ -690,4 +691,7 @@ private class DokkaDescriptorVisitor( Visibilities.PRIVATE -> KotlinVisibility.Private else -> KotlinVisibility.Public } + + private fun ConstantsEnumValue.fullEnumEntryName() = + "${this.enumClassId.relativeClassName.asString()}.${this.enumEntryName.identifier}" } diff --git a/plugins/base/src/main/kotlin/translators/documentables/PageContentBuilder.kt b/plugins/base/src/main/kotlin/translators/documentables/PageContentBuilder.kt index 658a86f2..5ff5a954 100644 --- a/plugins/base/src/main/kotlin/translators/documentables/PageContentBuilder.kt +++ b/plugins/base/src/main/kotlin/translators/documentables/PageContentBuilder.kt @@ -338,8 +338,10 @@ open class PageContentBuilder( value: SourceSetDependent<T>, platforms: Set<SourceSetData> = value.keys, transform: (T) -> String - ) = value.entries.filter { it.key in platforms }.forEach { (p, v) -> - transform(v).takeIf { it.isNotBlank() }?.also { text(it, sourceSets = setOf(p)) } + ) = value.entries.filter { it.key in platforms }.mapNotNull { (p, v) -> + transform(v).takeIf { it.isNotBlank() }?.let { it to p } + }.groupBy({ it.first }) { it.second }.forEach { + text(it.key, sourceSets = it.value.toSet()) } } diff --git a/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt b/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt index 0f8fc011..9c731528 100644 --- a/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt +++ b/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt @@ -1,5 +1,6 @@ package org.jetbrains.dokka.base.translators.psi +import com.intellij.icons.AllIcons.Nodes.Static import com.intellij.lang.jvm.annotation.JvmAnnotationAttribute import com.intellij.lang.jvm.JvmModifier import com.intellij.lang.jvm.types.JvmReferenceType @@ -275,18 +276,18 @@ object DefaultPsiToDocumentableTranslator : SourceToDocumentableTranslator { private fun PsiModifierListOwner.additionalExtras() = AdditionalModifiers( listOfNotNull( - ExtraModifiers.STATIC.takeIf { hasModifier(JvmModifier.STATIC) }, - ExtraModifiers.NATIVE.takeIf { hasModifier(JvmModifier.NATIVE) }, - ExtraModifiers.SYNCHRONIZED.takeIf { hasModifier(JvmModifier.SYNCHRONIZED) }, - ExtraModifiers.STRICTFP.takeIf { hasModifier(JvmModifier.STRICTFP) }, - ExtraModifiers.TRANSIENT.takeIf { hasModifier(JvmModifier.TRANSIENT) }, - ExtraModifiers.VOLATILE.takeIf { hasModifier(JvmModifier.VOLATILE) }, - ExtraModifiers.TRANSITIVE.takeIf { hasModifier(JvmModifier.TRANSITIVE) } + ExtraModifiers.JavaOnlyModifiers.Static.takeIf { hasModifier(JvmModifier.STATIC) }, + ExtraModifiers.JavaOnlyModifiers.Native.takeIf { hasModifier(JvmModifier.NATIVE) }, + ExtraModifiers.JavaOnlyModifiers.Synchronized.takeIf { hasModifier(JvmModifier.SYNCHRONIZED) }, + ExtraModifiers.JavaOnlyModifiers.StrictFP.takeIf { hasModifier(JvmModifier.STRICTFP) }, + ExtraModifiers.JavaOnlyModifiers.Transient.takeIf { hasModifier(JvmModifier.TRANSIENT) }, + ExtraModifiers.JavaOnlyModifiers.Volatile.takeIf { hasModifier(JvmModifier.VOLATILE) }, + ExtraModifiers.JavaOnlyModifiers.Transitive.takeIf { hasModifier(JvmModifier.TRANSITIVE) } ).toSet() ) private fun AdditionalModifiers.toListOfAnnotations() = this.content.map { - if (it.name != "STATIC") + if (it !is ExtraModifiers.JavaOnlyModifiers.Static) Annotations.Annotation(DRI("kotlin.jvm", it.name.toLowerCase().capitalize()), emptyMap()) else Annotations.Annotation(DRI("kotlin.jvm", "JvmStatic"), emptyMap()) diff --git a/plugins/base/src/test/kotlin/content/annotations/ContentForAnnotationsTest.kt b/plugins/base/src/test/kotlin/content/annotations/ContentForAnnotationsTest.kt index c4640824..98f572b4 100644 --- a/plugins/base/src/test/kotlin/content/annotations/ContentForAnnotationsTest.kt +++ b/plugins/base/src/test/kotlin/content/annotations/ContentForAnnotationsTest.kt @@ -49,8 +49,9 @@ class ContentForAnnotationsTest : AbstractCoreTest() { val page = module.children.single { it.name == "test" } .children.single { it.name == "function" } as ContentPage page.content.assertNode { - - header(1) { +"function" } + group { + header(1) { +"function" } + } divergentGroup { divergentInstance { divergent { diff --git a/plugins/base/src/test/kotlin/content/signatures/ContentForSignaturesTest.kt b/plugins/base/src/test/kotlin/content/signatures/ContentForSignaturesTest.kt index 3f0edec3..68042fd4 100644 --- a/plugins/base/src/test/kotlin/content/signatures/ContentForSignaturesTest.kt +++ b/plugins/base/src/test/kotlin/content/signatures/ContentForSignaturesTest.kt @@ -40,8 +40,9 @@ class ContentForSignaturesTest : AbstractCoreTest() { val page = module.children.single { it.name == "test" } .children.single { it.name == "function" } as ContentPage page.content.assertNode { - - header(1) { +"function" } + group { + header(1) { +"function" } + } divergentGroup { divergentInstance { divergent { @@ -78,7 +79,9 @@ class ContentForSignaturesTest : AbstractCoreTest() { val page = module.children.single { it.name == "test" } .children.single { it.name == "function" } as ContentPage page.content.assertNode { - header(1) { +"function" } + group { + header(1) { +"function" } + } divergentGroup { divergentInstance { divergent { @@ -115,7 +118,9 @@ class ContentForSignaturesTest : AbstractCoreTest() { val page = module.children.single { it.name == "test" } .children.single { it.name == "function" } as ContentPage page.content.assertNode { - header(1) { +"function" } + group { + header(1) { +"function" } + } divergentGroup { divergentInstance { divergent { @@ -152,8 +157,9 @@ class ContentForSignaturesTest : AbstractCoreTest() { val page = module.children.single { it.name == "test" } .children.single { it.name == "function" } as ContentPage page.content.assertNode { - - header(1) { +"function" } + group { + header(1) { +"function" } + } divergentGroup { divergentInstance { divergent { @@ -190,7 +196,9 @@ class ContentForSignaturesTest : AbstractCoreTest() { val page = module.children.single { it.name == "test" } .children.single { it.name == "function" } as ContentPage page.content.assertNode { - header(1) { +"function" } + group { + header(1) { +"function" } + } divergentGroup { divergentInstance { divergent { @@ -227,7 +235,9 @@ class ContentForSignaturesTest : AbstractCoreTest() { val page = module.children.single { it.name == "test" } .children.single { it.name == "function" } as ContentPage page.content.assertNode { - header(1) { +"function" } + group { + header(1) { +"function" } + } divergentGroup { divergentInstance { divergent { diff --git a/plugins/base/src/test/kotlin/model/ClassesTest.kt b/plugins/base/src/test/kotlin/model/ClassesTest.kt index 405ec8b6..4ca34b00 100644 --- a/plugins/base/src/test/kotlin/model/ClassesTest.kt +++ b/plugins/base/src/test/kotlin/model/ClassesTest.kt @@ -152,7 +152,7 @@ class ClassesTest : AbstractModelTest("/src/main/kotlin/classes/Test.kt", "class visibility.values allEquals KotlinVisibility.Public with(extra[AdditionalModifiers].assertNotNull("Extras")) { content counts 1 - content.first() equals ExtraModifiers.DATA + content.first() equals ExtraModifiers.KotlinOnlyModifiers.Data } } } @@ -185,7 +185,7 @@ class ClassesTest : AbstractModelTest("/src/main/kotlin/classes/Test.kt", "class with(content.first()) { dri.classNames equals "Deprecated" params.entries counts 1 -// params["message"].assertNotNull("message") equals "should no longer be used" + (params["message"].assertNotNull("message") as StringValue).value equals "\"should no longer be used\"" } } } @@ -275,7 +275,7 @@ class ClassesTest : AbstractModelTest("/src/main/kotlin/classes/Test.kt", "class with((this / "D").cast<DClass>()) { with(extra[AdditionalModifiers].assertNotNull("AdditionalModifiers")) { content counts 1 - content.first() equals ExtraModifiers.INNER + content.first() equals ExtraModifiers.KotlinOnlyModifiers.Inner } } } @@ -426,9 +426,7 @@ class ClassesTest : AbstractModelTest("/src/main/kotlin/classes/Test.kt", "class with((this / "classes" / "Foo").cast<DClass>()) { with(extra[Annotations]?.content?.firstOrNull().assertNotNull("annotations")) { dri.toString() equals "kotlin/Suppress///PointingToDeclaration/" -// with(params["names"].assertNotNull("param")) { -// this equals "[\"abc\"]" -// } + (params["names"].assertNotNull("param") as ArrayValue).value equals listOf(StringValue("\"abc\"")) } } } diff --git a/plugins/base/src/test/kotlin/model/FunctionsTest.kt b/plugins/base/src/test/kotlin/model/FunctionsTest.kt index 6cbb84f7..38f64df5 100644 --- a/plugins/base/src/test/kotlin/model/FunctionsTest.kt +++ b/plugins/base/src/test/kotlin/model/FunctionsTest.kt @@ -1,5 +1,6 @@ package model +import org.jetbrains.dokka.links.DRI import org.jetbrains.dokka.model.* import org.junit.jupiter.api.Test import utils.AbstractModelTest @@ -145,7 +146,7 @@ class FunctionTest : AbstractModelTest("/src/main/kotlin/function/Test.kt", "fun with(content.first()) { dri.classNames equals "Suppress" params.entries counts 1 -// params["names"].assertNotNull("names") equals "[\"FOO\"]" + (params["names"].assertNotNull("param") as ArrayValue).value equals listOf(StringValue("\"FOO\"")) } } } @@ -161,7 +162,7 @@ class FunctionTest : AbstractModelTest("/src/main/kotlin/function/Test.kt", "fun ) { with((this / "function" / "f").cast<DFunction>()) { extra[AdditionalModifiers]?.content counts 1 - extra[AdditionalModifiers]?.content exists ExtraModifiers.INLINE + extra[AdditionalModifiers]?.content exists ExtraModifiers.KotlinOnlyModifiers.Inline } } } @@ -175,7 +176,7 @@ class FunctionTest : AbstractModelTest("/src/main/kotlin/function/Test.kt", "fun ) { with((this / "function" / "f").cast<DFunction>()) { extra[AdditionalModifiers]?.content counts 1 - extra[AdditionalModifiers]?.content exists ExtraModifiers.SUSPEND + extra[AdditionalModifiers]?.content exists ExtraModifiers.KotlinOnlyModifiers.Suspend } } } @@ -189,8 +190,8 @@ class FunctionTest : AbstractModelTest("/src/main/kotlin/function/Test.kt", "fun ) { with((this / "function" / "f").cast<DFunction>()) { extra[AdditionalModifiers]?.content counts 2 - extra[AdditionalModifiers]?.content exists ExtraModifiers.SUSPEND - extra[AdditionalModifiers]?.content exists ExtraModifiers.INLINE + extra[AdditionalModifiers]?.content exists ExtraModifiers.KotlinOnlyModifiers.Suspend + extra[AdditionalModifiers]?.content exists ExtraModifiers.KotlinOnlyModifiers.Inline } } } @@ -205,8 +206,8 @@ class FunctionTest : AbstractModelTest("/src/main/kotlin/function/Test.kt", "fun with((this / "function" / "f").cast<DFunction>()) { with(extra[AdditionalModifiers].assertNotNull("AdditionalModifiers")) { content counts 2 - content exists ExtraModifiers.SUSPEND - content exists ExtraModifiers.INLINE + content exists ExtraModifiers.KotlinOnlyModifiers.Suspend + content exists ExtraModifiers.KotlinOnlyModifiers.Inline } } } @@ -229,10 +230,18 @@ class FunctionTest : AbstractModelTest("/src/main/kotlin/function/Test.kt", "fun content counts 3 with(content.map { it.dri.classNames to it }.toMap()) { with(this["Target"].assertNotNull("Target")) { -// params["allowedTargets"].assertNotNull("allowedTargets") equals "[AnnotationTarget.VALUE_PARAMETER]" + (params["allowedTargets"].assertNotNull("allowedTargets") as ArrayValue).value equals listOf( + EnumValue( + "AnnotationTarget.VALUE_PARAMETER", + DRI("kotlin.annotation", "AnnotationTarget.VALUE_PARAMETER") + ) + ) } with(this["Retention"].assertNotNull("Retention")) { -// params["value"].assertNotNull("value") equals "(kotlin/annotation/AnnotationRetention, SOURCE)" + (params["value"].assertNotNull("value") as EnumValue) equals EnumValue( + "AnnotationRetention.SOURCE", + DRI("kotlin.annotation", "AnnotationRetention.SOURCE") + ) } this["MustBeDocumented"].assertNotNull("MustBeDocumented").params.entries counts 0 } @@ -260,7 +269,7 @@ class FunctionTest : AbstractModelTest("/src/main/kotlin/function/Test.kt", "fun ) { with((this / "function" / "f" / "notInlined").cast<DParameter>()) { extra[AdditionalModifiers]?.content counts 1 - extra[AdditionalModifiers]?.content exists ExtraModifiers.NOINLINE + extra[AdditionalModifiers]?.content exists ExtraModifiers.KotlinOnlyModifiers.NoInline } } } @@ -291,10 +300,18 @@ class FunctionTest : AbstractModelTest("/src/main/kotlin/function/Test.kt", "fun content counts 3 with(content.map { it.dri.classNames to it }.toMap()) { with(this["Target"].assertNotNull("Target")) { -// params["allowedTargets"].assertNotNull("allowedTargets") equals "[AnnotationTarget.VALUE_PARAMETER]" + (params["allowedTargets"].assertNotNull("allowedTargets") as ArrayValue).value equals listOf( + EnumValue( + "AnnotationTarget.VALUE_PARAMETER", + DRI("kotlin.annotation", "AnnotationTarget.VALUE_PARAMETER") + ) + ) } with(this["Retention"].assertNotNull("Retention")) { -// params["value"].assertNotNull("value") equals "(kotlin/annotation/AnnotationRetention, SOURCE)" + (params["value"].assertNotNull("value") as EnumValue) equals EnumValue( + "AnnotationRetention.SOURCE", + DRI("kotlin.annotation", "AnnotationRetention.SOURCE") + ) } this["MustBeDocumented"].assertNotNull("MustBeDocumented").params.entries counts 0 } @@ -307,7 +324,7 @@ class FunctionTest : AbstractModelTest("/src/main/kotlin/function/Test.kt", "fun with(content.first()) { dri.classNames equals "Fancy" params.entries counts 1 -// params["size"] equals "1" + (params["size"] as StringValue).value equals "1" } } } @@ -369,7 +386,7 @@ class FunctionTest : AbstractModelTest("/src/main/kotlin/function/Test.kt", "fun with(content.first()) { dri.classNames equals "SinceKotlin" params.entries counts 1 -// params["version"].assertNotNull("version") equals "1.1" + (params["version"].assertNotNull("version") as StringValue).value equals "\"1.1\"" } } } diff --git a/plugins/base/src/test/kotlin/model/JavaTest.kt b/plugins/base/src/test/kotlin/model/JavaTest.kt index 07af7913..fd293b5c 100644 --- a/plugins/base/src/test/kotlin/model/JavaTest.kt +++ b/plugins/base/src/test/kotlin/model/JavaTest.kt @@ -1,9 +1,9 @@ package model import org.jetbrains.dokka.base.transformers.documentables.InheritorsInfo +import org.jetbrains.dokka.links.DRI import org.jetbrains.dokka.model.* import org.junit.jupiter.api.Assertions.assertTrue -import org.junit.jupiter.api.Disabled import org.junit.jupiter.api.Test import utils.AbstractModelTest import utils.assertNotNull @@ -297,7 +297,7 @@ class JavaTest : AbstractModelTest("/src/main/kotlin/java/Test.java", "java") { with((this / "java" / "C" / "foo").cast<DFunction>()) { with(extra[AdditionalModifiers].assertNotNull("AdditionalModifiers")) { content counts 1 - content.first() equals ExtraModifiers.STATIC + content.first() equals ExtraModifiers.JavaOnlyModifiers.Static } } } @@ -338,7 +338,11 @@ class JavaTest : AbstractModelTest("/src/main/kotlin/java/Test.java", "java") { with(extra[Annotations].assertNotNull("Annotations")) { with(content.single()) { dri.classNames equals "Target" -// params["value"].assertNotNull("value") equals "{ElementType.FIELD, ElementType.TYPE, ElementType.METHOD}" + (params["value"].assertNotNull("value") as ArrayValue).value equals listOf( + EnumValue("ElementType.FIELD", DRI("java.lang.annotation", "ElementType")), + EnumValue("ElementType.TYPE", DRI("java.lang.annotation", "ElementType")), + EnumValue("ElementType.METHOD", DRI("java.lang.annotation", "ElementType")) + ) } } } diff --git a/plugins/base/src/test/kotlin/model/PropertyTest.kt b/plugins/base/src/test/kotlin/model/PropertyTest.kt index 7429257b..90a9d782 100644 --- a/plugins/base/src/test/kotlin/model/PropertyTest.kt +++ b/plugins/base/src/test/kotlin/model/PropertyTest.kt @@ -155,7 +155,7 @@ class PropertyTest : AbstractModelTest("/src/main/kotlin/property/Test.kt", "pro with(content.first()) { dri.classNames equals "SinceKotlin" params.entries counts 1 -// params["version"].assertNotNull("version") equals "1.1" + (params["version"].assertNotNull("version") as StringValue).value equals "\"1.1\"" } } } diff --git a/plugins/base/src/test/kotlin/utils/contentUtils.kt b/plugins/base/src/test/kotlin/utils/contentUtils.kt index a1141832..ec119ebb 100644 --- a/plugins/base/src/test/kotlin/utils/contentUtils.kt +++ b/plugins/base/src/test/kotlin/utils/contentUtils.kt @@ -139,26 +139,28 @@ fun ContentMatcherBuilder<*>.propertySignature( header { +"Package test" } } group { - skipAllNotMatching() - header { +"Properties" } - table { - group { - link { +name } - platformHinted { - group { + group { + skipAllNotMatching() + header { +"Properties" } + table { + group { + link { +name } + platformHinted { group { - annotations.entries.forEach { - group { - unwrapAnnotation(it) + group { + annotations.entries.forEach { + group { + unwrapAnnotation(it) + } } - } - +("$visibility $modifier ${keywords.joinToString("") { "$it " }} $preposition") - link { +name } - if (type != null) { - +(": ") - group { - link { - +(type) + +("$visibility $modifier ${keywords.joinToString("") { "$it " }} $preposition") + link { +name } + if (type != null) { + +(": ") + group { + link { + +(type) + } } } } diff --git a/plugins/kotlin-as-java/src/main/kotlin/converters/KotlinToJavaConverter.kt b/plugins/kotlin-as-java/src/main/kotlin/converters/KotlinToJavaConverter.kt index 8d9ac20d..8f20f942 100644 --- a/plugins/kotlin-as-java/src/main/kotlin/converters/KotlinToJavaConverter.kt +++ b/plugins/kotlin-as-java/src/main/kotlin/converters/KotlinToJavaConverter.kt @@ -47,7 +47,7 @@ internal fun DPackage.asJava(): DPackage { generics = emptyList(), supertypes = emptyMap(), documentation = emptyMap(), - modifier = sourceSets.map{ it to JavaModifier.Final}.toMap(), + modifier = sourceSets.map { it to JavaModifier.Final }.toMap(), sourceSets = sourceSets, extra = PropertyContainer.empty() ) @@ -68,15 +68,15 @@ internal fun DProperty.asJava(isTopLevel: Boolean = false, relocateToClass: Stri dri.withClass(relocateToClass) }, modifier = if (setter == null) { - sourceSets.map{it to JavaModifier.Final}.toMap() + sourceSets.map { it to JavaModifier.Final }.toMap() } else { - sourceSets.map{it to JavaModifier.Empty}.toMap() + sourceSets.map { it to JavaModifier.Empty }.toMap() }, visibility = visibility.mapValues { JavaVisibility.Private }, type = type.asJava(), // TODO: check setter = null, getter = null, // Removing getters and setters as they will be available as functions - extra = if (isTopLevel) extra.plus(extra.mergeAdditionalModifiers(setOf(ExtraModifiers.STATIC))) else extra + extra = if (isTopLevel) extra.plus(extra.mergeAdditionalModifiers(setOf(ExtraModifiers.JavaOnlyModifiers.Static))) else extra ) internal fun DProperty.javaAccessors(isTopLevel: Boolean = false, relocateToClass: String? = null): List<DFunction> = @@ -89,13 +89,13 @@ internal fun DProperty.javaAccessors(isTopLevel: Boolean = false, relocateToClas }, name = "get" + name.capitalize(), modifier = if (setter == null) { - sourceSets.map{it to JavaModifier.Final}.toMap() + sourceSets.map { it to JavaModifier.Final }.toMap() } else { - sourceSets.map{it to JavaModifier.Empty}.toMap() + sourceSets.map { it to JavaModifier.Empty }.toMap() }, visibility = visibility.mapValues { JavaVisibility.Public }, type = type.asJava(), // TODO: check - extra = if (isTopLevel) getter!!.extra.plus(getter!!.extra.mergeAdditionalModifiers(setOf(ExtraModifiers.STATIC))) else getter!!.extra + extra = if (isTopLevel) getter!!.extra.plus(getter!!.extra.mergeAdditionalModifiers(setOf(ExtraModifiers.JavaOnlyModifiers.Static))) else getter!!.extra ), setter?.copy( dri = if (relocateToClass.isNullOrBlank()) { @@ -105,13 +105,13 @@ internal fun DProperty.javaAccessors(isTopLevel: Boolean = false, relocateToClas }, name = "set" + name.capitalize(), modifier = if (setter == null) { - sourceSets.map{it to JavaModifier.Final}.toMap() + sourceSets.map { it to JavaModifier.Final }.toMap() } else { - sourceSets.map{it to JavaModifier.Empty}.toMap() + sourceSets.map { it to JavaModifier.Empty }.toMap() }, visibility = visibility.mapValues { JavaVisibility.Public }, type = type.asJava(), // TODO: check - extra = if (isTopLevel) setter!!.extra.plus(setter!!.extra.mergeAdditionalModifiers(setOf(ExtraModifiers.STATIC))) else setter!!.extra + extra = if (isTopLevel) setter!!.extra.plus(setter!!.extra.mergeAdditionalModifiers(setOf(ExtraModifiers.JavaOnlyModifiers.Static))) else setter!!.extra ) ) @@ -125,9 +125,9 @@ internal fun DFunction.asJava(containingClassName: String): DFunction { // dri = dri.copy(callable = dri.callable?.asJava()), name = newName, type = type.asJava(), - modifier = if(modifier.all{(_,v)-> v is KotlinModifier.Final} && isConstructor) - sourceSets.map{it to JavaModifier.Empty}.toMap() - else sourceSets.map{it to modifier.values.first()}.toMap(), + modifier = if (modifier.all { (_, v) -> v is KotlinModifier.Final } && isConstructor) + sourceSets.map { it to JavaModifier.Empty }.toMap() + else sourceSets.map { it to modifier.values.first() }.toMap(), parameters = listOfNotNull(receiver?.asJava()) + parameters.map { it.asJava() }, receiver = null ) // TODO static if toplevel @@ -151,8 +151,9 @@ internal fun DClass.asJava(): DClass = copy( classlikes = classlikes.map { it.asJava() }, generics = generics.map { it.asJava() }, supertypes = supertypes.mapValues { it.value.map { it.possiblyAsJava() } }, - modifier = if (modifier.all{(_,v) -> v is KotlinModifier.Empty}) sourceSets.map{it to JavaModifier.Final}.toMap() - else sourceSets.map{it to modifier.values.first()}.toMap() + modifier = if (modifier.all { (_, v) -> v is KotlinModifier.Empty }) sourceSets.map { it to JavaModifier.Final } + .toMap() + else sourceSets.map { it to modifier.values.first() }.toMap() ) private fun DTypeParameter.asJava(): DTypeParameter = copy( @@ -188,7 +189,7 @@ internal fun DObject.asJava(): DObject = copy( properties = properties.map { it.asJava() } + DProperty( name = "INSTANCE", - modifier = sourceSets.map{it to JavaModifier.Final}.toMap(), + modifier = sourceSets.map { it to JavaModifier.Final }.toMap(), dri = dri.copy(callable = Callable("INSTANCE", null, emptyList())), documentation = emptyMap(), sources = emptyMap(), @@ -202,7 +203,7 @@ internal fun DObject.asJava(): DObject = copy( receiver = null, generics = emptyList(), expectPresentInSet = expectPresentInSet, - extra = PropertyContainer.empty<DProperty>() + AdditionalModifiers(setOf(ExtraModifiers.STATIC)) + extra = PropertyContainer.empty<DProperty>() + AdditionalModifiers(setOf(ExtraModifiers.JavaOnlyModifiers.Static)) ), classlikes = classlikes.map { it.asJava() }, supertypes = supertypes.mapValues { it.value.map { it.possiblyAsJava() } } diff --git a/plugins/kotlin-as-java/src/main/kotlin/signatures/JavaSignatureProvider.kt b/plugins/kotlin-as-java/src/main/kotlin/signatures/JavaSignatureProvider.kt index ec3221e2..a55f9339 100644 --- a/plugins/kotlin-as-java/src/main/kotlin/signatures/JavaSignatureProvider.kt +++ b/plugins/kotlin-as-java/src/main/kotlin/signatures/JavaSignatureProvider.kt @@ -1,15 +1,12 @@ package org.jetbrains.dokka.kotlinAsJava.signatures -import org.jetbrains.dokka.base.signatures.JvmSingatureUtils -import javaslang.Tuple2 -import org.jetbrains.dokka.base.signatures.All +import org.jetbrains.dokka.base.signatures.JvmSignatureUtils import org.jetbrains.dokka.base.signatures.SignatureProvider import org.jetbrains.dokka.base.transformers.pages.comments.CommentsToContentConverter import org.jetbrains.dokka.base.translators.documentables.PageContentBuilder import org.jetbrains.dokka.links.DRI import org.jetbrains.dokka.links.sureClassNames import org.jetbrains.dokka.model.* -import org.jetbrains.dokka.model.properties.WithExtraProperties import org.jetbrains.dokka.pages.ContentKind import org.jetbrains.dokka.pages.ContentNode import org.jetbrains.dokka.pages.TextStyle @@ -17,7 +14,7 @@ import org.jetbrains.dokka.utilities.DokkaLogger import kotlin.text.Typography.nbsp class JavaSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLogger) : SignatureProvider, - JvmSingatureUtils by JavaSignatureUtils { + JvmSignatureUtils by JavaSignatureUtils { private val contentBuilder = PageContentBuilder(ctcc, this, logger) private val ignoredVisibilities = setOf(JavaVisibility.Default) diff --git a/plugins/kotlin-as-java/src/main/kotlin/signatures/JavaSignatureUtils.kt b/plugins/kotlin-as-java/src/main/kotlin/signatures/JavaSignatureUtils.kt index 16c3f25a..e2f73bf9 100644 --- a/plugins/kotlin-as-java/src/main/kotlin/signatures/JavaSignatureUtils.kt +++ b/plugins/kotlin-as-java/src/main/kotlin/signatures/JavaSignatureUtils.kt @@ -1,14 +1,13 @@ package org.jetbrains.dokka.kotlinAsJava.signatures -import javaslang.Tuple2 + import org.jetbrains.dokka.base.signatures.All -import org.jetbrains.dokka.base.signatures.JvmSingatureUtils +import org.jetbrains.dokka.base.signatures.JvmSignatureUtils import org.jetbrains.dokka.base.translators.documentables.PageContentBuilder import org.jetbrains.dokka.links.DRI import org.jetbrains.dokka.model.* -import org.jetbrains.dokka.model.ExtraModifiers.Companion.javaOnlyModifiers import org.jetbrains.dokka.model.properties.WithExtraProperties -object JavaSignatureUtils : JvmSingatureUtils { +object JavaSignatureUtils : JvmSignatureUtils { val ignoredAnnotations = setOf( Annotations.Annotation(DRI("kotlin.jvm", "Transient"), emptyMap()), @@ -19,7 +18,7 @@ object JavaSignatureUtils : JvmSingatureUtils { ) private val strategy = All - private val listBrackets = Tuple2('{', '}') + private val listBrackets = Pair('{', '}') private val classExtension = ".class" override fun PageContentBuilder.DocumentableContentBuilder.annotationsBlock(d: Documentable) = @@ -29,6 +28,6 @@ object JavaSignatureUtils : JvmSingatureUtils { annotationsInlineWithIgnored(d, ignoredAnnotations, strategy, listBrackets, classExtension) override fun <T : Documentable> WithExtraProperties<T>.modifiers() = - modifiersWithFilter(javaOnlyModifiers) + extra[AdditionalModifiers]?.content?.filterIsInstance<ExtraModifiers.JavaOnlyModifiers>()?.toSet() ?: emptySet() }
\ No newline at end of file |