From fff8bb5ffe629bebd2d5e071dd12966a7d89f885 Mon Sep 17 00:00:00 2001 From: Filip Zybała Date: Thu, 14 May 2020 10:17:25 +0200 Subject: Added deprecation filter. Included some tests. --- .../documentables/DocumentableFilter.kt | 601 +++++++++++++++++++++ .../documentables/DocumentableVisibilityFilter.kt | 338 ------------ 2 files changed, 601 insertions(+), 338 deletions(-) create mode 100644 plugins/base/src/main/kotlin/transformers/documentables/DocumentableFilter.kt delete mode 100644 plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilter.kt (limited to 'plugins/base/src/main/kotlin/transformers') diff --git a/plugins/base/src/main/kotlin/transformers/documentables/DocumentableFilter.kt b/plugins/base/src/main/kotlin/transformers/documentables/DocumentableFilter.kt new file mode 100644 index 00000000..fcead846 --- /dev/null +++ b/plugins/base/src/main/kotlin/transformers/documentables/DocumentableFilter.kt @@ -0,0 +1,601 @@ +package org.jetbrains.dokka.base.transformers.documentables + +import org.jetbrains.dokka.DokkaConfiguration +import org.jetbrains.dokka.model.* +import org.jetbrains.dokka.model.DAnnotation +import org.jetbrains.dokka.model.DEnum +import org.jetbrains.dokka.model.DFunction +import org.jetbrains.dokka.model.properties.WithExtraProperties +import org.jetbrains.dokka.plugability.DokkaContext +import org.jetbrains.dokka.transformers.documentation.PreMergeDocumentableTransformer +import org.jetbrains.kotlin.utils.addToStdlib.safeAs + +internal class DocumentableFilter(val context: DokkaContext) : PreMergeDocumentableTransformer { + + override fun invoke(modules: List): List = modules.map { original -> + val packageOptions = + context.configuration.passesConfigurations.first { original.sourceSets.contains(context.sourceSet(it)) } + .perPackageOptions + val passOptions = context.configuration.passesConfigurations.first { + original.sourceSets.contains(context.sourceSet(it)) + } + original.let { + DeprecationFilter(passOptions,packageOptions).processModule(it) + }.let { + VisibilityFilter(packageOptions, passOptions).processModule(it) + }.let { + EmptyPackagesFilter(passOptions).processModule(it) + } + } + + private class VisibilityFilter( + val packageOptions: List, + val globalOptions: DokkaConfiguration.PassConfiguration + ) { + + fun Visibility.isAllowedInPackage(packageName: String?) = when (this) { + is JavaVisibility.Public, + is JavaVisibility.Default, + is KotlinVisibility.Public -> true + else -> packageName != null + && packageOptions.firstOrNull { packageName.startsWith(it.prefix) }?.includeNonPublic + ?: globalOptions.includeNonPublic + } + + fun processModule(original: DModule) = + filterPackages(original.packages).let { (modified, packages) -> + if (!modified) original + else + DModule( + original.name, + packages = packages, + documentation = original.documentation, + sourceSets = original.sourceSets, + extra = original.extra + ) + } + + + + private fun filterPackages(packages: List): Pair> { + var packagesListChanged = false + val filteredPackages = packages.mapNotNull { + var modified = false + val functions = filterFunctions(it.functions).let { (listModified, list) -> + modified = modified || listModified + list + } + val properties = filterProperties(it.properties).let { (listModified, list) -> + modified = modified || listModified + list + } + val classlikes = filterClasslikes(it.classlikes).let { (listModified, list) -> + modified = modified || listModified + list + } + when { + !modified -> it + else -> { + packagesListChanged = true + DPackage( + it.dri, + functions, + properties, + classlikes, + it.typealiases, + it.documentation, + it.expectPresentInSet, + it.sourceSets, + it.extra + ) + } + } + } + return Pair(packagesListChanged, filteredPackages) + } + + private fun alwaysTrue(a: T, p: SourceSetData) = true + private fun alwaysFalse(a: T, p: SourceSetData) = false + + private fun WithVisibility.visibilityForPlatform(data: SourceSetData): Visibility? = visibility[data] + + private fun T.filterPlatforms( + additionalCondition: (T, SourceSetData) -> Boolean = ::alwaysTrue, + alternativeCondition: (T, SourceSetData) -> Boolean = ::alwaysFalse + ) where T : Documentable, T : WithVisibility = + sourceSets.filter { d -> + visibilityForPlatform(d)?.isAllowedInPackage(dri.packageName) == true && + additionalCondition(this, d) || + alternativeCondition(this, d) + }.toSet() + + private fun List.transform( + additionalCondition: (T, SourceSetData) -> Boolean = ::alwaysTrue, + alternativeCondition: (T, SourceSetData) -> Boolean = ::alwaysFalse, + recreate: (T, Set) -> T + ): Pair> where T : Documentable, T : WithVisibility { + var changed = false + val values = mapNotNull { t -> + val filteredPlatforms = t.filterPlatforms(additionalCondition, alternativeCondition) + when (filteredPlatforms.size) { + t.visibility.size -> t + 0 -> { + changed = true + null + } + else -> { + changed = true + recreate(t, filteredPlatforms) + } + } + } + return Pair(changed, values) + } + + private fun filterFunctions( + functions: List, + additionalCondition: (DFunction, SourceSetData) -> Boolean = ::alwaysTrue + ) = + functions.transform(additionalCondition) { original, filteredPlatforms -> + with(original) { + DFunction( + dri, + name, + isConstructor, + parameters, + documentation.filtered(filteredPlatforms), + expectPresentInSet.filtered(filteredPlatforms), + sources.filtered(filteredPlatforms), + visibility.filtered(filteredPlatforms), + type, + generics.mapNotNull { it.filter(filteredPlatforms) }, + receiver, + modifier, + filteredPlatforms, + extra + ) + } + } + + private fun hasVisibleAccessorsForPlatform(property: DProperty, data: SourceSetData) = + property.getter?.visibilityForPlatform(data)?.isAllowedInPackage(property.dri.packageName) == true || + property.setter?.visibilityForPlatform(data)?.isAllowedInPackage(property.dri.packageName) == true + + private fun filterProperties( + properties: List, + additionalCondition: (DProperty, SourceSetData) -> Boolean = ::alwaysTrue + ): Pair> = + properties.transform(additionalCondition, ::hasVisibleAccessorsForPlatform) { original, filteredPlatforms -> + with(original) { + DProperty( + dri, + name, + documentation.filtered(filteredPlatforms), + expectPresentInSet.filtered(filteredPlatforms), + sources.filtered(filteredPlatforms), + visibility.filtered(filteredPlatforms), + type, + receiver, + setter, + getter, + modifier, + filteredPlatforms, + generics.mapNotNull { it.filter(filteredPlatforms) }, + extra + ) + } + } + + private fun filterEnumEntries(entries: List, filteredPlatforms: Set) = + entries.mapNotNull { entry -> + if (filteredPlatforms.containsAll(entry.sourceSets)) entry + else { + val intersection = filteredPlatforms.intersect(entry.sourceSets) + if (intersection.isEmpty()) null + else DEnumEntry( + entry.dri, + entry.name, + entry.documentation.filtered(intersection), + entry.expectPresentInSet.filtered(filteredPlatforms), + filterFunctions(entry.functions) { _, data -> data in intersection }.second, + filterProperties(entry.properties) { _, data -> data in intersection }.second, + filterClasslikes(entry.classlikes) { _, data -> data in intersection }.second, + intersection, + entry.extra + ) + } + } + + private fun filterClasslikes( + classlikeList: List, + additionalCondition: (DClasslike, SourceSetData) -> Boolean = ::alwaysTrue + ): Pair> { + var classlikesListChanged = false + val filteredClasslikes: List = classlikeList.mapNotNull { + with(it) { + val filteredPlatforms = filterPlatforms(additionalCondition) + if (filteredPlatforms.isEmpty()) { + classlikesListChanged = true + null + } else { + var modified = sourceSets.size != filteredPlatforms.size + val functions = + filterFunctions(functions) { _, data -> data in filteredPlatforms }.let { (listModified, list) -> + modified = modified || listModified + list + } + val properties = + filterProperties(properties) { _, data -> data in filteredPlatforms }.let { (listModified, list) -> + modified = modified || listModified + list + } + val classlikes = + filterClasslikes(classlikes) { _, data -> data in filteredPlatforms }.let { (listModified, list) -> + modified = modified || listModified + list + } + val companion = + if (this is WithCompanion) filterClasslikes(listOfNotNull(companion)) { _, data -> data in filteredPlatforms }.let { (listModified, list) -> + modified = modified || listModified + list.firstOrNull() as DObject? + } else null + val constructors = if (this is WithConstructors) + filterFunctions(constructors) { _, data -> data in filteredPlatforms }.let { (listModified, list) -> + modified = modified || listModified + list + } else emptyList() + val generics = + if (this is WithGenerics) generics.mapNotNull { param -> param.filter(filteredPlatforms) } else emptyList() + val enumEntries = + if (this is DEnum) filterEnumEntries(entries, filteredPlatforms) else emptyList() + classlikesListChanged = classlikesListChanged || modified + when { + !modified -> this + this is DClass -> DClass( + dri, + name, + constructors, + functions, + properties, + classlikes, + sources.filtered(filteredPlatforms), + visibility.filtered(filteredPlatforms), + companion, + generics, + supertypes.filtered(filteredPlatforms), + documentation.filtered(filteredPlatforms), + expectPresentInSet.filtered(filteredPlatforms), + modifier, + filteredPlatforms, + extra + ) + this is DAnnotation -> DAnnotation( + name, + dri, + documentation.filtered(filteredPlatforms), + expectPresentInSet.filtered(filteredPlatforms), + sources.filtered(filteredPlatforms), + functions, + properties, + classlikes, + visibility.filtered(filteredPlatforms), + companion, + constructors, + generics, + filteredPlatforms, + extra + ) + this is DEnum -> DEnum( + dri, + name, + enumEntries, + documentation.filtered(filteredPlatforms), + expectPresentInSet.filtered(filteredPlatforms), + sources.filtered(filteredPlatforms), + functions, + properties, + classlikes, + visibility.filtered(filteredPlatforms), + companion, + constructors, + supertypes.filtered(filteredPlatforms), + filteredPlatforms, + extra + ) + this is DInterface -> DInterface( + dri, + name, + documentation.filtered(filteredPlatforms), + expectPresentInSet.filtered(filteredPlatforms), + sources.filtered(filteredPlatforms), + functions, + properties, + classlikes, + visibility.filtered(filteredPlatforms), + companion, + generics, + supertypes.filtered(filteredPlatforms), + filteredPlatforms, + extra + ) + this is DObject -> DObject( + name, + dri, + documentation.filtered(filteredPlatforms), + expectPresentInSet.filtered(filteredPlatforms), + sources.filtered(filteredPlatforms), + functions, + properties, + classlikes, + visibility, + supertypes.filtered(filteredPlatforms), + filteredPlatforms, + extra + ) + else -> null + } + } + } + } + return Pair(classlikesListChanged, filteredClasslikes) + } + + + } + + private class DeprecationFilter( + val globalOptions: DokkaConfiguration.PassConfiguration, + val packageOptions: List + ) { + + fun T.isAllowedInPackage(): Boolean where T : WithExtraProperties, T : Documentable { + val packageName = this.dri.packageName + val condition = packageName != null && packageOptions.firstOrNull { + packageName.startsWith(it.prefix) + }?.skipDeprecated + ?: globalOptions.skipDeprecated + + fun T.isDeprecated() = extra[Annotations]?.let { annotations -> + annotations.content.values.flatten().any { + it.dri.toString() == "kotlin/Deprecated///PointingToDeclaration/" + } + } ?: false + + return !(condition && this.isDeprecated()) + } + + fun processModule(original: DModule) = + filterPackages(original.packages).let { (modified, packages) -> + if (!modified) original + else + DModule( + original.name, + packages = packages, + documentation = original.documentation, + sourceSets = original.sourceSets, + extra = original.extra + ) + } + + + private fun filterPackages(packages: List): Pair> { + var packagesListChanged = false + val filteredPackages = packages.mapNotNull { + var modified = false + val functions = filterFunctions(it.functions).let { (listModified, list) -> + modified = modified || listModified + list + } + val properties = filterProperties(it.properties).let { (listModified, list) -> + modified = modified || listModified + list + } + val classlikes = filterClasslikes(it.classlikes).let { (listModified, list) -> + modified = modified || listModified + list + } + when { + !modified -> it + else -> { + packagesListChanged = true + DPackage( + it.dri, + functions, + properties, + classlikes, + it.typealiases, + it.documentation, + it.expectPresentInSet, + it.sourceSets, + it.extra + ) + } + } + } + return Pair(packagesListChanged, filteredPackages) + } + + private fun filterFunctions( + functions: List + ) = functions.filter { it.isAllowedInPackage() }.let { + Pair(it.size != functions.size, it) + } + + private fun filterProperties( + properties: List + ): Pair> = properties.filter { + it.isAllowedInPackage() + }.let { + Pair(properties.size != it.size, it) + } + + private fun filterEnumEntries(entries: List) = + entries.filter { it.isAllowedInPackage() }.map { entry -> + DEnumEntry( + entry.dri, + entry.name, + entry.documentation, + entry.expectPresentInSet, + filterFunctions(entry.functions).second, + filterProperties(entry.properties).second, + filterClasslikes(entry.classlikes).second, + entry.sourceSets, + entry.extra + ) + } + + private fun filterClasslikes( + classlikeList: List + ): Pair> { + var modified = false + return classlikeList.filter { + when (it) { + is DClass -> it.isAllowedInPackage() + is DInterface -> it.isAllowedInPackage() + is DEnum -> it.isAllowedInPackage() + is DObject -> it.isAllowedInPackage() + is DAnnotation -> it.isAllowedInPackage() + } + }.map { + fun helper(): DClasslike = when (it) { + is DClass -> DClass( + it.dri, + it.name, + filterFunctions(it.constructors).let { + modified = modified || it.first; it.second + }, + filterFunctions(it.functions).let { + modified = modified || it.first; it.second + }, + filterProperties(it.properties).let { + modified = modified || it.first; it.second + }, + filterClasslikes(it.classlikes).let { + modified = modified || it.first; it.second + }, + it.sources, + it.visibility, + it.companion, + it.generics, + it.supertypes, + it.documentation, + it.expectPresentInSet, + it.modifier, + it.sourceSets, + it.extra + ) + is DAnnotation -> DAnnotation( + it.name, + it.dri, + it.documentation, + it.expectPresentInSet, + it.sources, + filterFunctions(it.functions).let { + modified = modified || it.first; it.second + }, + filterProperties(it.properties).let { + modified = modified || it.first; it.second + }, + filterClasslikes(it.classlikes).let { + modified = modified || it.first; it.second + }, + it.visibility, + it.companion, + filterFunctions(it.constructors).let { + modified = modified || it.first; it.second + }, + it.generics, + it.sourceSets, + it.extra + ) + is DEnum -> DEnum( + it.dri, + it.name, + filterEnumEntries(it.entries), + it.documentation, + it.expectPresentInSet, + it.sources, + filterFunctions(it.functions).let { + modified = modified || it.first; it.second + }, + filterProperties(it.properties).let { + modified = modified || it.first; it.second + }, + filterClasslikes(it.classlikes).let { + modified = modified || it.first; it.second + }, + it.visibility, + it.companion, + filterFunctions(it.constructors).let { + modified = modified || it.first; it.second + }, + it.supertypes, + it.sourceSets, + it.extra + ) + is DInterface -> DInterface( + it.dri, + it.name, + it.documentation, + it.expectPresentInSet, + it.sources, + filterFunctions(it.functions).let { + modified = modified || it.first; it.second + }, + filterProperties(it.properties).let { + modified = modified || it.first; it.second + }, + filterClasslikes(it.classlikes).let { + modified = modified || it.first; it.second + }, + it.visibility, + it.companion, + it.generics, + it.supertypes, + it.sourceSets, + it.extra + ) + is DObject -> DObject( + it.name, + it.dri, + it.documentation, + it.expectPresentInSet, + it.sources, + filterFunctions(it.functions).let { + modified = modified || it.first; it.second + }, + filterProperties(it.properties).let { + modified = modified || it.first; it.second + }, + filterClasslikes(it.classlikes).let { + modified = modified || it.first; it.second + }, + it.visibility, + it.supertypes, + it.sourceSets, + it.extra + ) + } + helper() + }.let { + Pair(it.size != classlikeList.size || modified, it) + } + } + } + + private class EmptyPackagesFilter( + val passOptions: DokkaConfiguration.PassConfiguration + ) { + fun DPackage.shouldBeSkipped() = passOptions.skipEmptyPackages && + functions.isEmpty() && + properties.isEmpty() && + classlikes.isEmpty() + + fun processModule(module: DModule) = module.copy( + packages = module.packages.mapNotNull { pckg -> + if (pckg.shouldBeSkipped()) null + else pckg + } + ) + } +} \ No newline at end of file diff --git a/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilter.kt b/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilter.kt deleted file mode 100644 index 66c917c5..00000000 --- a/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilter.kt +++ /dev/null @@ -1,338 +0,0 @@ -package org.jetbrains.dokka.base.transformers.documentables - -import org.jetbrains.dokka.DokkaConfiguration -import org.jetbrains.dokka.model.* -import org.jetbrains.dokka.model.DAnnotation -import org.jetbrains.dokka.model.DEnum -import org.jetbrains.dokka.model.DFunction -import org.jetbrains.dokka.plugability.DokkaContext -import org.jetbrains.dokka.transformers.documentation.PreMergeDocumentableTransformer - -internal class DocumentableVisibilityFilter(val context: DokkaContext) : PreMergeDocumentableTransformer { - - override fun invoke(modules: List): List = modules.map { original -> - val packageOptions = - context.configuration.passesConfigurations.first { original.sourceSets.contains(context.sourceSet(it)) } - .perPackageOptions - val passOptions = context.configuration.passesConfigurations.first { - original.platformData.contains(it.platformData) - } - - DocumentableFilter(packageOptions, passOptions).processModule(original) - } - - private class DocumentableFilter( - val packageOptions: List, - val globalOptions: DokkaConfiguration.PassConfiguration - ) { - - fun Visibility.isAllowedInPackage(packageName: String?) = when (this) { - is JavaVisibility.Public, - is JavaVisibility.Default, - is KotlinVisibility.Public -> true - else -> packageName != null - && packageOptions.firstOrNull { packageName.startsWith(it.prefix) }?.includeNonPublic - ?: globalOptions.includeNonPublic - } - - fun processModule(original: DModule) = - filterPackages(original.packages).let { (modified, packages) -> - if (!modified) original - else - DModule( - original.name, - packages = packages, - documentation = original.documentation, - sourceSets = original.sourceSets, - extra = original.extra - ) - } - - private fun filterPackages(packages: List): Pair> { - var packagesListChanged = false - val filteredPackages = packages.mapNotNull { - var modified = false - val functions = filterFunctions(it.functions).let { (listModified, list) -> - modified = modified || listModified - list - } - val properties = filterProperties(it.properties).let { (listModified, list) -> - modified = modified || listModified - list - } - val classlikes = filterClasslikes(it.classlikes).let { (listModified, list) -> - modified = modified || listModified - list - } - when { - !modified -> it - functions.isEmpty() && properties.isEmpty() && classlikes.isEmpty() -> { - packagesListChanged = true - null - } - else -> { - packagesListChanged = true - DPackage( - it.dri, - functions, - properties, - classlikes, - it.typealiases, - it.documentation, - it.expectPresentInSet, - it.sourceSets, - it.extra - ) - } - } - } - return Pair(packagesListChanged, filteredPackages) - } - - private fun alwaysTrue(a: T, p: SourceSetData) = true - private fun alwaysFalse(a: T, p: SourceSetData) = false - - private fun WithVisibility.visibilityForPlatform(data: SourceSetData): Visibility? = visibility[data] - - private fun T.filterPlatforms( - additionalCondition: (T, SourceSetData) -> Boolean = ::alwaysTrue, - alternativeCondition: (T, SourceSetData) -> Boolean = ::alwaysFalse - ) where T : Documentable, T : WithVisibility = - sourceSets.filter { d -> - visibilityForPlatform(d)?.isAllowedInPackage(dri.packageName) == true && - additionalCondition(this, d) || - alternativeCondition(this, d) - }.toSet() - - private fun List.transform( - additionalCondition: (T, SourceSetData) -> Boolean = ::alwaysTrue, - alternativeCondition: (T, SourceSetData) -> Boolean = ::alwaysFalse, - recreate: (T, Set) -> T - ): Pair> where T : Documentable, T : WithVisibility { - var changed = false - val values = mapNotNull { t -> - val filteredPlatforms = t.filterPlatforms(additionalCondition, alternativeCondition) - when (filteredPlatforms.size) { - t.visibility.size -> t - 0 -> { - changed = true - null - } - else -> { - changed = true - recreate(t, filteredPlatforms) - } - } - } - return Pair(changed, values) - } - - private fun filterFunctions( - functions: List, - additionalCondition: (DFunction, SourceSetData) -> Boolean = ::alwaysTrue - ) = - functions.transform(additionalCondition) { original, filteredPlatforms -> - with(original) { - DFunction( - dri, - name, - isConstructor, - parameters, - documentation.filtered(filteredPlatforms), - expectPresentInSet.filtered(filteredPlatforms), - sources.filtered(filteredPlatforms), - visibility.filtered(filteredPlatforms), - type, - generics.mapNotNull { it.filter(filteredPlatforms) }, - receiver, - modifier, - filteredPlatforms, - extra - ) - } - } - - private fun hasVisibleAccessorsForPlatform(property: DProperty, data: SourceSetData) = - property.getter?.visibilityForPlatform(data)?.isAllowedInPackage(property.dri.packageName) == true || - property.setter?.visibilityForPlatform(data)?.isAllowedInPackage(property.dri.packageName) == true - - private fun filterProperties( - properties: List, - additionalCondition: (DProperty, SourceSetData) -> Boolean = ::alwaysTrue - ): Pair> = - properties.transform(additionalCondition, ::hasVisibleAccessorsForPlatform) { original, filteredPlatforms -> - with(original) { - DProperty( - dri, - name, - documentation.filtered(filteredPlatforms), - expectPresentInSet.filtered(filteredPlatforms), - sources.filtered(filteredPlatforms), - visibility.filtered(filteredPlatforms), - type, - receiver, - setter, - getter, - modifier, - filteredPlatforms, - generics.mapNotNull { it.filter(filteredPlatforms) }, - extra - ) - } - } - - private fun filterEnumEntries(entries: List, filteredPlatforms: Set) = - entries.mapNotNull { entry -> - if (filteredPlatforms.containsAll(entry.sourceSets)) entry - else { - val intersection = filteredPlatforms.intersect(entry.sourceSets) - if (intersection.isEmpty()) null - else DEnumEntry( - entry.dri, - entry.name, - entry.documentation.filtered(intersection), - entry.expectPresentInSet.filtered(filteredPlatforms), - filterFunctions(entry.functions) { _, data -> data in intersection }.second, - filterProperties(entry.properties) { _, data -> data in intersection }.second, - filterClasslikes(entry.classlikes) { _, data -> data in intersection }.second, - intersection, - entry.extra - ) - } - } - - private fun filterClasslikes( - classlikeList: List, - additionalCondition: (DClasslike, SourceSetData) -> Boolean = ::alwaysTrue - ): Pair> { - var classlikesListChanged = false - val filteredClasslikes: List = classlikeList.mapNotNull { - with(it) { - val filteredPlatforms = filterPlatforms(additionalCondition) - if (filteredPlatforms.isEmpty()) { - classlikesListChanged = true - null - } else { - var modified = sourceSets.size != filteredPlatforms.size - val functions = - filterFunctions(functions) { _, data -> data in filteredPlatforms }.let { (listModified, list) -> - modified = modified || listModified - list - } - val properties = - filterProperties(properties) { _, data -> data in filteredPlatforms }.let { (listModified, list) -> - modified = modified || listModified - list - } - val classlikes = - filterClasslikes(classlikes) { _, data -> data in filteredPlatforms }.let { (listModified, list) -> - modified = modified || listModified - list - } - val companion = - if (this is WithCompanion) filterClasslikes(listOfNotNull(companion)) { _, data -> data in filteredPlatforms }.let { (listModified, list) -> - modified = modified || listModified - list.firstOrNull() as DObject? - } else null - val constructors = if (this is WithConstructors) - filterFunctions(constructors) { _, data -> data in filteredPlatforms }.let { (listModified, list) -> - modified = modified || listModified - list - } else emptyList() - val generics = - if (this is WithGenerics) generics.mapNotNull { param -> param.filter(filteredPlatforms) } else emptyList() - val enumEntries = - if (this is DEnum) filterEnumEntries(entries, filteredPlatforms) else emptyList() - classlikesListChanged = classlikesListChanged || modified - when { - !modified -> this - this is DClass -> DClass( - dri, - name, - constructors, - functions, - properties, - classlikes, - sources.filtered(filteredPlatforms), - visibility.filtered(filteredPlatforms), - companion, - generics, - supertypes.filtered(filteredPlatforms), - documentation.filtered(filteredPlatforms), - expectPresentInSet.filtered(filteredPlatforms), - modifier, - filteredPlatforms, - extra - ) - this is DAnnotation -> DAnnotation( - name, - dri, - documentation.filtered(filteredPlatforms), - expectPresentInSet.filtered(filteredPlatforms), - sources.filtered(filteredPlatforms), - functions, - properties, - classlikes, - visibility.filtered(filteredPlatforms), - companion, - constructors, - generics, - filteredPlatforms, - extra - ) - this is DEnum -> DEnum( - dri, - name, - enumEntries, - documentation.filtered(filteredPlatforms), - expectPresentInSet.filtered(filteredPlatforms), - sources.filtered(filteredPlatforms), - functions, - properties, - classlikes, - visibility.filtered(filteredPlatforms), - companion, - constructors, - supertypes.filtered(filteredPlatforms), - filteredPlatforms, - extra - ) - this is DInterface -> DInterface( - dri, - name, - documentation.filtered(filteredPlatforms), - expectPresentInSet.filtered(filteredPlatforms), - sources.filtered(filteredPlatforms), - functions, - properties, - classlikes, - visibility.filtered(filteredPlatforms), - companion, - generics, - supertypes.filtered(filteredPlatforms), - filteredPlatforms, - extra - ) - this is DObject -> DObject( - name, - dri, - documentation.filtered(filteredPlatforms), - expectPresentInSet.filtered(filteredPlatforms), - sources.filtered(filteredPlatforms), - functions, - properties, - classlikes, - visibility, - supertypes.filtered(filteredPlatforms), - filteredPlatforms, - extra - ) - else -> null - } - } - } - } - return Pair(classlikesListChanged, filteredClasslikes) - } - } -} \ No newline at end of file -- cgit