cmd/compile: stop changing Field.Sym for parameters

Field.Sym now always contains the original symbol as it appeared in Go
source, so we don't need OrigSym anymore.

Instead, when the mangled name is desired, Field.Nname.Sym() can be
used instead, which is always non-nil if Nname is non-nil.

Change-Id: I96cd61db6458d4a2e07ec5810239236e3dfba747
Reviewed-on: https://go-review.googlesource.com/c/go/+/527516
Auto-Submit: Matthew Dempsky <mdempsky@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: Than McIntosh <thanm@google.com>

diff --git a/src/cmd/compile/internal/abi/abiutils.go b/src/cmd/compile/internal/abi/abiutils.go
index 0ff8c0961a4dfc21aa92f92a85874928d371ac7a..db795b2d0aa936cb3faeeb6f80b05ea86c8cd9d0 100644 (file)
--- a/src/cmd/compile/internal/abi/abiutils.go
+++ b/src/cmd/compile/internal/abi/abiutils.go
@@ -423,7 +423,7 @@ func (config *ABIConfig) ABIAnalyze(t *types.Type, setNname bool) *ABIParamResul
 
 func (config *ABIConfig) updateOffset(result *ABIParamResultInfo, f *types.Field, a ABIParamAssignment, isResult, setNname bool) {
        if f.Offset != types.BADWIDTH {
-               base.Fatalf("field offset for %s at %s has been set to %d", f.Sym.Name, base.FmtPos(f.Pos), f.Offset)
+               base.Fatalf("field offset for %s at %s has been set to %d", f.Sym, base.FmtPos(f.Pos), f.Offset)
        }
 
        // Everything except return values in registers has either a frame home (if not in a register) or a frame spill location.

diff --git a/src/cmd/compile/internal/escape/escape.go b/src/cmd/compile/internal/escape/escape.go
index ef352fa078fa83b7739e90b59dc08887a2854c7d..7df367caf7049aa8db85d1e21c969394a40ee54d 100644 (file)
--- a/src/cmd/compile/internal/escape/escape.go
+++ b/src/cmd/compile/internal/escape/escape.go
@@ -379,8 +379,8 @@ const (
 
 func (b *batch) paramTag(fn *ir.Func, narg int, f *types.Field) string {
        name := func() string {
-               if f.Sym != nil {
-                       return f.Sym.Name
+               if f.Nname != nil {
+                       return f.Nname.Sym().Name
                }
                return fmt.Sprintf("arg#%d", narg)
        }
@@ -481,7 +481,7 @@ func (b *batch) reportLeaks(pos src.XPos, name string, esc leaks, sig *types.Typ
        }
        for i := 0; i < numEscResults; i++ {
                if x := esc.Result(i); x >= 0 {
-                       res := sig.Result(i).Sym
+                       res := sig.Result(i).Nname.Sym().Name
                        base.WarnfAt(pos, "leaking param: %v to result %v level=%d", name, res, x)
                        warned = true
                }

diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index 115c7e5faf3ccd4cb4624273ad73e077f38628e8..acb06ee5d70b4e58df5d22e3bb23b882de9017b6 100644 (file)
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -471,7 +471,7 @@ func canDelayResults(fn *ir.Func) bool {
 
        // temporaries for return values.
        for _, param := range fn.Type().Results() {
-               if sym := types.OrigSym(param.Sym); sym != nil && !sym.IsBlank() {
+               if sym := param.Sym; sym != nil && !sym.IsBlank() {
                        return false // found a named result parameter (case 3)
                }
        }

diff --git a/src/cmd/compile/internal/noder/reader.go b/src/cmd/compile/internal/noder/reader.go
index 4c7b2e3e51a399a4b592615f63666d96940177f2..2fe593c8e335ea5474e737f46157e087785112ef 100644 (file)
--- a/src/cmd/compile/internal/noder/reader.go
+++ b/src/cmd/compile/internal/noder/reader.go
@@ -1507,7 +1507,7 @@ func (r *reader) funcargs(fn *ir.Func) {
        }
 
        for i, param := range sig.Results() {
-               sym := types.OrigSym(param.Sym)
+               sym := param.Sym
 
                if sym == nil || sym.IsBlank() {
                        prefix := "~r"
@@ -1536,7 +1536,6 @@ func (r *reader) funcarg(param *types.Field, sym *types.Sym, ctxt ir.Class) {
 
        if r.inlCall == nil {
                if !r.funarghack {
-                       param.Sym = sym
                        param.Nname = name
                }
        } else {

diff --git a/src/cmd/compile/internal/types/fmt.go b/src/cmd/compile/internal/types/fmt.go
index 1b53430af7b1e797199751537d37f4528cd4e049..4f27baeab7c45ced6bf29a31381e5625c442676e 100644 (file)
--- a/src/cmd/compile/internal/types/fmt.go
+++ b/src/cmd/compile/internal/types/fmt.go
@@ -9,7 +9,6 @@ import (
        "encoding/binary"
        "fmt"
        "strconv"
-       "strings"
        "sync"
 
        "cmd/compile/internal/base"
@@ -28,31 +27,6 @@ var UnsafePkg *Pkg
 // BlankSym is the blank (_) symbol.
 var BlankSym *Sym
 
-// OrigSym returns the original symbol written by the user.
-func OrigSym(s *Sym) *Sym {
-       if s == nil {
-               return nil
-       }
-
-       if len(s.Name) > 1 && s.Name[0] == '~' {
-               switch s.Name[1] {
-               case 'r': // originally an unnamed result
-                       return nil
-               case 'b': // originally the blank identifier _
-                       // TODO(mdempsky): Does s.Pkg matter here?
-                       return BlankSym
-               }
-               return s
-       }
-
-       if strings.HasPrefix(s.Name, ".anon") {
-               // originally an unnamed or _ name (see subr.go: NewFuncParams)
-               return nil
-       }
-
-       return s
-}
-
 // numImport tracks how often a package with a given name is imported.
 // It is used to provide a better error message (by using the package
 // path to disambiguate) if a package that appears multiple times with
@@ -583,11 +557,6 @@ func fldconv(b *bytes.Buffer, f *Field, verb rune, mode fmtMode, visited map[*Ty
        if verb != 'S' {
                s := f.Sym
 
-               // Take the name from the original.
-               if mode == fmtGo {
-                       s = OrigSym(s)
-               }
-
                // Using type aliases and embedded fields, it's possible to
                // construct types that can't be directly represented as a
                // type literal. For example, given "type Int = int" (#50190),

diff --git a/src/cmd/compile/internal/walk/assign.go b/src/cmd/compile/internal/walk/assign.go
index e601ba61a18eb16db30462dd4dfdbba2dc7d6e55..8f3ff340c41b9b2af68671209bac4963caa11e49 100644 (file)
--- a/src/cmd/compile/internal/walk/assign.go
+++ b/src/cmd/compile/internal/walk/assign.go
@@ -392,7 +392,7 @@ func ascompatee(op ir.Op, nl, nr []ir.Node) []ir.Node {
                        continue
                }
 
-               if sym := types.OrigSym(name.Sym()); sym == nil || sym.IsBlank() {
+               if ir.IsBlank(name) {
                        // We can ignore assignments to blank or anonymous result parameters.
                        // These can't appear in expressions anyway.
                        continue