blob: 340df51524b8584e4a2645437e8652ac78b9579a [file] [log] [blame]
// Copyright 2021 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 types2
import "cmd/compile/internal/syntax"
// ----------------------------------------------------------------------------
// API
// An Interface represents an interface type.
type Interface struct {
check *Checker // for error reporting; nil once type set is computed
obj *TypeName // corresponding declared object; or nil (for better error messages)
methods []*Func // ordered list of explicitly declared methods
embeddeds []Type // ordered list of explicitly embedded elements
embedPos *[]syntax.Pos // positions of embedded elements; or nil (for error messages) - use pointer to save space
complete bool // indicates that all fields (except for tset) are set up
tset *_TypeSet // type set described by this interface, computed lazily
// typeSet returns the type set for interface t.
func (t *Interface) typeSet() *_TypeSet { return computeInterfaceTypeSet(t.check, nopos, t) }
// emptyInterface represents the empty interface
var emptyInterface = Interface{complete: true, tset: &topTypeSet}
// NewInterface returns a new interface for the given methods and embedded types.
// NewInterface takes ownership of the provided methods and may modify their types
// by setting missing receivers.
// Deprecated: Use NewInterfaceType instead which allows arbitrary embedded types.
func NewInterface(methods []*Func, embeddeds []*Named) *Interface {
tnames := make([]Type, len(embeddeds))
for i, t := range embeddeds {
tnames[i] = t
return NewInterfaceType(methods, tnames)
// NewInterfaceType returns a new interface for the given methods and embedded types.
// NewInterfaceType takes ownership of the provided methods and may modify their types
// by setting missing receivers.
func NewInterfaceType(methods []*Func, embeddeds []Type) *Interface {
if len(methods) == 0 && len(embeddeds) == 0 {
return &emptyInterface
// set method receivers if necessary
typ := new(Interface)
for _, m := range methods {
if sig := m.typ.(*Signature); sig.recv == nil {
sig.recv = NewVar(m.pos, m.pkg, "", typ)
// sort for API stability
typ.methods = methods
typ.embeddeds = embeddeds
typ.complete = true
return typ
// NumExplicitMethods returns the number of explicitly declared methods of interface t.
func (t *Interface) NumExplicitMethods() int { return len(t.methods) }
// ExplicitMethod returns the i'th explicitly declared method of interface t for 0 <= i < t.NumExplicitMethods().
// The methods are ordered by their unique Id.
func (t *Interface) ExplicitMethod(i int) *Func { return t.methods[i] }
// NumEmbeddeds returns the number of embedded types in interface t.
func (t *Interface) NumEmbeddeds() int { return len(t.embeddeds) }
// Embedded returns the i'th embedded defined (*Named) type of interface t for 0 <= i < t.NumEmbeddeds().
// The result is nil if the i'th embedded type is not a defined type.
// Deprecated: Use EmbeddedType which is not restricted to defined (*Named) types.
func (t *Interface) Embedded(i int) *Named { tname, _ := t.embeddeds[i].(*Named); return tname }
// EmbeddedType returns the i'th embedded type of interface t for 0 <= i < t.NumEmbeddeds().
func (t *Interface) EmbeddedType(i int) Type { return t.embeddeds[i] }
// NumMethods returns the total number of methods of interface t.
func (t *Interface) NumMethods() int { return t.typeSet().NumMethods() }
// Method returns the i'th method of interface t for 0 <= i < t.NumMethods().
// The methods are ordered by their unique Id.
func (t *Interface) Method(i int) *Func { return t.typeSet().Method(i) }
// Empty reports whether t is the empty interface.
func (t *Interface) Empty() bool { return t.typeSet().IsAll() }
// IsComparable reports whether each type in interface t's type set is comparable.
func (t *Interface) IsComparable() bool { return t.typeSet().IsComparable() }
// IsConstraint reports whether interface t is not just a method set.
func (t *Interface) IsConstraint() bool { return t.typeSet().IsConstraint() }
func (t *Interface) Underlying() Type { return t }
func (t *Interface) String() string { return TypeString(t, nil) }
// ----------------------------------------------------------------------------
// Implementation
func (check *Checker) interfaceType(ityp *Interface, iface *syntax.InterfaceType, def *Named) {
var tlist []syntax.Expr // types collected from all type lists
var tname *syntax.Name // most recent "type" name
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 {
// We have an embedded type; possibly a union of types.
addEmbedded(posFor(f.Type), parseUnion(check, flattenUnion(nil, f.Type)))
// f.Name != nil
// We have a method with name f.Name, or a type of a type list (f.Name.Value == "type").
name := f.Name.Value
if name == "_" {
if check.conf.CompilerErrorMessages {
check.error(f.Name, "methods must have a unique non-blank name")
} else {
check.error(f.Name, "invalid method name _")
continue // ignore
// TODO(gri) Remove type list handling once the parser doesn't accept type lists anymore.
if name == "type" {
// Report an error for the first type list per interface
// if we don't allow type lists, but continue.
if !check.conf.AllowTypeLists && tlist == nil {
check.softErrorf(f.Name, "use generalized embedding syntax instead of a type list")
// For now, collect all type list entries as if it
// were a single union, where each union element is
// of the form ~T.
op := new(syntax.Operation)
// We should also set the position (but there is no setter);
// we don't care because this code will eventually go away.
op.Op = syntax.Tilde
op.X = f.Type
tlist = append(tlist, op)
// Report an error if we have multiple type lists in an
// interface, but only if they are permitted in the first place.
if check.conf.AllowTypeLists && tname != nil && tname != f.Name {
check.error(f.Name, "cannot have multiple type lists in an interface")
tname = f.Name
typ := check.typ(f.Type)
sig, _ := typ.(*Signature)
if sig == nil {
if typ != Typ[Invalid] {
check.errorf(f.Type, invalidAST+"%s is not a method signature", typ)
continue // ignore
// Always type-check method type parameters but complain if they are not enabled.
// (This extra check is needed here because interface method signatures don't have
// a receiver specification.)
if sig.tparams != nil && !acceptMethodTypeParams {
check.error(f.Type, "methods cannot have type parameters")
// use named receiver type if available (for better error messages)
var recvTyp Type = ityp
if def != nil {
recvTyp = def
sig.recv = NewVar(f.Name.Pos(), check.pkg, "", recvTyp)
m := NewFunc(f.Name.Pos(), check.pkg, name, sig)
check.recordDef(f.Name, m)
ityp.methods = append(ityp.methods, m)
// If we saw a type list, add it like an embedded union.
if tlist != nil {
// Types T in a type list are added as ~T expressions but we don't
// have the position of the '~'. Use the first type position instead.
addEmbedded(tlist[0].(*syntax.Operation).X.Pos(), parseUnion(check, tlist))
// All methods and embedded elements for this interface are collected;
// i.e., this interface may be used in a type set computation.
ityp.complete = true
if len(ityp.methods) == 0 && len(ityp.embeddeds) == 0 {
// empty interface
ityp.tset = &topTypeSet
// sort for API stability
// (don't sort embeddeds: they must correspond to *embedPos entries)
// Compute type set with a non-nil *Checker as soon as possible
// to report any errors. Subsequent uses of type sets will use
// this computed type set and won't need to pass in a *Checker.
// Pin the checker to the interface type in the interim, in case the type set
// must be used before delayed funcs are processed (see issue #48234).
// TODO(rfindley): clean up use of *Checker with computeInterfaceTypeSet
ityp.check = check
check.later(func() {
computeInterfaceTypeSet(check, iface.Pos(), ityp)
ityp.check = nil
func flattenUnion(list []syntax.Expr, x syntax.Expr) []syntax.Expr {
if o, _ := x.(*syntax.Operation); o != nil && o.Op == syntax.Or {
list = flattenUnion(list, o.X)
x = o.Y
return append(list, x)