azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[FIR/IR generator] Deduplicate interface/abstract class configuration

Browse Source
This commit is contained in:
Sergej Jaskiewicz
2023-09-18 19:52:53 +02:00
committed by Space Team
parent b231e69cd3
commit 8c6da9fddb
5 changed files with 113 additions and 110 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/util/configureInterfacesAndAbstractClasses.kt
+8 -70
View File
@@ -9,81 +9,19 @@ import org.jetbrains.kotlin.fir.tree.generator.context.AbstractFirTreeBuilder
import org.jetbrains.kotlin.fir.tree.generator.model.*
import org.jetbrains.kotlin.generators.tree.ImplementationKindOwner
import org.jetbrains.kotlin.generators.tree.ImplementationKind
import org.jetbrains.kotlin.generators.util.Node
import org.jetbrains.kotlin.generators.util.solveGraphForClassVsInterface
import org.jetbrains.kotlin.generators.tree.InterfaceAndAbstractClassConfigurator
private class NodeImpl(val element: ImplementationKindOwner) : Node {
override val parents: List<Node>
get() = element.allParents.map(::NodeImpl)
private class FirInterfaceAndAbstractClassConfigurator(builder: AbstractFirTreeBuilder) : InterfaceAndAbstractClassConfigurator() {
override val origin: NodeImpl
get() = if (element.origin == element) this else NodeImpl(element.origin)
override val elements = (builder.elements + builder.elements.flatMap { it.allImplementations }).map { it.origin }
override fun equals(other: Any?): Boolean =
other is NodeImpl && element == other.element
override val ImplementationKindOwner.origin: ImplementationKindOwner
get() = if (this is ImplementationWithArg) implementation else this
override fun hashCode(): Int =
element.hashCode()
override fun shouldBeFinalClass(element: ImplementationKindOwner, allParents: Set<ImplementationKindOwner>): Boolean =
element is Implementation && element !in allParents
}
fun configureInterfacesAndAbstractClasses(builder: AbstractFirTreeBuilder) {
val elements = collectElements(builder)
val solution = solveGraphForClassVsInterface(
elements,
elements.filter { it.element.kind?.isInterface == true },
elements.filter { it.element.kind?.isInterface == false },
)
updateKinds(elements, solution)
updateSealedKinds(elements)
FirInterfaceAndAbstractClassConfigurator(builder).configureInterfacesAndAbstractClasses()
}
private fun collectElements(builder: AbstractFirTreeBuilder): List<NodeImpl> {
return (builder.elements + builder.elements.flatMap { it.allImplementations }).map { NodeImpl(it.origin) }
}
private fun updateKinds(nodes: List<NodeImpl>, solution: List<Boolean>) {
val allParents = nodes.flatMapTo(mutableSetOf()) { element -> element.parents.map { it.origin } }
for (index in solution.indices) {
val isClass = solution[index]
val node = nodes[index].origin
val element = node.element
val existingKind = element.kind
if (isClass) {
if (existingKind == ImplementationKind.Interface)
throw IllegalStateException(element.toString())
if (existingKind == null) {
element.kind = when (element) {
is Implementation -> {
if (node in allParents)
ImplementationKind.AbstractClass
else
ImplementationKind.FinalClass
}
is Element -> ImplementationKind.AbstractClass
else -> throw IllegalStateException()
}
}
} else {
element.kind = ImplementationKind.Interface
}
}
}
private fun updateSealedKinds(nodes: Collection<NodeImpl>) {
for (node in nodes) {
val element = node.element
if (element is Element) {
if (element.isSealed) {
element.kind = when (element.kind) {
ImplementationKind.AbstractClass -> ImplementationKind.SealedClass
ImplementationKind.Interface -> ImplementationKind.SealedInterface
else -> error("element $element with kind ${element.kind} can not be sealed")
}
}
}
}
}
private val ImplementationKindOwner.origin: ImplementationKindOwner get() = if (this is ImplementationWithArg) implementation else this