cmd/compile/internal/gc: remove dead code from stringtoarraylit

The code path for []byte is unused.
Rename function to stringtoruneslit to reflect change in the behavior.

Note that removed code had a bug in it,
it used [0] index instead of [i] inside a loop body.

Change-Id: I58ece5d9d3835887b014446f8a7d3e7fc2fdcaa3
Reviewed-on: https://go-review.googlesource.com/c/125796
Run-TryBot: Iskander Sharipov <iskander.sharipov@intel.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>

diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 992e59a0109eb20691091bc205c83b4167de4d61..0bbd89f05e4a1f3f44026aebc280aba61c2f89e8 100644 (file)
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -1719,14 +1719,14 @@ func typecheck1(n *Node, top int) *Node {
                                }
                        }
 
-               // do not use stringtoarraylit.
+               // do not convert to []byte literal. See CL 125796.
                // generated code and compiler memory footprint is better without it.
                case OSTRARRAYBYTE:
                        break
 
                case OSTRARRAYRUNE:
                        if n.Left.Op == OLITERAL {
-                               n = stringtoarraylit(n)
+                               n = stringtoruneslit(n)
                        }
                }
 
@@ -3509,27 +3509,19 @@ func typecheckfunc(n *Node) {
        }
 }
 
-// The result of stringtoarraylit MUST be assigned back to n, e.g.
-//     n.Left = stringtoarraylit(n.Left)
-func stringtoarraylit(n *Node) *Node {
+// The result of stringtoruneslit MUST be assigned back to n, e.g.
+//     n.Left = stringtoruneslit(n.Left)
+func stringtoruneslit(n *Node) *Node {
        if n.Left.Op != OLITERAL || n.Left.Val().Ctype() != CTSTR {
                Fatalf("stringtoarraylit %v", n)
        }
 
-       s := n.Left.Val().U.(string)
        var l []*Node
-       if n.Type.Elem().Etype == TUINT8 {
-               // []byte
-               for i := 0; i < len(s); i++ {
-                       l = append(l, nod(OKEY, nodintconst(int64(i)), nodintconst(int64(s[0]))))
-               }
-       } else {
-               // []rune
-               i := 0
-               for _, r := range s {
-                       l = append(l, nod(OKEY, nodintconst(int64(i)), nodintconst(int64(r))))
-                       i++
-               }
+       s := n.Left.Val().U.(string)
+       i := 0
+       for _, r := range s {
+               l = append(l, nod(OKEY, nodintconst(int64(i)), nodintconst(int64(r))))
+               i++
        }
 
        nn := nod(OCOMPLIT, nil, typenod(n.Type))