get() = document.content
                .filter { node -> isTopLevelConventionsCall(node, resolutionContainer) }
                .flatMap { (it as? ElementNode)?.content.orEmpty() }
                .filterIsInstance<ElementNode>()
                .filter { it.name in usedSoftwareTypes }

        override val sourceIdentifier: SourceIdentifier
            get() = document.sourceIdentifier
    }

                    } else {
                        val underlayElements = underlayItems.map { (it as? ElementNode) ?: error("cannot merge an element $overlayItem with non-elements $underlayItems") }
                        val underlayContent = underlayElements.flatMap(ElementNode::content)

     * their [DeclarativeDocument.DocumentNode.ElementNode.content]s merged together.
     */
    data class MergedElements(
        val underlayElement: DeclarativeDocument.DocumentNode.ElementNode,
        val overlayElement: DeclarativeDocument.DocumentNode.ElementNode
    ) : OverlayElementOrigin

    /**

import org.gradle.internal.declarativedsl.dom.DeclarativeDocument
import org.gradle.internal.declarativedsl.dom.DeclarativeDocument.DocumentNode
import org.gradle.internal.declarativedsl.dom.DeclarativeDocument.DocumentNode.ElementNode
import org.gradle.internal.declarativedsl.dom.DocumentResolution
import org.gradle.internal.declarativedsl.dom.DocumentResolution.ElementResolution.SuccessfulElementResolution.ConfiguringElementResolved

            values.matchesPairwise(other.values, ValueNode::structurallyEquals)
    }

    fun DocumentNode.structurallyEquals(other: DocumentNode): Boolean = when (this) {
        is ElementNode -> other is ElementNode &&
            name == other.name &&
            elementValues.matchesPairwise(other.elementValues, ValueNode::structurallyEquals) &&
            content.matchesPairwise(other.content, DocumentNode::structurallyEquals)

    buildMap {
        fun visit(node: DeclarativeDocument.DocumentNode) {
            put(node, data(node))
            when (node) {
                is DeclarativeDocument.DocumentNode.ElementNode -> node.content.forEach(::visit)
                is DeclarativeDocument.DocumentNode.ErrorNode,
                is DeclarativeDocument.DocumentNode.PropertyNode -> Unit
            }
        }

    fun data(node: DeclarativeDocument.DocumentNode): DNode = when (node) {
        is DeclarativeDocument.DocumentNode.ElementNode -> data(node)
        is DeclarativeDocument.DocumentNode.PropertyNode -> data(node)
        is DeclarativeDocument.DocumentNode.ErrorNode -> data(node)
    }
    fun data(node: DeclarativeDocument.DocumentNode.ElementNode): DElement
    fun data(node: DeclarativeDocument.DocumentNode.PropertyNode): DProperty

internal
class DefaultDocumentResolutionContainer(
    private val elementResolution: Map<ElementNode, ElementResolution>,
    private val propertyResolution: Map<PropertyNode, PropertyResolution>,
    private val valueFactoryResolution: Map<ValueFactoryNode, ValueFactoryResolution>
) : DocumentResolutionContainer {
    override fun data(node: ElementNode): ElementResolution = elementResolution.getValue(node)

            append(" ".repeat(indent * 4))
            append(nodeFormatter(documentNode))
            when (documentNode) {
                is DocumentNode.ElementNode -> {
                    documentNode.elementValues.forEach { value ->
                        appendLine()
                        visitValue(value, indent + 1)
                    }

    val valueMapping: MutableMap<DeclarativeDocument.ValueNode, Expr> = mutableMapOf()

    val languageTreeMappingContainer = object : LanguageTreeMappingContainer {
        override fun data(node: DeclarativeDocument.DocumentNode.ElementNode): BlockElement = nodeMapping.getValue(node)
        override fun data(node: DeclarativeDocument.DocumentNode.PropertyNode): BlockElement = nodeMapping.getValue(node)