createInstance: () -> T
): T {
    val trace = assignmentTrace(resolution)
    val context = ReflectionContext(SchemaTypeRefContext(schema), resolution, trace)
    val topLevel = reflect(resolution.topLevelReceiver, context)

    return createInstance().also {
        DeclarativeReflectionToObjectConverter(
            emptyMap(), it, MemberFunctionResolver(configureLambdas), ReflectionRuntimePropertyResolver, customAccessors

import org.gradle.internal.declarativedsl.demo.resolve
import org.gradle.internal.declarativedsl.schemaBuilder.schemaFromTypes


val schema = schemaFromTypes(
    topLevelReceiver = Abc::class,
    types = listOf(Abc::class, C::class, D::class),
    externalFunctions = listOf(::newD),
    defaultImports = listOf(DefaultFqName("com.example", "newD"))
)


object SimpleAnalysisDemo {

class DataSchemaBuilder(
    private val typeDiscovery: TypeDiscovery,
    private val propertyExtractor: PropertyExtractor,
    private val functionExtractor: FunctionExtractor
) {
    fun schemaFromTypes(
        topLevelReceiver: KClass<*>,
        types: Iterable<KClass<*>>,
        externalFunctions: List<KFunction<*>> = emptyList(),
        externalObjects: Map<FqName, KClass<*>> = emptyMap(),
        defaultImports: List<FqName> = emptyList(),

import org.junit.jupiter.api.Test
import kotlin.test.assertIs
import kotlin.test.assertNotNull
import kotlin.test.assertTrue


val schema = schemaFromTypes(
    topLevelReceiver = TopLevelScope::class,
    types = listOf(TopLevelScope::class, PluginsBlock::class, PluginDefinition::class)
)


fun main() {
    val result = schema.resolve(
        """
        plugins {

                is ObjectOrigin.ConfiguringLambdaReceiver -> receiverOrigin.copy(receiver = replace(receiverOrigin.receiver))
                is ObjectOrigin.TopLevelReceiver -> receiverOrigin
            }

        private
        fun replaceInFunction(origin: ObjectOrigin.FunctionOrigin): ObjectOrigin.FunctionOrigin = when (origin) {

    is ObjectOrigin.PropertyReference -> resolveRef(objectOrigin.property.valueType)
    is ObjectOrigin.PropertyDefaultValue -> resolveRef(objectOrigin.property.valueType)
    is ObjectOrigin.TopLevelReceiver -> objectOrigin.type
    is ObjectOrigin.NullObjectOrigin -> DataTypeInternal.DefaultNullType
    is ObjectOrigin.CustomConfigureAccessor -> resolveRef(objectOrigin.accessedType)

    is AnalysisStatementFilter.NotFilter -> !negationOf.shouldAnalyzeStatement(statement, scopes)
    is AnalysisStatementFilter.TopLevelElementFilter -> scopes.last().receiver is ObjectOrigin.TopLevelReceiver
}


internal
object AnalysisStatementFiltersImplementations {
    class DefaultAnalyzeEverythingFilter : AnalysisStatementFilter.AnalyzeEverythingFilter

        val referencedSoftwareTypes = findUsedSoftwareTypeNames(resolutionResult)
            .mapNotNull(softwareTypeConventionRepository::findConventions)

        with(ConventionTransformer(resolutionResult.topLevelReceiver)) {
            // For the referenced software types, add their conventions as operations mapped onto the top-level receiver
            val conventionAssignments = applyAssignmentConventions(referencedSoftwareTypes)

                }
            }

            is ObjectOrigin.NullObjectOrigin -> false
            is ObjectOrigin.PropertyReference -> true
            is ObjectOrigin.TopLevelReceiver -> true
            is ObjectOrigin.PropertyDefaultValue -> true
            is ObjectOrigin.CustomConfigureAccessor -> true
        }

        return when {

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

    private
    fun withResolved(other: ObjectOrigin, ifResolved: (receiver: ObjectOrigin) -> ObjectOrigin): ExpressionResolutionProgress {