checkdead()
	unlock(&sched.lock)

	for {
		lock(&newmHandoff.lock)
		for newmHandoff.newm != 0 {
			newm := newmHandoff.newm.ptr()
			newmHandoff.newm = 0
			unlock(&newmHandoff.lock)
			for newm != nil {
				next := newm.schedlink.ptr()
				newm.schedlink = 0
				newm1(newm)
				newm = next
			}
			lock(&newmHandoff.lock)
		}
		newmHandoff.waiting = true

	}
}

const funcsTestFile = `
package funcs

func F() {}

type S1 struct {
	S2  // embedded, exported
	s3  // embedded, unexported
}

func NewS1()  S1 {return S1{} }
func NewS1p() *S1 { return &S1{} }

func (S1) M1() {}
func (r S1) M2() {}
func(S1) m3() {}		// unexported not shown
func (*S1) P1() {}		// pointer receiver

type S2 int

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

package main

type T1 struct {
	X int
}

func NewT1(x int) T1 { return T1{x} }

type T2 int

func NewT2(x int) T2 { return T2(x) }

func main() {
	switch (T1{}) {
	case NewT1(1):
		panic("bad1")
	case NewT1(0):
		// ok
	default:
		panic("bad2")
	}

	switch T2(0) {
	case NewT2(2):
		panic("bad3")
	case NewT2(0):

			t.Errorf("%s: re-marshaled data differs from original: %v %v", k, data, newData)
		}
		if !reflect.DeepEqual(tc.orig, new1) {
			t.Errorf("%s: unmarshaled struct differs from original: %v %v", k, tc.orig, new1)
		}
		if !reflect.DeepEqual(new1, new2) {
			t.Errorf("%s: re-unmarshaled struct differs from original: %v %v", k, new1, new2)
		}
	}

func (ms *Messages) SortedDedupedCopy() Messages {
	newMs := append((*ms)[:0:0], *ms...)
	newMs.Sort()

	// Take advantage of the fact that the list is already sorted to dedupe
	// messages (any duplicates should be adjacent).
	var deduped Messages
	for _, m := range newMs {
		// Two messages are duplicates if they have the same string representation.

	assert.Equal(t, w.Mesh(), m)

	doneCh := make(chan struct{}, 1)

	var newM *meshconfig.MeshConfig
	w.AddMeshHandler(func() {
		newM = w.Mesh()
		close(doneCh)
	})

	// Change the file to trigger the update.
	m.IngressClass = "foo"
	writeMessage(t, path, m)

	select {
	case <-doneCh:
		assert.Equal(t, newM, m)
		assert.Equal(t, w.Mesh(), newM)
		break
	case <-time.After(time.Second * 5):

	ist, err := istio.Get(ctx)
	if err != nil {
		return err
	}

	// Now parse the provider YAML.
	newMC := &meshconfig.MeshConfig{}
	if err := protomarshal.ApplyYAML(providerYAML, newMC); err != nil {
		return err
	}

	providerNames := sets.New[string]()
	for _, p := range newMC.GetExtensionProviders() {
		providerNames.Insert(p.Name)
	}

	return ist.UpdateMeshConfig(ctx,

package p1

import "./p0"

type T1 interface {
	p0.T0
	m1()
}

type S1 struct {
	p0.S0
}

func (S1) m1() {}

func NewT0() p0.T0 {
	return S1{}
}

func NewT1() T1 {
	return S1{}

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

package main

import (
	"./p0"
	"./p1"
)

var (
	_ p0.T0 = p0.S0{}
	_ p0.T0 = p1.S1{}
	_ p0.T0 = p1.NewT0()
	_ p0.T0 = p1.NewT1() // same as p1.S1{}
)

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

package a2

import "./a0"

func New() int {
	return a0.Builder[int]{}.New1()