// TODO(gri) This should be a method of interfaces or type sets.
func (check *Checker) satisfies(pos token.Pos, targ Type, tpar *TypeParam, smap substMap) error {
iface := tpar.iface()
+
+ // Every type argument satisfies interface{}.
if iface.Empty() {
- return nil // no type bound
+ return nil
+ }
+
+ // A type argument that is a type parameter with an empty type set satisfies any constraint.
+ // (The empty set is a subset of any set.)
+ if targ := asTypeParam(targ); targ != nil && targ.iface().typeSet().IsEmpty() {
+ return nil
}
// TODO(rfindley): it would be great if users could pass in a qualifier here,
return errors.New(sprintf(nil, qf, false, format, args...))
}
+ // No type argument with non-empty type set satisfies the empty type set.
+ if iface.typeSet().IsEmpty() {
+ return errorf("%s does not satisfy %s (constraint type set is empty)", targ, tpar.bound)
+ }
+
// The type parameter bound is parameterized with the same type parameters
// as the instantiated type; before we can use it for bounds checking we
// need to instantiate it with the type arguments with which we instantiate
}
}
- // targ's underlying type must also be one of the interface types listed, if any
+ // targ must also be in the set of types of iface, if any.
+ // Constraints with empty type sets were already excluded above.
if !iface.typeSet().hasTerms() {
return nil // nothing to do
}
- // 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 is itself a type parameter, each of its possible types must be in the set
+ // of iface types (i.e., the targ type set must be a subset of the iface type set).
+ // Type arguments with empty type sets were already excluded above.
if targ := asTypeParam(targ); targ != nil {
targBound := targ.iface()
- if !targBound.typeSet().hasTerms() {
- return errorf("%s does not satisfy %s (%s has no type constraints)", targ, tpar.bound, targ)
- }
if !targBound.typeSet().subsetOf(iface.typeSet()) {
- // TODO(gri) need better error message
+ // TODO(gri) report which type is missing
return errorf("%s does not satisfy %s", targ, tpar.bound)
}
return nil
}
- // Otherwise, targ's type or underlying type must also be one of the interface types listed, if any.
+ // Otherwise, targ's type must be included in the iface type set.
if !iface.typeSet().includes(targ) {
- // TODO(gri) better error message
+ // TODO(gri) report which type is missing
return errorf("%s does not satisfy %s", targ, tpar.bound)
}
}
func f012[T I012]() {}
-var _ = f012[int /* ERROR does not satisfy I012 */ ]
-var _ = f012[bool /* ERROR does not satisfy I012 */ ]
-var _ = f012[string /* ERROR does not satisfy I012 */ ]
-var _ = f012[float64 /* ERROR does not satisfy I012 */ ]
+var _ = f012[int /* ERROR does not satisfy I012.*type set is empty */ ]
+var _ = f012[bool /* ERROR does not satisfy I012.*type set is empty */ ]
+var _ = f012[string /* ERROR does not satisfy I012.*type set is empty */ ]
+var _ = f012[float64 /* ERROR does not satisfy I012.*type set is empty */ ]
type I12 interface {
E1
// Using a function instance as a type is an error.
var _ f0 // ERROR not a type
var _ f0 /* ERROR not a type */ [int]
+
+// Empty type sets can only be satisfied by empty type sets.
+type none interface {
+ // force an empty type set
+ int
+ string
+}
+
+func ff[T none]() {}
+func gg[T any]() {}
+func hh[T ~int]() {}
+
+func _[T none]() {
+ _ = ff[int /* ERROR int does not satisfy none \(constraint type set is empty\) */ ]
+ _ = ff[T] // pathological but ok because T's type set is empty, too
+ _ = gg[int]
+ _ = gg[T]
+ _ = hh[int]
+ _ = hh[T]
+}