tmap:     make(map[string]loader.Sym),
		tdmap:    make(map[loader.Sym]loader.Sym),
		rtmap:    make(map[loader.Sym]loader.Sym),
	}
	d.typeRuntimeEface = d.lookupOrDiag("type:runtime.eface")
	d.typeRuntimeIface = d.lookupOrDiag("type:runtime.iface")

	if ctxt.HeadType == objabi.Haix {
		// Initial map used to store package size for each DWARF section.
		dwsectCUSize = make(map[string]uint64)
	}

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

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

-- 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)

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

			// duplicate its methods so we can replace the receiver
			// parameter's type (#49906).
			if iface, ok := underlying.(*types.Interface); ok && iface.NumExplicitMethods() != 0 {
				methods := make([]*types.Func, iface.NumExplicitMethods())
				for i := range methods {
					fn := iface.ExplicitMethod(i)
					sig := fn.Type().(*types.Signature)

					recv := types.NewVar(fn.Pos(), fn.Pkg(), "", named)

	t21 int = a /* ERRORx `cannot use .* variable declaration` */
)

// Various more complex expressions
var (
	u1 = x /* ERROR "not an interface" */ .(int)
	u2 = iface.([]int)
	u3 = iface.(a /* ERROR "not a type" */ )
	u4, ok = iface.(int)
	u5, ok2, ok3 = iface /* ERROR "assignment mismatch" */ .(int)
)

// Constant expression initializations
var (
	v1 = 1 /* ERROR "mismatched types untyped int and untyped string" */ + "foo"

		embeddeds, ecopied := subst.typeList(t.embeddeds)
		if mcopied || ecopied {
			iface := subst.check.newInterface()
			iface.embeddeds = embeddeds
			iface.embedPos = t.embedPos
			iface.implicit = t.implicit
			assert(t.complete) // otherwise we are copying incomplete data
			iface.complete = t.complete
			// If we've changed the interface type, we may need to replace its

	if err != nil {
		return nil, err
	}

	initIface := iface
	if initiatorName != "" {
		iface = bkportal[0] + ":" + spec.Name()
	}

	return &iscsiDisk{
		podUID:        podUID,
		VolName:       spec.Name(),
		Portals:       bkportal,
		Iqn:           iqn,
		Lun:           lun,
		InitIface:     initIface,
		Iface:         iface,
		chapDiscovery: chapDiscovery,
		chapSession:   chapSession,

		embeddeds, ecopied := subst.typeList(t.embeddeds)
		if mcopied || ecopied {
			iface := subst.check.newInterface()
			iface.embeddeds = embeddeds
			iface.embedPos = t.embedPos
			iface.implicit = t.implicit
			assert(t.complete) // otherwise we are copying incomplete data
			iface.complete = t.complete
			// If we've changed the interface type, we may need to replace its