From: Robert Findley Date: Mon, 16 Aug 2021 17:36:27 +0000 (-0400) Subject: go/types: remove targs from substMap X-Git-Tag: go1.18beta1~1757 X-Git-Url: http://www.git.cypherpunks.su/?a=commitdiff_plain;h=631af58e2058677072e213aeea25e924ebf19fcf;p=gostls13.git go/types: remove targs from substMap This is a straightforward port of CL 341859 to go/types. Change-Id: I5d2508f516b5cf4d8775c3a77cc8bed5d4bec338 Reviewed-on: https://go-review.googlesource.com/c/go/+/342480 Trust: Robert Findley Run-TryBot: Robert Findley Reviewed-by: Robert Griesemer TryBot-Result: Go Bot --- diff --git a/src/go/types/instantiate.go b/src/go/types/instantiate.go index 189a35ab88..8133067229 100644 --- a/src/go/types/instantiate.go +++ b/src/go/types/instantiate.go @@ -153,7 +153,7 @@ func (check *Checker) verify(pos token.Pos, tparams []*TypeName, targs []Type, p // parameter tpar (after any of its type parameters have been substituted through smap). // 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 { +func (check *Checker) satisfies(pos token.Pos, targ Type, tpar *TypeParam, smap substMap) bool { iface := tpar.iface() if iface.Empty() { return true // no type bound diff --git a/src/go/types/subst.go b/src/go/types/subst.go index 0d3bcefb0b..da0578ff5c 100644 --- a/src/go/types/subst.go +++ b/src/go/types/subst.go @@ -8,42 +8,31 @@ package types import ( "bytes" - "fmt" "go/token" ) // TODO(rFindley) decide error codes for the errors in this file, and check // if error spans can be improved -type substMap struct { - // The targs field is currently needed for *Named type substitution. - // TODO(gri) rewrite that code, get rid of this field, and make this - // struct just the map (proj) - targs []Type - proj map[*TypeParam]Type -} +type substMap map[*TypeParam]Type // makeSubstMap creates a new substitution map mapping tpars[i] to targs[i]. // If targs[i] is nil, tpars[i] is not substituted. -func makeSubstMap(tpars []*TypeName, targs []Type) *substMap { +func makeSubstMap(tpars []*TypeName, targs []Type) substMap { assert(len(tpars) == len(targs)) - proj := make(map[*TypeParam]Type, len(tpars)) + proj := make(substMap, len(tpars)) for i, tpar := range tpars { proj[tpar.typ.(*TypeParam)] = targs[i] } - return &substMap{targs, proj} -} - -func (m *substMap) String() string { - return fmt.Sprintf("%s", m.proj) + return proj } -func (m *substMap) empty() bool { - return len(m.proj) == 0 +func (m substMap) empty() bool { + return len(m) == 0 } -func (m *substMap) lookup(tpar *TypeParam) Type { - if t := m.proj[tpar]; t != nil { +func (m substMap) lookup(tpar *TypeParam) Type { + if t := m[tpar]; t != nil { return t } return tpar @@ -56,7 +45,7 @@ func (m *substMap) lookup(tpar *TypeParam) Type { // from the incoming type. // // If the given typMap is nil and check is non-nil, check.typMap is used. -func (check *Checker) subst(pos token.Pos, typ Type, smap *substMap, typMap map[string]*Named) Type { +func (check *Checker) subst(pos token.Pos, typ Type, smap substMap, typMap map[string]*Named) Type { if smap.empty() { return typ } @@ -94,7 +83,7 @@ func (check *Checker) subst(pos token.Pos, typ Type, smap *substMap, typMap map[ type subster struct { pos token.Pos - smap *substMap + smap substMap check *Checker // nil if called via Instantiate typMap map[string]*Named } @@ -205,41 +194,34 @@ func (subst *subster) typ(typ Type) Type { return t // type is not parameterized } - var newTargs []Type - - if len(t.targs) > 0 { - // already instantiated - dump(">>> %s already instantiated", t) - assert(len(t.targs) == t.TParams().Len()) - // For each (existing) type argument targ, determine if it needs - // to be substituted; i.e., if it is or contains a type parameter - // that has a type argument for it. - for i, targ := range t.targs { - dump(">>> %d targ = %s", i, targ) - newTarg := subst.typ(targ) - if newTarg != targ { - dump(">>> substituted %d targ %s => %s", i, targ, newTarg) - if newTargs == nil { - newTargs = make([]Type, t.TParams().Len()) - copy(newTargs, t.targs) - } - newTargs[i] = newTarg + var newTArgs []Type + assert(len(t.targs) == t.TParams().Len()) + + // already instantiated + dump(">>> %s already instantiated", t) + // For each (existing) type argument targ, determine if it needs + // to be substituted; i.e., if it is or contains a type parameter + // that has a type argument for it. + for i, targ := range t.targs { + dump(">>> %d targ = %s", i, targ) + new_targ := subst.typ(targ) + if new_targ != targ { + dump(">>> substituted %d targ %s => %s", i, targ, new_targ) + if newTArgs == nil { + newTArgs = make([]Type, t.TParams().Len()) + copy(newTArgs, t.targs) } + newTArgs[i] = new_targ } + } - if newTargs == nil { - dump(">>> nothing to substitute in %s", t) - return t // nothing to substitute - } - } else { - // not yet instantiated - dump(">>> first instantiation of %s", t) - // TODO(rFindley) can we instead subst the tparam types here? - newTargs = subst.smap.targs + if newTArgs == nil { + dump(">>> nothing to substitute in %s", t) + return t // nothing to substitute } // before creating a new named type, check if we have this one already - h := instantiatedHash(t, newTargs) + h := instantiatedHash(t, newTArgs) dump(">>> new type hash: %s", h) if named, found := subst.typMap[h]; found { dump(">>> found %s", named) @@ -250,12 +232,12 @@ func (subst *subster) typ(typ Type) Type { tname := NewTypeName(subst.pos, t.obj.pkg, t.obj.name, nil) t.load() named := subst.check.newNamed(tname, t.orig, t.underlying, t.TParams(), t.methods) // method signatures are updated lazily - named.targs = newTargs + named.targs = newTArgs subst.typMap[h] = named t.expand(subst.typMap) // must happen after typMap update to avoid infinite recursion // do the substitution - dump(">>> subst %s with %s (new: %s)", t.underlying, subst.smap, newTargs) + dump(">>> subst %s with %s (new: %s)", t.underlying, subst.smap, newTArgs) named.underlying = subst.typOrNil(t.underlying) dump(">>> underlying: %v", named.underlying) assert(named.underlying != nil)