cmd/compile/internal/types: use Type.LinkString in TypeHash

Now that Type.LinkString always returns a fully unique string ID, we
can use it in TypeHash to avoid collisions between instantiations of
the same generic type.

Updates #51734.

Change-Id: I38cb396c88259be7afa44bd4333124ca98666c3f
Reviewed-on: https://go-review.googlesource.com/c/go/+/393716
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>

diff --git a/src/cmd/compile/internal/types/fmt.go b/src/cmd/compile/internal/types/fmt.go
index c0eeb8685ff577dd1a9f8d3120aaf191dad4d7ce..c1138643b72e669a21b16a2cfc829b5e8977aadd 100644 (file)
--- a/src/cmd/compile/internal/types/fmt.go
+++ b/src/cmd/compile/internal/types/fmt.go
@@ -72,7 +72,6 @@ const (
        fmtDebug
        fmtTypeID
        fmtTypeIDName
-       fmtTypeIDHash
 )
 
 // Sym
@@ -144,18 +143,6 @@ func symfmt(b *bytes.Buffer, s *Sym, verb rune, mode fmtMode) {
        if q := pkgqual(s.Pkg, verb, mode); q != "" {
                b.WriteString(q)
                b.WriteByte('.')
-               switch mode {
-               case fmtTypeIDHash:
-                       // If name is a generic instantiation, don't hash the instantiating types.
-                       // This isn't great, but it is safe. If we hash the instantiating types, then
-                       // we need to make sure they have just the package name. At this point, they
-                       // either have "", or the whole package path, and it is hard to reconcile
-                       // the two without depending on -p (which we might do someday).
-                       // See issue 51250.
-                       if i := strings.Index(name, "["); i >= 0 {
-                               name = name[:i]
-                       }
-               }
        }
        b.WriteString(name)
 }
@@ -183,7 +170,7 @@ func pkgqual(pkg *Pkg, verb rune, mode fmtMode) string {
                case fmtDebug:
                        return pkg.Name
 
-               case fmtTypeIDName, fmtTypeIDHash:
+               case fmtTypeIDName:
                        // dcommontype, typehash
                        return pkg.Name
 
@@ -329,7 +316,7 @@ func tconv2(b *bytes.Buffer, t *Type, verb rune, mode fmtMode, visited map[*Type
        if t == AnyType || t == ByteType || t == RuneType {
                // in %-T mode collapse predeclared aliases with their originals.
                switch mode {
-               case fmtTypeIDName, fmtTypeIDHash, fmtTypeID:
+               case fmtTypeIDName, fmtTypeID:
                        t = Types[t.Kind()]
                default:
                        sconv2(b, t.Sym(), 'S', mode)
@@ -420,7 +407,7 @@ func tconv2(b *bytes.Buffer, t *Type, verb rune, mode fmtMode, visited map[*Type
        case TPTR:
                b.WriteByte('*')
                switch mode {
-               case fmtTypeID, fmtTypeIDName, fmtTypeIDHash:
+               case fmtTypeID, fmtTypeIDName:
                        if verb == 'S' {
                                tconv2(b, t.Elem(), 'S', mode, visited)
                                return
@@ -482,7 +469,7 @@ func tconv2(b *bytes.Buffer, t *Type, verb rune, mode fmtMode, visited map[*Type
                        case IsExported(f.Sym.Name):
                                sconv2(b, f.Sym, 'S', mode)
                        default:
-                               if mode != fmtTypeIDName && mode != fmtTypeIDHash {
+                               if mode != fmtTypeIDName {
                                        mode = fmtTypeID
                                }
                                sconv2(b, f.Sym, 'v', mode)
@@ -552,7 +539,7 @@ func tconv2(b *bytes.Buffer, t *Type, verb rune, mode fmtMode, visited map[*Type
                        b.WriteByte(byte(open))
                        fieldVerb := 'v'
                        switch mode {
-                       case fmtTypeID, fmtTypeIDName, fmtTypeIDHash, fmtGo:
+                       case fmtTypeID, fmtTypeIDName, fmtGo:
                                // no argument names on function signature, and no "noescape"/"nosplit" tags
                                fieldVerb = 'S'
                        }
@@ -686,7 +673,7 @@ func fldconv(b *bytes.Buffer, f *Field, verb rune, mode fmtMode, visited map[*Ty
                                if name == ".F" {
                                        name = "F" // Hack for toolstash -cmp.
                                }
-                               if !IsExported(name) && mode != fmtTypeIDName && mode != fmtTypeIDHash {
+                               if !IsExported(name) && mode != fmtTypeIDName {
                                        name = sconv(s, 0, mode) // qualify non-exported names (used on structs, not on funarg)
                                }
                        } else {
@@ -754,7 +741,7 @@ func FmtConst(v constant.Value, sharp bool) string {
 
 // TypeHash computes a hash value for type t to use in type switch statements.
 func TypeHash(t *Type) uint32 {
-       p := tconv(t, 0, fmtTypeIDHash)
+       p := t.LinkString()
 
        // Using SHA256 is overkill, but reduces accidental collisions.
        h := notsha256.Sum256([]byte(p))