}


internal
fun TypeRefContext.getDataType(objectOrigin: ObjectOrigin): DataType = when (objectOrigin) {
    is ObjectOrigin.DelegatingObjectOrigin -> getDataType(objectOrigin.delegate)
    is ObjectOrigin.ConstantOrigin -> objectOrigin.literal.type
    is ObjectOrigin.External -> resolveRef(objectOrigin.key.objectType)
    is ObjectOrigin.NewObjectFromMemberFunction -> resolveRef(objectOrigin.function.returnValueType)

            (String constantOrigin, String dependent) -> accessibleDependentToConstants.computeIfAbsent(dependent, { new LinkedHashSet<>() }).add(constantOrigin),
            (String constantOrigin, String dependent) -> privateDependentToConstants.computeIfAbsent(dependent, { new LinkedHashSet<>() }).add(constantOrigin)
        )
        compiler = new TestCompiler(

                is ObjectOrigin.PropertyReference -> origin.copy(receiver = replace(origin.receiver))

                is ObjectOrigin.ConstantOrigin,
                is ObjectOrigin.External,
                is ObjectOrigin.NullObjectOrigin -> origin
            }

        private
        fun replaceInReceiver(receiverOrigin: ObjectOrigin.ReceiverOrigin) =

        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)
    }

    @Test
    fun `collects successful resolution of assignment`() {
        val resolver = tracingCodeResolver()
        val result = schema.resolve(

            is ObjectOrigin.ConfiguringLambdaReceiver -> withResolvedReceiver(objectOrigin) { objectOrigin.copy(receiver = it) }

            is ObjectOrigin.NewObjectFromTopLevelFunction,
            is ObjectOrigin.ConstantOrigin,
            is ObjectOrigin.External,
            is ObjectOrigin.NullObjectOrigin,
            is ObjectOrigin.PropertyDefaultValue, // TODO: is it so?
            is ObjectOrigin.TopLevelReceiver -> Ok(objectOrigin)

            is ObjectOrigin.FromLocalValue -> true // TODO: also check for unused val?
            is ObjectOrigin.DelegatingObjectOrigin -> isPotentiallyPersistentReceiver(objectOrigin.delegate)
            is ObjectOrigin.ConstantOrigin -> false
            is ObjectOrigin.External -> true
            is ObjectOrigin.FunctionOrigin -> {
                val semantics = objectOrigin.function.semantics
                when (semantics) {

        override val originElement: LanguageTreeElement
            get() = assigned.originElement

        override fun toString(): String = "(val ${localValue.name} = $assigned)"
    }

    data class ConstantOrigin(val literal: Literal<*>) : ObjectOrigin {
        override val originElement: LanguageTreeElement
            get() = literal

        return when (objectOrigin) {
            is ObjectOrigin.DelegatingObjectOrigin -> getObjectByResolvedOrigin(objectOrigin.delegate)
            is ObjectOrigin.ConstantOrigin -> objectOrigin.literal.value
            is ObjectOrigin.External -> externalObjectsMap[objectOrigin.key] ?: error("No external object provided for external object key of ${objectOrigin.key}")

        projectEvaluated.stepResult.assignmentTrace.resolvedAssignments.entrySet().any {
            it.key.property.name == "id" && ((it.value as Assigned).objectOrigin as ObjectOrigin.ConstantOrigin).literal.value == "convention"
        }

        when: 'the build and settings files contain errors'