lateinit var expressionResolver: ExpressionResolver
    lateinit var codeAnalyzer: CodeAnalyzer
    lateinit var errorCollector: ErrorCollector

    override fun doResolveExpression(context: AnalysisContext, expr: Expr): ObjectOrigin? =
        expressionResolver.doResolveExpression(context, expr)

    override fun analyzeStatementsInProgramOrder(context: AnalysisContext, elements: List<DataStatement>) {

    override fun doResolveExpressionStatement(context: AnalysisContext, expr: Expr) {
        val resolvedExpr = expressionResolver.doResolveExpression(context, expr)

        when (expr) {
            is FunctionCall ->
                if (resolvedExpr is ObjectOrigin.FunctionOrigin && isDanglingPureCall(resolvedExpr))

interface ExpressionResolver {
    fun doResolveExpression(context: AnalysisContext, expr: Expr): ObjectOrigin?
}


class ExpressionResolverImpl(
    private val propertyAccessResolver: PropertyAccessResolver,
    private val functionCallResolver: FunctionCallResolver,
) : ExpressionResolver {
    override fun doResolveExpression(context: AnalysisContext, expr: Expr): ObjectOrigin? = with(context) {

            Resolution(resolution)
        } ?: elementErrors[expr]?.let { errors ->
            Errors(errors)
        } ?: NoResolution

    override fun doResolveExpression(context: AnalysisContext, expr: Expr): ObjectOrigin? {
        val result = expressionResolver.doResolveExpression(context, expr)
        if (result != null) {
            expressionResolution[expr] = result
        }
        return result
    }

    ) {
        require(propertyAccess.receiver != null) { "Property access with explicit receiver expected" }

        val propertyName = propertyAccess.name

        expressionResolver.doResolveExpression(this, propertyAccess.receiver)?.let { receiverOrigin ->
            findDataProperty(getDataType(receiverOrigin), propertyName)?.let { property ->

                functionCall.args.filterIsInstance<FunctionArgument.ValueArgument>().forEach {
                    val resolution = expressionResolver.doResolveExpression(context, it.expr)
                    if (resolution == null) {
                        hasErrors = true
                    } else {
                        put(it, resolution)
                    }