cmd/internal/gc: clean up walk conv* and assert*

This is preliminary cleanup for another change.

No functional changes. Passes toolstash -cmp.

Change-Id: I11d562fbd6cba5c48d9636f3149e210e5f5308ad
Reviewed-on: https://go-review.googlesource.com/7696
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Minux Ma <minux@golang.org>

diff --git a/src/cmd/internal/gc/subr.go b/src/cmd/internal/gc/subr.go
index 6347d666c5fb1f3b564226754bd3c842799cf151..32486c77bb83a522761b5e87f8ab4ef64b21eba1 100644 (file)
--- a/src/cmd/internal/gc/subr.go
+++ b/src/cmd/internal/gc/subr.go
@@ -3573,3 +3573,16 @@ func isdirectiface(t *Type) bool {
 
        return false
 }
+
+// type2IET returns "T" if t is a concrete type,
+// "I" if t is an interface type, and "E" if t is an empty interface type.
+// It is used to build calls to the conv* and assert* runtime routines.
+func type2IET(t *Type) string {
+       if isnilinter(t) {
+               return "E"
+       }
+       if Isinter(t) {
+               return "I"
+       }
+       return "T"
+}

diff --git a/src/cmd/internal/gc/walk.go b/src/cmd/internal/gc/walk.go
index 00ebcab494b957a333fbf9491c710e90949f67f2..e55b41581c37856a6785e56b99988cdf3bc1e002 100644 (file)
--- a/src/cmd/internal/gc/walk.go
+++ b/src/cmd/internal/gc/walk.go
@@ -678,20 +678,7 @@ func walkexpr(np **Node, init **NodeList) {
                        n1 := Nod(OADDR, n.Left, nil)
                        r := n.Right // i.(T)
 
-                       from := "I"
-
-                       to := "T"
-                       if isnilinter(r.Left.Type) {
-                               from = "E"
-                       }
-                       if isnilinter(r.Type) {
-                               to = "E"
-                       } else if Isinter(r.Type) {
-                               to = "I"
-                       }
-
-                       buf := fmt.Sprintf("assert%s2%s", from, to)
-
+                       buf := "assert" + type2IET(r.Left.Type) + "2" + type2IET(r.Type)
                        fn := syslook(buf, 1)
                        substArgTypes(fn, r.Left.Type, r.Type)
 
@@ -864,46 +851,37 @@ func walkexpr(np **Node, init **NodeList) {
                n = mkcall1(mapfndel("mapdelete", t), nil, init, typename(t), map_, key)
                goto ret
 
-               // a,b = i.(T)
+       // res, ok = i.(T)
        // orderstmt made sure a is addressable.
        case OAS2DOTTYPE:
                *init = concat(*init, n.Ninit)
-
                n.Ninit = nil
-               r := n.Rlist.N
-               walkexprlistsafe(n.List, init)
-               walkexpr(&r.Left, init)
-               var n1 *Node
-               if isblank(n.List.N) {
-                       n1 = nodnil()
-               } else {
-                       n1 = Nod(OADDR, n.List.N, nil)
-               }
-               n1.Etype = 1 // addr does not escape
 
-               from := "I"
+               e := n.Rlist.N // i.(T)
+               walkexprlistsafe(n.List, init)
+               walkexpr(&e.Left, init)
+               t := e.Type    // T
+               from := e.Left // i
 
-               to := "T"
-               if isnilinter(r.Left.Type) {
-                       from = "E"
+               oktype := Types[TBOOL]
+               ok := n.List.Next.N
+               if !isblank(ok) {
+                       oktype = ok.Type
                }
-               if isnilinter(r.Type) {
-                       to = "E"
-               } else if Isinter(r.Type) {
-                       to = "I"
+
+               var resptr *Node // &res
+               if isblank(n.List.N) {
+                       resptr = nodnil()
+               } else {
+                       resptr = Nod(OADDR, n.List.N, nil)
                }
-               buf := fmt.Sprintf("assert%s2%s2", from, to)
+               resptr.Etype = 1 // addr does not escape
 
+               buf := "assert" + type2IET(from.Type) + "2" + type2IET(t) + "2"
                fn := syslook(buf, 1)
-               substArgTypes(fn, r.Left.Type, r.Type)
-
-               t := Types[TBOOL]
-               ok := n.List.Next.N
-               if !isblank(ok) {
-                       t = ok.Type
-               }
-               r = mkcall1(fn, t, init, typename(r.Type), r.Left, n1)
-               n = Nod(OAS, ok, r)
+               substArgTypes(fn, from.Type, t)
+               call := mkcall1(fn, oktype, init, typename(t), from, resptr)
+               n = Nod(OAS, ok, call)
                typecheck(&n, Etop)
                goto ret
 
@@ -926,19 +904,7 @@ func walkexpr(np **Node, init **NodeList) {
                // Build name of function: convI2E etc.
                // Not all names are possible
                // (e.g., we'll never generate convE2E or convE2I).
-               from := "T"
-
-               to := "I"
-               if isnilinter(n.Left.Type) {
-                       from = "E"
-               } else if Isinter(n.Left.Type) {
-                       from = "I"
-               }
-               if isnilinter(n.Type) {
-                       to = "E"
-               }
-               buf := fmt.Sprintf("conv%s2%s", from, to)
-
+               buf := "conv" + type2IET(n.Left.Type) + "2" + type2IET(n.Type)
                fn := syslook(buf, 1)
                var ll *NodeList
                if !Isinter(n.Left.Type) {