From 56cf2640d18660fd8ce75d9cd5385bbe173ee169 Mon Sep 17 00:00:00 2001 From: Marcin Aman Date: Sat, 27 Feb 2021 18:41:29 +0100 Subject: [PATCH 1/2] Add ability to suppress obvious functions like equals, toString... --- core/src/main/kotlin/configuration.kt | 2 + core/src/main/kotlin/defaultConfiguration.kt | 1 + .../kotlin/model/documentableProperties.kt | 4 + .../TestDokkaConfigurationBuilder.kt | 2 + .../transformers/HideTagDocumentableFilter.kt | 4 +- plugins/base/src/main/kotlin/DokkaBase.kt | 7 +- ...sFunctionsDocumentableFilterTransformer.kt | 11 ++ .../SuppressTagDocumentableFilter.kt | 2 +- ...ConditionDocumentableFilterTransformer.kt} | 2 +- ...faultDescriptorToDocumentableTranslator.kt | 4 + .../psi/DefaultPsiToDocumentableTranslator.kt | 8 +- .../ObviousFunctionsDocumentableFilterTest.kt | 144 ++++++++++++++++++ ...tDescriptorToDocumentableTranslatorTest.kt | 1 + runners/cli/src/main/kotlin/cli/main.kt | 7 + 14 files changed, 192 insertions(+), 7 deletions(-) create mode 100644 plugins/base/src/main/kotlin/transformers/documentables/ObviousFunctionsDocumentableFilterTransformer.kt rename plugins/base/src/main/kotlin/transformers/documentables/{SuppressedByTagDocumentableFilterTransformer.kt => SuppressedByConditionDocumentableFilterTransformer.kt} (97%) create mode 100644 plugins/base/src/test/kotlin/transformers/ObviousFunctionsDocumentableFilterTest.kt diff --git a/core/src/main/kotlin/configuration.kt b/core/src/main/kotlin/configuration.kt index a3989ebce3..1501ab2fd4 100644 --- a/core/src/main/kotlin/configuration.kt +++ b/core/src/main/kotlin/configuration.kt @@ -32,6 +32,7 @@ object DokkaDefaults { const val sourceSetName = "main" val moduleVersion: String? = null val pluginsConfiguration = mutableListOf() + const val suppressObviousFunctions = true } enum class Platform(val key: String) { @@ -98,6 +99,7 @@ interface DokkaConfiguration : Serializable { val pluginsClasspath: List val pluginsConfiguration: List val delayTemplateSubstitution: Boolean + val suppressObviousFunctions: Boolean enum class SerializationFormat : Serializable { JSON, XML diff --git a/core/src/main/kotlin/defaultConfiguration.kt b/core/src/main/kotlin/defaultConfiguration.kt index 869a99edda..ec1dde8ed1 100644 --- a/core/src/main/kotlin/defaultConfiguration.kt +++ b/core/src/main/kotlin/defaultConfiguration.kt @@ -16,6 +16,7 @@ data class DokkaConfigurationImpl( override val modules: List = emptyList(), override val failOnWarning: Boolean = DokkaDefaults.failOnWarning, override val delayTemplateSubstitution: Boolean = false, + override val suppressObviousFunctions: Boolean = DokkaDefaults.suppressObviousFunctions, ) : DokkaConfiguration data class PluginConfigurationImpl( diff --git a/core/src/main/kotlin/model/documentableProperties.kt b/core/src/main/kotlin/model/documentableProperties.kt index 209a62963c..90ab3053e6 100644 --- a/core/src/main/kotlin/model/documentableProperties.kt +++ b/core/src/main/kotlin/model/documentableProperties.kt @@ -33,4 +33,8 @@ data class ExceptionInSupertypes(val exceptions: SourceSetDependent = ExceptionInSupertypes +} + +object ObviousMember : ExtraProperty, ExtraProperty.Key { + override val key: ExtraProperty.Key = this } \ No newline at end of file diff --git a/core/test-api/src/main/kotlin/testApi/testRunner/TestDokkaConfigurationBuilder.kt b/core/test-api/src/main/kotlin/testApi/testRunner/TestDokkaConfigurationBuilder.kt index 87e85c0218..82f6da3aca 100644 --- a/core/test-api/src/main/kotlin/testApi/testRunner/TestDokkaConfigurationBuilder.kt +++ b/core/test-api/src/main/kotlin/testApi/testRunner/TestDokkaConfigurationBuilder.kt @@ -34,6 +34,7 @@ class TestDokkaConfigurationBuilder { var pluginsConfigurations: MutableList = mutableListOf() var failOnWarning: Boolean = false var modules: List = emptyList() + var suppressObviousFunctions: Boolean = DokkaDefaults.suppressObviousFunctions private val lazySourceSets = mutableListOf>() fun build() = DokkaConfigurationImpl( @@ -47,6 +48,7 @@ class TestDokkaConfigurationBuilder { pluginsConfiguration = pluginsConfigurations, modules = modules, failOnWarning = failOnWarning, + suppressObviousFunctions = suppressObviousFunctions ) fun sourceSets(block: SourceSetsBuilder.() -> Unit) { diff --git a/plugins/android-documentation/src/main/kotlin/transformers/HideTagDocumentableFilter.kt b/plugins/android-documentation/src/main/kotlin/transformers/HideTagDocumentableFilter.kt index 074413cc40..a8db6668ea 100644 --- a/plugins/android-documentation/src/main/kotlin/transformers/HideTagDocumentableFilter.kt +++ b/plugins/android-documentation/src/main/kotlin/transformers/HideTagDocumentableFilter.kt @@ -1,13 +1,13 @@ package org.jetbrains.dokka.android.transformers -import org.jetbrains.dokka.base.transformers.documentables.SuppressedByTagDocumentableFilterTransformer +import org.jetbrains.dokka.base.transformers.documentables.SuppressedByConditionDocumentableFilterTransformer import org.jetbrains.dokka.model.Documentable import org.jetbrains.dokka.model.dfs import org.jetbrains.dokka.model.doc.CustomTagWrapper import org.jetbrains.dokka.plugability.DokkaContext class HideTagDocumentableFilter(val dokkaContext: DokkaContext) : - SuppressedByTagDocumentableFilterTransformer(dokkaContext) { + SuppressedByConditionDocumentableFilterTransformer(dokkaContext) { override fun shouldBeSuppressed(d: Documentable): Boolean = d.documentation.any { (_, docs) -> docs.dfs { it is CustomTagWrapper && it.name.trim() == "hide" } != null } } \ No newline at end of file diff --git a/plugins/base/src/main/kotlin/DokkaBase.kt b/plugins/base/src/main/kotlin/DokkaBase.kt index 2dbad3a7c1..a232cd1cd0 100644 --- a/plugins/base/src/main/kotlin/DokkaBase.kt +++ b/plugins/base/src/main/kotlin/DokkaBase.kt @@ -78,13 +78,18 @@ class DokkaBase : DokkaPlugin() { preMergeDocumentableTransformer providing ::DocumentableVisibilityFilterTransformer } + val fakeFunctionsVisbilityFilter by extending { + preMergeDocumentableTransformer providing ::ObviousFunctionsDocumentableFilterTransformer + } + val emptyPackagesFilter by extending { preMergeDocumentableTransformer providing ::EmptyPackagesFilterTransformer order { after( deprecatedDocumentableFilter, suppressedDocumentableFilter, documentableVisbilityFilter, - suppressedBySuppressTagDocumentableFilter + suppressedBySuppressTagDocumentableFilter, + fakeFunctionsVisbilityFilter ) } } diff --git a/plugins/base/src/main/kotlin/transformers/documentables/ObviousFunctionsDocumentableFilterTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/ObviousFunctionsDocumentableFilterTransformer.kt new file mode 100644 index 0000000000..57d7268e4a --- /dev/null +++ b/plugins/base/src/main/kotlin/transformers/documentables/ObviousFunctionsDocumentableFilterTransformer.kt @@ -0,0 +1,11 @@ +package org.jetbrains.dokka.base.transformers.documentables + +import org.jetbrains.dokka.model.DFunction +import org.jetbrains.dokka.model.Documentable +import org.jetbrains.dokka.model.ObviousMember +import org.jetbrains.dokka.plugability.DokkaContext + +class ObviousFunctionsDocumentableFilterTransformer(context: DokkaContext) : SuppressedByConditionDocumentableFilterTransformer(context) { + override fun shouldBeSuppressed(d: Documentable): Boolean = + context.configuration.suppressObviousFunctions && d is DFunction && d.extra[ObviousMember] != null +} \ No newline at end of file diff --git a/plugins/base/src/main/kotlin/transformers/documentables/SuppressTagDocumentableFilter.kt b/plugins/base/src/main/kotlin/transformers/documentables/SuppressTagDocumentableFilter.kt index 7efb23ab67..a297908db9 100644 --- a/plugins/base/src/main/kotlin/transformers/documentables/SuppressTagDocumentableFilter.kt +++ b/plugins/base/src/main/kotlin/transformers/documentables/SuppressTagDocumentableFilter.kt @@ -6,7 +6,7 @@ import org.jetbrains.dokka.plugability.DokkaContext import org.jetbrains.dokka.model.doc.Suppress class SuppressTagDocumentableFilter(val dokkaContext: DokkaContext) : - SuppressedByTagDocumentableFilterTransformer(dokkaContext) { + SuppressedByConditionDocumentableFilterTransformer(dokkaContext) { override fun shouldBeSuppressed(d: Documentable): Boolean = d.documentation.any { (_, docs) -> docs.dfs { it is Suppress } != null } } \ No newline at end of file diff --git a/plugins/base/src/main/kotlin/transformers/documentables/SuppressedByTagDocumentableFilterTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/SuppressedByConditionDocumentableFilterTransformer.kt similarity index 97% rename from plugins/base/src/main/kotlin/transformers/documentables/SuppressedByTagDocumentableFilterTransformer.kt rename to plugins/base/src/main/kotlin/transformers/documentables/SuppressedByConditionDocumentableFilterTransformer.kt index f40abe7029..b0bdd4b77c 100644 --- a/plugins/base/src/main/kotlin/transformers/documentables/SuppressedByTagDocumentableFilterTransformer.kt +++ b/plugins/base/src/main/kotlin/transformers/documentables/SuppressedByConditionDocumentableFilterTransformer.kt @@ -4,7 +4,7 @@ import org.jetbrains.dokka.model.* import org.jetbrains.dokka.plugability.DokkaContext import org.jetbrains.dokka.transformers.documentation.PreMergeDocumentableTransformer -abstract class SuppressedByTagDocumentableFilterTransformer(val context: DokkaContext) : PreMergeDocumentableTransformer { +abstract class SuppressedByConditionDocumentableFilterTransformer(val context: DokkaContext) : PreMergeDocumentableTransformer { override fun invoke(modules: List): List = modules.map { module -> val (documentable, wasChanged) = processModule(module) diff --git a/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt b/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt index b08c11b8aa..bc45337a0d 100644 --- a/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt +++ b/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt @@ -493,6 +493,7 @@ private class DokkaDescriptorVisitor( descriptor.additionalExtras().toSourceSetDependent().toAdditionalModifiers(), (descriptor.getAnnotations() + descriptor.fileLevelAnnotations()).toSourceSetDependent() .toAnnotations(), + ObviousMember.takeIf { descriptor.isFake }, ) ) } @@ -1036,6 +1037,9 @@ private class DokkaDescriptorVisitor( ?.toList() ?.parallelMap { it.toAnnotation(scope = Annotations.AnnotationScope.FILE) } .orEmpty() + + private val FunctionDescriptor.isFake: Boolean + get() = kind == CallableMemberDescriptor.Kind.FAKE_OVERRIDE || kind == CallableMemberDescriptor.Kind.SYNTHESIZED } private data class AncestryLevel( diff --git a/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt b/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt index c09d11561f..bc044ff69f 100644 --- a/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt +++ b/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt @@ -126,6 +126,9 @@ class DefaultPsiToDocumentableTranslator( private val PsiClassType.shouldBeIgnored: Boolean get() = isClass("java.lang.Enum") || isClass("java.lang.Object") + private val DRI.isObvious: Boolean + get() = packageName == "java.lang" && (classNames == "Object" || classNames == "Enum") + private fun PsiClassType.isClass(qName: String): Boolean { val shortName = qName.substringAfterLast('.') if (className == shortName) { @@ -184,7 +187,7 @@ class DefaultPsiToDocumentableTranslator( ancestryTree.add(AncestryLevel(level, classes.firstOrNull()?.first, interfaces.map { it.first })) superTypes.forEach { type -> - (type as? PsiClassType)?.takeUnless { type.shouldBeIgnored }?.resolve()?.let { + (type as? PsiClassType)?.resolve()?.let { val definedAt = DRI.from(it) it.methods.forEach { method -> val hash = method.hash @@ -392,7 +395,8 @@ class DefaultPsiToDocumentableTranslator( it.toSourceSetDependent().toAdditionalModifiers(), (psi.annotations.toList() .toListOfAnnotations() + it.toListOfAnnotations()).toSourceSetDependent() - .toAnnotations() + .toAnnotations(), + ObviousMember.takeIf { inheritedFrom != null && inheritedFrom.isObvious } ) } ) diff --git a/plugins/base/src/test/kotlin/transformers/ObviousFunctionsDocumentableFilterTest.kt b/plugins/base/src/test/kotlin/transformers/ObviousFunctionsDocumentableFilterTest.kt new file mode 100644 index 0000000000..5b62a1fc95 --- /dev/null +++ b/plugins/base/src/test/kotlin/transformers/ObviousFunctionsDocumentableFilterTest.kt @@ -0,0 +1,144 @@ +package transformers + +import org.jetbrains.dokka.base.testApi.testRunner.BaseAbstractTest +import org.junit.jupiter.api.Test +import kotlin.test.assertEquals + +class ObviousFunctionsDocumentableFilterTest : BaseAbstractTest() { + val suppressingConfiguration = dokkaConfiguration { + sourceSets { + sourceSet { + sourceRoots = listOf("src") + } + } + } + + val nonSuppressingConfiguration = dokkaConfiguration { + suppressObviousFunctions = false + sourceSets { + sourceSet { + sourceRoots = listOf("src") + } + } + } + + @Test + fun `should suppress toString, equals and hashcode`() { + testInline( + """ + /src/suppressed/Suppressed.kt + package suppressed + data class Suppressed(val x: String) + """.trimIndent(), + suppressingConfiguration + ) { + documentablesFirstTransformationStep = { modules -> + val functions = modules.flatMap { it.packages }.flatMap { it.classlikes }.flatMap { it.functions } + assertEquals(0, functions.size) + } + } + } + + @Test + fun `should suppress toString, equals and hashcode in Java`() { + testInline( + """ + /src/suppressed/Suppressed.java + package suppressed; + public class Suppressed { + } + """.trimIndent(), + suppressingConfiguration + ) { + documentablesFirstTransformationStep = { modules -> + val functions = modules.flatMap { it.packages }.flatMap { it.classlikes }.flatMap { it.functions } + assertEquals(0, functions.size) + } + } + } + + @Test + fun `should suppress toString, equals and hashcode but keep custom ones`() { + testInline( + """ + /src/suppressed/Suppressed.kt + package suppressed + data class Suppressed(val x: String) { + override fun toString(): String { + return "custom" + } + } + """.trimIndent(), + suppressingConfiguration + ) { + documentablesFirstTransformationStep = { modules -> + val functions = modules.flatMap { it.packages }.flatMap { it.classlikes }.flatMap { it.functions } + assertEquals(listOf("toString"), functions.map { it.name }) + } + } + } + + @Test + fun `should suppress toString, equals and hashcode but keep custom ones in Java`() { + testInline( + """ + /src/suppressed/Suppressed.java + package suppressed; + class Suppressed { + @Override + public String toString() { + return ""; + } + } + """.trimIndent(), + suppressingConfiguration + ) { + documentablesFirstTransformationStep = { modules -> + val functions = modules.flatMap { it.packages }.flatMap { it.classlikes }.flatMap { it.functions } + assertEquals(listOf("toString"), functions.map { it.name }) + } + } + } + + @Test + fun `should not suppress toString, equals and hashcode if custom config is provided`() { + testInline( + """ + /src/suppressed/Suppressed.kt + package suppressed + data class Suppressed(val x: String) + """.trimIndent(), + nonSuppressingConfiguration + ) { + documentablesFirstTransformationStep = { modules -> + val functions = modules.flatMap { it.packages }.flatMap { it.classlikes }.flatMap { it.functions } + assertEquals( + listOf("copy", "equals", "toString", "component1", "hashCode").sorted(), + functions.map { it.name }.sorted() + ) + } + } + } + + @Test + fun `should not suppress toString, equals and hashcode if custom config is provided in Java`() { + testInline( + """ + /src/suppressed/Suppressed.java + package suppressed; + public class Suppressed { + } + """.trimIndent(), + nonSuppressingConfiguration + ) { + documentablesFirstTransformationStep = { modules -> + val functions = modules.flatMap { it.packages }.flatMap { it.classlikes }.flatMap { it.functions } + //I would normally just assert names but this would make it JDK dependent, so this is better + assertEquals( + 5, + setOf("clone", "equals", "hashCode", "toString", "notify").intersect(functions.map { it.name }).size + ) + } + } + } +} \ No newline at end of file diff --git a/plugins/base/src/test/kotlin/translators/DefaultDescriptorToDocumentableTranslatorTest.kt b/plugins/base/src/test/kotlin/translators/DefaultDescriptorToDocumentableTranslatorTest.kt index 85f145ed3f..50d43e636e 100644 --- a/plugins/base/src/test/kotlin/translators/DefaultDescriptorToDocumentableTranslatorTest.kt +++ b/plugins/base/src/test/kotlin/translators/DefaultDescriptorToDocumentableTranslatorTest.kt @@ -11,6 +11,7 @@ import org.junit.jupiter.api.Test class DefaultDescriptorToDocumentableTranslatorTest : BaseAbstractTest() { val configuration = dokkaConfiguration { + suppressObviousFunctions = false sourceSets { sourceSet { sourceRoots = listOf("src/main/kotlin") diff --git a/runners/cli/src/main/kotlin/cli/main.kt b/runners/cli/src/main/kotlin/cli/main.kt index 1597ed5681..b11ed0dc0c 100644 --- a/runners/cli/src/main/kotlin/cli/main.kt +++ b/runners/cli/src/main/kotlin/cli/main.kt @@ -69,6 +69,13 @@ class GlobalArguments(args: Array) : DokkaConfiguration { description = "Delay substitution of some elements (usefull for incremental builds of multimodule projects)" ).default(DokkaDefaults.delayTemplateSubstitution) + val noSuppressObviousFunctions: Boolean by parser.option( + ArgType.Boolean, + description = "Document generated or obvious functions like default `toString` or `equals`" + ).default(!DokkaDefaults.suppressObviousFunctions) + + override val suppressObviousFunctions: Boolean by lazy{ !noSuppressObviousFunctions } + val globalPackageOptions by parser.option( ArgType.String, description = "List of package source sets in format \"prefix,-deprecated,-privateApi,+warnUndocumented,+suppress;...\" " From 5b1f55b157f951ee50bdda56b3e606a0623d292f Mon Sep 17 00:00:00 2001 From: Marcin Aman Date: Mon, 1 Mar 2021 13:06:45 +0100 Subject: [PATCH 2/2] Add ability to suppress obvious functions like equals, toString... --- .../HideTagDocumentableFilterTest.kt | 4 ++-- plugins/base/src/main/kotlin/DokkaBase.kt | 8 ++++---- .../psi/DefaultPsiToDocumentableTranslator.kt | 9 +++++---- .../ObviousFunctionsDocumentableFilterTest.kt | 16 ++++++++-------- .../kotlin/transformers/SuppressTagFilterTest.kt | 14 +++++++------- 5 files changed, 26 insertions(+), 25 deletions(-) diff --git a/plugins/android-documentation/src/test/kotlin/transformers/HideTagDocumentableFilterTest.kt b/plugins/android-documentation/src/test/kotlin/transformers/HideTagDocumentableFilterTest.kt index 01a802bfd5..823752012c 100644 --- a/plugins/android-documentation/src/test/kotlin/transformers/HideTagDocumentableFilterTest.kt +++ b/plugins/android-documentation/src/test/kotlin/transformers/HideTagDocumentableFilterTest.kt @@ -30,7 +30,7 @@ class HideTagDocumentableFilterTest : BaseAbstractTest() { |} """.trimIndent(), configuration ) { - documentablesFirstTransformationStep = { modules -> + preMergeDocumentablesTransformationStage = { modules -> val testingClass = modules.flatMap { it.packages }.flatMap { it.classlikes }.single() as DClass assertEquals(0, testingClass.functions.size) } @@ -60,7 +60,7 @@ class HideTagDocumentableFilterTest : BaseAbstractTest() { |} """.trimIndent(), configuration ) { - documentablesFirstTransformationStep = { modules -> + preMergeDocumentablesTransformationStage = { modules -> val classes = modules.flatMap { it.packages }.flatMap { it.classlikes }.map { it.name } assertEquals(listOf("Visible"), classes) } diff --git a/plugins/base/src/main/kotlin/DokkaBase.kt b/plugins/base/src/main/kotlin/DokkaBase.kt index a232cd1cd0..5a7164d1d4 100644 --- a/plugins/base/src/main/kotlin/DokkaBase.kt +++ b/plugins/base/src/main/kotlin/DokkaBase.kt @@ -74,11 +74,11 @@ class DokkaBase : DokkaPlugin() { preMergeDocumentableTransformer providing ::SuppressTagDocumentableFilter } - val documentableVisbilityFilter by extending { + val documentableVisibilityFilter by extending { preMergeDocumentableTransformer providing ::DocumentableVisibilityFilterTransformer } - val fakeFunctionsVisbilityFilter by extending { + val obviousFunctionsVisbilityFilter by extending { preMergeDocumentableTransformer providing ::ObviousFunctionsDocumentableFilterTransformer } @@ -87,9 +87,9 @@ class DokkaBase : DokkaPlugin() { after( deprecatedDocumentableFilter, suppressedDocumentableFilter, - documentableVisbilityFilter, + documentableVisibilityFilter, suppressedBySuppressTagDocumentableFilter, - fakeFunctionsVisbilityFilter + obviousFunctionsVisbilityFilter ) } } diff --git a/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt b/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt index bc044ff69f..14d57df0b0 100644 --- a/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt +++ b/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt @@ -111,11 +111,12 @@ class DefaultPsiToDocumentableTranslator( private val cachedBounds = hashMapOf() - private fun PsiModifierListOwner.getVisibility() = modifierList?.children?.toList()?.let { ml -> + private fun PsiModifierListOwner.getVisibility() = modifierList?.let { + val ml = it.children.toList() when { - ml.any { it.text == PsiKeyword.PUBLIC } -> JavaVisibility.Public - ml.any { it.text == PsiKeyword.PROTECTED } -> JavaVisibility.Protected - ml.any { it.text == PsiKeyword.PRIVATE } -> JavaVisibility.Private + ml.any { it.text == PsiKeyword.PUBLIC } || it.hasModifierProperty("public") -> JavaVisibility.Public + ml.any { it.text == PsiKeyword.PROTECTED } || it.hasModifierProperty("protected") -> JavaVisibility.Protected + ml.any { it.text == PsiKeyword.PRIVATE } || it.hasModifierProperty("private") -> JavaVisibility.Private else -> JavaVisibility.Default } } ?: JavaVisibility.Default diff --git a/plugins/base/src/test/kotlin/transformers/ObviousFunctionsDocumentableFilterTest.kt b/plugins/base/src/test/kotlin/transformers/ObviousFunctionsDocumentableFilterTest.kt index 5b62a1fc95..01641131fd 100644 --- a/plugins/base/src/test/kotlin/transformers/ObviousFunctionsDocumentableFilterTest.kt +++ b/plugins/base/src/test/kotlin/transformers/ObviousFunctionsDocumentableFilterTest.kt @@ -32,7 +32,7 @@ class ObviousFunctionsDocumentableFilterTest : BaseAbstractTest() { """.trimIndent(), suppressingConfiguration ) { - documentablesFirstTransformationStep = { modules -> + preMergeDocumentablesTransformationStage = { modules -> val functions = modules.flatMap { it.packages }.flatMap { it.classlikes }.flatMap { it.functions } assertEquals(0, functions.size) } @@ -50,7 +50,7 @@ class ObviousFunctionsDocumentableFilterTest : BaseAbstractTest() { """.trimIndent(), suppressingConfiguration ) { - documentablesFirstTransformationStep = { modules -> + preMergeDocumentablesTransformationStage = { modules -> val functions = modules.flatMap { it.packages }.flatMap { it.classlikes }.flatMap { it.functions } assertEquals(0, functions.size) } @@ -71,7 +71,7 @@ class ObviousFunctionsDocumentableFilterTest : BaseAbstractTest() { """.trimIndent(), suppressingConfiguration ) { - documentablesFirstTransformationStep = { modules -> + preMergeDocumentablesTransformationStage = { modules -> val functions = modules.flatMap { it.packages }.flatMap { it.classlikes }.flatMap { it.functions } assertEquals(listOf("toString"), functions.map { it.name }) } @@ -84,7 +84,7 @@ class ObviousFunctionsDocumentableFilterTest : BaseAbstractTest() { """ /src/suppressed/Suppressed.java package suppressed; - class Suppressed { + public class Suppressed { @Override public String toString() { return ""; @@ -93,7 +93,7 @@ class ObviousFunctionsDocumentableFilterTest : BaseAbstractTest() { """.trimIndent(), suppressingConfiguration ) { - documentablesFirstTransformationStep = { modules -> + preMergeDocumentablesTransformationStage = { modules -> val functions = modules.flatMap { it.packages }.flatMap { it.classlikes }.flatMap { it.functions } assertEquals(listOf("toString"), functions.map { it.name }) } @@ -110,7 +110,7 @@ class ObviousFunctionsDocumentableFilterTest : BaseAbstractTest() { """.trimIndent(), nonSuppressingConfiguration ) { - documentablesFirstTransformationStep = { modules -> + preMergeDocumentablesTransformationStage = { modules -> val functions = modules.flatMap { it.packages }.flatMap { it.classlikes }.flatMap { it.functions } assertEquals( listOf("copy", "equals", "toString", "component1", "hashCode").sorted(), @@ -131,12 +131,12 @@ class ObviousFunctionsDocumentableFilterTest : BaseAbstractTest() { """.trimIndent(), nonSuppressingConfiguration ) { - documentablesFirstTransformationStep = { modules -> + preMergeDocumentablesTransformationStage = { modules -> val functions = modules.flatMap { it.packages }.flatMap { it.classlikes }.flatMap { it.functions } //I would normally just assert names but this would make it JDK dependent, so this is better assertEquals( 5, - setOf("clone", "equals", "hashCode", "toString", "notify").intersect(functions.map { it.name }).size + setOf("equals", "hashCode", "toString", "notify", "notifyAll").intersect(functions.map { it.name }).size ) } } diff --git a/plugins/base/src/test/kotlin/transformers/SuppressTagFilterTest.kt b/plugins/base/src/test/kotlin/transformers/SuppressTagFilterTest.kt index 268f934d47..fb8f520eed 100644 --- a/plugins/base/src/test/kotlin/transformers/SuppressTagFilterTest.kt +++ b/plugins/base/src/test/kotlin/transformers/SuppressTagFilterTest.kt @@ -34,7 +34,7 @@ class SuppressTagFilterTest : BaseAbstractTest() { |class Suppressed """.trimIndent(), configuration ) { - documentablesFirstTransformationStep = { modules -> + preMergeDocumentablesTransformationStage = { modules -> assertEquals( "NotSuppressed", modules.flatMap { it.packages }.flatMap { it.classlikes }.singleOrNull()?.name @@ -57,7 +57,7 @@ class SuppressTagFilterTest : BaseAbstractTest() { |} """.trimIndent(), configuration ) { - documentablesFirstTransformationStep = { modules -> + preMergeDocumentablesTransformationStage = { modules -> assertNull(modules.flatMap { it.packages }.flatMap { it.classlikes }.flatMap { it.functions } .firstOrNull { it.name == "suppressedFun" }) } @@ -81,7 +81,7 @@ class SuppressTagFilterTest : BaseAbstractTest() { |fun notSuppressedFun() { } """.trimIndent(), configuration ) { - documentablesFirstTransformationStep = { modules -> + preMergeDocumentablesTransformationStage = { modules -> assertNull(modules.flatMap { it.packages }.flatMap { it.functions } .firstOrNull { it.name == "suppressedFun" }) } @@ -105,7 +105,7 @@ class SuppressTagFilterTest : BaseAbstractTest() { |typealias notSuppressedTypeAlias = String """.trimIndent(), configuration ) { - documentablesFirstTransformationStep = { modules -> + preMergeDocumentablesTransformationStage = { modules -> assertNull(modules.flatMap { it.packages }.flatMap { it.typealiases } .firstOrNull { it.name == "suppressedTypeAlias" }) assertNotNull(modules.flatMap { it.packages }.flatMap { it.typealiases } @@ -129,7 +129,7 @@ class SuppressTagFilterTest : BaseAbstractTest() { |} """.trimIndent(), configuration ) { - documentablesFirstTransformationStep = { modules -> + preMergeDocumentablesTransformationStage = { modules -> assertNull((modules.flatMap { it.packages }.flatMap { it.classlikes } .firstOrNull { it.name == "Suppressed" } as? WithCompanion)?.companion) } @@ -152,7 +152,7 @@ class SuppressTagFilterTest : BaseAbstractTest() { |} """.trimIndent(), configuration ) { - documentablesFirstTransformationStep = { modules -> + preMergeDocumentablesTransformationStage = { modules -> val testingClass = modules.flatMap { it.packages }.flatMap { it.classlikes }.single() assertNull(testingClass.classlikes.firstOrNull()) } @@ -178,7 +178,7 @@ class SuppressTagFilterTest : BaseAbstractTest() { |} """.trimIndent(), configuration ) { - documentablesFirstTransformationStep = { modules -> + preMergeDocumentablesTransformationStage = { modules -> val testingClass = modules.flatMap { it.packages }.flatMap { it.classlikes }.single() as DEnum assertEquals(listOf("NOT_SUPPRESSED"), testingClass.entries.map { it.name }) }