"k8s.io/kubernetes/pkg/kubelet/cm/containermap"
	"k8s.io/kubernetes/pkg/kubelet/lifecycle"
)

type noneScope struct {
	scope
}

// Ensure noneScope implements Scope interface
var _ Scope = &noneScope{}

// NewNoneScope returns a none scope.
func NewNoneScope() Scope {
	return &noneScope{
		scope{
			name:             noneTopologyScope,
			podTopologyHints: podTopologyHints{},

			setup: func() *scope {
				scope := newScope("s", nil)
				scope.add(res, &resourceID{id: res.IDValue})
				return scope
			},
		},
		"parent": {
			setup: func() *scope {
				p := newScope("p", nil)
				p.add(res, &resourceID{id: res.IDValue})
				scope := newScope("s", p)
				return scope
			},
		},
		"missing": {
			setup:    func() *scope { return newScope("s", nil) },

          a: CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in p2.A' type=p2.A origin=null
          content: FUN_EXPR type=@[ExtensionFunctionType] kotlin.Function1<p3.RowScope, kotlin.Unit> origin=LAMBDA

	"k8s.io/kubernetes/pkg/kubelet/lifecycle"
	"k8s.io/kubernetes/pkg/kubelet/metrics"
)

type podScope struct {
	scope
}

// Ensure podScope implements Scope interface
var _ Scope = &podScope{}

// NewPodScope returns a pod scope.
func NewPodScope(policy Policy) Scope {
	return &podScope{
		scope{
			name:             podTopologyScope,
			podTopologyHints: podTopologyHints{},

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

/*
// TODO(#56378): change back to "#cgo noescape noMatchedCFunction: no matched C function" in Go 1.23
// ERROR MESSAGE: #cgo noescape disabled until Go 1.23
#cgo noescape noMatchedCFunction
*/
import "C"

func main() {

package main

import (
	_ "reflect"
	"unsafe"
)

//go:linkname noescape runtime.noescape
func noescape(unsafe.Pointer) unsafe.Pointer

//go:linkname rtype_String reflect.(*rtype).String
func rtype_String(unsafe.Pointer) string

func main() {
	println(rtype_String(noescape(nil)))

	if bn == nil {
		return false
	}
	*bnp = bn
	return true
}

// noescape hides a pointer from escape analysis.  noescape is
// the identity function but escape analysis doesn't think the
// output depends on the input.  noescape is inlined and currently
// compiles down to zero instructions.
// USE CAREFULLY!
//
//go:nosplit
func noescape(p unsafe.Pointer) unsafe.Pointer {
	x := uintptr(p)
	return unsafe.Pointer(x ^ 0)

func f1() {
	var t T
	f := t.noescape // ERROR "t.noescape does not escape"
	f()
}

func f2() {
	var t T       // ERROR "moved to heap"
	f := t.escape // ERROR "t.escape does not escape"
	f()
}

func f3() {
	var t T        // ERROR "moved to heap"
	f := t.returns // ERROR "t.returns does not escape"
	sink = f()
}

type T struct{}

func (t *T) noescape()   {}           // ERROR "t does not escape"

				{
					"resource-3": nil,
				},
			},
		},
	}

	for _, tc := range tcases {
		podScope := &podScope{
			scope{
				hintProviders: tc.hp,
				policy:        &mockPolicy{},
				name:          podTopologyScope,
			},
		}

		podScope.calculateAffinity(&v1.Pod{})
		actual := podScope.policy.(*mockPolicy).ph
		if !reflect.DeepEqual(tc.expected, actual) {
			t.Errorf("Test Case: %s", tc.name)

		mp.libcallsp = getcallersp()
	} else {
		mp = nil
	}

	var libcall libcall
	libcall.fn = uintptr(unsafe.Pointer(fn))
	libcall.n = 1
	// TODO(rsc): Why is noescape necessary here and below?
	libcall.args = uintptr(noescape(unsafe.Pointer(&a1)))
	asmcgocall(unsafe.Pointer(&asmsysvicall6x), unsafe.Pointer(&libcall))
	if mp != nil {
		mp.libcallsp = 0
	}
	return libcall.r1, libcall.err
}