): ObjectOrigin.FunctionOrigin {
        val newFunctionCallId = nextCallId()
        val valueBinding = function.binding.toValueBinding(argResolutions, functionCall.args.lastOrNull() is FunctionArgument.Lambda)
        val semantics = function.schemaFunction.semantics

        checkBuilderSemantics(semantics, receiver, function)

        val result: ObjectOrigin.FunctionOrigin = invocationResultObjectOrigin(

        val resolvedExpr = expressionResolver.doResolveExpression(context, expr)

        when (expr) {
            is FunctionCall ->
                if (resolvedExpr is ObjectOrigin.FunctionOrigin && isDanglingPureCall(resolvedExpr))
                    errorCollector.collect(ResolutionError(expr, ErrorReason.DanglingPureExpression))

    }

    data class NullObjectOrigin(override val originElement: Null) : ObjectOrigin

    sealed interface FunctionOrigin : ObjectOrigin {
        val function: SchemaFunction
        val invocationId: OperationId
        val receiver: ObjectOrigin?
    }

    sealed interface FunctionInvocationOrigin : FunctionOrigin {
        val parameterBindings: ParameterValueBinding
    }

    data class BuilderReturnedReceiver(

                is ObjectOrigin.TopLevelReceiver -> receiverOrigin
            }

        private
        fun replaceInFunction(origin: ObjectOrigin.FunctionOrigin): ObjectOrigin.FunctionOrigin = when (origin) {
            is ObjectOrigin.AddAndConfigureReceiver -> replaceIn(origin)
            is ObjectOrigin.AccessAndConfigureReceiver -> replaceIn(origin)

        is ResolutionTrace.ResolutionOrErrors.Resolution -> run {
            val functionOrigin = callResolution.result as ObjectOrigin.FunctionOrigin
            val receiver = functionOrigin.receiver
            if (strictReceiverChecks && receiver is ObjectOrigin.ImplicitThisReceiver && !receiver.isCurrentScopeReceiver) {

            """.trimIndent(),
            resolver
        )

        val call = result.additions.single().dataObject.originElement as FunctionCall
        assertIs<ObjectOrigin.FunctionOrigin>(resolver.trace.expressionResolution(call).result)

        val arg = (call.args.single() as FunctionArgument.Positional).expr
        assertIs<ObjectOrigin.ConstantOrigin>(resolver.trace.expressionResolution(arg).result)

        override val objectOrigin: ObjectOrigin
    ) : ObjectReflection

    data class PureFunctionInvocation(
        override val type: DataType,
        override val objectOrigin: ObjectOrigin.FunctionOrigin,
        val parameterResolution: Map<DataParameter, ObjectReflection>
    ) : ObjectReflection

    data class AddedByUnitInvocation(
        override val objectOrigin: ObjectOrigin
    ) : ObjectReflection {