codeAnalyzer = CodeAnalyzerImpl(analysisStatementFilter, statementResolver)

        ResolverImpl(codeAnalyzer, errorCollector, generationId)
    }
}


fun tracingCodeResolver(generationId: OperationGenerationId = DefaultOperationGenerationId.finalEvaluation, elementFilter: AnalysisStatementFilter = analyzeEverything): TracingResolver {
    return ResolverServicesContainer().run {

    fun hasAssignmentInTheSameGeneration(existingNode: GenerationResolutionNode, generationId: OperationGenerationId): Boolean {
        return existingNode.generationId == generationId
    }

    private
    fun hasAssignmentInLowerGeneration(existingNode: GenerationResolutionNode, generationId: OperationGenerationId): Boolean {
        return existingNode.generationId < generationId
    }

    sealed interface AssignmentResolutionResult {

    }
}


/**
 * Represents a unique operation within a particular generation.  The invocation id should be unique within a single
 * interpretation step, but not across generations (i.e. two operations in different generations may have the same
 * invocation id).  Operations in different generations with the same invocation id have no relationship to each
 * other except by coincidence.
 */

    private val errorCollector: ErrorCollector,
    private val generationId: OperationGenerationId
) : Resolver {
    override fun resolve(schema: AnalysisSchema, imports: List<Import>, topLevelBlock: Block): ResolutionResult {
        val importContext = AnalysisContext(schema, emptyMap(), errorCollector, generationId)

            y = 1
            x = 2
            """.trimIndent()
        )

        val additionResults = resolution.assignments.map { impl.addAssignment(it.lhs, it.rhs, it.assignmentMethod, it.operationId.generationId) }
        assertIs<AssignmentResolver.AssignmentAdditionResult.Reassignment>(additionResults[2])

        val resultMap = impl.getAssignmentResults()

            assignments.forEach { (lhs, rhs, callId, method) ->
                add(
                    when (val additionResult = assignmentResolver.addAssignment(lhs, rhs, method, callId.generationId)) {
                        is AssignmentResolver.AssignmentAdditionResult.AssignmentAdded -> AssignmentTraceElement.RecordedAssignment(additionResult.resolvedLhs, rhs, additionResult.assignmentMethod)

// while reading the previous one. It's passed on when parsing the next
// generation.
type spilledBatch struct {
	gen uint64
	*batch
}

// readGeneration buffers and decodes the structural elements of a trace generation
// out of r. spill is the first batch of the new generation (already buffered and
// parsed from reading the last generation). Returns the generation and the first

// and not the string itself, that string ID may not be valid
// for use in future generations.

package main

import (
	"internal/trace"
	"internal/trace/event/go122"
	testgen "internal/trace/internal/testgen/go122"
)

func main() {
	testgen.Main(gen)
}

func gen(t *testgen.Trace) {
	g1 := t.Generation(1)

	// A running goroutine emits a task begin.
	b1 := g1.Batch(trace.ThreadID(0), 0)

	utilfeature "k8s.io/apiserver/pkg/util/feature"
	featuregatetesting "k8s.io/component-base/featuregate/testing"
)

func generation1() map[string]interface{} {
	return map[string]interface{}{
		"generation": int64(1),
	}
}

func generation2() map[string]interface{} {
	return map[string]interface{}{
		"generation": int64(2),
	}
}

func TestStrategyPrepareForUpdate(t *testing.T) {
	strategy := customResourceStrategy{}

// Regression test for an issue found in development.
//
// The core of the issue is that if generation counters
// aren't considered as part of sequence numbers, then
// it's possible to accidentally advance without a
// GoStatus event.
//
// The situation is one in which it just so happens that
// an event on the frontier for a following generation
// has a sequence number exactly one higher than the last