val resolver = tracingCodeResolver()

        val topLevelBlock = parseAsTopLevelBlock(
            """
            addAndConfigure("correct") { }
            addAndConfigure("lambda missing")
            addAndConfigure("incorrect signature", 1) {
                number = 123

])
sealed interface FunctionSemantics : Serializable {

    val returnValueType: DataTypeRef

    @ToolingModelContract(subTypes = [
        AccessAndConfigure::class,
        AddAndConfigure::class
    ])
    sealed interface ConfigureSemantics : FunctionSemantics {
        val configuredType: DataTypeRef
        val configureBlockRequirement: ConfigureBlockRequirement

        val schema = schemaFromTypes(ReceiverOne::class, listOf(ReceiverOne::class))
        val function = schema.dataClassesByFqName.values.single().memberFunctions.single()
        assertIs<FunctionSemantics.AddAndConfigure>(function.semantics)
    }

    @Test
    fun `adding function may not have a configuring lambda if it returns Unit`() {
        val exception = assertThrows<IllegalStateException> {

            }
        }
    }

    @Serializable
    @SerialName("addAndConfigure")
    data class DefaultAddAndConfigure(
        private val objectType: DataTypeRef,
        override val configureBlockRequirement: ConfigureBlockRequirement
    ) : AddAndConfigure {
        override val returnValueType: DataTypeRef
            get() = objectType

                when (semantics) {
                    is FunctionSemantics.Builder -> error("should be impossible?")
                    is FunctionSemantics.AccessAndConfigure -> true
                    is FunctionSemantics.AddAndConfigure -> true
                    is FunctionSemantics.Pure -> false
                }
            }

            is ObjectOrigin.NullObjectOrigin -> false
            is ObjectOrigin.PropertyReference -> true

                newOperationId
            ).also {
                result.receiver?.let { receiver -> recordNestedObjectAccess(receiver, it) }
            }

            is FunctionSemantics.AddAndConfigure -> ObjectOrigin.AddAndConfigureReceiver(result)
        }

        val lambda = call.args.filterIsInstance<FunctionArgument.Lambda>().singleOrNull()

        is ObjectOrigin.FunctionInvocationOrigin -> context.functionCall(objectOrigin.invocationId) {
            when (objectOrigin.function.semantics) {
                is FunctionSemantics.AddAndConfigure -> {
                    if (type is DataType.UnitType) {
                        ObjectReflection.AddedByUnitInvocation(objectOrigin)
                    } else {
                        reflectData(