private
    fun isDanglingPureCall(obj: ObjectOrigin.FunctionOrigin): Boolean {
        fun isPotentiallyPersistentReceiver(objectOrigin: ObjectOrigin): Boolean = when (objectOrigin) {
            is ObjectOrigin.AccessAndConfigureReceiver -> true
            is ObjectOrigin.ImplicitThisReceiver -> true
            is ObjectOrigin.FromLocalValue -> true // TODO: also check for unused val?

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

    private

        val result = AssignmentRecord(resolvedTarget, resolvedRhs, nextCallId(), assignmentMethod, originElement)
        mutableAssignments.add(result)
        return result
    }

    fun recordAddition(container: ObjectOrigin, dataObject: ObjectOrigin) {

    val conventionNestedObjectAccess: List<NestedObjectAccessRecord> = emptyList()
)


data class DataAdditionRecord(val container: ObjectOrigin, val dataObject: ObjectOrigin)


data class NestedObjectAccessRecord(val container: ObjectOrigin, val dataObject: ObjectOrigin.AccessAndConfigureReceiver)


data class ResolutionError(
    val element: LanguageTreeElement,
    val errorReason: ErrorReason
)

)


sealed interface AssignmentTraceElement {
    val lhs: PropertyReferenceResolution
    val rhs: ObjectOrigin

    sealed interface FailedToRecordAssignment : AssignmentTraceElement

    data class RecordedAssignment(
        override val lhs: PropertyReferenceResolution,
        override val rhs: ObjectOrigin,
        val assignmentMethod: AssignmentMethod
    ) : AssignmentTraceElement

            is ObjectReflection.PureFunctionInvocation -> {
                append(current.objectOrigin.function.simpleName)
                append("#" + current.objectOrigin.invocationId)
                if (visitedIdentity.add(current.objectOrigin.invocationId)) {
                    append("(")
                    if (current.parameterResolution.isNotEmpty()) {

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

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

 * the given [targetBaseReceiver].
 */
private
class ConventionTransformer(
    private val targetBaseReceiver: ObjectOrigin.ReceiverOrigin
) {
    fun transfer(origin: ObjectOrigin) = replaceReceivers(origin, ::isConventionsCall, targetBaseReceiver)

    fun applyAssignmentConventions(
        referencedSoftwareTypes: List<SoftwareTypeConventionResolutionResults>

        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'