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 <rfindley@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>

diff --git a/src/go/types/instantiate.go b/src/go/types/instantiate.go
index 189a35ab888697c1aa8b30037a36a56bca59d608..81330672298c28fb1b6591a25d3a95928f57d7c3 100644 (file)
--- 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 0d3bcefb0bd12019891e299f3fd4567f37a4b006..da0578ff5c0f294377a5f702221871ad584519b2 100644 (file)
--- 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)