v3;
package nointerface
pkgpath nointerface
types 3 2 133 17
type 1 "I" <type -11>
 func /*nointerface*/ (p <esc:0x1> <type 2>) Get () <type -11>
 func (p <esc:0x1> <type 2>) Set (v <type -11>)

// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package nointerface

type I int

//go:nointerface
func (p *I) Get() int { return int(*p) }

// Copyright 2023 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

func f(interface{ m() }) {}
func g()                 { f(new(T)) } // ERROR "m method is marked 'nointerface'"

type T struct{}

//go:nointerface

        interfaceMap);
  }

  private interface Interface1 {}

  private interface Interface2 {}

  private interface Interface3<T> extends Iterable<T> {}

  private interface Interface12 extends Interface1, Interface2 {}

  private static class Class1 implements Interface1 {}

  private static final class NoInterface {}

		return ""
	}

	if isptrto(t, types.TINTER) {
		return fmt.Sprintf("%v is pointer to interface, not interface", t)
	} else if have != nil && have.Sym == missing.Sym && have.Nointerface() {
		return fmt.Sprintf("%v does not implement %v (%v method is marked 'nointerface')", t, iface, missing.Sym)
	} else if have != nil && have.Sym == missing.Sym {

        interfaceMap);
  }

  private interface Interface1 {}

  private interface Interface2 {}

  private interface Interface3<T> extends Iterable<T> {}

  private interface Interface12 extends Interface1, Interface2 {}

  private static class Class1 implements Interface1 {}

  private static final class NoInterface {}

	{pkgpath: "nointerface", name: "I", want: "type I int"},
	{pkgpath: "issue29198", name: "FooServer", gccgoVersion: 7, want: "type FooServer struct{FooServer *FooServer; user string; ctx context.Context}"},

		// We only want to record exported functions.
		return nil
	}

	return f
}

// InterfaceType = "interface" "{" { ("?" Type | Func) ";" } "}" .
func (p *parser) parseInterfaceType(pkg *types.Package, nlist []any) types.Type {
	p.expectKeyword("interface")

	t := new(types.Interface)
	p.update(t, nlist)

	var methods []*types.Func
	var embeddeds []types.Type

	p.expect('{')

// These can either be concrete methods (for non-interface types) or interface
// methods (for interface types).
func (t *Type) Methods() []*Field {
	return t.methods.Slice()
}

// AllMethods returns a pointer to all the methods (including embedding) for type t.
// For an interface type, this is the set of methods that are typically iterated
// over. For non-interface types, AllMethods() only returns a valid result after

	FlagBroadcast                      // interface supports broadcast access capability
	FlagLoopback                       // interface is a loopback interface
	FlagPointToPoint                   // interface belongs to a point-to-point link
	FlagMulticast                      // interface supports multicast access capability
	FlagRunning                        // interface is in running state
)