Michael Anthony Knyszek <******@****.***> 1711143722 +0000

	}
	{
		var x []string
		verifyGCInfo(t, "stack slice", &x, infoSlice)
		runtime.KeepAlive(x)
	}
	{
		var x any
		verifyGCInfo(t, "stack eface", &x, infoEface)
		runtime.KeepAlive(x)
	}
	{
		var x Iface
		verifyGCInfo(t, "stack iface", &x, infoIface)
		runtime.KeepAlive(x)
	}

	for i := 0; i < 10; i++ {
		verifyGCInfo(t, "heap Ptr", runtime.Escape(new(Ptr)), trimDead(infoPtr))

            if (lep.startsWith("\\pipe\\")) {
                String iface = (String)INTERFACES.get(lep.substring(6));
                if (iface != null) {
                    int c, p;
                    c = iface.indexOf(':');
                    p = iface.indexOf('.', c + 1);
                    uuid = new UUID(iface.substring(0, c));
                    major = Integer.parseInt(iface.substring(c + 1, p));

	}
	return
}

func RangeChanIface[V iface]() (v iface) {
	for v = range chanOf(zero[V]()) {
	}
	return
}

func RangeMapAny[K comparable, V any]() (k, v any) {
	for k, v = range map[K]V{zero[K](): zero[V]()} {
	}
	return
}

func RangeMapIface[K interface {
	iface
	comparable
}, V iface]() (k, v iface) {
	for k, v = range map[K]V{zero[K](): zero[V]()} {
	}
	return
}

func (t *TypeParam) Underlying() Type {
	return t.iface()
}

func (t *TypeParam) String() string { return TypeString(t, nil) }

// ----------------------------------------------------------------------------
// Implementation

func (t *TypeParam) cleanup() {
	t.iface()
	t.check = nil
}

// iface returns the constraint interface of t.
func (t *TypeParam) iface() *Interface {
	bound := t.bound

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

package a

func A() {
	B[int](new(G[int]))
}

func B[T any](iface interface{ M(T) }) {
	x, ok := iface.(*G[T])
	if !ok || iface != x {
		panic("FAIL")
	}
}

type G[T any] struct{}

-- go.mod --
module m

go 1.20
-- main.go --
package main

import "m/sub"

func main() { sub.F() }
-- sub/sub.go --
package sub

type iface interface{ m() }

func F() {
	f := func(rt []iface) []iface {
		return append([]iface{}, rt...)
	}
	f(nil)

	_ = i + false     // ERROR "invalid operation.*mismatched types.*int and untyped bool"
	_ = iface + 1     // ERROR "invalid operation.*mismatched types.*interface *{} and int"
	_ = iface + 1.0   // ERROR "invalid operation.*mismatched types.*interface *{} and float64"
	_ = iface + false // ERROR "invalid operation.*mismatched types.*interface *{} and bool"

func (t *TypeParam) Underlying() Type {
	return t.iface()
}

func (t *TypeParam) String() string { return TypeString(t, nil) }

// ----------------------------------------------------------------------------
// Implementation

func (t *TypeParam) cleanup() {
	t.iface()
	t.check = nil
}

// iface returns the constraint interface of t.
func (t *TypeParam) iface() *Interface {
	bound := t.bound

// license that can be found in the LICENSE file.

// Ensure that late expansion correctly set OpLoad argument type interface{}

package p

type iface interface {
	m()
}

type it interface{}

type makeIface func() iface

func f() {
	var im makeIface
	e := im().(it)
	g(e)
}

//go:noinline