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'

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

    @Test

                id("test")
            }
            """.trimIndent()
        )

        assertEquals(1, result.additions.size)
        val idOrigin = result.additions.single().dataObject
        assertIs<ObjectOrigin.FunctionInvocationOrigin>(idOrigin)
        assertEquals("id", idOrigin.function.simpleName)
    }

        val xAssigned = assertIs<AssignmentResolver.AssignmentResolutionResult.Assigned>(resultMap.entries.single { it.key.property.name == "x" }.value)
        assertEquals(1, (xAssigned.objectOrigin.originElement as Literal.IntLiteral).value)
    }

    val schema = schemaFromTypes(Receiver::class, listOf(Receiver::class))

    private
    interface Receiver {
        @get:Restricted
        var x: Int

        val importFqnBySimpleName = collectImports(imports, importContext) + schema.defaultImports.associateBy { it.simpleName }

        val topLevelReceiver = ObjectOrigin.TopLevelReceiver(schema.topLevelReceiverType, topLevelBlock)
        val topLevelScope = AnalysisScope(null, topLevelReceiver, topLevelBlock)

package org.gradle.internal.declarativedsl.analysis

import org.gradle.declarative.dsl.model.annotations.Adding
import org.gradle.declarative.dsl.schema.FunctionSemantics
import org.gradle.internal.declarativedsl.analysis.ObjectOrigin.FunctionInvocationOrigin
import org.gradle.internal.declarativedsl.demo.resolve
import org.gradle.internal.declarativedsl.schemaBuilder.schemaFromTypes
import kotlin.test.Test
import kotlin.test.assertEquals

            } as DataObjectReflection

        val version = kotlinKaptPlugin.properties[versionProp]!!.value as ConstantValue

        val ast = version.objectOrigin.originElement.sourceData
        val versionRange = ast.indexRange

        println("=== version range:")
        println(versionRange)

        println("===")