var mode syntax.Mode
if strings.HasSuffix(filenames[0], ".go2") {
- mode |= syntax.AllowGenerics | syntax.AllowTypeLists
+ mode |= syntax.AllowGenerics | syntax.AllowTypeSets | syntax.AllowTypeLists
}
// parse files and collect parser errors
files, errlist := parseFiles(t, filenames, mode)
// This also preserves the grouped output of type parameter lists
// when printing type strings.
if i == 0 || f.Type != list[i-1].Type {
- bound = check.typ(f.Type)
+ bound = check.bound(f.Type)
}
tparams[i].bound = bound
}
check.later(func() {
for i, tpar := range tparams {
- u := under(tpar.bound)
- if _, ok := u.(*Interface); !ok && u != Typ[Invalid] {
- check.errorf(list[i].Type, "%s is not an interface", tpar.bound)
+ if _, ok := under(tpar.bound).(*TypeParam); ok {
+ check.error(list[i].Type, "cannot use a type parameter as constraint")
}
+ tpar.iface() // compute type set
}
})
}
+func (check *Checker) bound(x syntax.Expr) Type {
+ // A type set literal of the form ~T and A|B may only appear as constraint;
+ // embed it in an implicit interface so that only interface type-checking
+ // needs to take care of such type expressions.
+ if op, _ := x.(*syntax.Operation); op != nil && (op.Op == syntax.Tilde || op.Op == syntax.Or) {
+ // TODO(gri) Should mark this interface as "implicit" somehow
+ // (and propagate the info to types2.Interface) so
+ // that we can elide the interface again in error
+ // messages. Could use a sentinel name for the field.
+ x = &syntax.InterfaceType{MethodList: []*syntax.Field{{Type: x}}}
+ }
+ return check.typ(x)
+}
+
func (check *Checker) declareTypeParam(name *syntax.Name) *TypeParam {
// Use Typ[Invalid] for the type constraint to ensure that a type
// is present even if the actual constraint has not been assigned
--- /dev/null
+// 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.
+
+// This file shows some examples of constraint literals with elided interfaces.
+// These examples are permitted if proposal issue #48424 is accepted.
+
+package p
+
+// Constraint type sets of the form T, ~T, or A|B may omit the interface.
+type (
+ _[T int] struct{}
+ _[T ~int] struct{}
+ _[T int|string] struct{}
+ _[T ~int|~string] struct{}
+)
+
+func min[T int|string](x, y T) T {
+ if x < y {
+ return x
+ }
+ return y
+}
+
+func lookup[M ~map[K]V, K comparable, V any](m M, k K) V {
+ return m[k]
+}
+
+func deref[P ~*E, E any](p P) E {
+ return *p
+}
+
+func _() int {
+ p := new(int)
+ return deref(p)
+}
+
+func addrOfCopy[V any, P ~*V](v V) P {
+ return &v
+}
+
+func _() *int {
+ return addrOfCopy(0)
+}
+
+// A type parameter may not be embedded in an interface;
+// so it can also not be used as a constraint.
+func _[A any, B A /* ERROR cannot use a type parameter as constraint */ ]() {}
// A constraint must be an interface; it cannot
// be a type parameter, for instance.
-func _[A interface{ ~int }, B A /* ERROR not an interface */ ]() {}
+func _[A interface{ ~int }, B A /* ERROR cannot use a type parameter as constraint */ ]() {}
id uint64 // unique id, for debugging only
obj *TypeName // corresponding type name
index int // type parameter index in source order, starting at 0
- // TODO(rfindley): this could also be Typ[Invalid]. Verify that this is handled correctly.
- bound Type // *Named or *Interface; underlying type is always *Interface
+ bound Type // any type, but eventually an *Interface for correct programs (see TypeParam.iface)
}
// Obj returns the type name for the type parameter t.
// Constraint returns the type constraint specified for t.
func (t *TypeParam) Constraint() Type {
- // compute the type set if possible (we may not have an interface)
- if iface, _ := under(t.bound).(*Interface); iface != nil {
- // use the type bound position if we have one
- pos := nopos
- if n, _ := t.bound.(*Named); n != nil {
- pos = n.obj.pos
- }
- computeInterfaceTypeSet(t.check, pos, iface)
- }
return t.bound
}
// iface returns the constraint interface of t.
func (t *TypeParam) iface() *Interface {
- if iface, _ := under(t.Constraint()).(*Interface); iface != nil {
- return iface
+ bound := t.bound
+
+ // determine constraint interface
+ var ityp *Interface
+ switch u := under(bound).(type) {
+ case *Basic:
+ if u == Typ[Invalid] {
+ // error is reported elsewhere
+ return &emptyInterface
+ }
+ case *Interface:
+ ityp = u
+ case *TypeParam:
+ // error is reported in Checker.collectTypeParams
+ return &emptyInterface
+ }
+
+ // If we don't have an interface, wrap constraint into an implicit interface.
+ // TODO(gri) mark it as implicit - see comment in Checker.bound
+ if ityp == nil {
+ ityp = NewInterfaceType(nil, []Type{bound})
+ t.bound = ityp // update t.bound for next time (optimization)
}
- return &emptyInterface
+
+ // compute type set if necessary
+ if ityp.tset == nil {
+ // use the (original) type bound position if we have one
+ pos := nopos
+ if n, _ := bound.(*Named); n != nil {
+ pos = n.obj.pos
+ }
+ computeInterfaceTypeSet(t.check, pos, ityp)
+ }
+
+ return ityp
}
// structuralType returns the structural type of the type parameter's constraint; or nil.
// The predeclared identifier "any" may be used in place of interface{}.
var _ any
+
func _(_ any)
+
type _[_ any] struct{}
const N = 10
func _[T interface{}]() {}
func _[T C]() {}
-func _[T struct{}]() {} // ERROR "not an interface"
+func _[T struct{}]() {} // ok if #48424 is accepted
func _[T interface{ m() T }]() {}
func _[T1 interface{ m() T2 }, T2 interface{ m() T1 }]() {
var _ T1