diff options
Diffstat (limited to 'plugins/base/src/main/kotlin/transformers')
| -rw-r--r-- | plugins/base/src/main/kotlin/transformers/documentables/DefaultDocumentableMerger.kt | 270 |
1 files changed, 187 insertions, 83 deletions
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/DefaultDocumentableMerger.kt b/plugins/base/src/main/kotlin/transformers/documentables/DefaultDocumentableMerger.kt index 6b612733..485aca4c 100644 --- a/plugins/base/src/main/kotlin/transformers/documentables/DefaultDocumentableMerger.kt +++ b/plugins/base/src/main/kotlin/transformers/documentables/DefaultDocumentableMerger.kt @@ -3,20 +3,34 @@ package org.jetbrains.dokka.base.transformers.documentables import org.jetbrains.dokka.model.* import org.jetbrains.dokka.model.Enum import org.jetbrains.dokka.model.Function +import org.jetbrains.dokka.model.Package +import org.jetbrains.dokka.model.Annotation +import org.jetbrains.dokka.model.properties.mergeExtras +import org.jetbrains.dokka.pages.PlatformData import org.jetbrains.dokka.plugability.DokkaContext import org.jetbrains.dokka.transformers.documentation.DocumentableMerger +import org.jetbrains.kotlin.utils.addToStdlib.firstNotNullResult internal object DefaultDocumentableMerger : DocumentableMerger { override fun invoke(modules: Collection<Module>, context: DokkaContext): Module { - if (!modules.all { it.name == modules.first().name }) + val name = modules.map { it.name }.distinct().singleOrNull() ?: run { context.logger.error("All module names need to be the same") - return Module( - modules.first().name, - merge( - modules.flatMap { it.packages }, - Package::mergeWith - ) - ) + modules.first().name + } + + return modules.reduce { left, right -> + val list = listOf(left, right) + + Module( + name = name, + packages = merge( + list.flatMap { it.packages }, + Package::mergeWith + ), + documentation = list.platformDependentFor { documentation }, + platformData = list.flatMap { it.platformData }.distinct() + ).mergeExtras(left, right) + } } } @@ -25,91 +39,181 @@ private fun <T : Documentable> merge(elements: List<T>, reducer: (T, T) -> T): L .reduce { _, left, right -> reducer(left, right) } .values.toList() -fun PlatformInfo.mergeWith(other: PlatformInfo?) = BasePlatformInfo( - documentationNode, - (platformData + (other?.platformData ?: emptyList())).distinct() -) +private fun <T : Any, D : Documentable> Iterable<D>.platformDependentFor( + selector: D.() -> PlatformDependent<T> +): PlatformDependent<T> { + val actuals = map { it.selector().map } + .flatMap { it.entries } + .associate { (k, v) -> k to v } -fun ClassPlatformInfo.mergeWith(other: ClassPlatformInfo?) = ClassPlatformInfo( - info.mergeWith(other?.info), - (inherited + (other?.inherited ?: emptyList())).distinct() -) + val expected = firstNotNullResult { it.selector().expect } -fun List<ClassPlatformInfo>.mergeClassPlatformInfo(): List<ClassPlatformInfo> = - groupingBy { it.documentationNode.children + it.inherited }.reduce { _, left, right -> - left.mergeWith(right) - }.values.toList() - -fun List<PlatformInfo>.merge(): List<PlatformInfo> = - groupingBy { it.documentationNode }.reduce { _, left, right -> - left.mergeWith(right) - }.values.toList() - -fun Function.mergeWith(other: Function): Function = Function( - dri, - name, - returnType, - isConstructor, - other.receiver?.let { receiver?.mergeWith(it) }, - merge(parameters + other.parameters, Parameter::mergeWith), - expected?.mergeWith(other.expected), - (actual + other.actual).merge(), - visibility = (visibility + other.visibility) -) + return PlatformDependent(actuals, expected) +} -fun Property.mergeWith(other: Property) = Property( - dri, - name, - other.receiver?.let { receiver?.mergeWith(it) }, - expected?.mergeWith(other.expected), - (actual + other.actual).merge(), - accessors = (this.accessors + other.accessors).distinct(), - visibility = (visibility + other.visibility) +private fun <T: Any> PlatformDependent<T>.mergeWith(other: PlatformDependent<T>) = PlatformDependent( + map = this + other, + expect = expect ?: other.expect ) +private fun <T> mergeExpectActual( + elements: List<T>, + reducer: (T, T) -> T, + platformSetter: T.(List<PlatformData>) -> T +): List<T> where T : Documentable, T : WithExpectActual { + + fun findExpect(actual: T, expects: List<T>): Expect<T> = + expects.find { it.platformData.containsAll(actual.platformData) }.let { Expect.from(it) } + + fun reduceExpectActual(entry: Map.Entry<Expect<T>, List<T>>): List<T> = when (val expect = entry.key) { + Expect.NotFound -> entry.value + is Expect.Found -> entry.value.plus(expect.expect).reduce(reducer).let(::listOf) + } + + fun analyzeExpectActual(sameDriElements: List<T>): List<T> { + val (expect, actual) = sameDriElements.partition { it.actual.expect != null } + val mergedExpect = expect.groupBy { it.actual.expect?.path }.values.map { e -> + e.first().platformSetter(e.flatMap { it.platformData }.distinct()) + } + return actual.groupBy { findExpect(it, mergedExpect) }.flatMap { reduceExpectActual(it) } + } + + return elements.groupBy { it.dri }.values.flatMap(::analyzeExpectActual) +} + +private sealed class Expect<out T : Any> { + object NotFound : Expect<Nothing>() + data class Found<T : Any>(val expect: T) : Expect<T>() + + companion object { + fun <T : Any> from(t: T?) = t?.let(::Found) ?: NotFound + } +} + +fun Package.mergeWith(other: Package) : Package = copy( + functions = mergeExpectActual(functions + other.functions, Function::mergeWith) { copy(platformData = it) }, + properties = mergeExpectActual(properties + other.properties, Property::mergeWith) { copy(platformData = it) }, + classlikes = mergeExpectActual(classlikes + other.classlikes, Classlike::mergeWith, Classlike::setPlatformData), + packages = merge(packages + other.packages, Package::mergeWith), + documentation = documentation.mergeWith(other.documentation), + platformData = (platformData + other.platformData).distinct() +).mergeExtras(this, other) + +fun Function.mergeWith(other: Function) : Function = copy( + parameters = merge(this.parameters + other.parameters, Parameter::mergeWith), + receiver = receiver?.let { r -> other.receiver?.let { r.mergeWith(it) } ?: r } ?: other.receiver, + documentation = documentation.mergeWith(other.documentation), + actual = actual.mergeWith(other.actual), + visibility = visibility.mergeWith(other.visibility), + platformData = (platformData + other.platformData).distinct(), + generics = merge(generics + other.generics, TypeParameter::mergeWith) +).mergeExtras(this, other) + +fun Property.mergeWith(other: Property): Property = copy( + receiver = receiver?.let { r -> other.receiver?.let { r.mergeWith(it) } ?: r } ?: other.receiver, + documentation = documentation.mergeWith(other.documentation), + actual = actual.mergeWith(other.actual), + visibility = visibility.mergeWith(other.visibility), + platformData = (platformData + other.platformData).distinct(), + getter = getter.mergeWith(other.getter), + setter = setter?.let { s -> other.setter?.let { s.mergeWith(it) } ?: s } ?: other.setter +).mergeExtras(this, other) + +fun Classlike.setPlatformData(platformData: List<PlatformData>): Classlike = when(this) { + is Class -> copy(platformData = platformData) + is Enum -> copy(platformData = platformData) + is Interface -> copy(platformData = platformData) + is Object -> copy(platformData = platformData) + else -> throw IllegalStateException("${this::class.qualifiedName} ${this.name} cannot have platform set") +} + fun Classlike.mergeWith(other: Classlike): Classlike = when { this is Class && other is Class -> mergeWith(other) this is Enum && other is Enum -> mergeWith(other) - else -> throw IllegalStateException("${this::class.qualifiedName} ${this.name} cannot be merged with ${other::class.qualifiedName} ${other.name}") + this is Interface && other is Interface -> mergeWith(other) + this is Object && other is Object -> mergeWith(other) + this is Annotation && other is Annotation -> mergeWith(other) + else -> throw IllegalStateException("${this::class.qualifiedName} ${this.name} cannot be mergesd with ${other::class.qualifiedName} ${other.name}") } -fun Class.mergeWith(other: Class) = Class( - dri = dri, - name = name, - kind = kind, - constructors = merge(constructors + other.constructors, Function::mergeWith), - functions = merge(functions + other.functions, Function::mergeWith), - properties = merge(properties + other.properties, Property::mergeWith), - classlikes = merge(classlikes + other.classlikes, Classlike::mergeWith), - expected = expected?.mergeWith(other.expected), - actual = (actual + other.actual).mergeClassPlatformInfo(), - visibility = (visibility + other.visibility) -) +fun Class.mergeWith(other: Class): Class = copy( + constructors = mergeExpectActual(constructors + other.constructors, Function::mergeWith) { copy(platformData = it) }, + functions = mergeExpectActual(functions + other.functions, Function::mergeWith) { copy(platformData = it) }, + properties = mergeExpectActual(properties + other.properties, Property::mergeWith) { copy(platformData = it) }, + classlikes = mergeExpectActual(classlikes + other.classlikes, Classlike::mergeWith, Classlike::setPlatformData), + companion = companion?.let { c -> other.companion?.let { c.mergeWith(it) } ?: c } ?: other.companion, + generics = merge(generics + other.generics, TypeParameter::mergeWith), + supertypes = supertypes.mergeWith(other.supertypes), + documentation = documentation.mergeWith(other.documentation), + actual = actual.mergeWith(other.actual), + visibility = visibility.mergeWith(other.visibility), + platformData = (platformData + other.platformData).distinct() +).mergeExtras(this, other) -fun Enum.mergeWith(other: Enum) = Enum( - dri = dri, - name = name, - functions = merge(functions + other.functions, Function::mergeWith), - properties = merge(properties + other.properties, Property::mergeWith), - classlikes = merge(classlikes + other.classlikes, Classlike::mergeWith), - expected = expected?.mergeWith(other.expected), - actual = (actual + other.actual).mergeClassPlatformInfo(), - entries = (this.entries + other.entries.distinctBy { it.dri }.toList()), - constructors = merge(constructors + other.constructors, Function::mergeWith), - visibility = visibility -) +fun Enum.mergeWith(other: Enum): Enum = copy( + entries = merge(entries + other.entries, EnumEntry::mergeWith), + constructors = mergeExpectActual(constructors + other.constructors, Function::mergeWith) { copy(platformData = it) }, + functions = mergeExpectActual(functions + other.functions, Function::mergeWith) { copy(platformData = it) }, + properties = mergeExpectActual(properties + other.properties, Property::mergeWith) { copy(platformData = it) }, + classlikes = mergeExpectActual(classlikes + other.classlikes, Classlike::mergeWith, Classlike::setPlatformData), + companion = companion?.let { c -> other.companion?.let { c.mergeWith(it) } ?: c } ?: other.companion, + supertypes = supertypes.mergeWith(other.supertypes), + documentation = documentation.mergeWith(other.documentation), + actual = actual.mergeWith(other.actual), + visibility = visibility.mergeWith(other.visibility), + platformData = (platformData + other.platformData).distinct() +).mergeExtras(this, other) -fun Parameter.mergeWith(other: Parameter) = Parameter( - dri, - name, - type, - expected?.mergeWith(other.expected), - (actual + other.actual).merge() -) +fun EnumEntry.mergeWith(other: EnumEntry): EnumEntry = copy( + functions = mergeExpectActual(functions + other.functions, Function::mergeWith) { copy(platformData = it) }, + properties = mergeExpectActual(properties + other.properties, Property::mergeWith) { copy(platformData = it) }, + classlikes = mergeExpectActual(classlikes + other.classlikes, Classlike::mergeWith, Classlike::setPlatformData), + documentation = documentation.mergeWith(other.documentation), + platformData = (platformData + other.platformData).distinct() +).mergeExtras(this, other) + +fun Object.mergeWith(other: Object): Object = copy( + functions = mergeExpectActual(functions + other.functions, Function::mergeWith) { copy(platformData = it) }, + properties = mergeExpectActual(properties + other.properties, Property::mergeWith) { copy(platformData = it) }, + classlikes = mergeExpectActual(classlikes + other.classlikes, Classlike::mergeWith, Classlike::setPlatformData), + supertypes = supertypes.mergeWith(other.supertypes), + documentation = documentation.mergeWith(other.documentation), + actual = actual.mergeWith(other.actual), + visibility = visibility.mergeWith(other.visibility), + platformData = (platformData + other.platformData).distinct() +).mergeExtras(this, other) + +fun Interface.mergeWith(other: Interface): Interface = copy( + functions = mergeExpectActual(functions + other.functions, Function::mergeWith) { copy(platformData = it) }, + properties = mergeExpectActual(properties + other.properties, Property::mergeWith) { copy(platformData = it) }, + classlikes = mergeExpectActual(classlikes + other.classlikes, Classlike::mergeWith, Classlike::setPlatformData), + companion = companion?.let { c -> other.companion?.let { c.mergeWith(it) } ?: c } ?: other.companion, + generics = merge(generics + other.generics, TypeParameter::mergeWith), + supertypes = supertypes.mergeWith(other.supertypes), + documentation = documentation.mergeWith(other.documentation), + actual = actual.mergeWith(other.actual), + visibility = visibility.mergeWith(other.visibility), + platformData = (platformData + other.platformData).distinct() +).mergeExtras(this, other) + +fun Annotation.mergeWith(other: Annotation): Annotation = copy( + constructors = mergeExpectActual(constructors + other.constructors, Function::mergeWith) { copy(platformData = it) }, + functions = mergeExpectActual(functions + other.functions, Function::mergeWith) { copy(platformData = it) }, + properties = mergeExpectActual(properties + other.properties, Property::mergeWith) { copy(platformData = it) }, + classlikes = mergeExpectActual(classlikes + other.classlikes, Classlike::mergeWith, Classlike::setPlatformData), + companion = companion?.let { c -> other.companion?.let { c.mergeWith(it) } ?: c } ?: other.companion, + documentation = documentation.mergeWith(other.documentation), + actual = actual.mergeWith(other.actual), + visibility = visibility.mergeWith(other.visibility), + platformData = (platformData + other.platformData).distinct() +).mergeExtras(this, other) + +fun Parameter.mergeWith(other: Parameter): Parameter = copy( + documentation = documentation.mergeWith(other.documentation), + platformData = (platformData + other.platformData).distinct() +).mergeExtras(this, other) -fun Package.mergeWith(other: Package): Package = Package( - dri, - merge(functions + other.functions, Function::mergeWith), - merge(properties + other.properties, Property::mergeWith), - merge(classlikes + other.classlikes, Classlike::mergeWith) -)
\ No newline at end of file +fun TypeParameter.mergeWith(other: TypeParameter): TypeParameter = copy( + documentation = documentation.mergeWith(other.documentation), + platformData = (platformData + other.platformData).distinct() +).mergeExtras(this, other)
\ No newline at end of file |