Sergey Igushkin <******@****.***> 1716568486 +0400

            if (analysisStatementFilter.shouldAnalyzeStatement(element, context.currentScopes)) {
                doResolveStatement(context, element)
            }
        }
    }

    private
    fun doResolveStatement(context: AnalysisContext, statement: DataStatement) {
        when (statement) {
            is Assignment -> statementResolver.doResolveAssignment(context, statement)

        val context = AnalysisContext(schema, importFqnBySimpleName, errorCollector, generationId)
        context.withScope(topLevelScope) { codeAnalyzer.analyzeStatementsInProgramOrder(context, topLevelBlock.statements) }

        return ResolutionResult(topLevelReceiver, context.assignments, context.additions, context.nestedObjectAccess, errorCollector.errors)
    }

    fun collectImports(

        val (context, codecs) = cacheIO.writerContextFor(encoder)
        context.push(IsolateOwners.OwnerHost(host), codecs.userTypesCodec())
        context.runWriteOperation {
            write(value)
        }
    }

    private
    fun read(decoder: Decoder): BuildTreeModelSideEffect {
        val (context, codecs) = cacheIO.readerContextFor(decoder)

    fun <R> withReadContextFor(
        inputStream: InputStream,
        readOperation: suspend DefaultReadContext.(Codecs) -> R
    ): R =
        readerContextFor(inputStream).let { (context, codecs) ->
            context.use {
                context.run {
                    initClassLoader(javaClass.classLoader)
                    runReadOperation {
                        readOperation(codecs)
                    }.also {

        is EvaluationResult.Evaluated ->
            if (step is InterpretationSequenceStepWithConversion<*>) {
                val context = ReflectionContext(
                    SchemaTypeRefContext(step.evaluationSchemaForStep.analysisSchema),
                    analysisResult.stepResult.resolutionResult,
                    analysisResult.stepResult.assignmentTrace

        val artifacts = readNonNull<FileCollectionInternal>()
        return object : DefaultTransformUpstreamDependenciesResolver.FinalizeTransformDependencies() {
            override fun visitDependencies(context: TaskDependencyResolveContext) {
                throw UnsupportedOperationException("Should not be called")
            }

            override fun selectedArtifacts(): FileCollection {
                return artifacts

        return attributes
    }

    override fun getCapabilities(): ImmutableCapabilities {
        return ImmutableCapabilities.EMPTY
    }

    override fun visitDependencies(context: TaskDependencyResolveContext) {
        throw UnsupportedOperationException("Should not be called")
    }

    override fun visit(visitor: ResolvedArtifactSet.Visitor) {

        }.drop(1)

    private
    fun cacheFingerprintWriterContextFor(outputStream: OutputStream, profile: () -> String): DefaultWriteContext {
        val (context, codecs) = cacheIO.writerContextFor(outputStream, profile)
        return context.apply {
            push(IsolateOwners.OwnerHost(host), codecs.fingerprintTypesCodec())
        }
    }

    private

    val resolution = resolve(code)
    val trace = assignmentTrace(resolution)
    val context = ReflectionContext(SchemaTypeRefContext(this), resolution, trace)
    val topLevel = org.gradle.internal.declarativedsl.objectGraph.reflect(resolution.topLevelReceiver, context)

    return topLevel
}


fun printReflection(objectReflection: ObjectReflection) {