goto error
			}
			if buf.String() == "" {
				err = errors.New("empty output")
				goto error
			}
			if tc.shouldBeValidYAML {
				err = yaml.Unmarshal(buf.Bytes(), &iface)
			} else if tc.shouldBeValidJSON {
				err = json.Unmarshal(buf.Bytes(), &iface)
			}
		error:
			if (err != nil) != tc.expectedError {
				t.Errorf("Test case %q: RunVersion expected error: %v, saw: %v; %v", tc.name, tc.expectedError, err != nil, err)
			}

            if (superclass != null) {
                queue.add(superclass);
            }
            for (Class<?> iface : type.getInterfaces()) {
                if (seenInterfaces.add(iface)) {
                    queue.add(Cast.<Class<? super T>>uncheckedCast(iface));
                }
            }
        }
    }

    @FunctionalInterface
    public interface TypeVisitor<T> {

func (h *netlinkHandle) GetAllLocalAddressesExcept(dev string) (sets.Set[string], error) {
	ifaces, err := net.Interfaces()
	if err != nil {
		return nil, err
	}
	var addr []net.Addr
	for _, iface := range ifaces {
		if iface.Name == dev {
			continue
		}
		ifadr, err := iface.Addrs()
		if err != nil {
			// This may happen if the interface was deleted. Ignore
			// but log the error.

throw: interface compare

panic PC=0x28ceb8 [1]
throw+0x41 /Users/rsc/goX/src/runtime/runtime.c:54
	throw(0x3014a, 0x0)
ifaceeq+0x15c /Users/rsc/goX/src/runtime/iface.c:501
	ifaceeq(0x2aa7c0, 0x0, 0x0, 0x0, 0x2aa7c0, ...)
sys·ifaceeq+0x48 /Users/rsc/goX/src/runtime/iface.c:527
	sys·ifaceeq(0x2aa7c0, 0x0, 0x0, 0x0, 0x2aa7c0, ...)
main·main+0x190 /Users/rsc/goX/src/cmd/gc/x.go:10
	main·main()

	constraint := tparam.Constraint()
	if constraint == nil {
		return nil, fmt.Errorf("%s has nil constraint", tparam)
	}
	iface, _ := constraint.Underlying().(*types.Interface)
	if iface == nil {
		return nil, fmt.Errorf("constraint is %T, not *types.Interface", constraint.Underlying())
	}
	return InterfaceTermSet(iface)
}

// InterfaceTermSet computes the normalized terms for a constraint interface,

        file("api/src/main/java/org/gradle/FooException.java") << """
package org.gradle;

class FooException extends Exception { }
        """

        file("client/src/main/java/org/gradle/Iface.java") << """
package org.gradle;

interface Iface {
    /**
     * Method Description.
     *
     * @throws FooException whenever
     * @throws IllegalArgumentException otherwise
     */

}

func (check *Checker) interfaceType(ityp *Interface, iface *syntax.InterfaceType, def *TypeName) {
	addEmbedded := func(pos syntax.Pos, typ Type) {
		ityp.embeddeds = append(ityp.embeddeds, typ)
		if ityp.embedPos == nil {
			ityp.embedPos = new([]syntax.Pos)
		}
		*ityp.embedPos = append(*ityp.embedPos, pos)
	}

	for _, f := range iface.MethodList {
		if f.Name == nil {

}

func (check *Checker) interfaceType(ityp *Interface, iface *ast.InterfaceType, def *TypeName) {
	addEmbedded := func(pos token.Pos, typ Type) {
		ityp.embeddeds = append(ityp.embeddeds, typ)
		if ityp.embedPos == nil {
			ityp.embedPos = new([]token.Pos)
		}
		*ityp.embedPos = append(*ityp.embedPos, pos)
	}

	for _, f := range iface.Methods.List {
		if len(f.Names) == 0 {

func inlinetest(p **inltype) *inltype {
	return *p
}

type iface interface {
	Foo() *struct{ b bool }
}

type Int int

func (i Int) Foo() *struct{ b bool } {
	return &struct{ b bool }{false}
}

func TestNoRaceForInfiniteLoop(t *testing.T) {
	var x Int
	// interface conversion causes nodes to be put on init list
	for iface(x).Foo().b {
	}

		InterfaceStats: criInterfaceToSummary(criNetwork.DefaultInterface),
		Interfaces:     make([]statsapi.InterfaceStats, 0, len(criNetwork.Interfaces)),
	}
	for _, iface := range criNetwork.Interfaces {
		iStats.Interfaces = append(iStats.Interfaces, criInterfaceToSummary(iface))
	}
	ps.Network = &iStats
}

func addCRIPodMemoryStats(ps *statsapi.PodStats, criPodStat *runtimeapi.PodSandboxStats) {