sealed interface DocumentError


data class SyntaxError(val parsingError: ParsingError) : DocumentError // TODO: use a better representation once integration can be done


data class UnsupportedKotlinFeature(val unsupportedConstruct: UnsupportedConstruct) : DocumentError


data class UnsupportedSyntax(val cause: UnsupportedSyntaxCause) : DocumentError


sealed interface UnsupportedSyntaxCause {

        data class Failed(val errors: Collection<DocumentError>) : ExprConversion
    }


    private
    fun exprToValue(expr: Expr): ExprConversion = when (expr) {
        is Literal<*> -> ExprConversion.Converted(literalNode(expr))
        is FunctionCall -> run {
            val errors = mutableListOf<DocumentError>()

}


internal
data class DefaultErrorNode(
    override val sourceData: SourceData,
    override val errors: Collection<DocumentError>
) : DeclarativeDocument.DocumentNode.ErrorNode {
    override fun toString(): String = "error(${errors.joinToString()})"
}


internal
data class DefaultLiteralNode(
    override val value: Any,

            val elementValues: Collection<ValueNode>
            val content: Collection<DocumentNode>
        }

        interface ErrorNode : DocumentNode {
            val errors: Collection<DocumentError>
        }
    }

    sealed interface ValueNode : Node {
        override val sourceData: SourceData

        interface LiteralValueNode : ValueNode {
            val value: Any
        }

                }
            }

            document.content.forEach(::visit)
        }

        private
        fun errorString(error: DocumentError): String = when (error) {
            is SyntaxError -> "SyntaxError(${error.parsingError.message})"
            is UnsupportedKotlinFeature -> "UnsupportedKotlinFeature(${error.unsupportedConstruct.languageFeature})"