type go/types.Interface

124 uses

	go/types (current package)
		api_predicates.go#L19: func AssertableTo(V *Interface, T Type) bool {
		api_predicates.go#L53: func Implements(V Type, T *Interface) bool {
		api_predicates.go#L70: func Satisfies(V Type, T *Interface) bool {
		builtins.go#L186: 		case *Interface:
		builtins.go#L950: 	case *Interface:
		call.go#L215: 				if t, _ := under(T).(*Interface); t != nil && !isTypeParam(T) {
		decl.go#L537: 	u, _ := named.under().(*Interface)
		decl.go#L726: 		if t, _ := t.(*Interface); t != nil {
		expr.go#L410: 	case *Interface:
		expr.go#L1075: 		if _, ok := under(x.typ).(*Interface); !ok {
		gcsizes.go#L49: 	case *Slice, *Interface:
		gcsizes.go#L154: 	case *Interface:
		index.go#L104: 	case *Interface:
		infer.go#L608: 	case *Interface:
		infer.go#L762: 	case *Interface:
		instantiate.go#L251: 	Ti, _ := Tu.(*Interface)
		instantiate.go#L273: 	Vi, _ := Vu.(*Interface)
		instantiate.go#L383: 	case *Interface:
		interface.go#L17: type Interface struct {
		interface.go#L29: func (t *Interface) typeSet() *_TypeSet { return computeInterfaceTypeSet(t.check, nopos, t) }
		interface.go#L32: var emptyInterface = Interface{complete: true, tset: &topTypeSet}
		interface.go#L39: func NewInterface(methods []*Func, embeddeds []*Named) *Interface {
		interface.go#L53: func NewInterfaceType(methods []*Func, embeddeds []Type) *Interface {
		interface.go#L77: func (check *Checker) newInterface() *Interface {
		interface.go#L78: 	typ := &Interface{check: check}
		interface.go#L89: func (t *Interface) MarkImplicit() {
		interface.go#L94: func (t *Interface) NumExplicitMethods() int { return len(t.methods) }
		interface.go#L98: func (t *Interface) ExplicitMethod(i int) *Func { return t.methods[i] }
		interface.go#L101: func (t *Interface) NumEmbeddeds() int { return len(t.embeddeds) }
		interface.go#L107: func (t *Interface) Embedded(i int) *Named { return asNamed(t.embeddeds[i]) }
		interface.go#L110: func (t *Interface) EmbeddedType(i int) Type { return t.embeddeds[i] }
		interface.go#L113: func (t *Interface) NumMethods() int { return t.typeSet().NumMethods() }
		interface.go#L117: func (t *Interface) Method(i int) *Func { return t.typeSet().Method(i) }
		interface.go#L120: func (t *Interface) Empty() bool { return t.typeSet().IsAll() }
		interface.go#L123: func (t *Interface) IsComparable() bool { return t.typeSet().IsComparable(nil) }
		interface.go#L127: func (t *Interface) IsMethodSet() bool { return t.typeSet().IsMethodSet() }
		interface.go#L130: func (t *Interface) IsImplicit() bool { return t.implicit }
		interface.go#L139: func (t *Interface) Complete() *Interface {
		interface.go#L147: func (t *Interface) Underlying() Type { return t }
		interface.go#L148: func (t *Interface) String() string   { return TypeString(t, nil) }
		interface.go#L153: func (t *Interface) cleanup() {
		interface.go#L159: func (check *Checker) interfaceType(ityp *Interface, iface *ast.InterfaceType, def *TypeName) {
		iter.go#L20: func (t *Interface) Methods() iter.Seq[*Func] {
		iter.go#L34: func (t *Interface) ExplicitMethods() iter.Seq[*Func] {
		iter.go#L47: func (t *Interface) EmbeddedTypes() iter.Seq[Type] {
		lookup.go#L117: 		if _, ok := under(typ).(*Interface); ok {
		lookup.go#L199: 			case *Interface:
		lookup.go#L324: func MissingMethod(V Type, T *Interface, static bool) (method *Func, wrongType bool) {
		lookup.go#L338: 	methods := under(T).(*Interface).typeSet().methods // T must be an interface
		lookup.go#L358: 	if u, _ := under(V).(*Interface); u != nil {
		methodset.go#L157: 			case *Interface:
		mono.go#L246: 		case *Interface:
		named.go#L677: 	if iface, _ := underlying.(*Interface); iface != nil {
		object.go#L649: 			if _, ok := recv.Type().(*Interface); ok {
		operand.go#L249: 	case *Interface:
		operand.go#L363: 	if _, ok := Tu.(*Interface); ok && Tp == nil || isInterfacePtr(Tu) {
		operand.go#L378: 	if Vi, _ := Vu.(*Interface); Vi != nil && Vp == nil {
		predicates.go#L116: 	_, ok := under(t).(*Interface)
		predicates.go#L137: 		iface, _ := safeUnderlying(tpar.bound).(*Interface)
		predicates.go#L196: 	case *Interface:
		predicates.go#L219: 	case *Interface:
		predicates.go#L239: 	x, y *Interface
		predicates.go#L395: 	case *Interface:
		predicates.go#L403: 		if y, ok := y.(*Interface); ok {
		signature.go#L448: 		case *Pointer, *Interface:
		sizes.go#L87: 	case *Slice, *Interface:
		sizes.go#L221: 	case *Interface:
		stmt.go#L357: func (check *Checker) caseTypes_currently_unused(x *operand, xtyp *Interface, types []ast.Expr, seen map[string]ast.Expr) Type {
		struct.go#L160: 				case *Interface:
		subst.go#L190: 	case *Interface:
		typeparam.go#L114: func (t *TypeParam) iface() *Interface {
		typeparam.go#L118: 	var ityp *Interface
		typeparam.go#L125: 	case *Interface:
		typeset.go#L155: func computeInterfaceTypeSet(check *Checker, pos token.Pos, ityp *Interface) *_TypeSet {
		typeset.go#L271: 		case *Interface:
		typeset.go#L387: 		if ui, _ := u.(*Interface); ui != nil {
		typestring.go#L215: 	case *Interface:
		typexpr.go#L175: 		if t, _ := under(typ).(*Interface); t != nil {
		unify.go#L274: func asInterface(x Type) (i *Interface) {
		unify.go#L276: 		i, _ = under(x).(*Interface)
		unify.go#L659: 	case *Interface:
		unify.go#L666: 		if y, ok := y.(*Interface); ok {
		union.go#L98: 			f, _ := u.(*Interface)
		universe.go#L103: 		universeAnyNoAlias = NewTypeName(nopos, nil, "any", &Interface{complete: true, tset: &topTypeSet})
		universe.go#L131: 		ityp := &Interface{methods: []*Func{err}, complete: true}
		universe.go#L145: 		ityp := &Interface{complete: true, tset: &_TypeSet{nil, allTermlist, true}}
		validtype.go#L69: 	case *Interface:

	golang.org/x/exp/apidiff
		apidiff.go#L97: 		oIface, ok := otn1.Type().Underlying().(*types.Interface)
		apidiff.go#L101: 		nIface, ok := nt1.Underlying().(*types.Interface)
		compatibility.go#L11: 	case *types.Interface:
		compatibility.go#L12: 		if new, ok := new.(*types.Interface); ok {
		compatibility.go#L111: func (d *differ) checkCompatibleInterface(otn *types.TypeName, old, new *types.Interface) {
		compatibility.go#L127: func unexportedMethod(t *types.Interface) *types.Func {
		compatibility.go#L270: 	if _, ok := old.Underlying().(*types.Interface); ok {
		correspondence.go#L95: 	case *types.Interface:
		correspondence.go#L96: 		if new, ok := new.(*types.Interface); ok {
		correspondence.go#L259: func (d *differ) sortedMethods(iface *types.Interface) []*types.Func {
		correspondence.go#L282: 	x, y *types.Interface

	golang.org/x/tools/go/types/objectpath
		objectpath.go#L524: 	case *types.Interface:
		objectpath.go#L758: 			case *types.Interface:

	golang.org/x/tools/go/types/typeutil
		map.go#L274: 	case *types.Interface:
		map.go#L459: 	case *types.Interface:

	golang.org/x/tools/internal/gcimporter
		iexport.go#L761: 				if iface, _ := types.Unalias(constraint).(*types.Interface); iface != nil {
		iexport.go#L1112: 	case *types.Interface:
		iimport.go#L356: 		if iface, _ := typ.Underlying().(*types.Interface); iface != nil {
		iimport.go#L390: 	interfaceList []*types.Interface
		iimport.go#L543: 	iface, _ := types.Unalias(rhs).(*types.Interface)
		iimport.go#L660: 			iface, _ := types.Unalias(constraint).(*types.Interface)
		iimport.go#L869: 	_, ok := types.Unalias(t).(*types.Interface)
		ureader_yes.go#L45: 	ifaces []*types.Interface
		ureader_yes.go#L412: func (r *reader) interfaceType() *types.Interface {
		ureader_yes.go#L569: 				if iface, ok := types.Unalias(underlying).(*types.Interface); ok && iface.NumExplicitMethods() != 0 {

	golang.org/x/tools/internal/typeparams
		coretype.go#L17: 	if _, ok := U.(*types.Interface); !ok {
		coretype.go#L123: 	case *types.Interface:
		free.go#L89: 	case *types.Interface:
		normalize.go#L68: 	iface, _ := constraint.Underlying().(*types.Interface)
		normalize.go#L81: func InterfaceTermSet(iface *types.Interface) ([]*types.Term, error) {
		normalize.go#L159: 	case *types.Interface:
		normalize.go#L181: 			case *types.Interface:

	golang.org/x/tools/internal/typesinternal
		element.go#L75: 		case *types.Interface:
		zerovalue.go#L57: 	case *types.Interface:
		zerovalue.go#L150: 	case *types.Interface:
		zerovalue.go#L344: 	case *types.Interface: