type go/types.Interface
115 uses
go/types (current package)
api.go#L425: func AssertableTo(V *Interface, T Type) bool {
api.go#L459: func Implements(V Type, T *Interface) bool {
builtins.go#L195: case *Interface:
builtins.go#L812: case *Interface:
call.go#L140: if t, _ := under(T).(*Interface); t != nil && !isTypeParam(T) {
decl.go#L529: u, _ := named.under().(*Interface)
decl.go#L666: if t, _ := t.(*Interface); t != nil {
expr.go#L690: case *Interface:
expr.go#L881: case *Interface:
expr.go#L1563: if _, ok := under(x.typ).(*Interface); !ok {
expr.go#L1685: method, alt := check.assertableTo(under(x.typ).(*Interface), T)
index.go#L103: case *Interface:
infer.go#L419: case *Interface:
infer.go#L753: case *Interface:
instantiate.go#L170: Ti, _ := Tu.(*Interface)
instantiate.go#L189: Vi, _ := Vu.(*Interface)
interface.go#L16: type Interface struct {
interface.go#L29: func (t *Interface) typeSet() *_TypeSet { return computeInterfaceTypeSet(t.check, token.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 { tname, _ := t.embeddeds[i].(*Named); return tname }
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#L158: func (check *Checker) interfaceType(ityp *Interface, iface *ast.InterfaceType, def *Named) {
lookup.go#L100: if _, ok := under(typ).(*Interface); ok {
lookup.go#L183: case *Interface:
lookup.go#L294: func MissingMethod(V Type, T *Interface, static bool) (method *Func, wrongType bool) {
lookup.go#L308: func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method, alt *Func) {
lookup.go#L314: if u, _ := under(V).(*Interface); u != nil {
lookup.go#L438: func (check *Checker) assertableTo(V *Interface, T Type) (method, wrongType *Func) {
lookup.go#L452: func (check *Checker) newAssertableTo(V *Interface, T Type) error {
methodset.go#L149: case *Interface:
mono.go#L240: case *Interface:
named.go#L383: if iface, _ := underlying.(*Interface); iface != nil {
object.go#L535: if _, ok := recv.Type().(*Interface); ok {
operand.go#L282: if _, ok := Tu.(*Interface); ok && Tp == nil || isInterfacePtr(Tu) {
operand.go#L293: if Vi, _ := Vu.(*Interface); Vi != nil && Vp == nil {
predicates.go#L86: _, ok := under(t).(*Interface)
predicates.go#L146: case *Interface:
predicates.go#L159: case *Interface:
predicates.go#L169: x, y *Interface
predicates.go#L311: case *Interface:
predicates.go#L319: if y, ok := y.(*Interface); ok {
signature.go#L246: case *Pointer, *Interface:
sizes.go#L67: case *Slice, *Interface:
sizes.go#L156: case *Interface:
stmt.go#L692: if _, ok := under(x.typ).(*Interface); ok {
struct.go#L158: case *Interface:
subst.go#L159: case *Interface:
typeparam.go#L106: func (t *TypeParam) iface() *Interface {
typeparam.go#L110: var ityp *Interface
typeparam.go#L117: case *Interface:
typeset.go#L153: func computeInterfaceTypeSet(check *Checker, pos token.Pos, ityp *Interface) *_TypeSet {
typeset.go#L273: case *Interface:
typeset.go#L405: if ui, _ := u.(*Interface); ui != nil {
typestring.go#L204: case *Interface:
typexpr.go#L163: if t, _ := under(typ).(*Interface); t != nil {
unify.go#L474: case *Interface:
unify.go#L478: if y, ok := y.(*Interface); ok {
union.go#L97: f, _ := u.(*Interface)
universe.go#L86: def(NewTypeName(token.NoPos, nil, "any", &Interface{complete: true, tset: &topTypeSet}))
universe.go#L101: ityp := &Interface{obj: obj, methods: []*Func{err}, complete: true}
universe.go#L115: ityp := &Interface{obj: obj, complete: true, tset: &_TypeSet{nil, allTermlist, true}}
validtype.go#L56: 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/internal/gcimporter
bexport.go#L368: case *types.Interface:
bexport.go#L457: func (p *exporter) iface(t *types.Interface) {
bimport.go#L35: interfaceList []*types.Interface // for delayed completion only
iexport.go#L492: if iface, _ := constraint.(*types.Interface); iface != nil {
iexport.go#L788: case *types.Interface:
iimport.go#L308: interfaceList []*types.Interface
iimport.go#L459: iface, _ := rhs.(*types.Interface)
iimport.go#L561: iface, _ := constraint.(*types.Interface)
iimport.go#L767: _, ok := t.(*types.Interface)
newInterface11.go#L12: func newInterface(methods []*types.Func, embeddeds []types.Type) *types.Interface {
ureader_yes.go#L44: ifaces []*types.Interface
ureader_yes.go#L415: func (r *reader) interfaceType() *types.Interface {
ureader_yes.go#L566: if iface, ok := underlying.(*types.Interface); ok && iface.NumExplicitMethods() != 0 {
golang.org/x/tools/internal/typeparams
coretype.go#L16: if _, ok := U.(*types.Interface); !ok {
coretype.go#L117: case *types.Interface:
normalize.go#L68: iface, _ := constraint.Underlying().(*types.Interface)
normalize.go#L81: func InterfaceTermSet(iface *types.Interface) ([]*Term, error) {
normalize.go#L159: case *types.Interface:
normalize.go#L181: case *types.Interface:
typeparams_go118.go#L69: func IsComparable(iface *types.Interface) bool {
typeparams_go118.go#L74: func IsMethodSet(iface *types.Interface) bool {
typeparams_go118.go#L79: func IsImplicit(iface *types.Interface) bool {
typeparams_go118.go#L84: func MarkImplicit(iface *types.Interface) {