fun FlyweightCapableTreeStructure<LighterASTNode>.sourceData(
    sourceIdentifier: SourceIdentifier,
    sourceCode: String,
    sourceOffset: Int
) =
    LightTreeSourceData(
        sourceIdentifier,
        sourceCode,
        sourceOffset,
        root.range()
    )


class LightTreeSourceData(
    override val sourceIdentifier: SourceIdentifier,
    private val sourceCode: String,
    private val sourceOffset: Int,

import org.gradle.internal.declarativedsl.language.SourceIdentifier


interface LanguageTreeBuilder {
    fun build(parsedLightTree: ParsedLightTree, sourceIdentifier: SourceIdentifier): LanguageTreeResult
}


class DefaultLanguageTreeBuilder : LanguageTreeBuilder {
    override fun build(
        parsedLightTree: ParsedLightTree,
        sourceIdentifier: SourceIdentifier
    ): LanguageTreeResult =

                .filterIsInstance<ElementNode>()
                .filter { it.name in usedSoftwareTypes }

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

    private
    fun isTopLevelConventionsCall(
        node: DeclarativeDocument.DocumentNode,
        resolutionContainer: DocumentResolutionContainer

 */

package org.gradle.internal.declarativedsl.language


interface SourceData {
    val sourceIdentifier: SourceIdentifier
    val indexRange: IntRange
    val lineRange: IntRange
    val startColumn: Int
    val endColumn: Int

    fun text(): String
}

            return DefaultLanguageTreeBuilder().build(parsedTree, SourceIdentifier("test"))
        }

        fun parseAsTopLevelBlock(code: String): Block {
            val parsedTree = org.gradle.internal.declarativedsl.parsing.parse(code)
            return DefaultLanguageTreeBuilder().build(parsedTree, SourceIdentifier("test")).topLevelBlock
        }
    }
}


fun LanguageTreeResult.assert(

package org.gradle.internal.declarativedsl.dom

import org.gradle.internal.declarativedsl.language.SourceData
import org.gradle.internal.declarativedsl.language.SourceIdentifier


interface DeclarativeDocument {
    val content: Collection<DocumentNode>
    val sourceIdentifier: SourceIdentifier

    sealed interface Node {
        val sourceData: SourceData
    }

    sealed interface DocumentNode : Node {

        override fun getStartOffset(): Int = 0

        override fun getEndOffset(): Int = 0
    }

    private
    val sourceIdentifier = SourceIdentifier("test")

    private
    val mockSourceData = mockNode.sourceData(sourceIdentifier, "", 0)

    val languageTreeMappingContainer: LanguageTreeMappingContainer,
    override val content: Collection<DeclarativeDocument.DocumentNode>
) : DeclarativeDocument {

    override val sourceIdentifier: SourceIdentifier
        get() = block.sourceData.sourceIdentifier
}


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

            a = 1
            """.trimIndent()
        )

        val document = convertBlockToDocument(tree)

        assertEquals("test", document.sourceIdentifier.fileIdentifier)
        assertEquals(document.sourceIdentifier, document.content.single().sourceData.sourceIdentifier)
    }

    @Test
    fun `converts unsupported syntax to errors`() {
        val tree = parseAsTopLevelBlock(
            """
            myFun {

import org.gradle.internal.declarativedsl.language.LanguageTreeResult
import org.gradle.internal.declarativedsl.language.SourceIdentifier
import org.gradle.internal.declarativedsl.objectGraph.AssignmentResolver
import org.gradle.internal.declarativedsl.objectGraph.AssignmentTraceElement
import org.gradle.internal.declarativedsl.objectGraph.AssignmentTracer