This removes two more converter methods in favor of functions.
This further reduces the API surface of types2.Type and matches
the approach taken in go/types.
Change-Id: I3cdd54c5e0d1e7664a69f3697fc081a66315b969
Reviewed-on: https://go-review.googlesource.com/c/go/+/293292
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
func (t anyType) Underlying() types2.Type { return t }
func (t anyType) Under() types2.Type { return t }
func (t anyType) String() string { return "any" }
-
-// types2.aType is not exported for now so we need to implemented these here.
-func (anyType) Named() *types2.Named { return nil }
-func (anyType) TypeParam() *types2.TypeParam { return nil }
case _Alignof:
// unsafe.Alignof(x T) uintptr
- if x.typ.TypeParam() != nil {
+ if asTypeParam(x.typ) != nil {
check.invalidOpf(call, "unsafe.Alignof undefined for %s", x)
return
}
case _Sizeof:
// unsafe.Sizeof(x T) uintptr
- if x.typ.TypeParam() != nil {
+ if asTypeParam(x.typ) != nil {
check.invalidOpf(call, "unsafe.Sizeof undefined for %s", x)
return
}
// applyTypeFunc returns nil.
// If x is not a type parameter, the result is f(x).
func (check *Checker) applyTypeFunc(f func(Type) Type, x Type) Type {
- if tp := x.TypeParam(); tp != nil {
+ if tp := asTypeParam(x); tp != nil {
// Test if t satisfies the requirements for the argument
// type and collect possible result types at the same time.
var rtypes []Type
check.errorf(e.Sel, "cannot call pointer method %s on %s", sel, x.typ)
default:
var why string
- if tpar := x.typ.TypeParam(); tpar != nil {
+ if tpar := asTypeParam(x.typ); tpar != nil {
// Type parameter bounds don't specify fields, so don't mention "field".
switch obj := tpar.Bound().obj.(type) {
case nil:
// If the underlying type of a defined type is not a defined
// type, then that is the desired underlying type.
- n := u.Named()
+ n := asNamed(u)
if n == nil {
return u // common case
}
u = Typ[Invalid]
break
}
- n1 := u.Named()
+ n1 := asNamed(u)
if n1 == nil {
break // end of chain
}
// spec: "If the base type is a struct type, the non-blank method
// and field names must be distinct."
- base := obj.typ.Named() // shouldn't fail but be conservative
+ base := asNamed(obj.typ) // shouldn't fail but be conservative
if base != nil {
if t, _ := base.underlying.(*Struct); t != nil {
for _, fld := range t.fields {
// TODO(gri) We should not need this because we have the code
// for Sum types in convertUntypedInternal. But at least one
// test fails. Investigate.
- if t := target.TypeParam(); t != nil {
+ if t := asTypeParam(target); t != nil {
types := t.Bound().allTypes
if types == nil {
goto Error
// Thus, if we have a named pointer type, proceed with the underlying
// pointer type but discard the result if it is a method since we would
// not have found it for T (see also issue 8590).
- if t := T.Named(); t != nil {
+ if t := asNamed(T); t != nil {
if p, _ := t.underlying.(*Pointer); p != nil {
obj, index, indirect = check.rawLookupFieldOrMethod(p, false, pkg, name)
if _, ok := obj.(*Func); ok {
// If we have a named type, we may have associated methods.
// Look for those first.
- if named := typ.Named(); named != nil {
+ if named := asNamed(typ); named != nil {
if seen[named] {
// We have seen this type before, at a more shallow depth
// (note that multiples of this type at the current depth
// continue with underlying type, but only if it's not a type parameter
// TODO(gri) is this what we want to do for type parameters? (spec question)
typ = named.Under()
- if typ.TypeParam() != nil {
+ if asTypeParam(typ) != nil {
continue
}
}
// A concrete type implements T if it implements all methods of T.
Vd, _ := deref(V)
- Vn := Vd.Named()
+ Vn := asNamed(Vd)
for _, m := range T.allMethods {
// TODO(gri) should this be calling lookupFieldOrMethod instead (and why not)?
obj, _, _ := check.rawLookupFieldOrMethod(V, false, m.pkg, m.name)
switch {
case isGeneric(x.typ):
intro = " of generic type "
- case x.typ.TypeParam() != nil:
+ case asTypeParam(x.typ) != nil:
intro = " of type parameter type "
default:
intro = " of type "
// interface{ comparable; type []byte }
//
// is not comparable because []byte is not comparable.
- if t := T.TypeParam(); t != nil && optype(t) == theTop {
+ if t := asTypeParam(T); t != nil && optype(t) == theTop {
return t.Bound().IsComparable()
}
// If the type argument is a pointer to a type parameter, the type argument's
// method set is empty.
// TODO(gri) is this what we want? (spec question)
- if base, isPtr := deref(targ); isPtr && base.TypeParam() != nil {
+ if base, isPtr := deref(targ); isPtr && asTypeParam(base) != nil {
check.errorf(pos, "%s has no methods", targ)
break
}
// If targ is itself a type parameter, each of its possible types, but at least one, must be in the
// list of iface types (i.e., the targ type list must be a non-empty subset of the iface types).
- if targ := targ.TypeParam(); targ != nil {
+ if targ := asTypeParam(targ); targ != nil {
targBound := targ.Bound()
if targBound.allTypes == nil {
check.softErrorf(pos, "%s does not satisfy %s (%s has no type constraints)", targ, tpar.bound, targ)
// String returns a string representation of a type.
String() string
-
- // If the receiver for Named and TypeParam is of
- // the respective type (possibly after unpacking
- // an instance type), these methods return that
- // type. Otherwise the result is nil.
- Named() *Named
- TypeParam() *TypeParam
}
// aType implements default type behavior
func (aType) Under() Type { panic("unreachable") }
func (aType) String() string { panic("unreachable") }
-func (aType) Named() *Named { return nil }
-func (aType) TypeParam() *TypeParam { return nil }
-
// BasicKind describes the kind of basic type.
type BasicKind int
aType
}
+// TODO(gri) Don't represent empty tuples with a (*Tuple)(nil) pointer;
+// it's too subtle and causes problems. Use a singleton instead.
+
// NewTuple returns a new tuple for the given variables.
func NewTuple(x ...*Var) *Tuple {
if len(x) > 0 {
return nil
}
-// We cannot rely on the embedded X() *X methods because (*Tuple)(nil)
-// is a valid *Tuple value but (*Tuple)(nil).X() would panic without
-// these implementations. At the moment we only need X = Basic, Named,
-// but add all because missing one leads to very confusing bugs.
-// TODO(gri) Don't represent empty tuples with a (*Tuple)(nil) pointer;
-// it's too subtle and causes problems.
-
-func (*Tuple) Named() *Named { return nil }
-func (*Tuple) TypeParam() *TypeParam { return nil }
-
// Len returns the number variables of tuple t.
func (t *Tuple) Len() int {
if t != nil {
// Obj returns the type name for the named type t.
func (t *Named) Obj() *TypeName { return t.obj }
-// func (t *Named) Named() *Named // declared below
-func (t *Named) TypeParam() *TypeParam { return t.Under().TypeParam() }
-
// TODO(gri) Come up with a better representation and API to distinguish
// between parameterized instantiated and non-instantiated types.
// result may be the bottom or top type, but it is never
// the incoming type parameter.
func optype(typ Type) Type {
- if t := typ.TypeParam(); t != nil {
+ if t := asTypeParam(typ); t != nil {
// If the optype is typ, return the top type as we have
// no information. It also prevents infinite recursion
// via the TypeParam converter methods. This can happen
return typ.Under()
}
-// func (t *TypeParam) Named() *Named // Named does not unpack type parameters
-// func (t *TypeParam) TypeParam() *TypeParam // declared below
-
// An instance represents an instantiated generic type syntactically
// (without expanding the instantiation). Type instances appear only
// during type-checking and are replaced by their fully instantiated
aType
}
-func (t *instance) Named() *Named { return t.expand().Named() }
-func (t *instance) TypeParam() *TypeParam { return t.expand().TypeParam() }
-
// expand returns the instantiated (= expanded) type of t.
// The result is either an instantiated *Named type, or
// Typ[Invalid] if there was an error.
// theTop is the singleton top type.
var theTop = &top{}
-func (t *Named) Named() *Named { return t }
-func (t *TypeParam) TypeParam() *TypeParam { return t }
-
// Type-specific implementations of Underlying.
func (t *Basic) Underlying() Type { return t }
func (t *Array) Underlying() Type { return t }
op, _ := optype(t).(*Chan)
return op
}
+
+// If the argument to asNamed and asTypeParam is of the respective types
+// (possibly after expanding an instance type), these methods return that type.
+// Otherwise the result is nil.
+
+func asNamed(t Type) *Named {
+ e, _ := expand(t).(*Named)
+ return e
+}
+
+func asTypeParam(t Type) *TypeParam {
+ u, _ := t.Under().(*TypeParam)
+ return u
+}
// Also: Don't report an error via genericType since it will be reported
// again when we type-check the signature.
// TODO(gri) maybe the receiver should be marked as invalid instead?
- if recv := check.genericType(rname, false).Named(); recv != nil {
+ if recv := asNamed(check.genericType(rname, false)); recv != nil {
recvTParams = recv.tparams
}
}
// (ignore invalid types - error was reported before)
if t := rtyp; t != Typ[Invalid] {
var err string
- if T := t.Named(); T != nil {
+ if T := asNamed(t); T != nil {
// spec: "The type denoted by T is called the receiver base type; it must not
// be a pointer or interface type and it must be declared in the same package
// as the method."
check.atEnd(func() {
if !Comparable(typ.key) {
var why string
- if typ.key.TypeParam() != nil {
+ if asTypeParam(typ.key) != nil {
why = " (missing comparable constraint)"
}
check.errorf(e.Key, "invalid map key type %s%s", typ.key, why)
if b == Typ[Invalid] {
return b // error already reported
}
- base := b.Named()
+ base := asNamed(b)
if base == nil {
unreachable() // should have been caught by genericType
}
func (a byUniqueTypeName) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func sortName(t Type) string {
- if named := t.Named(); named != nil {
+ if named := asNamed(t); named != nil {
return named.obj.Id()
}
return ""
// match a type name against an unnamed type literal, consider
// the underlying type of the named type.
// (Subtle: We use isNamed to include any type with a name (incl.
- // basic types and type parameters. We use Named() because we only
+ // basic types and type parameters. We use asNamed because we only
// want *Named types.)
switch {
- case !isNamed(x) && y != nil && y.Named() != nil:
+ case !isNamed(x) && y != nil && asNamed(y) != nil:
return u.nify(x, y.Under(), p)
- case x != nil && x.Named() != nil && !isNamed(y):
+ case x != nil && asNamed(x) != nil && !isNamed(y):
return u.nify(x.Under(), y, p)
}
}
return // nothing to do
}
// fix Obj link for named types
- if typ := obj.Type().Named(); typ != nil {
+ if typ := asNamed(obj.Type()); typ != nil {
typ.obj = obj.(*TypeName)
}
// exported identifiers go into package unsafe