cmd/compile/internal/gc: add some Node methods

Focus on "isfoo" funcs that take a *Node, and conver them to isFoo
methods instead. This makes for more idiomatic Go code, and also more
readable func names.

Found candidates with grep, and applied most changes with sed. The funcs
chosen were isgoconst, isnil, and isblank. All had the same signature,
func(*Node) bool.

While at it, camelCase the isliteral and iszero function names. Don't
move these to methods, as they are only used in the backend part of gc,
which might one day be split into a separate package.

Passes toolstash -cmp on std cmd.

Change-Id: I4df081b12d36c46c253167c8841c5a841f1c5a16
Reviewed-on: https://go-review.googlesource.com/105555
Run-TryBot: Daniel Martí <mvdan@mvdan.cc>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>

diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index db038bd6c0ebc8cd22a65e588e8547d5e5df97de..6a05bef3aae9baa901ee1abbd79590410e773b25 100644 (file)
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -136,7 +136,7 @@ func closurename(outerfunc *Node) *types.Sym {
                // There may be multiple functions named "_". In those
                // cases, we can't use their individual Closgens as it
                // would lead to name clashes.
-               if !isblank(outerfunc.Func.Nname) {
+               if !outerfunc.Func.Nname.isBlank() {
                        gen = &outerfunc.Func.Closgen
                }
        }

diff --git a/src/cmd/compile/internal/gc/const.go b/src/cmd/compile/internal/gc/const.go
index a239cd6d3edfc4437b7e5f1d3e9752d5577c841f..cbb9c2ee08c1e265597ea4af96d2c79bb4e7b9fc 100644 (file)
--- a/src/cmd/compile/internal/gc/const.go
+++ b/src/cmd/compile/internal/gc/const.go
@@ -1506,12 +1506,14 @@ func nonnegintconst(n *Node) int64 {
        return vi.Int64()
 }
 
-// Is n a Go language constant (as opposed to a compile-time constant)?
+// isGoConst reports whether n is a Go language constant (as opposed to a
+// compile-time constant).
+//
 // Expressions derived from nil, like string([]byte(nil)), while they
 // may be known at compile time, are not Go language constants.
 // Only called for expressions known to evaluated to compile-time
 // constants.
-func isgoconst(n *Node) bool {
+func (n *Node) isGoConst() bool {
        if n.Orig != nil {
                n = n.Orig
        }
@@ -1545,18 +1547,18 @@ func isgoconst(n *Node) bool {
                OCOMPLEX,
                OREAL,
                OIMAG:
-               if isgoconst(n.Left) && (n.Right == nil || isgoconst(n.Right)) {
+               if n.Left.isGoConst() && (n.Right == nil || n.Right.isGoConst()) {
                        return true
                }
 
        case OCONV:
-               if okforconst[n.Type.Etype] && isgoconst(n.Left) {
+               if okforconst[n.Type.Etype] && n.Left.isGoConst() {
                        return true
                }
 
        case OLEN, OCAP:
                l := n.Left
-               if isgoconst(l) {
+               if l.isGoConst() {
                        return true
                }
 

diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index ab6dd8bc390c0c96984594ebc5e63a8320b37764..5db2c67d7f162f3bfe530d52dbe63a847b624113 100644 (file)
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -64,7 +64,7 @@ func declare(n *Node, ctxt Class) {
                return
        }
 
-       if isblank(n) {
+       if n.isBlank() {
                return
        }
 
@@ -178,7 +178,7 @@ func variter(vl []*Node, t *Node, el []*Node) []*Node {
                declare(v, dclcontext)
                v.Name.Param.Ntype = t
 
-               if e != nil || Curfn != nil || isblank(v) {
+               if e != nil || Curfn != nil || v.isBlank() {
                        if Curfn != nil {
                                init = append(init, nod(ODCL, v, nil))
                        }
@@ -326,7 +326,7 @@ func colasdefn(left []*Node, defn *Node) {
 
        var nnew, nerr int
        for i, n := range left {
-               if isblank(n) {
+               if n.isBlank() {
                        continue
                }
                if !colasname(n) {
@@ -367,7 +367,7 @@ func ifacedcl(n *Node) {
                Fatalf("ifacedcl")
        }
 
-       if isblank(n.Left) {
+       if n.Left.isBlank() {
                yyerror("methods must have a unique non-blank name")
        }
 }
@@ -457,7 +457,7 @@ func funcargs(nt *Node) {
                // TODO: n->left->missing = 1;
                n.Left.Op = ONAME
 
-               if isblank(n.Left) {
+               if n.Left.isBlank() {
                        // Give it a name so we can assign to it during return. ~b stands for 'blank'.
                        // The name must be different from ~r above because if you have
                        //      func f() (_ int)

diff --git a/src/cmd/compile/internal/gc/esc.go b/src/cmd/compile/internal/gc/esc.go
index fcb4e96a75c9551549ff975348e49fcce49d3227..64ac29e7640971a7c7045a7ac7e25c1a0680eb9e 100644 (file)
--- a/src/cmd/compile/internal/gc/esc.go
+++ b/src/cmd/compile/internal/gc/esc.go
@@ -1066,7 +1066,7 @@ func (e *EscState) escassignSinkWhyWhere(dst, src *Node, reason string, call *No
 // evaluated in curfn. For expr==nil, dst must still be examined for
 // evaluations inside it (e.g *f(x) = y)
 func (e *EscState) escassign(dst, src *Node, step *EscStep) {
-       if isblank(dst) || dst == nil || src == nil || src.Op == ONONAME || src.Op == OXXX {
+       if dst.isBlank() || dst == nil || src == nil || src.Op == ONONAME || src.Op == OXXX {
                return
        }
 

diff --git a/src/cmd/compile/internal/gc/gsubr.go b/src/cmd/compile/internal/gc/gsubr.go
index 0414d36157d53f1b67d852e74c6369d6db6ad3a1..d98e085705ad7e571d0fdabbbb0d09b16a5aa100 100644 (file)
--- a/src/cmd/compile/internal/gc/gsubr.go
+++ b/src/cmd/compile/internal/gc/gsubr.go
@@ -174,7 +174,7 @@ func (f *Func) initLSym() {
                Fatalf("Func.initLSym called twice")
        }
 
-       if nam := f.Nname; !isblank(nam) {
+       if nam := f.Nname; !nam.isBlank() {
                f.lsym = nam.Sym.Linksym()
                if f.Pragma&Systemstack != 0 {
                        f.lsym.Set(obj.AttrCFunc, true)

diff --git a/src/cmd/compile/internal/gc/init.go b/src/cmd/compile/internal/gc/init.go
index ea42664ba2021e3dcfd9b0a5000e77e6c6df2b1c..98ea289548733449074690ca664be5f0b9ab25f4 100644 (file)
--- a/src/cmd/compile/internal/gc/init.go
+++ b/src/cmd/compile/internal/gc/init.go
@@ -26,7 +26,7 @@ func anyinit(n []*Node) bool {
                switch ln.Op {
                case ODCLFUNC, ODCLCONST, ODCLTYPE, OEMPTY:
                case OAS:
-                       if !isblank(ln.Left) || !candiscard(ln.Right) {
+                       if !ln.Left.isBlank() || !candiscard(ln.Right) {
                                return true
                        }
                default:

diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index 9ee6176ead4d8175f4c5bd6b1ad73a77fd557aaa..6e3876f937d6847a3fe14e0ffcf7140c5aa794c1 100644 (file)
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -753,7 +753,7 @@ func mkinlcall(n *Node, fn *Node) *Node {
 }
 
 func tinlvar(t *types.Field, inlvars map[*Node]*Node) *Node {
-       if asNode(t.Nname) != nil && !isblank(asNode(t.Nname)) {
+       if asNode(t.Nname) != nil && !asNode(t.Nname).isBlank() {
                inlvar := inlvars[asNode(t.Nname)]
                if inlvar == nil {
                        Fatalf("missing inlvar for %v\n", asNode(t.Nname))
@@ -885,7 +885,7 @@ func mkinlcall1(n, fn *Node) *Node {
        for i, t := range fn.Type.Results().Fields().Slice() {
                var m *Node
                var mpos src.XPos
-               if t != nil && asNode(t.Nname) != nil && !isblank(asNode(t.Nname)) {
+               if t != nil && asNode(t.Nname) != nil && !asNode(t.Nname).isBlank() {
                        mpos = asNode(t.Nname).Pos
                        m = inlvar(asNode(t.Nname))
                        m = typecheck(m, Erv)

diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 412498b7df2a5d6542a791bdaa17b496c4ae4823..6083870735935d251fea9a4367d4ae7000a6d3fc 100644 (file)
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -654,7 +654,7 @@ func (p *noder) expr(expr syntax.Expr) *Node {
                n := p.nod(expr, OTYPESW, nil, p.expr(expr.X))
                if expr.Lhs != nil {
                        n.Left = p.declName(expr.Lhs)
-                       if isblank(n.Left) {
+                       if n.Left.isBlank() {
                                yyerror("invalid variable name %v in type switch", n.Left)
                        }
                }

diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index 6ba6f91a9a188551319477f792113487f8c2d029..b62c2412a0d607a80736c24160c1c256335dbd4f 100644 (file)
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -461,7 +461,7 @@ func (o *Order) mapAssign(n *Node) {
                                        m.Right = o.copyExpr(m.Right, m.Right.Type, false)
                                }
                                fallthrough
-                       case instrumenting && n.Op == OAS2FUNC && !isblank(m):
+                       case instrumenting && n.Op == OAS2FUNC && !m.isBlank():
                                t := o.newTemp(m.Type, false)
                                n.List.SetIndex(i, t)
                                a := nod(OAS, m, t)
@@ -700,7 +700,7 @@ func (o *Order) stmt(n *Node) {
                        Fatalf("orderstmt range %v", n.Type)
 
                case TARRAY, TSLICE:
-                       if n.List.Len() < 2 || isblank(n.List.Second()) {
+                       if n.List.Len() < 2 || n.List.Second().isBlank() {
                                // for i := range x will only use x once, to compute len(x).
                                // No need to copy it.
                                break
@@ -812,7 +812,7 @@ func (o *Order) stmt(n *Node) {
                                // temporary per distinct type, sharing the temp among all receives
                                // with that temp. Similarly one ok bool could be shared among all
                                // the x,ok receives. Not worth doing until there's a clear need.
-                               if r.Left != nil && isblank(r.Left) {
+                               if r.Left != nil && r.Left.isBlank() {
                                        r.Left = nil
                                }
                                if r.Left != nil {
@@ -833,7 +833,7 @@ func (o *Order) stmt(n *Node) {
                                        n2.Ninit.Append(tmp2)
                                }
 
-                               if r.List.Len() != 0 && isblank(r.List.First()) {
+                               if r.List.Len() != 0 && r.List.First().isBlank() {
                                        r.List.Set(nil)
                                }
                                if r.List.Len() != 0 {
@@ -1178,7 +1178,7 @@ func (o *Order) expr(n, lhs *Node) *Node {
 // okas creates and returns an assignment of val to ok,
 // including an explicit conversion if necessary.
 func okas(ok, val *Node) *Node {
-       if !isblank(ok) {
+       if !ok.isBlank() {
                val = conv(val, ok.Type)
        }
        return nod(OAS, ok, val)
@@ -1196,7 +1196,7 @@ func (o *Order) as2(n *Node) {
        tmplist := []*Node{}
        left := []*Node{}
        for _, l := range n.List.Slice() {
-               if !isblank(l) {
+               if !l.isBlank() {
                        tmp := o.newTemp(l.Type, types.Haspointers(l.Type))
                        tmplist = append(tmplist, tmp)
                        left = append(left, l)
@@ -1213,7 +1213,7 @@ func (o *Order) as2(n *Node) {
 
        ti := 0
        for ni, l := range n.List.Slice() {
-               if !isblank(l) {
+               if !l.isBlank() {
                        n.List.SetIndex(ni, tmplist[ti])
                        ti++
                }
@@ -1224,12 +1224,12 @@ func (o *Order) as2(n *Node) {
 // Just like as2, this also adds temporaries to ensure left-to-right assignment.
 func (o *Order) okAs2(n *Node) {
        var tmp1, tmp2 *Node
-       if !isblank(n.List.First()) {
+       if !n.List.First().isBlank() {
                typ := n.Rlist.First().Type
                tmp1 = o.newTemp(typ, types.Haspointers(typ))
        }
 
-       if !isblank(n.List.Second()) {
+       if !n.List.Second().isBlank() {
                tmp2 = o.newTemp(types.Types[TBOOL], false)
        }
 

diff --git a/src/cmd/compile/internal/gc/range.go b/src/cmd/compile/internal/gc/range.go
index d8e504dd14c0f0f1fed43e2c0492a59ed9e584bf..a7be2d3c9bedab0d12fc8aa3bdee2010bdd617fc 100644 (file)
--- a/src/cmd/compile/internal/gc/range.go
+++ b/src/cmd/compile/internal/gc/range.go
@@ -106,7 +106,7 @@ func typecheckrangeExpr(n *Node) {
        // "if the second iteration variable is the blank identifier, the range
        // clause is equivalent to the same clause with only the first variable
        // present."
-       if isblank(v2) {
+       if v2.isBlank() {
                if v1 != nil {
                        n.List.Set1(v1)
                }
@@ -177,11 +177,11 @@ func walkrange(n *Node) *Node {
                v2 = n.List.Second()
        }
 
-       if isblank(v2) {
+       if v2.isBlank() {
                v2 = nil
        }
 
-       if isblank(v1) && v2 == nil {
+       if v1.isBlank() && v2 == nil {
                v1 = nil
        }
 
@@ -478,7 +478,7 @@ func memclrrange(n, v1, v2, a *Node) bool {
                return false
        }
        elemsize := n.Type.Elem().Width
-       if elemsize <= 0 || !iszero(stmt.Right) {
+       if elemsize <= 0 || !isZero(stmt.Right) {
                return false
        }
 

diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index d083fc420891130255971c938fa2cd45c0c30d20..b5e9a3c48dce8eb26dc214c670ac510ac2b0bae7 100644 (file)
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -56,7 +56,7 @@ func init1(n *Node, out *[]*Node) {
        switch n.Class() {
        case PEXTERN, PFUNC:
        default:
-               if isblank(n) && n.Name.Curfn == nil && n.Name.Defn != nil && n.Name.Defn.Initorder() == InitNotStarted {
+               if n.isBlank() && n.Name.Curfn == nil && n.Name.Defn != nil && n.Name.Defn.Initorder() == InitNotStarted {
                        // blank names initialization is part of init() but not
                        // when they are inside a function.
                        break
@@ -115,7 +115,7 @@ func init1(n *Node, out *[]*Node) {
                                Dump("defn", defn)
                                Fatalf("init1: bad defn")
                        }
-                       if isblank(defn.Left) && candiscard(defn.Right) {
+                       if defn.Left.isBlank() && candiscard(defn.Right) {
                                defn.Op = OEMPTY
                                defn.Left = nil
                                defn.Right = nil
@@ -126,7 +126,7 @@ func init1(n *Node, out *[]*Node) {
                        if Debug['j'] != 0 {
                                fmt.Printf("%v\n", n.Sym)
                        }
-                       if isblank(n) || !staticinit(n, out) {
+                       if n.isBlank() || !staticinit(n, out) {
                                if Debug['%'] != 0 {
                                        Dump("nonstatic", defn)
                                }
@@ -303,7 +303,7 @@ func staticcopy(l *Node, r *Node, out *[]*Node) bool {
                return true
 
        case OLITERAL:
-               if iszero(r) {
+               if isZero(r) {
                        return true
                }
                gdata(l, r, int(l.Type.Width))
@@ -380,7 +380,7 @@ func staticassign(l *Node, r *Node, out *[]*Node) bool {
                return staticcopy(l, r, out)
 
        case OLITERAL:
-               if iszero(r) {
+               if isZero(r) {
                        return true
                }
                gdata(l, r, int(l.Type.Width))
@@ -578,7 +578,7 @@ func staticname(t *types.Type) *Node {
        return n
 }
 
-func isliteral(n *Node) bool {
+func isLiteral(n *Node) bool {
        // Treat nils as zeros rather than literals.
        return n.Op == OLITERAL && n.Val().Ctype() != CTNIL
 }
@@ -607,7 +607,7 @@ const (
 func getdyn(n *Node, top bool) initGenType {
        switch n.Op {
        default:
-               if isliteral(n) {
+               if isLiteral(n) {
                        return initConst
                }
                return initDynamic
@@ -742,7 +742,7 @@ func fixedlit(ctxt initContext, kind initKind, n *Node, var_ *Node, init *Nodes)
                        continue
                }
 
-               islit := isliteral(value)
+               islit := isLiteral(value)
                if (kind == initKindStatic && !islit) || (kind == initKindDynamic && islit) {
                        continue
                }
@@ -898,7 +898,7 @@ func slicelit(ctxt initContext, n *Node, var_ *Node, init *Nodes) {
                        continue
                }
 
-               if isliteral(value) {
+               if isLiteral(value) {
                        continue
                }
 
@@ -1264,7 +1264,7 @@ func initplan(n *Node) {
 
 func addvalue(p *InitPlan, xoffset int64, n *Node) {
        // special case: zero can be dropped entirely
-       if iszero(n) {
+       if isZero(n) {
                return
        }
 
@@ -1284,13 +1284,13 @@ func addvalue(p *InitPlan, xoffset int64, n *Node) {
        p.E = append(p.E, InitEntry{Xoffset: xoffset, Expr: n})
 }
 
-func iszero(n *Node) bool {
+func isZero(n *Node) bool {
        switch n.Op {
        case OLITERAL:
                switch u := n.Val().U.(type) {
                default:
                        Dump("unexpected literal", n)
-                       Fatalf("iszero")
+                       Fatalf("isZero")
                case *NilVal:
                        return true
                case string:
@@ -1310,7 +1310,7 @@ func iszero(n *Node) bool {
                        if n1.Op == OKEY {
                                n1 = n1.Right
                        }
-                       if !iszero(n1) {
+                       if !isZero(n1) {
                                return false
                        }
                }
@@ -1318,7 +1318,7 @@ func iszero(n *Node) bool {
 
        case OSTRUCTLIT:
                for _, n1 := range n.List.Slice() {
-                       if !iszero(n1.Left) {
+                       if !isZero(n1.Left) {
                                return false
                        }
                }

diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 69c20719ce37d2d456beb0c928cf358e01c946e7..59de5efe112ecbaf8b64fdb4c9c94e427f6fa67d 100644 (file)
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -800,7 +800,7 @@ func (s *state) stmt(n *Node) {
                                // All literals with nonzero fields have already been
                                // rewritten during walk. Any that remain are just T{}
                                // or equivalents. Use the zero value.
-                               if !iszero(rhs) {
+                               if !isZero(rhs) {
                                        Fatalf("literal with nonzero value in SSA: %v", rhs)
                                }
                                rhs = nil
@@ -828,7 +828,7 @@ func (s *state) stmt(n *Node) {
                        }
                }
 
-               if isblank(n.Left) {
+               if n.Left.isBlank() {
                        // _ = rhs
                        // Just evaluate rhs for side-effects.
                        if rhs != nil {
@@ -2115,7 +2115,7 @@ func (s *state) expr(n *Node) *ssa.Value {
                        // All literals with nonzero fields have already been
                        // rewritten during walk. Any that remain are just T{}
                        // or equivalents. Use the zero value.
-                       if !iszero(n.Left) {
+                       if !isZero(n.Left) {
                                Fatalf("literal with nonzero value in SSA: %v", n.Left)
                        }
                        return s.zeroVal(n.Type)
@@ -2267,7 +2267,7 @@ func (s *state) expr(n *Node) *ssa.Value {
                // All literals with nonzero fields have already been
                // rewritten during walk. Any that remain are just T{}
                // or equivalents. Use the zero value.
-               if !iszero(n) {
+               if !isZero(n) {
                        Fatalf("literal with nonzero value in SSA: %v", n)
                }
                return s.zeroVal(n.Type)
@@ -2495,7 +2495,7 @@ const (
 // If deref is true and right == nil, just do left = 0.
 // skip indicates assignments (at the top level) that can be avoided.
 func (s *state) assign(left *Node, right *ssa.Value, deref bool, skip skipMask) {
-       if left.Op == ONAME && isblank(left) {
+       if left.Op == ONAME && left.isBlank() {
                return
        }
        t := left.Type

diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index f46279cf6e5f0f2acee2e226e8156f615c6b4880..2f8f92271e2ee33ff37faefea58516fbeec47243 100644 (file)
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -438,8 +438,8 @@ func treecopy(n *Node, pos src.XPos) *Node {
        }
 }
 
-// isnil reports whether n represents the universal untyped zero value "nil".
-func isnil(n *Node) bool {
+// isNil reports whether n represents the universal untyped zero value "nil".
+func (n *Node) isNil() bool {
        // Check n.Orig because constant propagation may produce typed nil constants,
        // which don't exist in the Go spec.
        return Isconst(n.Orig, CTNIL)
@@ -462,7 +462,7 @@ func isptrto(t *types.Type, et types.EType) bool {
        return true
 }
 
-func isblank(n *Node) bool {
+func (n *Node) isBlank() bool {
        if n == nil {
                return false
        }

diff --git a/src/cmd/compile/internal/gc/swt.go b/src/cmd/compile/internal/gc/swt.go
index cc69d86870c615f879dd29206c00382165dfc964..8dbbb553de0e60ebb8d178867252dda1530ddb36 100644 (file)
--- a/src/cmd/compile/internal/gc/swt.go
+++ b/src/cmd/compile/internal/gc/swt.go
@@ -70,7 +70,7 @@ func typecheckswitch(n *Node) {
                if t != nil && !t.IsInterface() {
                        yyerrorl(n.Pos, "cannot type switch on non-interface value %L", n.Left.Right)
                }
-               if v := n.Left.Left; v != nil && !isblank(v) && n.List.Len() == 0 {
+               if v := n.Left.Left; v != nil && !v.isBlank() && n.List.Len() == 0 {
                        // We don't actually declare the type switch's guarded
                        // declaration itself. So if there are no cases, we
                        // won't notice that it went unused.
@@ -143,7 +143,7 @@ func typecheckswitch(n *Node) {
                                                } else {
                                                        yyerrorl(ncase.Pos, "invalid case %v in switch (mismatched types %v and bool)", n1, n1.Type)
                                                }
-                                       case nilonly != "" && !isnil(n1):
+                                       case nilonly != "" && !n1.isNil():
                                                yyerrorl(ncase.Pos, "invalid case %v in switch (can only compare %s %v to nil)", n1, nilonly, n.Left)
                                        case t.IsInterface() && !n1.Type.IsInterface() && !IsComparable(n1.Type):
                                                yyerrorl(ncase.Pos, "invalid case %L in switch (incomparable type)", n1)

diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index bd0c4aec9e73a897e7c6c9963c4442212ef72a74..00c3242815ae660180fb1395e0ca150d842cde05 100644 (file)
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -307,7 +307,7 @@ func typecheck1(n *Node, top int) *Node {
 
                if top&Easgn == 0 {
                        // not a write to the variable
-                       if isblank(n) {
+                       if n.isBlank() {
                                yyerror("cannot use _ as value")
                                n.Type = nil
                                return n
@@ -673,19 +673,19 @@ func typecheck1(n *Node, top int) *Node {
                        return n
                }
 
-               if l.Type.IsSlice() && !isnil(l) && !isnil(r) {
+               if l.Type.IsSlice() && !l.isNil() && !r.isNil() {
                        yyerror("invalid operation: %v (slice can only be compared to nil)", n)
                        n.Type = nil
                        return n
                }
 
-               if l.Type.IsMap() && !isnil(l) && !isnil(r) {
+               if l.Type.IsMap() && !l.isNil() && !r.isNil() {
                        yyerror("invalid operation: %v (map can only be compared to nil)", n)
                        n.Type = nil
                        return n
                }
 
-               if l.Type.Etype == TFUNC && !isnil(l) && !isnil(r) {
+               if l.Type.Etype == TFUNC && !l.isNil() && !r.isNil() {
                        yyerror("invalid operation: %v (func can only be compared to nil)", n)
                        n.Type = nil
                        return n
@@ -3304,7 +3304,7 @@ func typecheckas(n *Node) {
        if n.Left.Typecheck() == 0 {
                n.Left = typecheck(n.Left, Erv|Easgn)
        }
-       if !isblank(n.Left) {
+       if !n.Left.isBlank() {
                checkwidth(n.Left.Type) // ensure width is calculated for backend
        }
 }
@@ -3664,7 +3664,7 @@ func typecheckdef(n *Node) {
                        goto ret
                }
 
-               if e.Type != nil && e.Op != OLITERAL || !isgoconst(e) {
+               if e.Type != nil && e.Op != OLITERAL || !e.isGoConst() {
                        if !e.Diag() {
                                yyerror("const initializer %v is not a constant", e)
                                e.SetDiag(true)

diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index e84d96a8a4e3a94f2e94db09c99c54bd0c79b1c3..c7c39232f4c987d753e9e9265944706bb99bf7fa 100644 (file)
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -703,7 +703,7 @@ opswitch:
                        break
                }
 
-               if !instrumenting && iszero(n.Right) {
+               if !instrumenting && isZero(n.Right) {
                        break
                }
 
@@ -783,7 +783,7 @@ opswitch:
                walkexprlistsafe(n.List.Slice(), init)
                r.Left = walkexpr(r.Left, init)
                var n1 *Node
-               if isblank(n.List.First()) {
+               if n.List.First().isBlank() {
                        n1 = nodnil()
                } else {
                        n1 = nod(OADDR, n.List.First(), nil)
@@ -834,14 +834,14 @@ opswitch:
                // mapaccess2* returns a typed bool, but due to spec changes,
                // the boolean result of i.(T) is now untyped so we make it the
                // same type as the variable on the lhs.
-               if ok := n.List.Second(); !isblank(ok) && ok.Type.IsBoolean() {
+               if ok := n.List.Second(); !ok.isBlank() && ok.Type.IsBoolean() {
                        r.Type.Field(1).Type = ok.Type
                }
                n.Rlist.Set1(r)
                n.Op = OAS2FUNC
 
                // don't generate a = *var if a is _
-               if !isblank(a) {
+               if !a.isBlank() {
                        var_ := temp(types.NewPtr(t.Val()))
                        var_.SetTypecheck(1)
                        var_.SetNonNil(true) // mapaccess always returns a non-nil pointer
@@ -1216,7 +1216,7 @@ opswitch:
                n.Left = walkexpr(n.Left, init)
                low, high, max := n.SliceBounds()
                low = walkexpr(low, init)
-               if low != nil && iszero(low) {
+               if low != nil && isZero(low) {
                        // Reduce x[0:j] to x[:j] and x[0:j:k] to x[:j:k].
                        low = nil
                }
@@ -1848,7 +1848,7 @@ func ascompatet(nl Nodes, nr *types.Type) []*Node {
 
        var nn, mm Nodes
        for i, l := range nl.Slice() {
-               if isblank(l) {
+               if l.isBlank() {
                        continue
                }
                r := nr.Field(i)
@@ -1967,7 +1967,7 @@ func nodarg(t interface{}, fp int) *Node {
        // Rewrite argument named _ to __,
        // or else the assignment to _ will be
        // discarded during code generation.
-       if isblank(n) {
+       if n.isBlank() {
                n.Sym = lookup("__")
        }
 
@@ -2268,7 +2268,7 @@ func convas(n *Node, init *Nodes) *Node {
                return n
        }
 
-       if isblank(n.Left) {
+       if n.Left.isBlank() {
                n.Right = defaultlit(n.Right, nil)
                return n
        }