context.withScope(topLevelScope) { codeAnalyzer.analyzeStatementsInProgramOrder(context, topLevelBlock.statements) }

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

    fun collectImports(
        trees: List<Import>,
        analysisContext: AnalysisContext
    ): Map<String, FqName> = buildMap {

//     in conjunction with the RouteController to configure the network to get
//     connectivity.
//   - CloudAllocator is an allocator that synchronizes PodCIDRs from IP
//     ranges assignments from the underlying cloud platform.
//   - (Alpha only) IPAMFromCluster is an allocator that has the similar
//     functionality as the RangeAllocator but also synchronizes cluster-managed
//     ranges into the cloud platform.

func getAssignedCPUsOfSiblings(s state.State, podUID string, containerName string) cpuset.CPUSet {
	assignments := s.GetCPUAssignments()
	cset := cpuset.New()
	for name, cpus := range assignments[podUID] {
		if containerName == name {
			continue
		}
		cset = cset.Union(cpus)
	}
	return cset
}

	"k8s.io/kubernetes/pkg/kubelet/checkpointmanager/checksum"
)

var _ checkpointmanager.Checkpoint = &MemoryManagerCheckpoint{}

// MemoryManagerCheckpoint struct is used to store memory/pod assignments in a checkpoint
type MemoryManagerCheckpoint struct {
	PolicyName   string                     `json:"policyName"`
	MachineState NUMANodeMap                `json:"machineState"`

        val result = schema.resolve("plugins = plugins { }")
        assertTrue { result.errors.any { it.errorReason == ErrorReason.UnitAssignment } }
    }

    @Test
    fun `type mismatch in assignments is reported as an error`() {
        val result = schema.resolve(
            """
            plugins {
                val i = id("test")
                i.version = 1
            }
            """.trimIndent()

        val resolution = schema.resolve(
            """
            x = 1
            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])

#include "textflag.h"

// condition code masks
#define EQ 8
#define NE 7

// register assignments
#define R_ZERO R0
#define R_VAL  R1
#define R_TMP  R2
#define R_PTR  R3
#define R_LEN  R4
#define R_CHAR R5
#define R_RET  R6
#define R_ITER R7
#define R_CNT  R8
#define R_MPTR R9

// vector register assignments
#define V_ZERO V0
#define V_CHAR V1
#define V_MASK V2
#define V_VAL  V3
#define V_CNT  V4

import org.gradle.internal.declarativedsl.language.LocalValue


data class ResolutionResult(
    val topLevelReceiver: ObjectOrigin.TopLevelReceiver,
    val assignments: List<AssignmentRecord>,
    val additions: List<DataAdditionRecord>,
    val nestedObjectAccess: List<NestedObjectAccessRecord>,
    val errors: List<ResolutionError>,

		return false
	}
	if !isSimpleName(n.X) {
		// not a special composite literal assignment
		return false
	}
	x := n.X.(*ir.Name)
	if !types.Identical(n.X.Type(), n.Y.Type()) {
		// not a special composite literal assignment
		return false
	}
	if x.Addrtaken() {
		// If x is address-taken, the RHS may (implicitly) uses LHS.
		// Not safe to do a special composite literal assignment

type I1 interface {
	M(p1.T)
}

// t0 satisfies I0 and p0.I
type t0 int

func (t0) M(p0.T) {}

// t1 satisfies I1 and p1.I
type t1 float64

func (t1) M(p1.T) {}

// check static interface assignments
var i0 I0 = t0(0) // ok
var i1 I1 = t1(0) // ok

var i2 I0 = t1(0) // ERROR "does not implement|incompatible"
var i3 I1 = t0(0) // ERROR "does not implement|incompatible"

var p0i p0.I = t0(0) // ok