private final Buildable buildable;
    private final Class<T> valueType;
    private final Factory<T> valueFactory;

    public BuildableBackedProvider(Buildable buildable, Class<T> valueType, Factory<T> valueFactory) {
        this.buildable = buildable;
        this.valueType = valueType;
        this.valueFactory = valueFactory;
    }

    @Nullable
    @Override
    public Class<T> getType() {
        return valueType;

            * element(adding, [literal(1)], content.size = 2) -> element(NestedReceiver)
                - literal(1) -> literal
                * property(b, valueFactory(myInt, [])) -> property(Int)
                    - valueFactory(myInt, []) -> valueFactory
                * element(unresolved4, [], content.size = 0) -> notResolved(UnresolvedSignature)
            * element(configuring, [], content.size = 4) -> configuring(NestedReceiver)

            """.trimIndent()
        )

        assertEquals(
            """
            element(myFun)[0..106]
                property(a, literal(1)[16..16])[12..16]
                property(b, valueFactory(f, literal(x)[28..30], valueFactory(z.f, literal(y)[37..39])[35..40])[26..41])[22..41]
                property(c, literal(true)[51..54])[47..54]
                element(nested)[60..89]
                    property(x, literal(y)[81..83])[77..83]

    override val sourceData: SourceData,
    override val values: List<DeclarativeDocument.ValueNode>
) : DeclarativeDocument.ValueNode.ValueFactoryNode {
    override fun toString(): String = "valueFactory($factoryName, [${values.joinToString()}])"

    }
}


internal
class OverlayRoutedValueDataContainer<DValue, DValueFactory : DValue, DLiteral : DValue>(
    private val overlayOriginContainer: OverlayOriginContainer,
    private val underlay: ValueDataContainer<DValue, DValueFactory, DLiteral>,
    private val overlay: ValueDataContainer<DValue, DValueFactory, DLiteral>
) : ValueDataContainer<DValue, DValueFactory, DLiteral> {

interface ValueDataContainer<DValue, DValueFactory : DValue, DLiteral : DValue> {
    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