}


private
fun propertyNode(blockElement: Assignment, valueNode: DeclarativeDocument.ValueNode) = DefaultPropertyNode(blockElement.lhs.name, blockElement.sourceData, valueNode)


private
fun elementNode(blockElement: FunctionCall, arguments: List<DeclarativeDocument.ValueNode>, content: Collection<DeclarativeDocument.DocumentNode>) =

import org.gradle.internal.declarativedsl.dom.DeclarativeDocument.DocumentNode.PropertyNode
import org.gradle.internal.declarativedsl.dom.DeclarativeDocument.ValueNode
import org.gradle.internal.declarativedsl.dom.DeclarativeDocument.ValueNode.LiteralValueNode
import org.gradle.internal.declarativedsl.dom.DeclarativeDocument.ValueNode.ValueFactoryNode


/**
 * Checks the data in the content of the documents for equality structurally, ignoring:

    fun data(value: DeclarativeDocument.ValueNode): DValue = when (value) {
        is DeclarativeDocument.ValueNode.ValueFactoryNode -> data(value)
        is DeclarativeDocument.ValueNode.LiteralValueNode -> data(value)
    }

    fun data(value: DeclarativeDocument.ValueNode.ValueFactoryNode): DValueFactory
    fun data(value: DeclarativeDocument.ValueNode.LiteralValueNode): DLiteral
}

    override val sourceData: SourceData
) : DeclarativeDocument.ValueNode.LiteralValueNode {
    override fun toString(): String = "literal($value)"
}


internal
data class DefaultValueFactoryNode(
    override val factoryName: String,
    override val sourceData: SourceData,
    override val values: List<DeclarativeDocument.ValueNode>
) : DeclarativeDocument.ValueNode.ValueFactoryNode {

            fun valueToString(valueNode: DeclarativeDocument.ValueNode): String = when (valueNode) {
                is DeclarativeDocument.ValueNode.ValueFactoryNode -> "valueFactory(${valueNode.factoryName}" +
                    (if (valueNode.values.isNotEmpty()) ", ${valueNode.values.joinToString { valueToString(it) }})" else ")") +
                    maybeSourceData(valueNode)

        }
    }

    sealed interface ValueNode : Node {
        override val sourceData: SourceData

        interface LiteralValueNode : ValueNode {
            val value: Any
        }

        interface ValueFactoryNode : ValueNode {
            val factoryName: String
            val values: List<ValueNode> // TODO: restrict to a single value? or even a single literal?
        }
    }

import org.gradle.internal.declarativedsl.dom.DeclarativeDocument.ValueNode


object DomTestUtil {
    fun printDomByTraversal(
        document: DeclarativeDocument,
        nodeFormatter: (DocumentNode) -> String,
        valueFormatter: (ValueNode) -> String
    ): String = buildString {
        fun visitValue(valueNode: ValueNode, indent: Int) {
            append(" ".repeat(indent * 4))

) : ValueDataContainer<DValue, DValueFactory, DLiteral> {
    override fun data(value: ValueNode.ValueFactoryNode): DValueFactory = when (overlayOriginContainer.data(value)) {
        is FromOverlay -> overlay.data(value)
        is FromUnderlay -> underlay.data(value)
    }

    override fun data(value: ValueNode.LiteralValueNode): DLiteral = when (overlayOriginContainer.data(value)) {
        is FromOverlay -> overlay.data(value)

                    visit(node.value)
                }

                is DeclarativeDocument.ValueNode.ValueFactoryNode -> {
                    node.values.forEach(::visit)
                }

                is DeclarativeDocument.DocumentNode.ErrorNode,
                is DeclarativeDocument.ValueNode.LiteralValueNode -> Unit
            }
        }
        document.content.forEach(::visit)

            }
        }
    }

    private
    fun recordValueOriginRecursively(value: ValueNode, origin: OverlayValueOrigin) {
        overlayValueOrigin[value] = origin
        when (value) {
            is ValueNode.ValueFactoryNode -> value.values.forEach { recordValueOriginRecursively(it, origin) }
            is ValueNode.LiteralValueNode -> Unit
        }
    }

    /**
     * A key for merging document nodes.