From 3efc8f9a8dc93ccacb8b139cafc44ee0709d8fdd Mon Sep 17 00:00:00 2001 From: Rob Findley Date: Tue, 3 Aug 2021 21:14:31 -0400 Subject: [PATCH] [dev.typeparams] go/types: (TypeParam) SetBound -> SetConstraint This is a straightforward port of CL 338196 to go/types, minus the deprecated TypeParam.Bound() method (since it is not needed), plus an adjustment for methodset.go. Change-Id: Ie372bfeec245094102a2c3257a43499d75981447 Reviewed-on: https://go-review.googlesource.com/c/go/+/339675 Trust: Robert Findley Run-TryBot: Robert Findley TryBot-Result: Go Bot Reviewed-by: Robert Griesemer --- src/go/types/builtins.go | 2 +- src/go/types/call.go | 2 +- src/go/types/instantiate.go | 6 +++--- src/go/types/lookup.go | 2 +- src/go/types/methodset.go | 2 +- src/go/types/predicates.go | 2 +- src/go/types/type.go | 2 +- src/go/types/typeparam.go | 25 +++++++++++-------------- 8 files changed, 20 insertions(+), 23 deletions(-) diff --git a/src/go/types/builtins.go b/src/go/types/builtins.go index ecb9920a811..aae05438cd3 100644 --- a/src/go/types/builtins.go +++ b/src/go/types/builtins.go @@ -826,7 +826,7 @@ func (check *Checker) applyTypeFunc(f func(Type) Type, x Type) Type { // type and collect possible result types at the same time. var rtypes []Type var tildes []bool - if !tp.Bound().is(func(typ Type, tilde bool) bool { + if !tp.iface().is(func(typ Type, tilde bool) bool { if r := f(typ); r != nil { rtypes = append(rtypes, r) tildes = append(tildes, tilde) diff --git a/src/go/types/call.go b/src/go/types/call.go index 16b8e4eb7c4..da2f319a4a7 100644 --- a/src/go/types/call.go +++ b/src/go/types/call.go @@ -482,7 +482,7 @@ func (check *Checker) selector(x *operand, e *ast.SelectorExpr) { var why string if tpar := asTypeParam(x.typ); tpar != nil { // Type parameter bounds don't specify fields, so don't mention "field". - if tname := tpar.Bound().obj; tname != nil { + if tname := tpar.iface().obj; tname != nil { why = check.sprintf("interface %s has no method %s", tname.name, sel) } else { why = check.sprintf("type bound for %s has no method %s", x.typ, sel) diff --git a/src/go/types/instantiate.go b/src/go/types/instantiate.go index 2e6c20723b3..6d56eb7ea21 100644 --- a/src/go/types/instantiate.go +++ b/src/go/types/instantiate.go @@ -162,7 +162,7 @@ func (check *Checker) verify(pos token.Pos, tparams []*TypeName, targs []Type, p // A suitable error is reported if the result is false. // 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) bool { - iface := tpar.Bound() + iface := tpar.iface() if iface.Empty() { return true // no type bound } @@ -176,7 +176,7 @@ func (check *Checker) satisfies(pos token.Pos, targ Type, tpar *TypeParam, smap // if iface is comparable, targ must be comparable // TODO(gri) the error messages needs to be better, here if iface.IsComparable() && !Comparable(targ) { - if tpar := asTypeParam(targ); tpar != nil && tpar.Bound().typeSet().IsTop() { + if tpar := asTypeParam(targ); tpar != nil && tpar.iface().typeSet().IsTop() { check.softErrorf(atPos(pos), _Todo, "%s has no constraints", targ) return false } @@ -222,7 +222,7 @@ func (check *Checker) satisfies(pos token.Pos, targ Type, tpar *TypeParam, smap // 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 := asTypeParam(targ); targ != nil { - targBound := targ.Bound() + targBound := targ.iface() if targBound.typeSet().types == nil { check.softErrorf(atPos(pos), _Todo, "%s does not satisfy %s (%s has no type constraints)", targ, tpar.bound, targ) return false diff --git a/src/go/types/lookup.go b/src/go/types/lookup.go index 6d38db45238..7cab336dbe2 100644 --- a/src/go/types/lookup.go +++ b/src/go/types/lookup.go @@ -190,7 +190,7 @@ func lookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (o } case *TypeParam: - if i, m := t.Bound().typeSet().LookupMethod(pkg, name); m != nil { + if i, m := t.iface().typeSet().LookupMethod(pkg, name); m != nil { assert(m.typ != nil) index = concat(e.index, i) if obj != nil || e.multiples { diff --git a/src/go/types/methodset.go b/src/go/types/methodset.go index 491917d6bcd..1462601d586 100644 --- a/src/go/types/methodset.go +++ b/src/go/types/methodset.go @@ -160,7 +160,7 @@ func NewMethodSet(T Type) *MethodSet { mset = mset.add(t.typeSet().methods, e.index, true, e.multiples) case *TypeParam: - mset = mset.add(t.Bound().typeSet().methods, e.index, true, e.multiples) + mset = mset.add(t.iface().typeSet().methods, e.index, true, e.multiples) } } diff --git a/src/go/types/predicates.go b/src/go/types/predicates.go index 579d35da420..f9cac34a031 100644 --- a/src/go/types/predicates.go +++ b/src/go/types/predicates.go @@ -113,7 +113,7 @@ func comparable(T Type, seen map[Type]bool) bool { case *Array: return comparable(t.elem, seen) case *TypeParam: - return t.Bound().IsComparable() + return t.iface().IsComparable() } return false } diff --git a/src/go/types/type.go b/src/go/types/type.go index 2ad89d97059..5819dd290ca 100644 --- a/src/go/types/type.go +++ b/src/go/types/type.go @@ -56,7 +56,7 @@ func optype(typ Type) Type { // for a type parameter list of the form: // (type T interface { type T }). // See also issue #39680. - if a := t.Bound().typeSet().types; a != nil && a != typ { + if a := t.iface().typeSet().types; a != nil && a != typ { // If we have a union with a single entry, ignore // any tilde because under(~t) == under(t). if u, _ := a.(*Union); u != nil && u.NumTerms() == 1 { diff --git a/src/go/types/typeparam.go b/src/go/types/typeparam.go index 8cb44ea25ec..33a516c2097 100644 --- a/src/go/types/typeparam.go +++ b/src/go/types/typeparam.go @@ -74,25 +74,22 @@ func (t *TypeParam) Constraint() Type { return t.bound } -// Bound returns the underlying type of the type parameter's -// constraint. -// Deprecated for external use. Use Constraint instead. -func (t *TypeParam) Bound() *Interface { +// SetConstraint sets the type constraint for t. +func (t *TypeParam) SetConstraint(bound Type) { + if bound == nil { + panic("types2.TypeParam.SetConstraint: bound must not be nil") + } + t.bound = bound +} + +// iface returns the constraint interface of t. +func (t *TypeParam) iface() *Interface { if iface, _ := under(t.Constraint()).(*Interface); iface != nil { return iface } return &emptyInterface } -// TODO(rfindley): document the SetBound methods. - -func (t *TypeParam) SetBound(bound Type) { - if bound == nil { - panic("internal error: bound must not be nil") - } - t.bound = bound -} - func (t *TypeParam) Underlying() Type { return t } func (t *TypeParam) String() string { return TypeString(t, nil) } @@ -135,5 +132,5 @@ func bindTParams(list []*TypeName) *TypeParams { // Implementation func (t *TypeParam) underIs(f func(Type) bool) bool { - return t.Bound().typeSet().underIs(f) + return t.iface().typeSet().underIs(f) }