cmd/compile: rewrite code to omit many nodeSeq calls
This CL was automatically generated using a special-purpose AST
rewriting tool, followed by manual editing to put some comments back in
the right places and fix some bad line breaks.
The result is not perfect but it's a big step toward getting back to
sanity, and because it was automatically generated there is a decent
chance that it is correct.
Passes toolstash -cmp.
Update #14473.
Change-Id: I01c09078a6d78e2b008bc304d744b79469a38d3d
Reviewed-on: https://go-review.googlesource.com/20440
Reviewed-by: David Crawshaw <crawshaw@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
diff --git a/src/cmd/compile/internal/gc/alg.go b/src/cmd/compile/internal/gc/alg.go
index f14e758f..2913d61 100644
--- a/src/cmd/compile/internal/gc/alg.go
+++ b/src/cmd/compile/internal/gc/alg.go
@@ -185,13 +185,13 @@
fn.Func.Nname.Name.Param.Ntype = tfn
n := Nod(ODCLFIELD, newname(Lookup("p")), typenod(Ptrto(t)))
- appendNodeSeqNode(&tfn.List, n)
+ tfn.List.Append(n)
np := n.Left
n = Nod(ODCLFIELD, newname(Lookup("h")), typenod(Types[TUINTPTR]))
- appendNodeSeqNode(&tfn.List, n)
+ tfn.List.Append(n)
nh := n.Left
n = Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])) // return value
- appendNodeSeqNode(&tfn.Rlist, n)
+ tfn.Rlist.Append(n)
funchdr(fn)
typecheck(&fn.Func.Nname.Name.Param.Ntype, Etype)
@@ -216,10 +216,10 @@
n := Nod(ORANGE, nil, Nod(OIND, np, nil))
ni := newname(Lookup("i"))
ni.Type = Types[TINT]
- setNodeSeq(&n.List, []*Node{ni})
+ n.List.Set([]*Node{ni})
n.Colas = true
colasdefn(n.List, n)
- ni = nodeSeqFirst(n.List)
+ ni = n.List.First()
// h = hashel(&p[i], h)
call := Nod(OCALL, hashel, nil)
@@ -228,8 +228,8 @@
nx.Bounded = true
na := Nod(OADDR, nx, nil)
na.Etype = 1 // no escape to heap
- appendNodeSeqNode(&call.List, na)
- appendNodeSeqNode(&call.List, nh)
+ call.List.Append(na)
+ call.List.Append(nh)
n.Nbody.Append(Nod(OAS, nh, call))
fn.Nbody.Append(n)
@@ -251,8 +251,8 @@
nx := Nod(OXDOT, np, newname(f.Sym)) // TODO: fields from other packages?
na := Nod(OADDR, nx, nil)
na.Etype = 1 // no escape to heap
- appendNodeSeqNode(&call.List, na)
- appendNodeSeqNode(&call.List, nh)
+ call.List.Append(na)
+ call.List.Append(nh)
fn.Nbody.Append(Nod(OAS, nh, call))
f = f.Down
continue
@@ -267,9 +267,9 @@
nx := Nod(OXDOT, np, newname(f.Sym)) // TODO: fields from other packages?
na := Nod(OADDR, nx, nil)
na.Etype = 1 // no escape to heap
- appendNodeSeqNode(&call.List, na)
- appendNodeSeqNode(&call.List, nh)
- appendNodeSeqNode(&call.List, Nodintconst(size))
+ call.List.Append(na)
+ call.List.Append(nh)
+ call.List.Append(Nodintconst(size))
fn.Nbody.Append(Nod(OAS, nh, call))
f = next
@@ -277,7 +277,7 @@
}
r := Nod(ORETURN, nil, nil)
- appendNodeSeqNode(&r.List, nh)
+ r.List.Append(nh)
fn.Nbody.Append(r)
if Debug['r'] != 0 {
@@ -339,9 +339,9 @@
n := newname(sym)
n.Class = PFUNC
tfn := Nod(OTFUNC, nil, nil)
- appendNodeSeqNode(&tfn.List, Nod(ODCLFIELD, nil, typenod(Ptrto(t))))
- appendNodeSeqNode(&tfn.List, Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
- appendNodeSeqNode(&tfn.Rlist, Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
+ tfn.List.Append(Nod(ODCLFIELD, nil, typenod(Ptrto(t))))
+ tfn.List.Append(Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
+ tfn.Rlist.Append(Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
typecheck(&tfn, Etype)
n.Type = tfn.Type
return n
@@ -367,13 +367,13 @@
fn.Func.Nname.Name.Param.Ntype = tfn
n := Nod(ODCLFIELD, newname(Lookup("p")), typenod(Ptrto(t)))
- appendNodeSeqNode(&tfn.List, n)
+ tfn.List.Append(n)
np := n.Left
n = Nod(ODCLFIELD, newname(Lookup("q")), typenod(Ptrto(t)))
- appendNodeSeqNode(&tfn.List, n)
+ tfn.List.Append(n)
nq := n.Left
n = Nod(ODCLFIELD, nil, typenod(Types[TBOOL]))
- appendNodeSeqNode(&tfn.Rlist, n)
+ tfn.Rlist.Append(n)
funchdr(fn)
@@ -398,10 +398,10 @@
ni := newname(Lookup("i"))
ni.Type = Types[TINT]
- setNodeSeq(&nrange.List, []*Node{ni})
+ nrange.List.Set([]*Node{ni})
nrange.Colas = true
colasdefn(nrange.List, nrange)
- ni = nodeSeqFirst(nrange.List)
+ ni = nrange.List.First()
// if p[i] != q[i] { return false }
nx := Nod(OINDEX, np, ni)
@@ -413,14 +413,14 @@
nif := Nod(OIF, nil, nil)
nif.Left = Nod(ONE, nx, ny)
r := Nod(ORETURN, nil, nil)
- appendNodeSeqNode(&r.List, Nodbool(false))
+ r.List.Append(Nodbool(false))
nif.Nbody.Append(r)
nrange.Nbody.Append(nif)
fn.Nbody.Append(nrange)
// return true
ret := Nod(ORETURN, nil, nil)
- appendNodeSeqNode(&ret.List, Nodbool(true))
+ ret.List.Append(Nodbool(true))
fn.Nbody.Append(ret)
case TSTRUCT:
@@ -474,7 +474,7 @@
}
ret := Nod(ORETURN, nil, nil)
- appendNodeSeqNode(&ret.List, and)
+ ret.List.Append(and)
fn.Nbody.Append(ret)
}
@@ -531,10 +531,10 @@
typecheck(&ny, Erv)
call := Nod(OCALL, eqmemfunc(size, nx.Type.Type, &needsize), nil)
- appendNodeSeqNode(&call.List, nx)
- appendNodeSeqNode(&call.List, ny)
+ call.List.Append(nx)
+ call.List.Append(ny)
if needsize != 0 {
- appendNodeSeqNode(&call.List, Nodintconst(size))
+ call.List.Append(Nodintconst(size))
}
return call
diff --git a/src/cmd/compile/internal/gc/bexport.go b/src/cmd/compile/internal/gc/bexport.go
index d0bb56a..97ce543 100644
--- a/src/cmd/compile/internal/gc/bexport.go
+++ b/src/cmd/compile/internal/gc/bexport.go
@@ -848,7 +848,7 @@
// expressions
case OMAKEMAP, OMAKECHAN, OMAKESLICE:
- if p.bool(nodeSeqLen(n.List) != 0) {
+ if p.bool(n.List.Len() != 0) {
p.nodeList(n.List) // TODO(gri) do we still need to export this?
}
p.nodesOrNil(n.Left, n.Right)
@@ -970,7 +970,7 @@
p.nodeList(n.Nbody)
case ORANGE:
- if p.bool(nodeSeqLen(n.List) != 0) {
+ if p.bool(n.List.Len() != 0) {
p.nodeList(n.List)
}
p.node(n.Right)
@@ -982,7 +982,7 @@
p.nodeList(n.List)
case OCASE, OXCASE:
- if p.bool(nodeSeqLen(n.List) != 0) {
+ if p.bool(n.List.Len() != 0) {
p.nodeList(n.List)
}
p.nodeList(n.Nbody)
diff --git a/src/cmd/compile/internal/gc/bimport.go b/src/cmd/compile/internal/gc/bimport.go
index 16993d0..ac4c4b1 100644
--- a/src/cmd/compile/internal/gc/bimport.go
+++ b/src/cmd/compile/internal/gc/bimport.go
@@ -589,7 +589,7 @@
// expressions
case OMAKEMAP, OMAKECHAN, OMAKESLICE:
if p.bool() {
- setNodeSeq(&n.List, p.nodeList())
+ n.List.Set(p.nodeList())
}
n.Left, n.Right = p.nodesOrNil()
n.Type = p.typ()
@@ -604,19 +604,19 @@
n.Right = p.node()
case OADDSTR:
- setNodeSeq(&n.List, p.nodeList())
+ n.List.Set(p.nodeList())
case OPTRLIT:
n.Left = p.node()
case OSTRUCTLIT:
n.Type = p.typ()
- setNodeSeq(&n.List, p.nodeList())
+ n.List.Set(p.nodeList())
n.Implicit = p.bool()
case OARRAYLIT, OMAPLIT:
n.Type = p.typ()
- setNodeSeq(&n.List, p.nodeList())
+ n.List.Set(p.nodeList())
n.Implicit = p.bool()
case OKEY:
@@ -635,9 +635,9 @@
// }
x := Nod(OCALL, p.typ().Nod, nil)
if p.bool() {
- setNodeSeq(&x.List, []*Node{p.node()})
+ x.List.Set([]*Node{p.node()})
} else {
- setNodeSeq(&x.List, p.nodeList())
+ x.List.Set(p.nodeList())
}
return x
@@ -667,12 +667,12 @@
case OREAL, OIMAG, OAPPEND, OCAP, OCLOSE, ODELETE, OLEN, OMAKE, ONEW, OPANIC,
ORECOVER, OPRINT, OPRINTN:
n.Left, _ = p.nodesOrNil()
- setNodeSeq(&n.List, p.nodeList())
+ n.List.Set(p.nodeList())
n.Isddd = p.bool()
case OCALL, OCALLFUNC, OCALLMETH, OCALLINTER, OGETG:
n.Left = p.node()
- setNodeSeq(&n.List, p.nodeList())
+ n.List.Set(p.nodeList())
n.Isddd = p.bool()
case OCMPSTR, OCMPIFACE:
@@ -698,45 +698,45 @@
n.Etype = EType(p.int())
case OAS2, OASWB:
- setNodeSeq(&n.List, p.nodeList())
- setNodeSeq(&n.Rlist, p.nodeList())
+ n.List.Set(p.nodeList())
+ n.Rlist.Set(p.nodeList())
case OAS2DOTTYPE, OAS2FUNC, OAS2MAPR, OAS2RECV:
- setNodeSeq(&n.List, p.nodeList())
- setNodeSeq(&n.Rlist, p.nodeList())
+ n.List.Set(p.nodeList())
+ n.Rlist.Set(p.nodeList())
case ORETURN:
- setNodeSeq(&n.List, p.nodeList())
+ n.List.Set(p.nodeList())
case OPROC, ODEFER:
n.Left = p.node()
case OIF:
- setNodeSeq(&n.Ninit, p.nodeList())
+ n.Ninit.Set(p.nodeList())
n.Left = p.node()
n.Nbody.Set(p.nodeList())
- setNodeSeq(&n.Rlist, p.nodeList())
+ n.Rlist.Set(p.nodeList())
case OFOR:
- setNodeSeq(&n.Ninit, p.nodeList())
+ n.Ninit.Set(p.nodeList())
n.Left, n.Right = p.nodesOrNil()
n.Nbody.Set(p.nodeList())
case ORANGE:
if p.bool() {
- setNodeSeq(&n.List, p.nodeList())
+ n.List.Set(p.nodeList())
}
n.Right = p.node()
n.Nbody.Set(p.nodeList())
case OSELECT, OSWITCH:
- setNodeSeq(&n.Ninit, p.nodeList())
+ n.Ninit.Set(p.nodeList())
n.Left, _ = p.nodesOrNil()
- setNodeSeq(&n.List, p.nodeList())
+ n.List.Set(p.nodeList())
case OCASE, OXCASE:
if p.bool() {
- setNodeSeq(&n.List, p.nodeList())
+ n.List.Set(p.nodeList())
}
n.Nbody.Set(p.nodeList())
diff --git a/src/cmd/compile/internal/gc/cgen.go b/src/cmd/compile/internal/gc/cgen.go
index c9d4897..439c52d 100644
--- a/src/cmd/compile/internal/gc/cgen.go
+++ b/src/cmd/compile/internal/gc/cgen.go
@@ -1752,7 +1752,7 @@
func bvgenjump(n, res *Node, wantTrue, geninit bool) {
init := n.Ninit
if !geninit {
- setNodeSeq(&n.Ninit, nil)
+ n.Ninit.Set(nil)
}
p1 := Gbranch(obj.AJMP, nil, 0)
p2 := Pc
@@ -1762,7 +1762,7 @@
Bgen(n, wantTrue, 0, p2)
Thearch.Gmove(Nodbool(false), res)
Patch(p3, Pc)
- setNodeSeq(&n.Ninit, init)
+ n.Ninit.Set(init.Slice())
}
// bgenx is the backend for Bgen and Bvgen.
@@ -1920,11 +1920,11 @@
if Isfloat[nr.Type.Etype] {
// Brcom is not valid on floats when NaN is involved.
ll := n.Ninit // avoid re-genning Ninit
- setNodeSeq(&n.Ninit, nil)
+ n.Ninit.Set(nil)
if genval {
bgenx(n, res, true, likely, to)
Thearch.Gins(Thearch.Optoas(OXOR, Types[TUINT8]), Nodintconst(1), res) // res = !res
- setNodeSeq(&n.Ninit, ll)
+ n.Ninit.Set(ll.Slice())
return
}
p1 := Gbranch(obj.AJMP, nil, 0)
@@ -1933,7 +1933,7 @@
bgenx(n, res, true, -likely, p2)
Patch(Gbranch(obj.AJMP, nil, 0), to)
Patch(p2, Pc)
- setNodeSeq(&n.Ninit, ll)
+ n.Ninit.Set(ll.Slice())
return
}
@@ -2799,13 +2799,13 @@
Dump("cgen_append-n", n)
Dump("cgen_append-res", res)
}
- if res.Op != ONAME && !samesafeexpr(res, nodeSeqFirst(n.List)) {
+ if res.Op != ONAME && !samesafeexpr(res, n.List.First()) {
Dump("cgen_append-n", n)
Dump("cgen_append-res", res)
Fatalf("append not lowered")
}
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- if it.N().Ullman >= UINF {
+ for _, n1 := range n.List.Slice() {
+ if n1.Ullman >= UINF {
Fatalf("append with function call arguments")
}
}
@@ -2814,7 +2814,7 @@
//
// If res and src are the same, we can avoid writing to base and cap
// unless we grow the underlying array.
- needFullUpdate := !samesafeexpr(res, nodeSeqFirst(n.List))
+ needFullUpdate := !samesafeexpr(res, n.List.First())
// Copy src triple into base, len, cap.
base := temp(Types[Tptr])
@@ -2822,7 +2822,7 @@
cap := temp(Types[TUINT])
var src Node
- Igen(nodeSeqFirst(n.List), &src, nil)
+ Igen(n.List.First(), &src, nil)
src.Type = Types[Tptr]
Thearch.Gmove(&src, base)
src.Type = Types[TUINT]
@@ -2835,7 +2835,7 @@
var rlen Node
Regalloc(&rlen, Types[TUINT], nil)
Thearch.Gmove(len, &rlen)
- Thearch.Ginscon(Thearch.Optoas(OADD, Types[TUINT]), int64(nodeSeqLen(n.List)-1), &rlen)
+ Thearch.Ginscon(Thearch.Optoas(OADD, Types[TUINT]), int64(n.List.Len()-1), &rlen)
p := Thearch.Ginscmp(OLE, Types[TUINT], &rlen, cap, +1)
// Note: rlen and src are Regrealloc'ed below at the target of the
// branch we just emitted; do not reuse these Go variables for
@@ -2905,7 +2905,7 @@
dst.Xoffset += int64(Widthptr)
Regalloc(&r1, Types[TUINT], nil)
Thearch.Gmove(len, &r1)
- Thearch.Ginscon(Thearch.Optoas(OADD, Types[TUINT]), int64(nodeSeqLen(n.List)-1), &r1)
+ Thearch.Ginscon(Thearch.Optoas(OADD, Types[TUINT]), int64(n.List.Len()-1), &r1)
Thearch.Gmove(&r1, &dst)
Regfree(&r1)
dst.Xoffset += int64(Widthptr)
diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index d040bdc..af5c7c9 100644
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -26,30 +26,29 @@
// references to these variables need to
// refer to the variables in the external
// function declared below; see walkclosure.
- setNodeSeq(&n.List, ntype.List)
+ n.List.Set(ntype.List.Slice())
- setNodeSeq(&n.Rlist, ntype.Rlist)
- setNodeSeq(&ntype.List, nil)
- setNodeSeq(&ntype.Rlist, nil)
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- name = it.N().Left
+ n.Rlist.Set(ntype.Rlist.Slice())
+ ntype.List.Set(nil)
+ ntype.Rlist.Set(nil)
+ for _, n1 := range n.List.Slice() {
+ name = n1.Left
if name != nil {
name = newname(name.Sym)
}
- a = Nod(ODCLFIELD, name, it.N().Right)
- a.Isddd = it.N().Isddd
+ a = Nod(ODCLFIELD, name, n1.Right)
+ a.Isddd = n1.Isddd
if name != nil {
name.Isddd = a.Isddd
}
- appendNodeSeqNode(&ntype.List, a)
+ ntype.List.Append(a)
}
-
- for it := nodeSeqIterate(n.Rlist); !it.Done(); it.Next() {
- name = it.N().Left
+ for _, n2 := range n.Rlist.Slice() {
+ name = n2.Left
if name != nil {
name = newname(name.Sym)
}
- appendNodeSeqNode(&ntype.Rlist, Nod(ODCLFIELD, name, it.N().Right))
+ ntype.Rlist.Append(Nod(ODCLFIELD, name, n2.Right))
}
}
@@ -177,8 +176,8 @@
// that begins by reading closure parameters.
xtype := Nod(OTFUNC, nil, nil)
- setNodeSeq(&xtype.List, func_.List)
- setNodeSeq(&xtype.Rlist, func_.Rlist)
+ xtype.List.Set(func_.List.Slice())
+ xtype.Rlist.Set(func_.Rlist.Slice())
// create the function
xfunc := Nod(ODCLFUNC, nil, nil)
@@ -205,8 +204,8 @@
func_.Func.Closure = xfunc
func_.Nbody.Set(nil)
- setNodeSeq(&func_.List, nil)
- setNodeSeq(&func_.Rlist, nil)
+ func_.List.Set(nil)
+ func_.Rlist.Set(nil)
return xfunc
}
@@ -426,7 +425,7 @@
typ := Nod(OTSTRUCT, nil, nil)
- setNodeSeq(&typ.List, []*Node{Nod(ODCLFIELD, newname(Lookup(".F")), typenod(Types[TUINTPTR]))})
+ typ.List.Set([]*Node{Nod(ODCLFIELD, newname(Lookup(".F")), typenod(Types[TUINTPTR]))})
var typ1 *Node
for _, v := range func_.Func.Cvars.Slice() {
if v.Op == OXXX {
@@ -436,13 +435,13 @@
if !v.Name.Byval {
typ1 = Nod(OIND, typ1, nil)
}
- appendNodeSeqNode(&typ.List, Nod(ODCLFIELD, newname(v.Sym), typ1))
+ typ.List.Append(Nod(ODCLFIELD, newname(v.Sym), typ1))
}
clos := Nod(OCOMPLIT, nil, Nod(OIND, typ, nil))
clos.Esc = func_.Esc
clos.Right.Implicit = true
- setNodeSeq(&clos.List, append([]*Node{Nod(OCFUNC, func_.Func.Closure.Func.Nname, nil)}, func_.Func.Enter.Slice()...))
+ clos.List.Set(append([]*Node{Nod(OCFUNC, func_.Func.Closure.Func.Nname, nil)}, func_.Func.Enter.Slice()...))
// Force type conversion from *struct to the func type.
clos = Nod(OCONVNOP, clos, nil)
@@ -550,7 +549,7 @@
l = append(l, fld)
}
- setNodeSeq(&xtype.List, l)
+ xtype.List.Set(l)
i = 0
l = nil
var retargs []*Node
@@ -563,7 +562,7 @@
l = append(l, Nod(ODCLFIELD, n, typenod(t.Type)))
}
- setNodeSeq(&xtype.Rlist, l)
+ xtype.Rlist.Set(l)
xfunc.Func.Dupok = true
xfunc.Func.Nname = newfuncname(sym)
@@ -600,14 +599,14 @@
}
call := Nod(OCALL, Nod(OXDOT, ptr, meth), nil)
- setNodeSeq(&call.List, callargs)
+ call.List.Set(callargs)
call.Isddd = ddd
if t0.Outtuple == 0 {
body = append(body, call)
} else {
n := Nod(OAS2, nil, nil)
- setNodeSeq(&n.List, retargs)
- setNodeSeq(&n.Rlist, []*Node{call})
+ n.List.Set(retargs)
+ n.Rlist.Set([]*Node{call})
body = append(body, n)
n = Nod(ORETURN, nil, nil)
body = append(body, n)
@@ -640,14 +639,14 @@
}
typ := Nod(OTSTRUCT, nil, nil)
- setNodeSeq(&typ.List, []*Node{Nod(ODCLFIELD, newname(Lookup("F")), typenod(Types[TUINTPTR]))})
- appendNodeSeqNode(&typ.List, Nod(ODCLFIELD, newname(Lookup("R")), typenod(n.Left.Type)))
+ typ.List.Set([]*Node{Nod(ODCLFIELD, newname(Lookup("F")), typenod(Types[TUINTPTR]))})
+ typ.List.Append(Nod(ODCLFIELD, newname(Lookup("R")), typenod(n.Left.Type)))
clos := Nod(OCOMPLIT, nil, Nod(OIND, typ, nil))
clos.Esc = n.Esc
clos.Right.Implicit = true
- setNodeSeq(&clos.List, []*Node{Nod(OCFUNC, n.Func.Nname, nil)})
- appendNodeSeqNode(&clos.List, n.Left)
+ clos.List.Set([]*Node{Nod(OCFUNC, n.Func.Nname, nil)})
+ clos.List.Append(n.Left)
// Force type conversion from *struct to the func type.
clos = Nod(OCONVNOP, clos, nil)
diff --git a/src/cmd/compile/internal/gc/const.go b/src/cmd/compile/internal/gc/const.go
index 0a9b3c0..f2a3e7d 100644
--- a/src/cmd/compile/internal/gc/const.go
+++ b/src/cmd/compile/internal/gc/const.go
@@ -543,7 +543,7 @@
// merge adjacent constants in the argument list.
case OADDSTR:
- s := nodeSeqSlice(n.List)
+ s := n.List.Slice()
for i1 := 0; i1 < len(s); i1++ {
if Isconst(s[i1], CTSTR) && i1+1 < len(s) && Isconst(s[i1+1], CTSTR) {
// merge from i1 up to but not including i2
@@ -567,7 +567,7 @@
n.Op = OLITERAL
n.SetVal(s[0].Val())
} else {
- setNodeSeq(&n.List, s)
+ n.List.Set(s)
}
return
@@ -1736,14 +1736,13 @@
if hascallchan(n.Left) || hascallchan(n.Right) {
return true
}
-
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- if hascallchan(it.N()) {
+ for _, n1 := range n.List.Slice() {
+ if hascallchan(n1) {
return true
}
}
- for it := nodeSeqIterate(n.Rlist); !it.Done(); it.Next() {
- if hascallchan(it.N()) {
+ for _, n2 := range n.Rlist.Slice() {
+ if hascallchan(n2) {
return true
}
}
diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 22ab3cc..6cda036 100644
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -228,7 +228,7 @@
e := el.N
as2 := Nod(OAS2, nil, nil)
setNodeSeq(&as2.List, vl)
- setNodeSeqNode(&as2.Rlist, e)
+ as2.Rlist.Set([]*Node{e})
var v *Node
for ; vl != nil; vl = vl.Next {
v = vl.N
@@ -438,17 +438,17 @@
}
func colasdefn(left Nodes, defn *Node) {
- for it := nodeSeqIterate(left); !it.Done(); it.Next() {
- if it.N().Sym != nil {
- it.N().Sym.Flags |= SymUniq
+ for _, n1 := range left.Slice() {
+ if n1.Sym != nil {
+ n1.Sym.Flags |= SymUniq
}
}
nnew := 0
nerr := 0
var n *Node
- for it := nodeSeqIterate(left); !it.Done(); it.Next() {
- n = it.N()
+ for i2, n2 := range left.Slice() {
+ n = n2
if isblank(n) {
continue
}
@@ -474,8 +474,8 @@
n = newname(n.Sym)
declare(n, dclcontext)
n.Name.Defn = defn
- appendNodeSeqNode(&defn.Ninit, Nod(ODCL, n, nil))
- *it.P() = n
+ defn.Ninit.Append(Nod(ODCL, n, nil))
+ left.Slice()[i2] = n
}
if nnew == 0 && nerr == 0 {
@@ -492,11 +492,11 @@
colasdefn(as.List, as)
// make the tree prettier; not necessary
- if nodeSeqLen(as.List) == 1 && nodeSeqLen(as.Rlist) == 1 {
- as.Left = nodeSeqFirst(as.List)
- as.Right = nodeSeqFirst(as.Rlist)
- setNodeSeq(&as.List, nil)
- setNodeSeq(&as.Rlist, nil)
+ if as.List.Len() == 1 && as.Rlist.Len() == 1 {
+ as.Left = as.List.First()
+ as.Right = as.Rlist.First()
+ as.List.Set(nil)
+ as.Rlist.Set(nil)
as.Op = OAS
}
@@ -570,7 +570,7 @@
// re-start the variable generation number
// we want to use small numbers for the return variables,
// so let them have the chunk starting at 1.
- vargen = nodeSeqLen(nt.Rlist)
+ vargen = nt.Rlist.Len()
// declare the receiver and in arguments.
// no n->defn because type checking of func header
@@ -592,8 +592,7 @@
}
var n *Node
- for it := nodeSeqIterate(nt.List); !it.Done(); it.Next() {
- n = it.N()
+ for _, n = range nt.List.Slice() {
if n.Op != ODCLFIELD {
Fatalf("funcargs in %v", Oconv(n.Op, 0))
}
@@ -609,12 +608,10 @@
}
// declare the out arguments.
- gen := nodeSeqLen(nt.List)
+ gen := nt.List.Len()
var i int = 0
var nn *Node
- for it := nodeSeqIterate(nt.Rlist); !it.Done(); it.Next() {
- n = it.N()
-
+ for _, n = range nt.Rlist.Slice() {
if n.Op != ODCLFIELD {
Fatalf("funcargs out %v", Oconv(n.Op, 0))
}
@@ -964,10 +961,10 @@
}
tp := &t.Type
- for it := nodeSeqIterate(l); !it.Done(); it.Next() {
- f := interfacefield(it.N())
+ for _, n := range l {
+ f := interfacefield(n)
- if it.N().Left == nil && f.Type.Etype == TINTER {
+ if n.Left == nil && f.Type.Etype == TINTER {
// embedded interface, inline methods
for t1 := f.Type.Type; t1 != nil; t1 = t1.Down {
f = typ(TFIELD)
@@ -1536,8 +1533,8 @@
}
func (c *nowritebarrierrecChecker) visitcodelist(l Nodes) {
- for it := nodeSeqIterate(l); !it.Done(); it.Next() {
- c.visitcode(it.N())
+ for _, n := range l.Slice() {
+ c.visitcode(n)
}
}
diff --git a/src/cmd/compile/internal/gc/esc.go b/src/cmd/compile/internal/gc/esc.go
index 5dc4348..a814ce1 100644
--- a/src/cmd/compile/internal/gc/esc.go
+++ b/src/cmd/compile/internal/gc/esc.go
@@ -111,8 +111,8 @@
}
func (v *bottomUpVisitor) visitcodelist(l Nodes, min uint32) uint32 {
- for it := nodeSeqIterate(l); !it.Done(); it.Next() {
- min = v.visitcode(it.N(), min)
+ for _, n := range l.Slice() {
+ min = v.visitcode(n, min)
}
return min
}
@@ -523,8 +523,8 @@
var nonlooping Label
func escloopdepthlist(e *EscState, l Nodes) {
- for it := nodeSeqIterate(l); !it.Done(); it.Next() {
- escloopdepth(e, it.N())
+ for _, n := range l.Slice() {
+ escloopdepth(e, n)
}
}
@@ -567,8 +567,8 @@
}
func esclist(e *EscState, l Nodes, up *Node) {
- for it := nodeSeqIterate(l); !it.Done(); it.Next() {
- esc(e, it.N(), up)
+ for _, n := range l.Slice() {
+ esc(e, n, up)
}
}
@@ -597,10 +597,10 @@
// must happen before processing of switch body,
// so before recursion.
if n.Op == OSWITCH && n.Left != nil && n.Left.Op == OTYPESW {
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() { // cases
+ for _, n1 := range n.List.Slice() { // cases
// it.N().Rlist is the variable per case
- if nodeSeqLen(it.N().Rlist) != 0 {
- e.nodeEscState(nodeSeqFirst(it.N().Rlist)).Escloopdepth = e.loopdepth
+ if n1.Rlist.Len() != 0 {
+ e.nodeEscState(n1.Rlist.First()).Escloopdepth = e.loopdepth
}
}
}
@@ -659,7 +659,7 @@
n.Left.Sym.Label = nil
case ORANGE:
- if nodeSeqLen(n.List) >= 2 {
+ if n.List.Len() >= 2 {
// Everything but fixed array is a dereference.
// If fixed array is really the address of fixed array,
@@ -667,20 +667,20 @@
// dereferenced (see #12588)
if Isfixedarray(n.Type) &&
!(Isptr[n.Right.Type.Etype] && Eqtype(n.Right.Type.Type, n.Type)) {
- escassign(e, nodeSeqSecond(n.List), n.Right)
+ escassign(e, n.List.Second(), n.Right)
} else {
- escassignDereference(e, nodeSeqSecond(n.List), n.Right)
+ escassignDereference(e, n.List.Second(), n.Right)
}
}
case OSWITCH:
if n.Left != nil && n.Left.Op == OTYPESW {
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
+ for _, n2 := range n.List.Slice() {
// cases
// n.Left.Right is the argument of the .(type),
// it.N().Rlist is the variable per case
- if nodeSeqLen(it.N().Rlist) != 0 {
- escassign(e, nodeSeqFirst(it.N().Rlist), n.Left.Right)
+ if n2.Rlist.Len() != 0 {
+ escassign(e, n2.Rlist.First(), n.Left.Right)
}
}
}
@@ -721,10 +721,10 @@
escassign(e, n.Left, n.Right)
case OAS2: // x,y = a,b
- if nodeSeqLen(n.List) == nodeSeqLen(n.Rlist) {
+ if n.List.Len() == n.Rlist.Len() {
lrit := nodeSeqIterate(n.Rlist)
- for llit := nodeSeqIterate(n.List); !llit.Done(); llit.Next() {
- escassign(e, llit.N(), lrit.N())
+ for _, n3 := range n.List.Slice() {
+ escassign(e, n3, lrit.N())
lrit.Next()
}
}
@@ -732,7 +732,7 @@
case OAS2RECV, // v, ok = <-ch
OAS2MAPR, // v, ok = m[k]
OAS2DOTTYPE: // v, ok = x.(type)
- escassign(e, nodeSeqFirst(n.List), nodeSeqFirst(n.Rlist))
+ escassign(e, n.List.First(), n.Rlist.First())
case OSEND: // ch <- x
escassign(e, &e.theSink, n.Right)
@@ -750,8 +750,8 @@
escassign(e, &e.theSink, n.Left.Left)
escassign(e, &e.theSink, n.Left.Right) // ODDDARG for call
- for it := nodeSeqIterate(n.Left.List); !it.Done(); it.Next() {
- escassign(e, &e.theSink, it.N())
+ for _, n4 := range n.Left.List.Slice() {
+ escassign(e, &e.theSink, n4)
}
case OCALLMETH, OCALLFUNC, OCALLINTER:
@@ -759,7 +759,7 @@
// esccall already done on n->rlist->n. tie it's escretval to n->list
case OAS2FUNC: // x,y = f()
- lrit := nodeSeqIterate(e.nodeEscState(nodeSeqFirst(n.Rlist)).Escretval)
+ lrit := nodeSeqIterate(e.nodeEscState(n.Rlist.First()).Escretval)
var llit nodeSeqIterator
for llit = nodeSeqIterate(n.List); !lrit.Done() && !llit.Done(); llit.Next() {
@@ -772,11 +772,11 @@
case ORETURN:
ll := n.List
- if nodeSeqLen(n.List) == 1 && Curfn.Type.Outtuple > 1 {
+ if n.List.Len() == 1 && Curfn.Type.Outtuple > 1 {
// OAS2FUNC in disguise
// esccall already done on n->list->n
// tie n->list->n->escretval to curfn->dcl PPARAMOUT's
- ll = e.nodeEscState(nodeSeqFirst(n.List)).Escretval
+ ll = e.nodeEscState(n.List.First()).Escretval
}
llit := nodeSeqIterate(ll)
@@ -808,13 +808,13 @@
}
} else {
// append(slice1, slice2...) -- slice2 itself does not escape, but contents do.
- slice2 := nodeSeqSecond(n.List)
+ slice2 := n.List.Second()
escassignDereference(e, &e.theSink, slice2) // lose track of assign of dereference
if Debug['m'] > 2 {
Warnl(n.Lineno, "%v special treatment of append(slice1, slice2...) %v", e.curfnSym(n), Nconv(n, obj.FmtShort))
}
}
- escassignDereference(e, &e.theSink, nodeSeqFirst(n.List)) // The original elements are now leaked, too
+ escassignDereference(e, &e.theSink, n.List.First()) // The original elements are now leaked, too
case OCOPY:
escassignDereference(e, &e.theSink, n.Right) // lose track of assign of dereference
@@ -831,16 +831,15 @@
// Slice itself is not leaked until proven otherwise
e.track(n)
}
-
// Link values to array/slice
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- escassign(e, n, it.N().Right)
+ for _, n5 := range n.List.Slice() {
+ escassign(e, n, n5.Right)
}
// Link values to struct.
case OSTRUCTLIT:
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- escassign(e, n, it.N().Right)
+ for _, n6 := range n.List.Slice() {
+ escassign(e, n, n6.Right)
}
case OPTRLIT:
@@ -857,11 +856,10 @@
case OMAPLIT:
e.track(n)
-
// Keys and values make it to memory, lose track.
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- escassign(e, &e.theSink, it.N().Left)
- escassign(e, &e.theSink, it.N().Right)
+ for _, n7 := range n.List.Slice() {
+ escassign(e, &e.theSink, n7.Left)
+ escassign(e, &e.theSink, n7.Right)
}
// Link addresses of captured variables to closure.
@@ -1036,8 +1034,8 @@
// Flowing multiple returns to a single dst happens when
// analyzing "go f(g())": here g() flows to sink (issue 4529).
case OCALLMETH, OCALLFUNC, OCALLINTER:
- for it := nodeSeqIterate(e.nodeEscState(src).Escretval); !it.Done(); it.Next() {
- escflows(e, dst, it.N())
+ for _, n := range e.nodeEscState(src).Escretval.Slice() {
+ escflows(e, dst, n)
}
// A non-pointer escaping from a struct does not concern us.
@@ -1071,7 +1069,7 @@
case OAPPEND:
// Append returns first argument.
// Subsequent arguments are already leaked because they are operands to append.
- escassign(e, dst, nodeSeqFirst(src.List))
+ escassign(e, dst, src.List.First())
case OINDEX:
// Index of array preserves input value.
@@ -1369,8 +1367,8 @@
}
ll := n.List
- if nodeSeqLen(n.List) == 1 {
- a := nodeSeqFirst(n.List)
+ if n.List.Len() == 1 {
+ a := n.List.First()
if a.Type.Etype == TSTRUCT && a.Type.Funarg { // f(g()).
ll = e.nodeEscState(a).Escretval
}
@@ -1379,10 +1377,10 @@
if indirect {
// We know nothing!
// Leak all the parameters
- for it := nodeSeqIterate(ll); !it.Done(); it.Next() {
- escassign(e, &e.theSink, it.N())
+ for _, n1 := range ll.Slice() {
+ escassign(e, &e.theSink, n1)
if Debug['m'] > 2 {
- fmt.Printf("%v::esccall:: indirect call <- %v, untracked\n", linestr(lineno), Nconv(it.N(), obj.FmtShort))
+ fmt.Printf("%v::esccall:: indirect call <- %v, untracked\n", linestr(lineno), Nconv(n1, obj.FmtShort))
}
}
// Set up bogus outputs
@@ -1407,13 +1405,12 @@
// function in same mutually recursive group. Incorporate into flow graph.
// print("esc local fn: %N\n", fn->ntype);
- if fn.Name.Defn.Esc == EscFuncUnknown || nodeSeqLen(nE.Escretval) != 0 {
+ if fn.Name.Defn.Esc == EscFuncUnknown || nE.Escretval.Len() != 0 {
Fatalf("graph inconsistency")
}
-
// set up out list on this call node
- for it := nodeSeqIterate(fn.Name.Param.Ntype.Rlist); !it.Done(); it.Next() {
- appendNodeSeqNode(&nE.Escretval, it.N().Left) // type.rlist -> dclfield -> ONAME (PPARAMOUT)
+ for _, n2 := range fn.Name.Param.Ntype.Rlist.Slice() {
+ nE.Escretval.Append(n2.Left) // type.rlist -> dclfield -> ONAME (PPARAMOUT)
}
// Receiver.
@@ -1458,7 +1455,7 @@
}
// Imported or completely analyzed function. Use the escape tags.
- if nodeSeqLen(nE.Escretval) != 0 {
+ if nE.Escretval.Len() != 0 {
Fatalf("esc already decorated call %v\n", Nconv(n, obj.FmtSign))
}
@@ -1739,7 +1736,7 @@
}
case OAPPEND:
- escwalk(e, level, dst, nodeSeqFirst(src.List))
+ escwalk(e, level, dst, src.List.First())
case ODDDARG:
if leaks {
@@ -1756,8 +1753,8 @@
if Isfixedarray(src.Type) {
break
}
- for it := nodeSeqIterate(src.List); !it.Done(); it.Next() {
- escwalk(e, level.dec(), dst, it.N().Right)
+ for _, n1 := range src.List.Slice() {
+ escwalk(e, level.dec(), dst, n1.Right)
}
fallthrough
@@ -1809,13 +1806,13 @@
// See e.g. #10466
// This can only happen with functions returning a single result.
case OCALLMETH, OCALLFUNC, OCALLINTER:
- if nodeSeqLen(srcE.Escretval) != 0 {
+ if srcE.Escretval.Len() != 0 {
if Debug['m'] > 1 {
fmt.Printf("%v:[%d] dst %v escwalk replace src: %v with %v\n",
linestr(lineno), e.loopdepth,
- Nconv(dst, obj.FmtShort), Nconv(src, obj.FmtShort), Nconv(nodeSeqFirst(srcE.Escretval), obj.FmtShort))
+ Nconv(dst, obj.FmtShort), Nconv(src, obj.FmtShort), Nconv(srcE.Escretval.First(), obj.FmtShort))
}
- src = nodeSeqFirst(srcE.Escretval)
+ src = srcE.Escretval.First()
srcE = e.nodeEscState(src)
}
}
diff --git a/src/cmd/compile/internal/gc/export.go b/src/cmd/compile/internal/gc/export.go
index 5c53da3..e46dcd1 100644
--- a/src/cmd/compile/internal/gc/export.go
+++ b/src/cmd/compile/internal/gc/export.go
@@ -107,8 +107,8 @@
// Look for anything we need for the inline body
func reexportdeplist(ll Nodes) {
- for it := nodeSeqIterate(ll); !it.Done(); it.Next() {
- reexportdep(it.N())
+ for _, n := range ll.Slice() {
+ reexportdep(n)
}
}
diff --git a/src/cmd/compile/internal/gc/fmt.go b/src/cmd/compile/internal/gc/fmt.go
index ac1d8cb..a900376 100644
--- a/src/cmd/compile/internal/gc/fmt.go
+++ b/src/cmd/compile/internal/gc/fmt.go
@@ -800,10 +800,10 @@
// block starting with the init statements.
// if we can just say "for" n->ninit; ... then do so
- simpleinit := nodeSeqLen(n.Ninit) == 1 && nodeSeqLen(nodeSeqFirst(n.Ninit).Ninit) == 0 && stmtwithinit(n.Op)
+ simpleinit := n.Ninit.Len() == 1 && n.Ninit.First().Ninit.Len() == 0 && stmtwithinit(n.Op)
// otherwise, print the inits as separate statements
- complexinit := nodeSeqLen(n.Ninit) != 0 && !simpleinit && (fmtmode != FErr)
+ complexinit := n.Ninit.Len() != 0 && !simpleinit && (fmtmode != FErr)
// but if it was for if/for/switch, put in an extra surrounding block to limit the scope
extrablock := complexinit && stmtwithinit(n.Op)
@@ -885,11 +885,11 @@
case OIF:
if simpleinit {
- f += fmt.Sprintf("if %v; %v { %v }", nodeSeqFirst(n.Ninit), n.Left, n.Nbody)
+ f += fmt.Sprintf("if %v; %v { %v }", n.Ninit.First(), n.Left, n.Nbody)
} else {
f += fmt.Sprintf("if %v { %v }", n.Left, n.Nbody)
}
- if nodeSeqLen(n.Rlist) != 0 {
+ if n.Rlist.Len() != 0 {
f += fmt.Sprintf(" else { %v }", n.Rlist)
}
@@ -901,7 +901,7 @@
f += "for"
if simpleinit {
- f += fmt.Sprintf(" %v;", nodeSeqFirst(n.Ninit))
+ f += fmt.Sprintf(" %v;", n.Ninit.First())
} else if n.Right != nil {
f += " ;"
}
@@ -924,7 +924,7 @@
break
}
- if nodeSeqLen(n.List) == 0 {
+ if n.List.Len() == 0 {
f += fmt.Sprintf("for range %v { %v }", n.Right, n.Nbody)
break
}
@@ -939,7 +939,7 @@
f += Oconv(n.Op, obj.FmtSharp)
if simpleinit {
- f += fmt.Sprintf(" %v;", nodeSeqFirst(n.Ninit))
+ f += fmt.Sprintf(" %v;", n.Ninit.First())
}
if n.Left != nil {
f += Nconv(n.Left, 0)
@@ -948,7 +948,7 @@
f += fmt.Sprintf(" { %v }", n.List)
case OCASE, OXCASE:
- if nodeSeqLen(n.List) != 0 {
+ if n.List.Len() != 0 {
f += fmt.Sprintf("case %v: %v", Hconv(n.List, obj.FmtComma), n.Nbody)
} else {
f += fmt.Sprintf("default: %v", n.Nbody)
@@ -1391,7 +1391,7 @@
return f
case OMAKEMAP, OMAKECHAN, OMAKESLICE:
- if nodeSeqLen(n.List) != 0 { // pre-typecheck
+ if n.List.Len() != 0 { // pre-typecheck
return fmt.Sprintf("make(%v, %v)", n.Type, Hconv(n.List, obj.FmtComma))
}
if n.Right != nil {
@@ -1450,11 +1450,11 @@
case OADDSTR:
var f string
i := 0
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
+ for _, n1 := range n.List.Slice() {
if i != 0 {
f += " + "
}
- f += exprfmt(it.N(), nprec)
+ f += exprfmt(n1, nprec)
i++
}
@@ -1523,7 +1523,7 @@
return buf.String()
}
- if nodeSeqLen(n.Ninit) != 0 {
+ if n.Ninit.Len() != 0 {
fmt.Fprintf(&buf, "%v-init%v", Oconv(n.Op, 0), n.Ninit)
indent(&buf)
}
@@ -1576,12 +1576,12 @@
if n.Right != nil {
buf.WriteString(Nconv(n.Right, 0))
}
- if nodeSeqLen(n.List) != 0 {
+ if n.List.Len() != 0 {
indent(&buf)
fmt.Fprintf(&buf, "%v-list%v", Oconv(n.Op, 0), n.List)
}
- if nodeSeqLen(n.Rlist) != 0 {
+ if n.Rlist.Len() != 0 {
indent(&buf)
fmt.Fprintf(&buf, "%v-rlist%v", Oconv(n.Op, 0), n.Rlist)
}
@@ -1711,7 +1711,7 @@
// Fmt '%H': NodeList.
// Flags: all those of %N plus ',': separate with comma's instead of semicolons.
func Hconv(l Nodes, flag int) string {
- if nodeSeqLen(l) == 0 && fmtmode == FDbg {
+ if l.Len() == 0 && fmtmode == FDbg {
return "<nil>"
}
diff --git a/src/cmd/compile/internal/gc/gen.go b/src/cmd/compile/internal/gc/gen.go
index c30d0e0..12c296c 100644
--- a/src/cmd/compile/internal/gc/gen.go
+++ b/src/cmd/compile/internal/gc/gen.go
@@ -216,8 +216,8 @@
// compile statements
func Genlist(l Nodes) {
- for it := nodeSeqIterate(l); !it.Done(); it.Next() {
- gen(it.N())
+ for _, n := range l.Slice() {
+ gen(n)
}
}
@@ -440,7 +440,7 @@
r1.Type = byteptr
r2.Type = byteptr
setNodeSeq(&call.List, list(list(list1(&r1), &r2), typename(n.Left.Type)))
- setNodeSeq(&call.List, ascompatte(OCALLFUNC, call, false, fn.Type.ParamsP(), call.List.Slice(), 0, nil))
+ call.List.Set(ascompatte(OCALLFUNC, call, false, fn.Type.ParamsP(), call.List.Slice(), 0, nil))
gen(call)
Regfree(&r1)
Regfree(&r2)
@@ -526,7 +526,7 @@
dowidth(fn.Type)
call := Nod(OCALLFUNC, fn, nil)
setNodeSeq(&call.List, list(list(list1(&r1), &r2), typename(n.Left.Type)))
- setNodeSeq(&call.List, ascompatte(OCALLFUNC, call, false, fn.Type.ParamsP(), call.List.Slice(), 0, nil))
+ call.List.Set(ascompatte(OCALLFUNC, call, false, fn.Type.ParamsP(), call.List.Slice(), 0, nil))
gen(call)
Regfree(&r1)
Regfree(&r2)
@@ -638,7 +638,7 @@
goto ret
}
- if nodeSeqLen(n.Ninit) > 0 {
+ if n.Ninit.Len() > 0 {
Genlist(n.Ninit)
}
@@ -845,7 +845,7 @@
Cgen_as_wb(n.Left, n.Right, true)
case OAS2DOTTYPE:
- cgen_dottype(nodeSeqFirst(n.Rlist), nodeSeqFirst(n.List), nodeSeqSecond(n.List), needwritebarrier(nodeSeqFirst(n.List), nodeSeqFirst(n.Rlist)))
+ cgen_dottype(n.Rlist.First(), n.List.First(), n.List.Second(), needwritebarrier(n.List.First(), n.Rlist.First()))
case OCALLMETH:
cgen_callmeth(n, 0)
diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index c2faff7..69615ba 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -171,8 +171,8 @@
// Look for anything we want to punt on.
func ishairylist(ll Nodes, budget *int) bool {
- for it := nodeSeqIterate(ll); !it.Done(); it.Next() {
- if ishairy(it.N(), budget) {
+ for _, n := range ll.Slice() {
+ if ishairy(n, budget) {
return true
}
}
@@ -247,8 +247,8 @@
// the exportlist.
func inlcopylist(ll []*Node) []*Node {
s := make([]*Node, 0, nodeSeqLen(ll))
- for it := nodeSeqIterate(ll); !it.Done(); it.Next() {
- s = append(s, inlcopy(it.N()))
+ for _, n := range ll {
+ s = append(s, inlcopy(n))
}
return s
}
@@ -270,9 +270,9 @@
}
m.Left = inlcopy(n.Left)
m.Right = inlcopy(n.Right)
- setNodeSeq(&m.List, inlcopylist(n.List.Slice()))
- setNodeSeq(&m.Rlist, inlcopylist(n.Rlist.Slice()))
- setNodeSeq(&m.Ninit, inlcopylist(n.Ninit.Slice()))
+ m.List.Set(inlcopylist(n.List.Slice()))
+ m.Rlist.Set(inlcopylist(n.Rlist.Slice()))
+ m.Ninit.Set(inlcopylist(n.Ninit.Slice()))
m.Nbody.Set(inlcopylist(n.Nbody.Slice()))
return m
@@ -295,17 +295,17 @@
n.Op = OBLOCK
// n->ninit stays
- setNodeSeq(&n.List, n.Nbody)
+ n.List.Set(n.Nbody.Slice())
n.Nbody.Set(nil)
- setNodeSeq(&n.Rlist, nil)
+ n.Rlist.Set(nil)
}
// Turn an OINLCALL into a single valued expression.
func inlconv2expr(np **Node) {
n := *np
- r := nodeSeqFirst(n.Rlist)
- addinit(&r, append(nodeSeqSlice(n.Ninit), n.Nbody.Slice()...))
+ r := n.Rlist.First()
+ addinit(&r, append(n.Ninit.Slice(), n.Nbody.Slice()...))
*np = r
}
@@ -315,18 +315,18 @@
// order will be preserved Used in return, oas2func and call
// statements.
func inlconv2list(n *Node) []*Node {
- if n.Op != OINLCALL || nodeSeqLen(n.Rlist) == 0 {
+ if n.Op != OINLCALL || n.Rlist.Len() == 0 {
Fatalf("inlconv2list %v\n", Nconv(n, obj.FmtSign))
}
- s := nodeSeqSlice(n.Rlist)
- addinit(&s[0], append(nodeSeqSlice(n.Ninit), n.Nbody.Slice()...))
+ s := n.Rlist.Slice()
+ addinit(&s[0], append(n.Ninit.Slice(), n.Nbody.Slice()...))
return s
}
func inlnodelist(l Nodes) {
- for it := nodeSeqIterate(l); !it.Done(); it.Next() {
- inlnode(it.P())
+ for i := range l.Slice() {
+ inlnode(&l.Slice()[i])
}
}
@@ -367,9 +367,9 @@
lno := setlineno(n)
inlnodelist(n.Ninit)
- for it := nodeSeqIterate(n.Ninit); !it.Done(); it.Next() {
- if it.N().Op == OINLCALL {
- inlconv2stmt(it.N())
+ for _, n1 := range n.Ninit.Slice() {
+ if n1.Op == OINLCALL {
+ inlconv2stmt(n1)
}
}
@@ -390,9 +390,9 @@
inlnodelist(n.List)
switch n.Op {
case OBLOCK:
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- if it.N().Op == OINLCALL {
- inlconv2stmt(it.N())
+ for _, n2 := range n.List.Slice() {
+ if n2.Op == OINLCALL {
+ inlconv2stmt(n2)
}
}
@@ -404,16 +404,16 @@
OCALLINTER,
OAPPEND,
OCOMPLEX:
- if nodeSeqLen(n.List) == 1 && nodeSeqFirst(n.List).Op == OINLCALL && nodeSeqLen(nodeSeqFirst(n.List).Rlist) > 1 {
- setNodeSeq(&n.List, inlconv2list(nodeSeqFirst(n.List)))
+ if n.List.Len() == 1 && n.List.First().Op == OINLCALL && n.List.First().Rlist.Len() > 1 {
+ n.List.Set(inlconv2list(n.List.First()))
break
}
fallthrough
default:
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- if it.N().Op == OINLCALL {
- inlconv2expr(it.P())
+ for i3, n3 := range n.List.Slice() {
+ if n3.Op == OINLCALL {
+ inlconv2expr(&n.List.Slice()[i3])
}
}
}
@@ -421,8 +421,8 @@
inlnodelist(n.Rlist)
switch n.Op {
case OAS2FUNC:
- if nodeSeqFirst(n.Rlist).Op == OINLCALL {
- setNodeSeq(&n.Rlist, inlconv2list(nodeSeqFirst(n.Rlist)))
+ if n.Rlist.First().Op == OINLCALL {
+ n.Rlist.Set(inlconv2list(n.Rlist.First()))
n.Op = OAS2
n.Typecheck = 0
typecheck(np, Etop)
@@ -431,12 +431,12 @@
fallthrough
default:
- for it := nodeSeqIterate(n.Rlist); !it.Done(); it.Next() {
- if it.N().Op == OINLCALL {
+ for i4, n4 := range n.Rlist.Slice() {
+ if n4.Op == OINLCALL {
if n.Op == OIF {
- inlconv2stmt(it.N())
+ inlconv2stmt(n4)
} else {
- inlconv2expr(it.P())
+ inlconv2expr(&n.Rlist.Slice()[i4])
}
}
}
@@ -585,7 +585,7 @@
typecheck(&ln.Name.Inlvar, Erv)
if ln.Class&^PHEAP != PAUTO {
- appendNodeSeqNode(&ninit, Nod(ODCL, ln.Name.Inlvar, nil)) // otherwise gen won't emit the allocations for heapallocs
+ ninit.Append(Nod(ODCL, ln.Name.Inlvar, nil)) // otherwise gen won't emit the allocations for heapallocs
}
}
}
@@ -603,7 +603,7 @@
i++
}
- appendNodeSeqNode(&ninit, Nod(ODCL, m, nil))
+ ninit.Append(Nod(ODCL, m, nil))
inlretvars = list(inlretvars, m)
}
@@ -625,7 +625,7 @@
as = Nod(OAS, tinlvar(t), n.Left.Left)
if as != nil {
typecheck(&as, Etop)
- appendNodeSeqNode(&ninit, as)
+ ninit.Append(as)
}
}
@@ -649,17 +649,17 @@
// check if argument is actually a returned tuple from call.
multiret := 0
- if nodeSeqLen(n.List) == 1 {
- switch nodeSeqFirst(n.List).Op {
+ if n.List.Len() == 1 {
+ switch n.List.First().Op {
case OCALL, OCALLFUNC, OCALLINTER, OCALLMETH:
- if nodeSeqFirst(n.List).Left.Type.Outtuple > 1 {
- multiret = nodeSeqFirst(n.List).Left.Type.Outtuple - 1
+ if n.List.First().Left.Type.Outtuple > 1 {
+ multiret = n.List.First().Left.Type.Outtuple - 1
}
}
}
if variadic {
- varargcount = nodeSeqLen(n.List) + multiret
+ varargcount = n.List.Len() + multiret
if n.Left.Op != ODOTMETH {
varargcount -= fn.Type.Thistuple
}
@@ -669,13 +669,13 @@
// assign arguments to the parameters' temp names
as = Nod(OAS2, nil, nil)
- setNodeSeq(&as.Rlist, n.List)
+ as.Rlist.Set(n.List.Slice())
it := nodeSeqIterate(n.List)
// TODO: if len(nlist) == 1 but multiple args, check that n->list->n is a call?
if fn.Type.Thistuple != 0 && n.Left.Op != ODOTMETH {
// non-method call to method
- if nodeSeqLen(n.List) == 0 {
+ if n.List.Len() == 0 {
Fatalf("non-method call to method without first arg: %v", Nconv(n, obj.FmtSign))
}
@@ -688,12 +688,12 @@
if t == nil {
Fatalf("method call unknown receiver type: %v", Nconv(n, obj.FmtSign))
}
- appendNodeSeqNode(&as.List, tinlvar(t))
+ as.List.Append(tinlvar(t))
it.Next() // track argument count.
}
// append ordinary arguments to LHS.
- chkargcount := nodeSeqLen(n.List) > 1
+ chkargcount := n.List.Len() > 1
var vararg *Node // the slice argument to a variadic call
var varargs []*Node // the list of LHS names to put in vararg.
@@ -706,13 +706,13 @@
for i = 0; i < varargcount && it.Len() != 0; i++ {
m = argvar(varargtype, i)
varargs = append(varargs, m)
- appendNodeSeqNode(&as.List, m)
+ as.List.Append(m)
}
break
}
- appendNodeSeqNode(&as.List, tinlvar(t))
+ as.List.Append(tinlvar(t))
}
} else {
// match arguments except final variadic (unless the call is dotted itself)
@@ -724,7 +724,7 @@
if variadic && t.Isddd {
break
}
- appendNodeSeqNode(&as.List, tinlvar(t))
+ as.List.Append(tinlvar(t))
t = t.Down
it.Next()
}
@@ -736,7 +736,7 @@
for i = 0; i < varargcount && !it.Done(); i++ {
m = argvar(varargtype, i)
varargs = append(varargs, m)
- appendNodeSeqNode(&as.List, m)
+ as.List.Append(m)
it.Next()
}
@@ -750,9 +750,9 @@
}
}
- if nodeSeqLen(as.Rlist) != 0 {
+ if as.Rlist.Len() != 0 {
typecheck(&as, Etop)
- appendNodeSeqNode(&ninit, as)
+ ninit.Append(as)
}
// turn the variadic args into a slice.
@@ -767,19 +767,19 @@
vararrtype.Bound = int64(varargcount)
as.Right = Nod(OCOMPLIT, nil, typenod(varargtype))
- setNodeSeq(&as.Right.List, varargs)
+ as.Right.List.Set(varargs)
as.Right = Nod(OSLICE, as.Right, Nod(OKEY, nil, nil))
}
typecheck(&as, Etop)
- appendNodeSeqNode(&ninit, as)
+ ninit.Append(as)
}
// zero the outparams
for ll := inlretvars; ll != nil; ll = ll.Next {
as = Nod(OAS, ll.N, nil)
typecheck(&as, Etop)
- appendNodeSeqNode(&ninit, as)
+ ninit.Append(as)
}
inlretlabel = newlabel_inl()
@@ -795,7 +795,7 @@
call := Nod(OINLCALL, nil, nil)
- setNodeSeq(&call.Ninit, ninit)
+ call.Ninit.Set(ninit.Slice())
call.Nbody.Set(body)
setNodeSeq(&call.Rlist, inlretvars)
call.Type = n.Type
@@ -804,11 +804,11 @@
// Hide the args from setlno -- the parameters to the inlined
// call already have good line numbers that should be preserved.
args := as.Rlist
- setNodeSeq(&as.Rlist, nil)
+ as.Rlist.Set(nil)
setlno(call, n.Lineno)
- setNodeSeq(&as.Rlist, args)
+ as.Rlist.Set(args.Slice())
//dumplist("call body", body);
@@ -900,9 +900,9 @@
// to input/output parameters with ones to the tmpnames, and
// substituting returns with assignments to the output.
func inlsubstlist(ll Nodes) []*Node {
- s := make([]*Node, 0, nodeSeqLen(ll))
- for it := nodeSeqIterate(ll); !it.Done(); it.Next() {
- s = append(s, inlsubst(it.N()))
+ s := make([]*Node, 0, ll.Len())
+ for _, n := range ll.Slice() {
+ s = append(s, inlsubst(n))
}
return s
}
@@ -935,18 +935,18 @@
case ORETURN:
m := Nod(OGOTO, inlretlabel, nil)
- setNodeSeq(&m.Ninit, inlsubstlist(n.Ninit))
+ m.Ninit.Set(inlsubstlist(n.Ninit))
- if inlretvars != nil && nodeSeqLen(n.List) != 0 {
+ if inlretvars != nil && n.List.Len() != 0 {
as := Nod(OAS2, nil, nil)
// shallow copy or OINLCALL->rlist will be the same list, and later walk and typecheck may clobber that.
for ll := inlretvars; ll != nil; ll = ll.Next {
- appendNodeSeqNode(&as.List, ll.N)
+ as.List.Append(ll.N)
}
- setNodeSeq(&as.Rlist, inlsubstlist(n.List))
+ as.Rlist.Set(inlsubstlist(n.List))
typecheck(&as, Etop)
- appendNodeSeqNode(&m.Ninit, as)
+ m.Ninit.Append(as)
}
typechecklist(m.Ninit.Slice(), Etop)
@@ -958,7 +958,7 @@
case OGOTO, OLABEL:
m := Nod(OXXX, nil, nil)
*m = *n
- setNodeSeq(&m.Ninit, nil)
+ m.Ninit.Set(nil)
p := fmt.Sprintf("%s·%d", n.Left.Sym.Name, inlgen)
m.Left = newname(Lookup(p))
@@ -967,7 +967,7 @@
m := Nod(OXXX, nil, nil)
*m = *n
- setNodeSeq(&m.Ninit, nil)
+ m.Ninit.Set(nil)
if n.Op == OCLOSURE {
Fatalf("cannot inline function containing closure: %v", Nconv(n, obj.FmtSign))
@@ -975,9 +975,9 @@
m.Left = inlsubst(n.Left)
m.Right = inlsubst(n.Right)
- setNodeSeq(&m.List, inlsubstlist(n.List))
- setNodeSeq(&m.Rlist, inlsubstlist(n.Rlist))
- setNodeSeq(&m.Ninit, append(nodeSeqSlice(m.Ninit), inlsubstlist(n.Ninit)...))
+ m.List.Set(inlsubstlist(n.List))
+ m.Rlist.Set(inlsubstlist(n.Rlist))
+ m.Ninit.Set(append(m.Ninit.Slice(), inlsubstlist(n.Ninit)...))
m.Nbody.Set(inlsubstlist(n.Nbody))
return m
@@ -985,8 +985,8 @@
// Plaster over linenumbers
func setlnolist(ll Nodes, lno int32) {
- for it := nodeSeqIterate(ll); !it.Done(); it.Next() {
- setlno(it.N(), lno)
+ for _, n := range ll.Slice() {
+ setlno(n, lno)
}
}
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index 7f74082..d287ae6 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -250,8 +250,8 @@
// Orderstmtlist orders each of the statements in the list.
func orderstmtlist(l Nodes, order *Order) {
- for it := nodeSeqIterate(l); !it.Done(); it.Next() {
- orderstmt(it.N(), order)
+ for _, n := range l.Slice() {
+ orderstmt(n, order)
}
}
@@ -304,17 +304,17 @@
// Orderinit moves n's init list to order->out.
func orderinit(n *Node, order *Order) {
orderstmtlist(n.Ninit, order)
- setNodeSeq(&n.Ninit, nil)
+ n.Ninit.Set(nil)
}
// Ismulticall reports whether the list l is f() for a multi-value function.
// Such an f() could appear as the lone argument to a multi-arg function.
func ismulticall(l Nodes) bool {
// one arg only
- if nodeSeqLen(l) != 1 {
+ if l.Len() != 1 {
return false
}
- n := nodeSeqFirst(l)
+ n := l.First()
// must be call
switch n.Op {
@@ -360,7 +360,7 @@
func ordercallargs(l Nodes, order *Order) Nodes {
if ismulticall(l) {
// return f() where f() is multiple values.
- return copyret(nodeSeqFirst(l), order)
+ return copyret(l.First(), order)
} else {
orderexprlist(l, order)
return l
@@ -443,23 +443,23 @@
var post []*Node
var m *Node
var a *Node
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- if it.N().Op == OINDEXMAP {
- m = it.N()
+ for i1, n1 := range n.List.Slice() {
+ if n1.Op == OINDEXMAP {
+ m = n1
if !istemp(m.Left) {
m.Left = ordercopyexpr(m.Left, m.Left.Type, order, 0)
}
if !istemp(m.Right) {
m.Right = ordercopyexpr(m.Right, m.Right.Type, order, 0)
}
- *it.P() = ordertemp(m.Type, order, false)
- a = Nod(OAS, m, it.N())
+ n.List.Slice()[i1] = ordertemp(m.Type, order, false)
+ a = Nod(OAS, m, n.List.Slice()[i1])
typecheck(&a, Etop)
post = append(post, a)
- } else if instrumenting && n.Op == OAS2FUNC && !isblank(it.N()) {
- m = it.N()
- *it.P() = ordertemp(m.Type, order, false)
- a = Nod(OAS, m, it.N())
+ } else if instrumenting && n.Op == OAS2FUNC && !isblank(n.List.Slice()[i1]) {
+ m = n.List.Slice()[i1]
+ n.List.Slice()[i1] = ordertemp(m.Type, order, false)
+ a = Nod(OAS, m, n.List.Slice()[i1])
typecheck(&a, Etop)
post = append(post, a)
}
@@ -546,7 +546,7 @@
t := marktemp(order)
orderexprlist(n.List, order)
- r := nodeSeqFirst(n.Rlist)
+ r := n.Rlist.First()
orderexpr(&r.Left, order, nil)
orderexpr(&r.Right, order, nil)
@@ -563,7 +563,7 @@
t := marktemp(order)
orderexprlist(n.List, order)
- ordercall(nodeSeqFirst(n.Rlist), order)
+ ordercall(n.Rlist.First(), order)
ordermapassign(n, order)
cleantemp(t, order)
@@ -574,17 +574,17 @@
t := marktemp(order)
orderexprlist(n.List, order)
- orderexpr(&nodeSeqFirst(n.Rlist).Left, order, nil) // i in i.(T)
- if isblank(nodeSeqFirst(n.List)) {
+ orderexpr(&n.Rlist.First().Left, order, nil) // i in i.(T)
+ if isblank(n.List.First()) {
order.out = append(order.out, n)
} else {
- typ := nodeSeqFirst(n.Rlist).Type
+ typ := n.Rlist.First().Type
tmp1 := ordertemp(typ, order, haspointers(typ))
order.out = append(order.out, n)
- r := Nod(OAS, nodeSeqFirst(n.List), tmp1)
+ r := Nod(OAS, n.List.First(), tmp1)
typecheck(&r, Etop)
ordermapassign(r, order)
- setNodeSeq(&n.List, []*Node{tmp1, nodeSeqSecond(n.List)})
+ n.List.Set([]*Node{tmp1, n.List.Second()})
}
cleantemp(t, order)
@@ -595,23 +595,23 @@
t := marktemp(order)
orderexprlist(n.List, order)
- orderexpr(&nodeSeqFirst(n.Rlist).Left, order, nil) // arg to recv
- ch := nodeSeqFirst(n.Rlist).Left.Type
+ orderexpr(&n.Rlist.First().Left, order, nil) // arg to recv
+ ch := n.Rlist.First().Left.Type
tmp1 := ordertemp(ch.Type, order, haspointers(ch.Type))
var tmp2 *Node
- if !isblank(nodeSeqSecond(n.List)) {
- tmp2 = ordertemp(nodeSeqSecond(n.List).Type, order, false)
+ if !isblank(n.List.Second()) {
+ tmp2 = ordertemp(n.List.Second().Type, order, false)
} else {
tmp2 = ordertemp(Types[TBOOL], order, false)
}
order.out = append(order.out, n)
- r := Nod(OAS, nodeSeqFirst(n.List), tmp1)
+ r := Nod(OAS, n.List.First(), tmp1)
typecheck(&r, Etop)
ordermapassign(r, order)
- r = Nod(OAS, nodeSeqSecond(n.List), tmp2)
+ r = Nod(OAS, n.List.Second(), tmp2)
typecheck(&r, Etop)
ordermapassign(r, order)
- setNodeSeq(&n.List, []*Node{tmp1, tmp2})
+ n.List.Set([]*Node{tmp1, tmp2})
cleantemp(t, order)
// Special: does not save n onto out.
@@ -699,10 +699,10 @@
n.Nbody.Set(append(l, n.Nbody.Slice()...))
l = nil
cleantempnopop(t, order, &l)
- setNodeSeq(&n.Rlist, append(l, nodeSeqSlice(n.Rlist)...))
+ n.Rlist.Set(append(l, n.Rlist.Slice()...))
poptemp(t, order)
orderblockNodes(&n.Nbody)
- setNodeSeq(&n.Rlist, orderblock(n.Rlist))
+ n.Rlist.Set(orderblock(n.Rlist))
order.out = append(order.out, n)
// Special: argument will be converted to interface using convT2E
@@ -739,7 +739,7 @@
if n.Right.Op == OSTRARRAYBYTE {
n.Right.Op = OSTRARRAYBYTETMP
}
- if nodeSeqLen(n.List) < 2 || isblank(nodeSeqSecond(n.List)) {
+ if n.List.Len() < 2 || isblank(n.List.Second()) {
// for i := range x will only use x once, to compute len(x).
// No need to copy it.
break
@@ -771,9 +771,8 @@
// n->alloc is the temp for the iterator.
prealloc[n] = ordertemp(Types[TUINT8], order, true)
}
-
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- orderexprinplace(it.P(), order)
+ for i1 := range n.List.Slice() {
+ orderexprinplace(&n.List.Slice()[i1], order)
}
orderblockNodes(&n.Nbody)
order.out = append(order.out, n)
@@ -798,16 +797,16 @@
var tmp1 *Node
var tmp2 *Node
var r *Node
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- if it.N().Op != OXCASE {
- Fatalf("order select case %v", Oconv(it.N().Op, 0))
+ for _, n2 := range n.List.Slice() {
+ if n2.Op != OXCASE {
+ Fatalf("order select case %v", Oconv(n2.Op, 0))
}
- r = it.N().Left
- setlineno(it.N())
+ r = n2.Left
+ setlineno(n2)
// Append any new body prologue to ninit.
// The next loop will insert ninit into nbody.
- if nodeSeqLen(it.N().Ninit) != 0 {
+ if n2.Ninit.Len() != 0 {
Fatalf("order select ninit")
}
if r != nil {
@@ -826,15 +825,15 @@
if itinit.Len() != 0 && itinit.N().Op == ODCL && itinit.N().Left == r.Left {
itinit.Next()
}
- if itinit.Len() != 0 && itinit.N().Op == ODCL && nodeSeqLen(r.List) != 0 && itinit.N().Left == nodeSeqFirst(r.List) {
+ if itinit.Len() != 0 && itinit.N().Op == ODCL && r.List.Len() != 0 && itinit.N().Left == r.List.First() {
itinit.Next()
}
if itinit.Done() {
- setNodeSeq(&r.Ninit, nil)
+ r.Ninit.Set(nil)
}
}
- if nodeSeqLen(r.Ninit) != 0 {
+ if r.Ninit.Len() != 0 {
Yyerror("ninit on select recv")
dumplist("ninit", r.Ninit)
}
@@ -868,36 +867,35 @@
if r.Colas {
tmp2 = Nod(ODCL, tmp1, nil)
typecheck(&tmp2, Etop)
- appendNodeSeqNode(&it.N().Ninit, tmp2)
+ n2.Ninit.Append(tmp2)
}
r.Left = ordertemp(r.Right.Left.Type.Type, order, haspointers(r.Right.Left.Type.Type))
tmp2 = Nod(OAS, tmp1, r.Left)
typecheck(&tmp2, Etop)
- appendNodeSeqNode(&it.N().Ninit, tmp2)
+ n2.Ninit.Append(tmp2)
}
- if nodeSeqLen(r.List) != 0 && isblank(nodeSeqFirst(r.List)) {
- setNodeSeq(&r.List, nil)
+ if r.List.Len() != 0 && isblank(r.List.First()) {
+ r.List.Set(nil)
}
- if nodeSeqLen(r.List) != 0 {
- tmp1 = nodeSeqFirst(r.List)
+ if r.List.Len() != 0 {
+ tmp1 = r.List.First()
if r.Colas {
tmp2 = Nod(ODCL, tmp1, nil)
typecheck(&tmp2, Etop)
- appendNodeSeqNode(&it.N().Ninit, tmp2)
+ n2.Ninit.Append(tmp2)
}
setNodeSeq(&r.List, list1(ordertemp(tmp1.Type, order, false)))
- tmp2 = Nod(OAS, tmp1, nodeSeqFirst(r.List))
+ tmp2 = Nod(OAS, tmp1, r.List.First())
typecheck(&tmp2, Etop)
- appendNodeSeqNode(&it.N().Ninit, tmp2)
+ n2.Ninit.Append(tmp2)
}
-
- setNodeSeq(&it.N().Ninit, orderblock(it.N().Ninit))
+ n2.Ninit.Set(orderblock(n2.Ninit))
case OSEND:
- if nodeSeqLen(r.Ninit) != 0 {
+ if r.Ninit.Len() != 0 {
Yyerror("ninit on select send")
dumplist("ninit", r.Ninit)
}
@@ -916,17 +914,16 @@
}
}
- orderblockNodes(&it.N().Nbody)
+ orderblockNodes(&n2.Nbody)
}
-
// Now that we have accumulated all the temporaries, clean them.
// Also insert any ninit queued during the previous loop.
// (The temporary cleaning must follow that ninit work.)
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- s := nodeSeqSlice(it.N().Ninit)
+ for _, n3 := range n.List.Slice() {
+ s := n3.Ninit.Slice()
cleantempnopop(t, order, &s)
- it.N().Nbody.Set(append(s, it.N().Nbody.Slice()...))
- setNodeSeq(&it.N().Ninit, nil)
+ n3.Nbody.Set(append(s, n3.Nbody.Slice()...))
+ n3.Ninit.Set(nil)
}
order.out = append(order.out, n)
@@ -953,12 +950,12 @@
t := marktemp(order)
orderexpr(&n.Left, order, nil)
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- if it.N().Op != OXCASE {
- Fatalf("order switch case %v", Oconv(it.N().Op, 0))
+ for _, n4 := range n.List.Slice() {
+ if n4.Op != OXCASE {
+ Fatalf("order switch case %v", Oconv(n4.Op, 0))
}
- orderexprlistinplace(it.N().List, order)
- orderblockNodes(&it.N().Nbody)
+ orderexprlistinplace(n4.List, order)
+ orderblockNodes(&n4.Nbody)
}
order.out = append(order.out, n)
@@ -970,16 +967,16 @@
// Orderexprlist orders the expression list l into order.
func orderexprlist(l Nodes, order *Order) {
- for it := nodeSeqIterate(l); !it.Done(); it.Next() {
- orderexpr(it.P(), order, nil)
+ for i := range l.Slice() {
+ orderexpr(&l.Slice()[i], order, nil)
}
}
// Orderexprlist orders the expression list l but saves
// the side effects on the individual expression ninit lists.
func orderexprlistinplace(l Nodes, order *Order) {
- for it := nodeSeqIterate(l); !it.Done(); it.Next() {
- orderexprinplace(it.P(), order)
+ for i := range l.Slice() {
+ orderexprinplace(&l.Slice()[i], order)
}
}
@@ -1013,9 +1010,9 @@
case OADDSTR:
orderexprlist(n.List, order)
- if nodeSeqLen(n.List) > 5 {
+ if n.List.Len() > 5 {
t := typ(TARRAY)
- t.Bound = int64(nodeSeqLen(n.List))
+ t.Bound = int64(n.List.Len())
t.Type = Types[TSTRING]
prealloc[n] = ordertemp(t, order, false)
}
@@ -1030,15 +1027,15 @@
hasbyte := false
haslit := false
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- hasbyte = hasbyte || it.N().Op == OARRAYBYTESTR
- haslit = haslit || it.N().Op == OLITERAL && len(it.N().Val().U.(string)) != 0
+ for _, n1 := range n.List.Slice() {
+ hasbyte = hasbyte || n1.Op == OARRAYBYTESTR
+ haslit = haslit || n1.Op == OLITERAL && len(n1.Val().U.(string)) != 0
}
if haslit && hasbyte {
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- if it.N().Op == OARRAYBYTESTR {
- it.N().Op = OARRAYBYTESTRTMP
+ for _, n2 := range n.List.Slice() {
+ if n2.Op == OARRAYBYTESTR {
+ n2.Op = OARRAYBYTESTRTMP
}
}
}
@@ -1103,7 +1100,7 @@
var s []*Node
cleantempnopop(mark, order, &s)
- setNodeSeq(&n.Right.Ninit, append(s, nodeSeqSlice(n.Right.Ninit)...))
+ n.Right.Ninit.Set(append(s, n.Right.Ninit.Slice()...))
orderexprinplace(&n.Right, order)
case OCALLFUNC,
@@ -1130,7 +1127,7 @@
case OAPPEND:
setNodeSeq(&n.List, ordercallargs(n.List, order))
- if lhs == nil || lhs.Op != ONAME && !samesafeexpr(lhs, nodeSeqFirst(n.List)) {
+ if lhs == nil || lhs.Op != ONAME && !samesafeexpr(lhs, n.List.First()) {
n = ordercopyexpr(n, n.Type, order, 0)
}
diff --git a/src/cmd/compile/internal/gc/parser.go b/src/cmd/compile/internal/gc/parser.go
index 9a5dfe9..6312756 100644
--- a/src/cmd/compile/internal/gc/parser.go
+++ b/src/cmd/compile/internal/gc/parser.go
@@ -684,7 +684,7 @@
label.Name.Defn = ls
l := []*Node{label}
if ls != nil {
- if ls.Op == OBLOCK && nodeSeqLen(ls.Ninit) == 0 {
+ if ls.Op == OBLOCK && ls.Ninit.Len() == 0 {
l = append(l, ls.List.Slice()...)
} else {
l = append(l, ls)
@@ -726,7 +726,7 @@
// type switch - declare variable
nn := newname(n.Sym)
declare(nn, dclcontext)
- setNodeSeq(&stmt.Rlist, []*Node{nn})
+ stmt.Rlist.Set([]*Node{nn})
// keep track of the instances for reporting unused
nn.Name.Defn = tswitch
@@ -752,9 +752,9 @@
} else {
n = Nod(OAS2, nil, nil)
setNodeSeq(&n.List, cases)
- setNodeSeq(&n.Rlist, []*Node{rhs})
+ n.Rlist.Set([]*Node{rhs})
}
- setNodeSeq(&stmt.List, []*Node{n})
+ stmt.List.Set([]*Node{n})
p.want(':') // consume ':' after declaring select cases for correct lineno
return stmt
@@ -770,7 +770,7 @@
// done in casebody()
markdcl() // matching popdcl in caseblock
stmt := Nod(OXCASE, nil, nil)
- setNodeSeq(&stmt.List, []*Node{colas(cases, list1(rhs), lno)})
+ stmt.List.Set([]*Node{colas(cases, list1(rhs), lno)})
p.want(':') // consume ':' after declaring select cases for correct lineno
return stmt
@@ -794,7 +794,7 @@
// type switch - declare variable
nn := newname(n.Sym)
declare(nn, dclcontext)
- setNodeSeq(&stmt.Rlist, []*Node{nn})
+ stmt.Rlist.Set([]*Node{nn})
// keep track of the instances for reporting unused
nn.Name.Defn = tswitch
@@ -918,7 +918,7 @@
}
h := Nod(OFOR, nil, nil)
if init != nil {
- setNodeSeq(&h.Ninit, []*Node{init})
+ h.Ninit.Set([]*Node{init})
}
h.Left = cond
h.Right = post
@@ -1022,7 +1022,7 @@
init, cond, _ := p.header(false)
h := Nod(OIF, nil, nil)
if init != nil {
- setNodeSeq(&h.Ninit, []*Node{init})
+ h.Ninit.Set([]*Node{init})
}
h.Left = cond
return h
@@ -1047,13 +1047,13 @@
if p.got(LELSE) {
if p.tok == LIF {
- setNodeSeq(&stmt.Rlist, []*Node{p.if_stmt()})
+ stmt.Rlist.Set([]*Node{p.if_stmt()})
} else {
cs := p.compound_stmt(true)
- if cs.Op == OBLOCK && nodeSeqLen(cs.Ninit) == 0 {
- setNodeSeq(&stmt.Rlist, cs.List)
+ if cs.Op == OBLOCK && cs.Ninit.Len() == 0 {
+ stmt.Rlist.Set(cs.List.Slice())
} else {
- setNodeSeq(&stmt.Rlist, []*Node{cs})
+ stmt.Rlist.Set([]*Node{cs})
}
}
}
@@ -1553,7 +1553,7 @@
p.xnest--
p.want('}')
- setNodeSeq(&n.List, l)
+ n.List.Set(l)
return n
}
@@ -1842,7 +1842,7 @@
p.want('}')
t := Nod(OTINTER, nil, nil)
- setNodeSeq(&t.List, l)
+ t.List.Set(l)
return t
}
@@ -2514,7 +2514,7 @@
stmt := Nod(ORETURN, nil, nil)
setNodeSeq(&stmt.List, results)
- if nodeSeqLen(stmt.List) == 0 && Curfn != nil {
+ if stmt.List.Len() == 0 && Curfn != nil {
for _, ln := range Curfn.Func.Dcl {
if ln.Class == PPARAM {
continue
@@ -2549,7 +2549,7 @@
if s == missing_stmt {
break
}
- if s != nil && s.Op == OBLOCK && nodeSeqLen(s.Ninit) == 0 {
+ if s != nil && s.Op == OBLOCK && s.Ninit.Len() == 0 {
appendNodeSeq(&l, s.List)
} else {
appendNodeSeqNode(&l, s)
diff --git a/src/cmd/compile/internal/gc/racewalk.go b/src/cmd/compile/internal/gc/racewalk.go
index ab08405..04afc587 100644
--- a/src/cmd/compile/internal/gc/racewalk.go
+++ b/src/cmd/compile/internal/gc/racewalk.go
@@ -87,11 +87,11 @@
}
func instrumentlist(l Nodes, init *Nodes) {
- for it := nodeSeqIterate(l); !it.Done(); it.Next() {
+ for i := range l.Slice() {
var instr Nodes
- instrumentnode(it.P(), &instr, 0, 0)
+ instrumentnode(&l.Slice()[i], &instr, 0, 0)
if init == nil {
- it.N().Ninit.AppendNodes(&instr)
+ l.Slice()[i].Ninit.AppendNodes(&instr)
} else {
init.AppendNodes(&instr)
}
@@ -121,7 +121,7 @@
// nil it out and handle it separately before putting it back.
l := n.Ninit
- setNodeSeq(&n.Ninit, nil)
+ n.Ninit.Set(nil)
instrumentlist(l, nil)
instrumentnode(&n, &l, wr, skip) // recurse with nil n->ninit
appendinit(&n, l)
@@ -167,7 +167,7 @@
out = append(outn.Slice(), it.N())
}
}
- setNodeSeq(&n.List, out)
+ n.List.Set(out)
goto ret
case ODEFER:
@@ -595,8 +595,8 @@
}
func foreachlist(l Nodes, f func(*Node, interface{}), c interface{}) {
- for it := nodeSeqIterate(l); !it.Done(); it.Next() {
- foreachnode(it.N(), f, c)
+ for _, n := range l.Slice() {
+ foreachnode(n, f, c)
}
}
@@ -619,7 +619,7 @@
// appendinit is like addinit in subr.go
// but appends rather than prepends.
func appendinit(np **Node, init Nodes) {
- if nodeSeqLen(init) == 0 {
+ if init.Len() == 0 {
return
}
@@ -635,6 +635,6 @@
*np = n
}
- appendNodeSeq(&n.Ninit, init)
+ n.Ninit.AppendNodes(&init)
n.Ullman = UINF
}
diff --git a/src/cmd/compile/internal/gc/range.go b/src/cmd/compile/internal/gc/range.go
index 43447b459..841c95b 100644
--- a/src/cmd/compile/internal/gc/range.go
+++ b/src/cmd/compile/internal/gc/range.go
@@ -31,11 +31,10 @@
if t == nil {
goto out
}
-
// delicate little dance. see typecheckas2
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- if it.N().Name == nil || it.N().Name.Defn != n {
- typecheck(it.P(), Erv|Easgn)
+ for i1, n1 := range n.List.Slice() {
+ if n1.Name == nil || n1.Name.Defn != n {
+ typecheck(&n.List.Slice()[i1], Erv|Easgn)
}
}
@@ -66,7 +65,7 @@
t1 = t.Type
t2 = nil
- if nodeSeqLen(n.List) == 2 {
+ if n.List.Len() == 2 {
toomany = 1
}
@@ -75,17 +74,17 @@
t2 = runetype
}
- if nodeSeqLen(n.List) > 2 || toomany != 0 {
+ if n.List.Len() > 2 || toomany != 0 {
Yyerror("too many variables in range")
}
v1 = nil
- if nodeSeqLen(n.List) != 0 {
- v1 = nodeSeqFirst(n.List)
+ if n.List.Len() != 0 {
+ v1 = n.List.First()
}
v2 = nil
- if nodeSeqLen(n.List) > 1 {
- v2 = nodeSeqSecond(n.List)
+ if n.List.Len() > 1 {
+ v2 = n.List.Second()
}
// this is not only a optimization but also a requirement in the spec.
@@ -94,7 +93,7 @@
// present."
if isblank(v2) {
if v1 != nil {
- setNodeSeq(&n.List, []*Node{v1})
+ n.List.Set([]*Node{v1})
}
v2 = nil
}
@@ -120,10 +119,9 @@
// second half of dance
out:
n.Typecheck = 1
-
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- if it.N().Typecheck == 0 {
- typecheck(it.P(), Erv|Easgn)
+ for i2, n2 := range n.List.Slice() {
+ if n2.Typecheck == 0 {
+ typecheck(&n.List.Slice()[i2], Erv|Easgn)
}
}
@@ -147,17 +145,17 @@
n.Right = nil
var v1 *Node
- if nodeSeqLen(n.List) != 0 {
- v1 = nodeSeqFirst(n.List)
+ if n.List.Len() != 0 {
+ v1 = n.List.First()
}
var v2 *Node
- if nodeSeqLen(n.List) > 1 && !isblank(nodeSeqSecond(n.List)) {
- v2 = nodeSeqSecond(n.List)
+ if n.List.Len() > 1 && !isblank(n.List.Second()) {
+ v2 = n.List.Second()
}
// n->list has no meaning anymore, clear it
// to avoid erroneous processing by racewalk.
- setNodeSeq(&n.List, nil)
+ n.List.Set(nil)
var body []*Node
var init []*Node
@@ -195,8 +193,8 @@
body = []*Node{Nod(OAS, v1, hv1)}
} else {
a := Nod(OAS2, nil, nil)
- setNodeSeq(&a.List, []*Node{v1, v2})
- setNodeSeq(&a.Rlist, []*Node{hv1, Nod(OIND, hp, nil)})
+ a.List.Set([]*Node{v1, v2})
+ a.Rlist.Set([]*Node{hv1, Nod(OIND, hp, nil)})
body = []*Node{a}
// Advance pointer as part of increment.
@@ -215,7 +213,7 @@
tmp.Right.Typecheck = 1
a = Nod(OAS, hp, tmp)
typecheck(&a, Etop)
- setNodeSeq(&n.Right.Ninit, []*Node{a})
+ n.Right.Ninit.Set([]*Node{a})
}
// orderstmt allocated the iterator for us.
@@ -250,8 +248,8 @@
val := Nod(ODOT, hit, valname)
val = Nod(OIND, val, nil)
a := Nod(OAS2, nil, nil)
- setNodeSeq(&a.List, []*Node{v1, v2})
- setNodeSeq(&a.Rlist, []*Node{key, val})
+ a.List.Set([]*Node{v1, v2})
+ a.Rlist.Set([]*Node{key, val})
body = []*Node{a}
}
@@ -271,9 +269,9 @@
n.Left = Nod(ONE, hb, Nodbool(false))
a := Nod(OAS2RECV, nil, nil)
a.Typecheck = 1
- setNodeSeq(&a.List, []*Node{hv1, hb})
- setNodeSeq(&a.Rlist, []*Node{Nod(ORECV, ha, nil)})
- setNodeSeq(&n.Left.Ninit, []*Node{a})
+ a.List.Set([]*Node{hv1, hb})
+ a.Rlist.Set([]*Node{Nod(ORECV, ha, nil)})
+ n.Left.Ninit.Set([]*Node{a})
if v1 == nil {
body = nil
} else {
@@ -296,13 +294,13 @@
} else {
hv2 = temp(runetype)
a = Nod(OAS2, nil, nil)
- setNodeSeq(&a.List, []*Node{hv1, hv2})
+ a.List.Set([]*Node{hv1, hv2})
fn := syslook("stringiter2")
- setNodeSeq(&a.Rlist, []*Node{mkcall1(fn, fn.Type.Results(), nil, ha, hv1)})
+ a.Rlist.Set([]*Node{mkcall1(fn, fn.Type.Results(), nil, ha, hv1)})
}
n.Left = Nod(ONE, hv1, Nodintconst(0))
- setNodeSeq(&n.Left.Ninit, []*Node{Nod(OAS, ohv1, hv1), a})
+ n.Left.Ninit.Set([]*Node{Nod(OAS, ohv1, hv1), a})
body = nil
if v1 != nil {
@@ -315,7 +313,7 @@
n.Op = OFOR
typechecklist(init, Etop)
- appendNodeSeq(&n.Ninit, init)
+ n.Ninit.Append(init...)
typechecklist(n.Left.Ninit.Slice(), Etop)
typecheck(&n.Left, Erv)
typecheck(&n.Right, Etop)
diff --git a/src/cmd/compile/internal/gc/select.go b/src/cmd/compile/internal/gc/select.go
index 16d7575..91cb086 100644
--- a/src/cmd/compile/internal/gc/select.go
+++ b/src/cmd/compile/internal/gc/select.go
@@ -13,28 +13,28 @@
lno := setlineno(sel)
count := 0
typechecklist(sel.Ninit.Slice(), Etop)
- for it := nodeSeqIterate(sel.List); !it.Done(); it.Next() {
+ for _, n1 := range sel.List.Slice() {
count++
- ncase = it.N()
+ ncase = n1
setlineno(ncase)
if ncase.Op != OXCASE {
Fatalf("typecheckselect %v", Oconv(ncase.Op, 0))
}
- if nodeSeqLen(ncase.List) == 0 {
+ if ncase.List.Len() == 0 {
// default
if def != nil {
Yyerror("multiple defaults in select (first at %v)", def.Line())
} else {
def = ncase
}
- } else if nodeSeqLen(ncase.List) > 1 {
+ } else if ncase.List.Len() > 1 {
Yyerror("select cases cannot be lists")
} else {
it2 := nodeSeqIterate(ncase.List)
n = typecheck(it2.P(), Etop)
ncase.Left = n
- setNodeSeq(&ncase.List, nil)
+ ncase.List.Set(nil)
setlineno(n)
switch n.Op {
default:
@@ -57,16 +57,16 @@
// convert x, ok = <-c into OSELRECV2(x, <-c) with ntest=ok
case OAS2RECV:
- if nodeSeqFirst(n.Rlist).Op != ORECV {
+ if n.Rlist.First().Op != ORECV {
Yyerror("select assignment must have receive on right hand side")
break
}
n.Op = OSELRECV2
- n.Left = nodeSeqFirst(n.List)
- setNodeSeq(&n.List, []*Node{nodeSeqSecond(n.List)})
- n.Right = nodeSeqFirst(n.Rlist)
- setNodeSeq(&n.Rlist, nil)
+ n.Left = n.List.First()
+ n.List.Set([]*Node{n.List.Second()})
+ n.Right = n.Rlist.First()
+ n.Rlist.Set(nil)
// convert <-c into OSELRECV(N, <-c)
case ORECV:
@@ -88,12 +88,12 @@
}
func walkselect(sel *Node) {
- if nodeSeqLen(sel.List) == 0 && sel.Xoffset != 0 {
+ if sel.List.Len() == 0 && sel.Xoffset != 0 {
Fatalf("double walkselect") // already rewrote
}
lno := setlineno(sel)
- i := nodeSeqLen(sel.List)
+ i := sel.List.Len()
// optimization: zero-case select
var init []*Node
@@ -111,13 +111,13 @@
// TODO(rsc): Reenable optimization once order.go can handle it.
// golang.org/issue/7672.
if i == 1 {
- cas := nodeSeqFirst(sel.List)
+ cas := sel.List.First()
setlineno(cas)
- l := nodeSeqSlice(cas.Ninit)
+ l := cas.Ninit.Slice()
if cas.Left != nil { // not default:
n := cas.Left
- l = append(l, nodeSeqSlice(n.Ninit)...)
- setNodeSeq(&n.Ninit, nil)
+ l = append(l, n.Ninit.Slice()...)
+ n.Ninit.Set(nil)
var ch *Node
switch n.Op {
default:
@@ -129,7 +129,7 @@
case OSELRECV, OSELRECV2:
ch = n.Right.Left
- if n.Op == OSELRECV || nodeSeqLen(n.List) == 0 {
+ if n.Op == OSELRECV || n.List.Len() == 0 {
if n.Left == nil {
n = n.Right
} else {
@@ -144,8 +144,8 @@
}
n.Op = OAS2
- setNodeSeq(&n.List, append([]*Node{n.Left}, nodeSeqSlice(n.List)...))
- setNodeSeq(&n.Rlist, []*Node{n.Right})
+ n.List.Set(append([]*Node{n.Left}, n.List.Slice()...))
+ n.Rlist.Set([]*Node{n.Right})
n.Right = nil
n.Left = nil
n.Typecheck = 0
@@ -185,7 +185,7 @@
typecheck(&n.Right, Erv)
case OSELRECV, OSELRECV2:
- if n.Op == OSELRECV2 && nodeSeqLen(n.List) == 0 {
+ if n.Op == OSELRECV2 && n.List.Len() == 0 {
n.Op = OSELRECV
}
if n.Op == OSELRECV2 {
@@ -204,21 +204,21 @@
}
// optimization: two-case select but one is default: single non-blocking op.
- if i == 2 && (nodeSeqFirst(sel.List).Left == nil || nodeSeqSecond(sel.List).Left == nil) {
+ if i == 2 && (sel.List.First().Left == nil || sel.List.Second().Left == nil) {
var cas *Node
var dflt *Node
- if nodeSeqFirst(sel.List).Left == nil {
- cas = nodeSeqSecond(sel.List)
- dflt = nodeSeqFirst(sel.List)
+ if sel.List.First().Left == nil {
+ cas = sel.List.Second()
+ dflt = sel.List.First()
} else {
- dflt = nodeSeqSecond(sel.List)
+ dflt = sel.List.Second()
cas = nodeSeqFirst(sel.List.Slice())
}
n := cas.Left
setlineno(n)
r := Nod(OIF, nil, nil)
- setNodeSeq(&r.Ninit, cas.Ninit)
+ r.Ninit.Set(cas.Ninit.Slice())
switch n.Op {
default:
Fatalf("select %v", Oconv(n.Op, 0))
@@ -233,7 +233,7 @@
case OSELRECV:
r = Nod(OIF, nil, nil)
- setNodeSeq(&r.Ninit, cas.Ninit)
+ r.Ninit.Set(cas.Ninit.Slice())
ch := n.Right.Left
r.Left = mkcall1(chanfn("selectnbrecv", 2, ch.Type), Types[TBOOL], &r.Ninit, typename(ch.Type), n.Left, ch)
@@ -241,20 +241,20 @@
case OSELRECV2:
r = Nod(OIF, nil, nil)
- setNodeSeq(&r.Ninit, cas.Ninit)
+ r.Ninit.Set(cas.Ninit.Slice())
ch := n.Right.Left
- r.Left = mkcall1(chanfn("selectnbrecv2", 2, ch.Type), Types[TBOOL], &r.Ninit, typename(ch.Type), n.Left, nodeSeqFirst(n.List), ch)
+ r.Left = mkcall1(chanfn("selectnbrecv2", 2, ch.Type), Types[TBOOL], &r.Ninit, typename(ch.Type), n.Left, n.List.First(), ch)
}
typecheck(&r.Left, Erv)
r.Nbody.Set(cas.Nbody.Slice())
- setNodeSeq(&r.Rlist, append(nodeSeqSlice(dflt.Ninit), dflt.Nbody.Slice()...))
+ r.Rlist.Set(append(dflt.Ninit.Slice(), dflt.Nbody.Slice()...))
sel.Nbody.Set([]*Node{r})
goto out
}
- init = nodeSeqSlice(sel.Ninit)
- setNodeSeq(&sel.Ninit, nil)
+ init = sel.Ninit.Slice()
+ sel.Ninit.Set(nil)
// generate sel-struct
setlineno(sel)
@@ -267,18 +267,16 @@
r = mkcall("newselect", nil, nil, var_, Nodintconst(selv.Type.Width), Nodintconst(sel.Xoffset))
typecheck(&r, Etop)
init = append(init, r)
-
// register cases
- for it := nodeSeqIterate(sel.List); !it.Done(); it.Next() {
- cas = it.N()
+ for _, cas = range sel.List.Slice() {
setlineno(cas)
n = cas.Left
r = Nod(OIF, nil, nil)
- setNodeSeq(&r.Ninit, cas.Ninit)
- setNodeSeq(&cas.Ninit, nil)
+ r.Ninit.Set(cas.Ninit.Slice())
+ cas.Ninit.Set(nil)
if n != nil {
- appendNodeSeq(&r.Ninit, n.Ninit)
- setNodeSeq(&n.Ninit, nil)
+ r.Ninit.AppendNodes(&n.Ninit)
+ n.Ninit.Set(nil)
}
if n == nil {
@@ -299,7 +297,7 @@
// selectrecv2(sel *byte, hchan *chan any, elem *any, received *bool) (selected bool);
case OSELRECV2:
- r.Left = mkcall1(chanfn("selectrecv2", 2, n.Right.Left.Type), Types[TBOOL], &r.Ninit, var_, n.Right.Left, n.Left, nodeSeqFirst(n.List))
+ r.Left = mkcall1(chanfn("selectrecv2", 2, n.Right.Left.Type), Types[TBOOL], &r.Ninit, var_, n.Right.Left, n.Left, n.List.First())
}
}
@@ -318,7 +316,7 @@
sel.Nbody.Set(init)
out:
- setNodeSeq(&sel.List, nil)
+ sel.List.Set(nil)
walkstmtlist(sel.Nbody.Slice())
lineno = lno
}
@@ -329,41 +327,41 @@
// and then cache; and also cache Select per size.
sudog := Nod(OTSTRUCT, nil, nil)
- appendNodeSeqNode(&sudog.List, Nod(ODCLFIELD, newname(Lookup("g")), typenod(Ptrto(Types[TUINT8]))))
- appendNodeSeqNode(&sudog.List, Nod(ODCLFIELD, newname(Lookup("selectdone")), typenod(Ptrto(Types[TUINT8]))))
- appendNodeSeqNode(&sudog.List, Nod(ODCLFIELD, newname(Lookup("next")), typenod(Ptrto(Types[TUINT8]))))
- appendNodeSeqNode(&sudog.List, Nod(ODCLFIELD, newname(Lookup("prev")), typenod(Ptrto(Types[TUINT8]))))
- appendNodeSeqNode(&sudog.List, Nod(ODCLFIELD, newname(Lookup("elem")), typenod(Ptrto(Types[TUINT8]))))
- appendNodeSeqNode(&sudog.List, Nod(ODCLFIELD, newname(Lookup("releasetime")), typenod(Types[TUINT64])))
- appendNodeSeqNode(&sudog.List, Nod(ODCLFIELD, newname(Lookup("nrelease")), typenod(Types[TINT32])))
- appendNodeSeqNode(&sudog.List, Nod(ODCLFIELD, newname(Lookup("waitlink")), typenod(Ptrto(Types[TUINT8]))))
+ sudog.List.Append(Nod(ODCLFIELD, newname(Lookup("g")), typenod(Ptrto(Types[TUINT8]))))
+ sudog.List.Append(Nod(ODCLFIELD, newname(Lookup("selectdone")), typenod(Ptrto(Types[TUINT8]))))
+ sudog.List.Append(Nod(ODCLFIELD, newname(Lookup("next")), typenod(Ptrto(Types[TUINT8]))))
+ sudog.List.Append(Nod(ODCLFIELD, newname(Lookup("prev")), typenod(Ptrto(Types[TUINT8]))))
+ sudog.List.Append(Nod(ODCLFIELD, newname(Lookup("elem")), typenod(Ptrto(Types[TUINT8]))))
+ sudog.List.Append(Nod(ODCLFIELD, newname(Lookup("releasetime")), typenod(Types[TUINT64])))
+ sudog.List.Append(Nod(ODCLFIELD, newname(Lookup("nrelease")), typenod(Types[TINT32])))
+ sudog.List.Append(Nod(ODCLFIELD, newname(Lookup("waitlink")), typenod(Ptrto(Types[TUINT8]))))
typecheck(&sudog, Etype)
sudog.Type.Noalg = true
sudog.Type.Local = true
scase := Nod(OTSTRUCT, nil, nil)
- appendNodeSeqNode(&scase.List, Nod(ODCLFIELD, newname(Lookup("elem")), typenod(Ptrto(Types[TUINT8]))))
- appendNodeSeqNode(&scase.List, Nod(ODCLFIELD, newname(Lookup("chan")), typenod(Ptrto(Types[TUINT8]))))
- appendNodeSeqNode(&scase.List, Nod(ODCLFIELD, newname(Lookup("pc")), typenod(Types[TUINTPTR])))
- appendNodeSeqNode(&scase.List, Nod(ODCLFIELD, newname(Lookup("kind")), typenod(Types[TUINT16])))
- appendNodeSeqNode(&scase.List, Nod(ODCLFIELD, newname(Lookup("so")), typenod(Types[TUINT16])))
- appendNodeSeqNode(&scase.List, Nod(ODCLFIELD, newname(Lookup("receivedp")), typenod(Ptrto(Types[TUINT8]))))
- appendNodeSeqNode(&scase.List, Nod(ODCLFIELD, newname(Lookup("releasetime")), typenod(Types[TUINT64])))
+ scase.List.Append(Nod(ODCLFIELD, newname(Lookup("elem")), typenod(Ptrto(Types[TUINT8]))))
+ scase.List.Append(Nod(ODCLFIELD, newname(Lookup("chan")), typenod(Ptrto(Types[TUINT8]))))
+ scase.List.Append(Nod(ODCLFIELD, newname(Lookup("pc")), typenod(Types[TUINTPTR])))
+ scase.List.Append(Nod(ODCLFIELD, newname(Lookup("kind")), typenod(Types[TUINT16])))
+ scase.List.Append(Nod(ODCLFIELD, newname(Lookup("so")), typenod(Types[TUINT16])))
+ scase.List.Append(Nod(ODCLFIELD, newname(Lookup("receivedp")), typenod(Ptrto(Types[TUINT8]))))
+ scase.List.Append(Nod(ODCLFIELD, newname(Lookup("releasetime")), typenod(Types[TUINT64])))
typecheck(&scase, Etype)
scase.Type.Noalg = true
scase.Type.Local = true
sel := Nod(OTSTRUCT, nil, nil)
- appendNodeSeqNode(&sel.List, Nod(ODCLFIELD, newname(Lookup("tcase")), typenod(Types[TUINT16])))
- appendNodeSeqNode(&sel.List, Nod(ODCLFIELD, newname(Lookup("ncase")), typenod(Types[TUINT16])))
- appendNodeSeqNode(&sel.List, Nod(ODCLFIELD, newname(Lookup("pollorder")), typenod(Ptrto(Types[TUINT8]))))
- appendNodeSeqNode(&sel.List, Nod(ODCLFIELD, newname(Lookup("lockorder")), typenod(Ptrto(Types[TUINT8]))))
+ sel.List.Append(Nod(ODCLFIELD, newname(Lookup("tcase")), typenod(Types[TUINT16])))
+ sel.List.Append(Nod(ODCLFIELD, newname(Lookup("ncase")), typenod(Types[TUINT16])))
+ sel.List.Append(Nod(ODCLFIELD, newname(Lookup("pollorder")), typenod(Ptrto(Types[TUINT8]))))
+ sel.List.Append(Nod(ODCLFIELD, newname(Lookup("lockorder")), typenod(Ptrto(Types[TUINT8]))))
arr := Nod(OTARRAY, Nodintconst(int64(size)), scase)
- appendNodeSeqNode(&sel.List, Nod(ODCLFIELD, newname(Lookup("scase")), arr))
+ sel.List.Append(Nod(ODCLFIELD, newname(Lookup("scase")), arr))
arr = Nod(OTARRAY, Nodintconst(int64(size)), typenod(Ptrto(Types[TUINT8])))
- appendNodeSeqNode(&sel.List, Nod(ODCLFIELD, newname(Lookup("lockorderarr")), arr))
+ sel.List.Append(Nod(ODCLFIELD, newname(Lookup("lockorderarr")), arr))
arr = Nod(OTARRAY, Nodintconst(int64(size)), typenod(Types[TUINT16]))
- appendNodeSeqNode(&sel.List, Nod(ODCLFIELD, newname(Lookup("pollorderarr")), arr))
+ sel.List.Append(Nod(ODCLFIELD, newname(Lookup("pollorderarr")), arr))
typecheck(&sel, Etype)
sel.Type.Noalg = true
sel.Type.Local = true
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index a0ec4cc..4b73001 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -30,8 +30,8 @@
}
init1(n.Left, out)
init1(n.Right, out)
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- init1(it.N(), out)
+ for _, n1 := range n.List.Slice() {
+ init1(n1, out)
}
if n.Left != nil && n.Type != nil && n.Left.Op == OTYPE && n.Class == PFUNC {
@@ -128,8 +128,8 @@
break
}
defn.Initorder = InitPending
- for it := nodeSeqIterate(defn.Rlist); !it.Done(); it.Next() {
- init1(it.N(), out)
+ for _, n2 := range defn.Rlist.Slice() {
+ init1(n2, out)
}
if Debug['%'] != 0 {
Dump("nonstatic", defn)
@@ -192,7 +192,7 @@
return
}
- if n.Op == ONAME && nodeSeqLen(n.Ninit) != 0 {
+ if n.Op == ONAME && n.Ninit.Len() != 0 {
Fatalf("name %v with ninit: %v\n", n.Sym, Nconv(n, obj.FmtSign))
}
@@ -213,23 +213,21 @@
}
func init2list(l Nodes, out *[]*Node) {
- for it := nodeSeqIterate(l); !it.Done(); it.Next() {
- init2(it.N(), out)
+ for _, n := range l.Slice() {
+ init2(n, out)
}
}
func initreorder(l []*Node, out *[]*Node) {
var n *Node
-
- for it := nodeSeqIterate(l); !it.Done(); it.Next() {
- n = it.N()
+ for _, n = range l {
switch n.Op {
case ODCLFUNC, ODCLCONST, ODCLTYPE:
continue
}
initreorder(n.Ninit.Slice(), out)
- setNodeSeq(&n.Ninit, nil)
+ n.Ninit.Set(nil)
init1(n, out)
}
}
@@ -558,9 +556,8 @@
case OSTRUCTLIT:
break
}
-
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- value := it.N().Right
+ for _, n1 := range n.List.Slice() {
+ value := n1.Right
mode |= getdyn(value, 0)
if mode == MODEDYNAM|MODECONST {
break
@@ -571,8 +568,7 @@
}
func structlit(ctxt int, pass int, n *Node, var_ *Node, init *Nodes) {
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- r := it.N()
+ for _, r := range n.List.Slice() {
if r.Op != OKEY {
Fatalf("structlit: rhs not OKEY: %v", r)
}
@@ -636,8 +632,7 @@
}
func arraylit(ctxt int, pass int, n *Node, var_ *Node, init *Nodes) {
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- r := it.N()
+ for _, r := range n.List.Slice() {
if r.Op != OKEY {
Fatalf("arraylit: rhs not OKEY: %v", r)
}
@@ -784,7 +779,7 @@
a = Nod(OADDR, a, nil)
} else {
a = Nod(ONEW, nil, nil)
- setNodeSeq(&a.List, []*Node{typenod(t)})
+ a.List.Set([]*Node{typenod(t)})
}
a = Nod(OAS, vauto, a)
@@ -809,10 +804,8 @@
orderstmtinplace(&a)
walkstmt(&a)
init.Append(a)
-
// put dynamics into slice (6)
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- r := it.N()
+ for _, r := range n.List.Slice() {
if r.Op != OKEY {
Fatalf("slicelit: rhs not OKEY: %v", r)
}
@@ -858,13 +851,12 @@
nerr := nerrors
a := Nod(OMAKE, nil, nil)
- setNodeSeq(&a.List, []*Node{typenod(n.Type)})
+ a.List.Set([]*Node{typenod(n.Type)})
litas(var_, a, init)
// count the initializers
b := 0
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- r := it.N()
+ for _, r := range n.List.Slice() {
if r.Op != OKEY {
Fatalf("maplit: rhs not OKEY: %v", r)
}
@@ -907,9 +899,7 @@
vstat := staticname(tarr, ctxt)
b := int64(0)
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- r := it.N()
-
+ for _, r := range n.List.Slice() {
if r.Op != OKEY {
Fatalf("maplit: rhs not OKEY: %v", r)
}
@@ -965,7 +955,7 @@
a = Nod(OFOR, nil, nil)
a.Nbody.Set([]*Node{r})
- setNodeSeq(&a.Ninit, []*Node{Nod(OAS, index, Nodintconst(0))})
+ a.Ninit.Set([]*Node{Nod(OAS, index, Nodintconst(0))})
a.Left = Nod(OLT, index, Nodintconst(tarr.Bound))
a.Right = Nod(OAS, index, Nod(OADD, index, Nodintconst(1)))
@@ -976,9 +966,7 @@
// put in dynamic entries one-at-a-time
var key, val *Node
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- r := it.N()
-
+ for _, r := range n.List.Slice() {
if r.Op != OKEY {
Fatalf("maplit: rhs not OKEY: %v", r)
}
@@ -1065,7 +1053,7 @@
Fatalf("anylit: not struct")
}
- if simplename(var_) && nodeSeqLen(n.List) > 4 {
+ if simplename(var_) && n.List.Len() > 4 {
if ctxt == 0 {
// lay out static data
vstat := staticname(t, ctxt)
@@ -1091,7 +1079,7 @@
}
// initialize of not completely specified
- if simplename(var_) || nodeSeqLen(n.List) < structcount(t) {
+ if simplename(var_) || n.List.Len() < structcount(t) {
a := Nod(OAS, var_, nil)
typecheck(&a, Etop)
walkexpr(&a, init)
@@ -1109,7 +1097,7 @@
break
}
- if simplename(var_) && nodeSeqLen(n.List) > 4 {
+ if simplename(var_) && n.List.Len() > 4 {
if ctxt == 0 {
// lay out static data
vstat := staticname(t, ctxt)
@@ -1135,7 +1123,7 @@
}
// initialize of not completely specified
- if simplename(var_) || int64(nodeSeqLen(n.List)) < t.Bound {
+ if simplename(var_) || int64(n.List.Len()) < t.Bound {
a := Nod(OAS, var_, nil)
typecheck(&a, Etop)
walkexpr(&a, init)
@@ -1257,8 +1245,7 @@
Fatalf("initplan")
case OARRAYLIT:
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- a := it.N()
+ for _, a := range n.List.Slice() {
if a.Op != OKEY || !Smallintconst(a.Left) {
Fatalf("initplan arraylit")
}
@@ -1266,8 +1253,7 @@
}
case OSTRUCTLIT:
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- a := it.N()
+ for _, a := range n.List.Slice() {
if a.Op != OKEY || a.Left.Type == nil {
Fatalf("initplan structlit")
}
@@ -1275,8 +1261,7 @@
}
case OMAPLIT:
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- a := it.N()
+ for _, a := range n.List.Slice() {
if a.Op != OKEY {
Fatalf("initplan maplit")
}
@@ -1351,8 +1336,8 @@
// fall through
case OSTRUCTLIT:
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- if !iszero(it.N().Right) {
+ for _, n1 := range n.List.Slice() {
+ if !iszero(n1.Right) {
return false
}
}
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 8027a90..e124d02b 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -510,8 +510,8 @@
// ssaStmtList converts the statement n to SSA and adds it to s.
func (s *state) stmtList(l Nodes) {
- for it := nodeSeqIterate(l); !it.Done(); it.Next() {
- s.stmt(it.N())
+ for _, n := range l.Slice() {
+ s.stmt(n)
}
}
@@ -559,9 +559,9 @@
s.call(n.Left, callGo)
case OAS2DOTTYPE:
- res, resok := s.dottype(nodeSeqFirst(n.Rlist), true)
- s.assign(nodeSeqFirst(n.List), res, needwritebarrier(nodeSeqFirst(n.List), nodeSeqFirst(n.Rlist)), false, n.Lineno)
- s.assign(nodeSeqSecond(n.List), resok, false, false, n.Lineno)
+ res, resok := s.dottype(n.Rlist.First(), true)
+ s.assign(n.List.First(), res, needwritebarrier(n.List.First(), n.Rlist.First()), false, n.Lineno)
+ s.assign(n.List.Second(), resok, false, false, n.Lineno)
return
case ODCL:
@@ -702,7 +702,7 @@
bThen := s.f.NewBlock(ssa.BlockPlain)
bEnd := s.f.NewBlock(ssa.BlockPlain)
var bElse *ssa.Block
- if nodeSeqLen(n.Rlist) != 0 {
+ if n.Rlist.Len() != 0 {
bElse = s.f.NewBlock(ssa.BlockPlain)
s.condBranch(n.Left, bThen, bElse, n.Likely)
} else {
@@ -715,7 +715,7 @@
b.AddEdgeTo(bEnd)
}
- if nodeSeqLen(n.Rlist) != 0 {
+ if n.Rlist.Len() != 0 {
s.startBlock(bElse)
s.stmtList(n.Rlist)
if b := s.endBlock(); b != nil {
@@ -2025,14 +2025,14 @@
pt := Ptrto(et)
// Evaluate slice
- slice := s.expr(nodeSeqFirst(n.List))
+ slice := s.expr(n.List.First())
// Allocate new blocks
grow := s.f.NewBlock(ssa.BlockPlain)
assign := s.f.NewBlock(ssa.BlockPlain)
// Decide if we need to grow
- nargs := int64(nodeSeqLen(n.List) - 1)
+ nargs := int64(n.List.Len() - 1)
p := s.newValue1(ssa.OpSlicePtr, pt, slice)
l := s.newValue1(ssa.OpSliceLen, Types[TINT], slice)
c := s.newValue1(ssa.OpSliceCap, Types[TINT], slice)
diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 4d4be84..b264717 100644
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -536,7 +536,7 @@
m.Orig = m
m.Left = treecopy(n.Left, lineno)
m.Right = treecopy(n.Right, lineno)
- setNodeSeq(&m.List, listtreecopy(n.List.Slice(), lineno))
+ m.List.Set(listtreecopy(n.List.Slice(), lineno))
if lineno != 0 {
m.Lineno = lineno
}
@@ -1379,7 +1379,7 @@
var ul int
var ur int
- if nodeSeqLen(n.Ninit) != 0 {
+ if n.Ninit.Len() != 0 {
ul = UINF
goto out
}
@@ -1497,7 +1497,7 @@
return nil
}
- if nodeSeqLen(n.Ninit) != 0 {
+ if n.Ninit.Len() != 0 {
walkstmtlist(n.Ninit.Slice())
init.AppendNodes(&n.Ninit)
}
@@ -1968,8 +1968,8 @@
l = append(l, pad)
}
- setNodeSeq(&t.List, append(l, in...))
- setNodeSeq(&t.Rlist, out)
+ t.List.Set(append(l, in...))
+ t.Rlist.Set(out)
fn := Nod(ODCLFUNC, nil, nil)
fn.Func.Nname = newname(newnam)
@@ -2008,7 +2008,7 @@
v.U = method.Sym.Name
l = append(l, nodlit(v)) // method name
call := Nod(OCALL, syslook("panicwrap"), nil)
- setNodeSeq(&call.List, l)
+ call.List.Set(l)
n.Nbody.Set([]*Node{call})
fn.Nbody.Append(n)
}
@@ -2031,11 +2031,11 @@
} else {
fn.Func.Wrapper = true // ignore frame for panic+recover matching
call := Nod(OCALL, dot, nil)
- setNodeSeq(&call.List, args)
+ call.List.Set(args)
call.Isddd = isddd
if method.Type.Outtuple > 0 {
n := Nod(ORETURN, nil, nil)
- setNodeSeq(&n.List, []*Node{call})
+ n.List.Set([]*Node{call})
call = n
}
@@ -2069,10 +2069,10 @@
n := newname(sym)
n.Class = PFUNC
tfn := Nod(OTFUNC, nil, nil)
- appendNodeSeqNode(&tfn.List, Nod(ODCLFIELD, nil, typenod(Ptrto(t))))
- appendNodeSeqNode(&tfn.List, Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
- appendNodeSeqNode(&tfn.List, Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
- appendNodeSeqNode(&tfn.Rlist, Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
+ tfn.List.Append(Nod(ODCLFIELD, nil, typenod(Ptrto(t))))
+ tfn.List.Append(Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
+ tfn.List.Append(Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
+ tfn.Rlist.Append(Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
typecheck(&tfn, Etype)
n.Type = tfn.Type
return n
@@ -2218,15 +2218,15 @@
func listtreecopy(l []*Node, lineno int32) []*Node {
var out []*Node
- for it := nodeSeqIterate(l); !it.Done(); it.Next() {
- out = append(out, treecopy(it.N(), lineno))
+ for _, n := range l {
+ out = append(out, treecopy(n, lineno))
}
return out
}
func liststmt(l []*Node) *Node {
n := Nod(OBLOCK, nil, nil)
- setNodeSeq(&n.List, l)
+ n.List.Set(l)
if nodeSeqLen(l) != 0 {
n.Lineno = nodeSeqFirst(l).Lineno
}
@@ -2573,7 +2573,7 @@
*np = n
}
- setNodeSeq(&n.Ninit, append(nodeSeqSlice(init), nodeSeqSlice(n.Ninit)...))
+ n.Ninit.Set(append(nodeSeqSlice(init), n.Ninit.Slice()...))
n.Ullman = UINF
}
diff --git a/src/cmd/compile/internal/gc/swt.go b/src/cmd/compile/internal/gc/swt.go
index 070f2ca..d54e4d6 100644
--- a/src/cmd/compile/internal/gc/swt.go
+++ b/src/cmd/compile/internal/gc/swt.go
@@ -105,10 +105,9 @@
n.Type = t
var def *Node
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- ncase := it.N()
+ for _, ncase := range n.List.Slice() {
setlineno(n)
- if nodeSeqLen(ncase.List) == 0 {
+ if ncase.List.Len() == 0 {
// default
if def != nil {
Yyerror("multiple defaults in switch (first at %v)", def.Line())
@@ -116,30 +115,30 @@
def = ncase
}
} else {
- for it2 := nodeSeqIterate(ncase.List); !it2.Done(); it2.Next() {
- setlineno(it2.N())
- typecheck(it2.P(), Erv|Etype)
- if it2.N().Type == nil || t == nil {
+ for i1, n1 := range ncase.List.Slice() {
+ setlineno(n1)
+ typecheck(&ncase.List.Slice()[i1], Erv|Etype)
+ if ncase.List.Slice()[i1].Type == nil || t == nil {
continue
}
setlineno(ncase)
switch top {
// expression switch
case Erv:
- defaultlit(it2.P(), t)
+ defaultlit(&ncase.List.Slice()[i1], t)
switch {
- case it2.N().Op == OTYPE:
- Yyerror("type %v is not an expression", it2.N().Type)
- case it2.N().Type != nil && assignop(it2.N().Type, t, nil) == 0 && assignop(t, it2.N().Type, nil) == 0:
+ case ncase.List.Slice()[i1].Op == OTYPE:
+ Yyerror("type %v is not an expression", ncase.List.Slice()[i1].Type)
+ case ncase.List.Slice()[i1].Type != nil && assignop(ncase.List.Slice()[i1].Type, t, nil) == 0 && assignop(t, ncase.List.Slice()[i1].Type, nil) == 0:
if n.Left != nil {
- Yyerror("invalid case %v in switch on %v (mismatched types %v and %v)", it2.N(), n.Left, it2.N().Type, t)
+ Yyerror("invalid case %v in switch on %v (mismatched types %v and %v)", ncase.List.Slice()[i1], n.Left, ncase.List.Slice()[i1].Type, t)
} else {
- Yyerror("invalid case %v in switch (mismatched types %v and bool)", it2.N(), it2.N().Type)
+ Yyerror("invalid case %v in switch (mismatched types %v and bool)", ncase.List.Slice()[i1], ncase.List.Slice()[i1].Type)
}
- case nilonly != "" && !isnil(it2.N()):
- Yyerror("invalid case %v in switch (can only compare %s %v to nil)", it2.N(), nilonly, n.Left)
- case Isinter(t) && !Isinter(it2.N().Type) && algtype1(it2.N().Type, nil) == ANOEQ:
- Yyerror("invalid case %v in switch (incomparable type)", Nconv(it2.N(), obj.FmtLong))
+ case nilonly != "" && !isnil(ncase.List.Slice()[i1]):
+ Yyerror("invalid case %v in switch (can only compare %s %v to nil)", ncase.List.Slice()[i1], nilonly, n.Left)
+ case Isinter(t) && !Isinter(ncase.List.Slice()[i1].Type) && algtype1(ncase.List.Slice()[i1].Type, nil) == ANOEQ:
+ Yyerror("invalid case %v in switch (incomparable type)", Nconv(ncase.List.Slice()[i1], obj.FmtLong))
}
// type switch
@@ -147,16 +146,16 @@
var missing, have *Type
var ptr int
switch {
- case it2.N().Op == OLITERAL && Istype(it2.N().Type, TNIL):
- case it2.N().Op != OTYPE && it2.N().Type != nil: // should this be ||?
- Yyerror("%v is not a type", Nconv(it2.N(), obj.FmtLong))
+ case ncase.List.Slice()[i1].Op == OLITERAL && Istype(ncase.List.Slice()[i1].Type, TNIL):
+ case ncase.List.Slice()[i1].Op != OTYPE && ncase.List.Slice()[i1].Type != nil: // should this be ||?
+ Yyerror("%v is not a type", Nconv(ncase.List.Slice()[i1], obj.FmtLong))
// reset to original type
- *it2.P() = n.Left.Right
- case it2.N().Type.Etype != TINTER && t.Etype == TINTER && !implements(it2.N().Type, t, &missing, &have, &ptr):
+ ncase.List.Slice()[i1] = n.Left.Right
+ case ncase.List.Slice()[i1].Type.Etype != TINTER && t.Etype == TINTER && !implements(ncase.List.Slice()[i1].Type, t, &missing, &have, &ptr):
if have != nil && !missing.Broke && !have.Broke {
- Yyerror("impossible type switch case: %v cannot have dynamic type %v"+" (wrong type for %v method)\n\thave %v%v\n\twant %v%v", Nconv(n.Left.Right, obj.FmtLong), it2.N().Type, missing.Sym, have.Sym, Tconv(have.Type, obj.FmtShort), missing.Sym, Tconv(missing.Type, obj.FmtShort))
+ Yyerror("impossible type switch case: %v cannot have dynamic type %v"+" (wrong type for %v method)\n\thave %v%v\n\twant %v%v", Nconv(n.Left.Right, obj.FmtLong), ncase.List.Slice()[i1].Type, missing.Sym, have.Sym, Tconv(have.Type, obj.FmtShort), missing.Sym, Tconv(missing.Type, obj.FmtShort))
} else if !missing.Broke {
- Yyerror("impossible type switch case: %v cannot have dynamic type %v"+" (missing %v method)", Nconv(n.Left.Right, obj.FmtLong), it2.N().Type, missing.Sym)
+ Yyerror("impossible type switch case: %v cannot have dynamic type %v"+" (missing %v method)", Nconv(n.Left.Right, obj.FmtLong), ncase.List.Slice()[i1].Type, missing.Sym)
}
}
}
@@ -165,11 +164,11 @@
if top == Etype && n.Type != nil {
ll := ncase.List
- if nodeSeqLen(ncase.Rlist) != 0 {
- nvar := nodeSeqFirst(ncase.Rlist)
- if nodeSeqLen(ll) == 1 && nodeSeqFirst(ll).Type != nil && !Istype(nodeSeqFirst(ll).Type, TNIL) {
+ if ncase.Rlist.Len() != 0 {
+ nvar := ncase.Rlist.First()
+ if ll.Len() == 1 && ll.First().Type != nil && !Istype(ll.First().Type, TNIL) {
// single entry type switch
- nvar.Name.Param.Ntype = typenod(nodeSeqFirst(ll).Type)
+ nvar.Name.Param.Ntype = typenod(ll.First().Type)
} else {
// multiple entry type switch or default
nvar.Name.Param.Ntype = typenod(n.Type)
@@ -244,7 +243,7 @@
// enumerate the cases, and lop off the default case
cc := caseClauses(sw, s.kind)
- setNodeSeq(&sw.List, nil)
+ sw.List.Set(nil)
var def *Node
if len(cc) > 0 && cc[0].typ == caseKindDefault {
def = cc[0].node.Right
@@ -326,7 +325,7 @@
}
typecheck(&a.Left, Erv)
a.Nbody.Set([]*Node{s.walkCases(cc[:half])})
- setNodeSeq(&a.Rlist, []*Node{s.walkCases(cc[half:])})
+ a.Rlist.Set([]*Node{s.walkCases(cc[half:])})
return a
}
@@ -334,7 +333,7 @@
// It makes labels between cases and statements
// and deals with fallthrough, break, and unreachable statements.
func casebody(sw *Node, typeswvar *Node) {
- if nodeSeqLen(sw.List) == 0 {
+ if sw.List.Len() == 0 {
return
}
@@ -352,10 +351,10 @@
Fatalf("casebody %v", Oconv(n.Op, 0))
}
n.Op = OCASE
- needvar := nodeSeqLen(n.List) != 1 || nodeSeqFirst(n.List).Op == OLITERAL
+ needvar := n.List.Len() != 1 || n.List.First().Op == OLITERAL
jmp := Nod(OGOTO, newCaseLabel(), nil)
- if nodeSeqLen(n.List) == 0 {
+ if n.List.Len() == 0 {
if def != nil {
Yyerror("more than one default case")
}
@@ -364,24 +363,24 @@
def = n
}
- if nodeSeqLen(n.List) == 1 {
+ if n.List.Len() == 1 {
// one case -- reuse OCASE node
- n.Left = nodeSeqFirst(n.List)
+ n.Left = n.List.First()
n.Right = jmp
- setNodeSeq(&n.List, nil)
+ n.List.Set(nil)
cas = append(cas, n)
} else {
// expand multi-valued cases
- for lcit := nodeSeqIterate(n.List); !lcit.Done(); lcit.Next() {
- cas = append(cas, Nod(OCASE, lcit.N(), jmp))
+ for _, n1 := range n.List.Slice() {
+ cas = append(cas, Nod(OCASE, n1, jmp))
}
}
stat = append(stat, Nod(OLABEL, jmp.Left, nil))
- if typeswvar != nil && needvar && nodeSeqLen(n.Rlist) != 0 {
+ if typeswvar != nil && needvar && n.Rlist.Len() != 0 {
l := []*Node{
- Nod(ODCL, nodeSeqFirst(n.Rlist), nil),
- Nod(OAS, nodeSeqFirst(n.Rlist), typeswvar),
+ Nod(ODCL, n.Rlist.First(), nil),
+ Nod(OAS, n.Rlist.First(), typeswvar),
}
typecheckslice(l, Etop)
stat = append(stat, l...)
@@ -412,7 +411,7 @@
cas = append(cas, def)
}
- setNodeSeq(&sw.List, cas)
+ sw.List.Set(cas)
sw.Nbody.Set(stat)
lineno = lno
}
@@ -432,8 +431,7 @@
// Kind is the kind of switch statement.
func caseClauses(sw *Node, kind int) []*caseClause {
var cc []*caseClause
- for it := nodeSeqIterate(sw.List); !it.Done(); it.Next() {
- n := it.N()
+ for _, n := range sw.List.Slice() {
c := new(caseClause)
cc = append(cc, c)
c.ordinal = len(cc)
@@ -518,7 +516,7 @@
sw.Left = nil
if cond == nil {
- setNodeSeq(&sw.List, nil)
+ sw.List.Set(nil)
return
}
if cond.Right == nil {
@@ -552,7 +550,7 @@
casebody(sw, s.facename)
cc := caseClauses(sw, switchKindType)
- setNodeSeq(&sw.List, nil)
+ sw.List.Set(nil)
var def *Node
if len(cc) > 0 && cc[0].typ == caseKindDefault {
def = cc[0].node.Right
@@ -588,7 +586,7 @@
i.Nbody.Set([]*Node{Nod(OGOTO, lbl, nil)})
// Wrap default case with label.
blk := Nod(OBLOCK, nil, nil)
- setNodeSeq(&blk.List, []*Node{Nod(OLABEL, lbl, nil), def})
+ blk.List.Set([]*Node{Nod(OLABEL, lbl, nil), def})
def = blk
}
typecheck(&i.Left, Erv)
@@ -669,7 +667,7 @@
if nerrors == 0 {
cas = append(cas, def)
sw.Nbody.Set(append(cas, sw.Nbody.Slice()...))
- setNodeSeq(&sw.List, nil)
+ sw.List.Set(nil)
walkstmtlist(sw.Nbody.Slice())
}
}
@@ -679,11 +677,11 @@
func (s *typeSwitch) typeone(t *Node) *Node {
var name *Node
var init []*Node
- if nodeSeqLen(t.Rlist) == 0 {
+ if t.Rlist.Len() == 0 {
name = nblank
typecheck(&nblank, Erv|Easgn)
} else {
- name = nodeSeqFirst(t.Rlist)
+ name = t.Rlist.First()
init = []*Node{Nod(ODCL, name, nil)}
a := Nod(OAS, name, nil)
typecheck(&a, Etop)
@@ -691,10 +689,10 @@
}
a := Nod(OAS2, nil, nil)
- setNodeSeq(&a.List, []*Node{name, s.okname}) // name, ok =
+ a.List.Set([]*Node{name, s.okname}) // name, ok =
b := Nod(ODOTTYPE, s.facename, nil)
b.Type = t.Left.Type // interface.(type)
- setNodeSeq(&a.Rlist, []*Node{b})
+ a.Rlist.Set([]*Node{b})
typecheck(&a, Etop)
init = append(init, a)
@@ -729,7 +727,7 @@
a.Left = Nod(OLE, s.hashname, Nodintconst(int64(cc[half-1].hash)))
typecheck(&a.Left, Erv)
a.Nbody.Set([]*Node{s.walkCases(cc[:half])})
- setNodeSeq(&a.Rlist, []*Node{s.walkCases(cc[half:])})
+ a.Rlist.Set([]*Node{s.walkCases(cc[half:])})
return a
}
diff --git a/src/cmd/compile/internal/gc/syntax.go b/src/cmd/compile/internal/gc/syntax.go
index 6ac1f29..59748ea 100644
--- a/src/cmd/compile/internal/gc/syntax.go
+++ b/src/cmd/compile/internal/gc/syntax.go
@@ -429,6 +429,26 @@
return *n.slice
}
+// Len returns the number of entries in Nodes.
+func (n *Nodes) Len() int {
+ if n.slice == nil {
+ return 0
+ }
+ return len(*n.slice)
+}
+
+// First returns the first element of Nodes.
+// It panics if Nodes has no elements.
+func (n *Nodes) First() *Node {
+ return (*n.slice)[0]
+}
+
+// Second returns the second element of Nodes.
+// It panics if Nodes has fewer than two elements.
+func (n *Nodes) Second() *Node {
+ return (*n.slice)[1]
+}
+
// NodeList returns the entries in Nodes as a NodeList.
// Changes to the NodeList entries (as in l.N = n) will *not* be
// reflected in the Nodes.
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 85605dc..e1840ee 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -35,8 +35,8 @@
}
func typechecklist(l []*Node, top int) {
- for it := nodeSeqIterate(l); !it.Done(); it.Next() {
- typecheck(it.P(), top)
+ for i := range l {
+ typecheck(&l[i], top)
}
}
@@ -221,8 +221,8 @@
}
func callrecvlist(l Nodes) bool {
- for it := nodeSeqIterate(l); !it.Done(); it.Next() {
- if callrecv(it.N()) {
+ for _, n := range l.Slice() {
+ if callrecv(n) {
return true
}
}
@@ -431,7 +431,7 @@
n.Type = nil
return
}
- setNodeSeq(&n.List, nil)
+ n.List.Set(nil)
case OTINTER:
ok |= Etype
@@ -704,14 +704,14 @@
n.Op = OADDSTR
if l.Op == OADDSTR {
- setNodeSeq(&n.List, l.List)
+ n.List.Set(l.List.Slice())
} else {
- setNodeSeq(&n.List, []*Node{l})
+ n.List.Set([]*Node{l})
}
if r.Op == OADDSTR {
- appendNodeSeq(&n.List, r.List)
+ n.List.AppendNodes(&r.List)
} else {
- appendNodeSeqNode(&n.List, r)
+ n.List.Append(r)
}
n.Left = nil
n.Right = nil
@@ -1288,7 +1288,7 @@
return
}
- if nodeSeqLen(n.List) == 1 && !n.Isddd {
+ if n.List.Len() == 1 && !n.Isddd {
it := nodeSeqIterate(n.List)
typecheck(it.P(), Erv|Efnstruct)
} else {
@@ -1446,22 +1446,22 @@
ok |= Erv
var r *Node
var l *Node
- if nodeSeqLen(n.List) == 1 {
+ if n.List.Len() == 1 {
typechecklist(n.List.Slice(), Efnstruct)
- if nodeSeqFirst(n.List).Op != OCALLFUNC && nodeSeqFirst(n.List).Op != OCALLMETH {
+ if n.List.First().Op != OCALLFUNC && n.List.First().Op != OCALLMETH {
Yyerror("invalid operation: complex expects two arguments")
n.Type = nil
return
}
- t := nodeSeqFirst(n.List).Left.Type
+ t := n.List.First().Left.Type
if t.Outtuple != 2 {
- Yyerror("invalid operation: complex expects two arguments, %v returns %d results", nodeSeqFirst(n.List), t.Outtuple)
+ Yyerror("invalid operation: complex expects two arguments, %v returns %d results", n.List.First(), t.Outtuple)
n.Type = nil
return
}
- t = nodeSeqFirst(n.List).Type.Type
+ t = n.List.First().Type.Type
l = t.Nname
r = t.Down.Nname
} else {
@@ -1548,19 +1548,19 @@
case ODELETE:
args := n.List
- if nodeSeqLen(args) == 0 {
+ if args.Len() == 0 {
Yyerror("missing arguments to delete")
n.Type = nil
return
}
- if nodeSeqLen(args) == 1 {
+ if args.Len() == 1 {
Yyerror("missing second (key) argument to delete")
n.Type = nil
return
}
- if nodeSeqLen(args) != 2 {
+ if args.Len() != 2 {
Yyerror("too many arguments to delete")
n.Type = nil
return
@@ -1568,8 +1568,8 @@
ok |= Etop
typechecklist(args.Slice(), Erv)
- l := nodeSeqFirst(args)
- r := nodeSeqSecond(args)
+ l := args.First()
+ r := args.Second()
if l.Type != nil && l.Type.Etype != TMAP {
Yyerror("first argument to delete must be map; have %v", Tconv(l.Type, obj.FmtLong))
n.Type = nil
@@ -1584,20 +1584,20 @@
case OAPPEND:
ok |= Erv
args := n.List
- if nodeSeqLen(args) == 0 {
+ if args.Len() == 0 {
Yyerror("missing arguments to append")
n.Type = nil
return
}
- if nodeSeqLen(args) == 1 && !n.Isddd {
+ if args.Len() == 1 && !n.Isddd {
it := nodeSeqIterate(args)
typecheck(it.P(), Erv|Efnstruct)
} else {
typechecklist(args.Slice(), Erv)
}
- t := nodeSeqFirst(args).Type
+ t := args.First().Type
if t == nil {
n.Type = nil
return
@@ -1612,7 +1612,7 @@
n.Type = t
if !Isslice(t) {
- if Isconst(nodeSeqFirst(args), CTNIL) {
+ if Isconst(args.First(), CTNIL) {
Yyerror("first argument to append must be typed slice; have untyped nil")
n.Type = nil
return
@@ -1624,19 +1624,19 @@
}
if n.Isddd {
- if nodeSeqLen(args) == 1 {
+ if args.Len() == 1 {
Yyerror("cannot use ... on first argument to append")
n.Type = nil
return
}
- if nodeSeqLen(args) != 2 {
+ if args.Len() != 2 {
Yyerror("too many arguments to append")
n.Type = nil
return
}
- if Istype(t.Type, TUINT8) && Istype(nodeSeqSecond(args).Type, TSTRING) {
+ if Istype(t.Type, TUINT8) && Istype(args.Second().Type, TSTRING) {
it := nodeSeqIterate(args)
it.Next()
defaultlit(it.P(), Types[TSTRING])
@@ -1645,7 +1645,7 @@
it := nodeSeqIterate(args)
it.Next()
- *it.P() = assignconv(nodeSeqSecond(args), t.Orig, "append")
+ *it.P() = assignconv(args.Second(), t.Orig, "append")
break OpSwitch
}
@@ -1671,21 +1671,21 @@
case OCOPY:
ok |= Etop | Erv
args := n.List
- if nodeSeqLen(args) < 2 {
+ if args.Len() < 2 {
Yyerror("missing arguments to copy")
n.Type = nil
return
}
- if nodeSeqLen(args) > 2 {
+ if args.Len() > 2 {
Yyerror("too many arguments to copy")
n.Type = nil
return
}
- n.Left = nodeSeqFirst(args)
- n.Right = nodeSeqSecond(args)
- setNodeSeq(&n.List, nil)
+ n.Left = args.First()
+ n.Right = args.Second()
+ n.List.Set(nil)
n.Type = Types[TINT]
typecheck(&n.Left, Erv)
typecheck(&n.Right, Erv)
@@ -1784,7 +1784,7 @@
return
}
- setNodeSeq(&n.List, nil)
+ n.List.Set(nil)
l := args.N()
args.Next()
typecheck(&l, Etype)
@@ -1896,20 +1896,20 @@
case ONEW:
ok |= Erv
args := n.List
- if nodeSeqLen(args) == 0 {
+ if args.Len() == 0 {
Yyerror("missing argument to new")
n.Type = nil
return
}
- l := nodeSeqFirst(args)
+ l := args.First()
typecheck(&l, Etype)
t := l.Type
if t == nil {
n.Type = nil
return
}
- if nodeSeqLen(args) > 1 {
+ if args.Len() > 1 {
Yyerror("too many arguments to new(%v)", t)
n.Type = nil
return
@@ -1922,12 +1922,12 @@
case OPRINT, OPRINTN:
ok |= Etop
typechecklist(n.List.Slice(), Erv|Eindir) // Eindir: address does not escape
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
+ for i1, n1 := range n.List.Slice() {
// Special case for print: int constant is int64, not int.
- if Isconst(it.N(), CTINT) {
- defaultlit(it.P(), Types[TINT64])
+ if Isconst(n1, CTINT) {
+ defaultlit(&n.List.Slice()[i1], Types[TINT64])
} else {
- defaultlit(it.P(), nil)
+ defaultlit(&n.List.Slice()[i1], nil)
}
}
@@ -1949,7 +1949,7 @@
case ORECOVER:
ok |= Erv | Etop
- if nodeSeqLen(n.List) != 0 {
+ if n.List.Len() != 0 {
Yyerror("too many arguments to recover")
n.Type = nil
return
@@ -2093,7 +2093,7 @@
case ORETURN:
ok |= Etop
- if nodeSeqLen(n.List) == 1 {
+ if n.List.Len() == 1 {
typechecklist(n.List.Slice(), Erv|Efnstruct)
} else {
typechecklist(n.List.Slice(), Erv)
@@ -2104,7 +2104,7 @@
return
}
- if Curfn.Type.Outnamed && nodeSeqLen(n.List) == 0 {
+ if Curfn.Type.Outnamed && n.List.Len() == 0 {
break OpSwitch
}
typecheckaste(ORETURN, nil, false, Curfn.Type.Results(), n.List, func() string { return "return argument" })
@@ -2332,22 +2332,22 @@
if n.Left != nil {
return true
}
- if nodeSeqLen(n.List) == 0 {
+ if n.List.Len() == 0 {
p := fmt.Sprintf(f, args...)
Yyerror("missing argument to %s: %v", p, n)
return false
}
- if nodeSeqLen(n.List) > 1 {
+ if n.List.Len() > 1 {
p := fmt.Sprintf(f, args...)
Yyerror("too many arguments to %s: %v", p, n)
- n.Left = nodeSeqFirst(n.List)
- setNodeSeq(&n.List, nil)
+ n.Left = n.List.First()
+ n.List.Set(nil)
return false
}
- n.Left = nodeSeqFirst(n.List)
- setNodeSeq(&n.List, nil)
+ n.Left = n.List.First()
+ n.List.Set(nil)
return true
}
@@ -2355,26 +2355,26 @@
if n.Left != nil {
return true
}
- if nodeSeqLen(n.List) == 0 {
+ if n.List.Len() == 0 {
Yyerror("missing argument to %v - %v", Oconv(n.Op, 0), n)
return false
}
- n.Left = nodeSeqFirst(n.List)
- if nodeSeqLen(n.List) == 1 {
+ n.Left = n.List.First()
+ if n.List.Len() == 1 {
Yyerror("missing argument to %v - %v", Oconv(n.Op, 0), n)
- setNodeSeq(&n.List, nil)
+ n.List.Set(nil)
return false
}
- if nodeSeqLen(n.List) > 2 {
+ if n.List.Len() > 2 {
Yyerror("too many arguments to %v - %v", Oconv(n.Op, 0), n)
- setNodeSeq(&n.List, nil)
+ n.List.Set(nil)
return false
}
- n.Right = nodeSeqSecond(n.List)
- setNodeSeq(&n.List, nil)
+ n.Right = n.List.Second()
+ n.List.Set(nil)
return true
}
@@ -2576,8 +2576,8 @@
}
func nokeys(l Nodes) bool {
- for it := nodeSeqIterate(l); !it.Done(); it.Next() {
- if it.N().Op == OKEY {
+ for _, n := range l.Slice() {
+ if n.Op == OKEY {
return false
}
}
@@ -2620,8 +2620,8 @@
}
n = nil
- if nodeSeqLen(nl) == 1 {
- n = nodeSeqFirst(nl)
+ if nl.Len() == 1 {
+ n = nl.First()
if n.Type != nil {
if n.Type.Etype == TSTRUCT && n.Type.Funarg {
if !hasddd(tstruct) {
@@ -2675,7 +2675,7 @@
}
n1 = downcount(tstruct)
- n2 = nodeSeqLen(nl)
+ n2 = nl.Len()
if !hasddd(tstruct) {
if n2 > n1 {
goto toomany
@@ -2917,8 +2917,8 @@
}()
if n.Right == nil {
- if nodeSeqLen(n.List) != 0 {
- setlineno(nodeSeqFirst(n.List))
+ if n.List.Len() != 0 {
+ setlineno(n.List.First())
}
Yyerror("missing type in composite literal")
n.Type = nil
@@ -2968,22 +2968,22 @@
case TARRAY:
// Only allocate hash if there are some key/value pairs.
var hash map[int64]*Node
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- if it.N().Op == OKEY {
+ for _, n1 := range n.List.Slice() {
+ if n1.Op == OKEY {
hash = make(map[int64]*Node)
break
}
}
length := int64(0)
i := 0
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- l := it.N()
+ for i2, n2 := range n.List.Slice() {
+ l := n2
setlineno(l)
if l.Op != OKEY {
l = Nod(OKEY, Nodintconst(int64(i)), l)
l.Left.Type = Types[TINT]
l.Left.Typecheck = 1
- *it.P() = l
+ n.List.Slice()[i2] = l
}
typecheck(&l.Left, Erv)
@@ -3026,11 +3026,11 @@
case TMAP:
hash := make(map[uint32][]*Node)
var l *Node
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- l = it.N()
+ for i3, n3 := range n.List.Slice() {
+ l = n3
setlineno(l)
if l.Op != OKEY {
- typecheck(it.P(), Erv)
+ typecheck(&n.List.Slice()[i3], Erv)
Yyerror("missing key in map literal")
continue
}
@@ -3055,14 +3055,14 @@
case TSTRUCT:
bad := 0
- if nodeSeqLen(n.List) != 0 && nokeys(n.List) {
+ if n.List.Len() != 0 && nokeys(n.List) {
// simple list of variables
f := t.Type
var s *Sym
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- setlineno(it.N())
- typecheck(it.P(), Erv)
+ for i4, n4 := range n.List.Slice() {
+ setlineno(n4)
+ typecheck(&n.List.Slice()[i4], Erv)
if f == nil {
if bad == 0 {
Yyerror("too many values in struct initializer")
@@ -3075,13 +3075,11 @@
if s != nil && !exportname(s.Name) && s.Pkg != localpkg {
Yyerror("implicit assignment of unexported field '%s' in %v literal", s.Name, t)
}
-
// No pushtype allowed here. Must name fields for that.
- *it.P() = assignconv(it.N(), f.Type, "field value")
-
- *it.P() = Nod(OKEY, newname(f.Sym), it.N())
- it.N().Left.Type = f
- it.N().Left.Typecheck = 1
+ n.List.Slice()[i4] = assignconv(n.List.Slice()[i4], f.Type, "field value")
+ n.List.Slice()[i4] = Nod(OKEY, newname(f.Sym), n.List.Slice()[i4])
+ n.List.Slice()[i4].Left.Type = f
+ n.List.Slice()[i4].Left.Typecheck = 1
f = f.Down
}
@@ -3096,15 +3094,15 @@
var f *Type
var l *Node
var s1 *Sym
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- l = it.N()
+ for i5, n5 := range n.List.Slice() {
+ l = n5
setlineno(l)
if l.Op != OKEY {
if bad == 0 {
Yyerror("mixture of field:value and value initializers")
}
bad++
- typecheck(it.P(), Erv)
+ typecheck(&n.List.Slice()[i5], Erv)
continue
}
@@ -3236,8 +3234,8 @@
}
func checkassignlist(stmt *Node, l Nodes) {
- for it := nodeSeqIterate(l); !it.Done(); it.Next() {
- checkassign(stmt, it.N())
+ for _, n := range l.Slice() {
+ checkassign(stmt, n)
}
}
@@ -3315,17 +3313,17 @@
}
func typecheckas2(n *Node) {
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
+ for i1 := range n.List.Slice() {
// delicate little dance.
- *it.P() = resolve(it.N())
+ n.List.Slice()[i1] = resolve(n.List.Slice()[i1])
- if it.N().Name == nil || it.N().Name.Defn != n || it.N().Name.Param.Ntype != nil {
- typecheck(it.P(), Erv|Easgn)
+ if n.List.Slice()[i1].Name == nil || n.List.Slice()[i1].Name.Defn != n || n.List.Slice()[i1].Name.Param.Ntype != nil {
+ typecheck(&n.List.Slice()[i1], Erv|Easgn)
}
}
- cl := nodeSeqLen(n.List)
- cr := nodeSeqLen(n.Rlist)
+ cl := n.List.Len()
+ cr := n.Rlist.Len()
if cl > 1 && cr == 1 {
it := nodeSeqIterate(n.Rlist)
typecheck(it.P(), Erv|Efnstruct)
@@ -3339,13 +3337,13 @@
if cl == cr {
// easy
lrit := nodeSeqIterate(n.Rlist)
- for llit := nodeSeqIterate(n.List); !llit.Done(); llit.Next() {
- if llit.N().Type != nil && lrit.N().Type != nil {
- *lrit.P() = assignconv(lrit.N(), llit.N().Type, "assignment")
+ for _, n2 := range n.List.Slice() {
+ if n2.Type != nil && lrit.N().Type != nil {
+ *lrit.P() = assignconv(lrit.N(), n2.Type, "assignment")
}
- if llit.N().Name != nil && llit.N().Name.Defn == n && llit.N().Name.Param.Ntype == nil {
+ if n2.Name != nil && n2.Name.Defn == n && n2.Name.Param.Ntype == nil {
defaultlit(lrit.P(), nil)
- llit.N().Type = lrit.N().Type
+ n2.Type = lrit.N().Type
}
lrit.Next()
}
@@ -3353,8 +3351,8 @@
goto out
}
- l = nodeSeqFirst(n.List)
- r = nodeSeqFirst(n.Rlist)
+ l = n.List.First()
+ r = n.Rlist.First()
// x,y,z = f()
if cr == 1 {
@@ -3372,12 +3370,12 @@
}
n.Op = OAS2FUNC
t, s := IterFields(r.Type)
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- if t.Type != nil && it.N().Type != nil {
- checkassignto(t.Type, it.N())
+ for _, n3 := range n.List.Slice() {
+ if t.Type != nil && n3.Type != nil {
+ checkassignto(t.Type, n3)
}
- if it.N().Name != nil && it.N().Name.Defn == n && it.N().Name.Param.Ntype == nil {
- it.N().Type = t.Type
+ if n3.Name != nil && n3.Name.Defn == n && n3.Name.Param.Ntype == nil {
+ n3.Type = t.Type
}
t = s.Next()
}
@@ -3411,7 +3409,7 @@
if l.Name != nil && l.Name.Defn == n {
l.Type = r.Type
}
- l := nodeSeqSecond(n.List)
+ l := n.List.Second()
if l.Type != nil && l.Type.Etype != TBOOL {
checkassignto(Types[TBOOL], l)
}
@@ -3428,10 +3426,9 @@
// second half of dance
out:
n.Typecheck = 1
-
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- if it.N().Typecheck == 0 {
- typecheck(it.P(), Erv|Easgn)
+ for i4, n4 := range n.List.Slice() {
+ if n4.Typecheck == 0 {
+ typecheck(&n.List.Slice()[i4], Erv|Easgn)
}
}
}
@@ -3480,7 +3477,7 @@
}
nn := Nod(OCOMPLIT, nil, typenod(n.Type))
- setNodeSeq(&nn.List, l)
+ nn.List.Set(l)
typecheck(&nn, Erv)
*np = nn
}
@@ -3966,11 +3963,11 @@
return false
}
def := 0
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- if !it.N().Nbody.isterminating() {
+ for _, n1 := range n.List.Slice() {
+ if !n1.Nbody.isterminating() {
return false
}
- if nodeSeqLen(it.N().List) == 0 { // default
+ if n1.List.Len() == 0 { // default
def = 1
}
}
diff --git a/src/cmd/compile/internal/gc/unsafe.go b/src/cmd/compile/internal/gc/unsafe.go
index 9bfc6a5..99e0ac8 100644
--- a/src/cmd/compile/internal/gc/unsafe.go
+++ b/src/cmd/compile/internal/gc/unsafe.go
@@ -26,12 +26,12 @@
return nil
}
- if nodeSeqLen(args) == 0 {
+ if args.Len() == 0 {
Yyerror("missing argument for %v", s)
return nil
}
- r := nodeSeqFirst(args)
+ r := args.First()
var v int64
if s.Name == "Sizeof" {
@@ -129,7 +129,7 @@
goto ret
yes:
- if nodeSeqLen(args) > 1 {
+ if args.Len() > 1 {
Yyerror("extra arguments for %v", s)
}
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 1db951c..a53d1bd 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -119,8 +119,7 @@
var lhs *Node
callfunc := n.Left
- for argsit := nodeSeqIterate(callfunc.List); !argsit.Done(); argsit.Next() {
- arg = argsit.N()
+ for _, arg = range callfunc.List.Slice() {
if arg.Op != OAS {
Yyerror("call arg not assignment")
}
@@ -189,7 +188,7 @@
Fatalf("missing typecheck: %v", Nconv(n, obj.FmtSign))
}
init := n.Ninit
- setNodeSeq(&n.Ninit, nil)
+ n.Ninit.Set(nil)
walkexpr(&n, &init)
addinit(&n, init.Slice())
if (*np).Op == OCOPY && n.Op == OCONVNOP {
@@ -203,7 +202,7 @@
Fatalf("missing typecheck: %v", Nconv(n, obj.FmtSign))
}
init := n.Ninit
- setNodeSeq(&n.Ninit, nil)
+ n.Ninit.Set(nil)
walkexpr(&n.Left, &init)
n = mkcall1(chanfn("chanrecv1", 2, n.Left.Type), nil, &init, typename(n.Left.Type), n.Left, nodnil())
@@ -255,7 +254,7 @@
if n.Left != nil {
walkstmtlist(n.Left.Ninit.Slice())
init := n.Left.Ninit
- setNodeSeq(&n.Left.Ninit, nil)
+ n.Left.Ninit.Set(nil)
walkexpr(&n.Left, &init)
addinit(&n.Left, init.Slice())
}
@@ -285,10 +284,10 @@
case ORETURN:
walkexprlist(n.List.Slice(), &n.Ninit)
- if nodeSeqLen(n.List) == 0 {
+ if n.List.Len() == 0 {
break
}
- if (Curfn.Type.Outnamed && nodeSeqLen(n.List) > 1) || paramoutheap(Curfn) {
+ if (Curfn.Type.Outnamed && n.List.Len() > 1) || paramoutheap(Curfn) {
// assign to the function out parameters,
// so that reorder3 can fix up conflicts
var rl []*Node
@@ -304,7 +303,7 @@
}
}
- if got, want := nodeSeqLen(n.List), len(rl); got != want {
+ if got, want := n.List.Len(), len(rl); got != want {
// order should have rewritten multi-value function calls
// with explicit OAS2FUNC nodes.
Fatalf("expected %v return arguments, have %v", want, got)
@@ -312,7 +311,7 @@
if samelist(rl, n.List.Slice()) {
// special return in disguise
- setNodeSeq(&n.List, nil)
+ n.List.Set(nil)
break
}
@@ -321,15 +320,15 @@
walkexprlistsafe(n.List.Slice(), &n.Ninit)
ll := ascompatee(n.Op, rl, n.List.Slice(), &n.Ninit)
- setNodeSeq(&n.List, reorder3(ll))
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- *it.P() = applywritebarrier(it.N())
+ n.List.Set(reorder3(ll))
+ for i1 := range n.List.Slice() {
+ n.List.Slice()[i1] = applywritebarrier(n.List.Slice()[i1])
}
break
}
ll := ascompatte(n.Op, nil, false, Curfn.Type.ResultsP(), n.List.Slice(), 1, &n.Ninit)
- setNodeSeq(&n.List, ll)
+ n.List.Set(ll)
case ORETJMP:
break
@@ -465,7 +464,7 @@
Fatalf("walkexpr init == &n->ninit")
}
- if nodeSeqLen(n.Ninit) != 0 {
+ if n.Ninit.Len() != 0 {
walkstmtlist(n.Ninit.Slice())
init.AppendNodes(&n.Ninit)
}
@@ -572,8 +571,8 @@
OCOMPLEX,
OLROT:
if n.Op == OCOMPLEX && n.Left == nil && n.Right == nil {
- n.Left = nodeSeqFirst(n.List)
- n.Right = nodeSeqSecond(n.List)
+ n.Left = n.List.First()
+ n.Right = n.List.Second()
}
walkexpr(&n.Left, init)
@@ -633,13 +632,13 @@
case OCALLINTER:
t := n.Left.Type
- if nodeSeqLen(n.List) != 0 && nodeSeqFirst(n.List).Op == OAS {
+ if n.List.Len() != 0 && n.List.First().Op == OAS {
break
}
walkexpr(&n.Left, init)
walkexprlist(n.List.Slice(), init)
ll := ascompatte(n.Op, n, n.Isddd, t.ParamsP(), n.List.Slice(), 0, init)
- setNodeSeq(&n.List, reorder1(ll))
+ n.List.Set(reorder1(ll))
case OCALLFUNC:
if n.Left.Op == OCLOSURE {
@@ -647,7 +646,7 @@
// transformclosure already did all preparation work.
// Prepend captured variables to argument list.
- setNodeSeq(&n.List, append(n.Left.Func.Enter.Slice(), nodeSeqSlice(n.List)...))
+ n.List.Set(append(n.Left.Func.Enter.Slice(), n.List.Slice()...))
n.Left.Func.Enter.Set(nil)
@@ -668,7 +667,7 @@
}
t := n.Left.Type
- if nodeSeqLen(n.List) != 0 && nodeSeqFirst(n.List).Op == OAS {
+ if n.List.Len() != 0 && n.List.First().Op == OAS {
break
}
@@ -679,18 +678,18 @@
switch Thearch.Thechar {
case '5', '6', '7':
n.Op = OSQRT
- n.Left = nodeSeqFirst(n.List)
- setNodeSeq(&n.List, nil)
+ n.Left = n.List.First()
+ n.List.Set(nil)
break opswitch
}
}
ll := ascompatte(n.Op, n, n.Isddd, t.ParamsP(), n.List.Slice(), 0, init)
- setNodeSeq(&n.List, reorder1(ll))
+ n.List.Set(reorder1(ll))
case OCALLMETH:
t := n.Left.Type
- if nodeSeqLen(n.List) != 0 && nodeSeqFirst(n.List).Op == OAS {
+ if n.List.Len() != 0 && n.List.First().Op == OAS {
break
}
walkexpr(&n.Left, init)
@@ -700,7 +699,7 @@
ll = append(ll, lr...)
n.Left.Left = nil
ullmancalc(n.Left)
- setNodeSeq(&n.List, reorder1(ll))
+ n.List.Set(reorder1(ll))
case OAS:
init.AppendNodes(&n.Ninit)
@@ -799,7 +798,7 @@
case OAS2FUNC:
init.AppendNodes(&n.Ninit)
- r := nodeSeqFirst(n.Rlist)
+ r := n.Rlist.First()
walkexprlistsafe(n.List.Slice(), init)
walkexpr(&r, init)
@@ -814,26 +813,26 @@
case OAS2RECV:
init.AppendNodes(&n.Ninit)
- r := nodeSeqFirst(n.Rlist)
+ r := n.Rlist.First()
walkexprlistsafe(n.List.Slice(), init)
walkexpr(&r.Left, init)
var n1 *Node
- if isblank(nodeSeqFirst(n.List)) {
+ if isblank(n.List.First()) {
n1 = nodnil()
} else {
- n1 = Nod(OADDR, nodeSeqFirst(n.List), nil)
+ n1 = Nod(OADDR, n.List.First(), nil)
}
n1.Etype = 1 // addr does not escape
fn := chanfn("chanrecv2", 2, r.Left.Type)
- r = mkcall1(fn, nodeSeqSecond(n.List).Type, init, typename(r.Left.Type), r.Left, n1)
- n = Nod(OAS, nodeSeqSecond(n.List), r)
+ r = mkcall1(fn, n.List.Second().Type, init, typename(r.Left.Type), r.Left, n1)
+ n = Nod(OAS, n.List.Second(), r)
typecheck(&n, Etop)
// a,b = m[i];
case OAS2MAPR:
init.AppendNodes(&n.Ninit)
- r := nodeSeqFirst(n.Rlist)
+ r := n.Rlist.First()
walkexprlistsafe(n.List.Slice(), init)
walkexpr(&r.Left, init)
walkexpr(&r.Right, init)
@@ -867,7 +866,7 @@
// to:
// var,b = mapaccess2*(t, m, i)
// a = *var
- a := nodeSeqFirst(n.List)
+ a := n.List.First()
fn := mapfn(p, t)
r = mkcall1(fn, fn.Type.Results(), init, typename(t), r.Left, key)
@@ -875,8 +874,8 @@
// 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 !isblank(nodeSeqSecond(n.List)) {
- r.Type.Type.Down.Type = nodeSeqSecond(n.List).Type
+ if !isblank(n.List.Second()) {
+ r.Type.Type.Down.Type = n.List.Second().Type
}
setNodeSeq(&n.Rlist, list1(r))
n.Op = OAS2FUNC
@@ -899,8 +898,8 @@
case ODELETE:
init.AppendNodes(&n.Ninit)
- map_ := nodeSeqFirst(n.List)
- key := nodeSeqSecond(n.List)
+ map_ := n.List.First()
+ key := n.List.Second()
walkexpr(&map_, init)
walkexpr(&key, init)
@@ -911,7 +910,7 @@
n = mkcall1(mapfndel("mapdelete", t), nil, init, typename(t), map_, key)
case OAS2DOTTYPE:
- e := nodeSeqFirst(n.Rlist) // i.(T)
+ e := n.Rlist.First() // i.(T)
// TODO(rsc): The Isfat is for consistency with componentgen and orderexpr.
// It needs to be removed in all three places.
// That would allow inlining x.(struct{*int}) the same as x.(*int).
@@ -932,7 +931,7 @@
from := e.Left // i
oktype := Types[TBOOL]
- ok := nodeSeqSecond(n.List)
+ ok := n.List.Second()
if !isblank(ok) {
oktype = ok.Type
}
@@ -943,7 +942,7 @@
// Avoid runtime calls in a few cases of the form _, ok := i.(T).
// This is faster and shorter and allows the corresponding assertX2X2
// routines to skip nil checks on their last argument.
- if isblank(nodeSeqFirst(n.List)) {
+ if isblank(n.List.First()) {
var fast *Node
switch {
case fromKind == 'E' && toKind == 'T':
@@ -967,10 +966,10 @@
}
var resptr *Node // &res
- if isblank(nodeSeqFirst(n.List)) {
+ if isblank(n.List.First()) {
resptr = nodnil()
} else {
- resptr = Nod(OADDR, nodeSeqFirst(n.List), nil)
+ resptr = Nod(OADDR, n.List.First(), nil)
}
resptr.Etype = 1 // addr does not escape
@@ -1344,9 +1343,9 @@
}
// s + "badgerbadgerbadger" == "badgerbadgerbadger"
- if (Op(n.Etype) == OEQ || Op(n.Etype) == ONE) && Isconst(n.Right, CTSTR) && n.Left.Op == OADDSTR && nodeSeqLen(n.Left.List) == 2 && Isconst(nodeSeqSecond(n.Left.List), CTSTR) && strlit(n.Right) == strlit(nodeSeqSecond(n.Left.List)) {
+ if (Op(n.Etype) == OEQ || Op(n.Etype) == ONE) && Isconst(n.Right, CTSTR) && n.Left.Op == OADDSTR && n.Left.List.Len() == 2 && Isconst(n.Left.List.Second(), CTSTR) && strlit(n.Right) == strlit(n.Left.List.Second()) {
// TODO(marvin): Fix Node.EType type union.
- r := Nod(Op(n.Etype), Nod(OLEN, nodeSeqFirst(n.Left.List), nil), Nodintconst(0))
+ r := Nod(Op(n.Etype), Nod(OLEN, n.Left.List.First(), nil), Nodintconst(0))
typecheck(&r, Erv)
walkexpr(&r, init)
r.Type = n.Type
@@ -1654,11 +1653,11 @@
// expr-list = expr-list
// ensure order of evaluation for function calls
- for nlit := nodeSeqIterate(nl); !nlit.Done(); nlit.Next() {
- *nlit.P() = safeexpr(nlit.N(), init)
+ for i := range nl {
+ nl[i] = safeexpr(nl[i], init)
}
- for nrit := nodeSeqIterate(nr); !nrit.Done(); nrit.Next() {
- *nrit.P() = safeexpr(nrit.N(), init)
+ for i1 := range nr {
+ nr[i1] = safeexpr(nr[i1], init)
}
var nn []*Node
@@ -1751,7 +1750,7 @@
}
if !it.Done() || r != nil {
- Yyerror("ascompatet: assignment count mismatch: %d = %d", nodeSeqLen(nl), structcount(*nr))
+ Yyerror("ascompatet: assignment count mismatch: %d = %d", nl.Len(), structcount(*nr))
}
if ucount != 0 {
@@ -1780,7 +1779,7 @@
if ddd != nil && prealloc[ddd] != nil {
prealloc[n] = prealloc[ddd] // temporary to use
}
- setNodeSeq(&n.List, lr0)
+ n.List.Set(lr0)
n.Esc = esc
typecheck(&n, Erv)
if n.Type == nil {
@@ -1820,8 +1819,7 @@
fmt_ := ""
fmt_ += "\t"
first := 1
- for it := nodeSeqIterate(l); !it.Done(); it.Next() {
- r = it.N()
+ for _, r = range l {
if first != 0 {
first = 0
} else {
@@ -1874,8 +1872,8 @@
}
a = Nod(OAS2, nil, nil)
- setNodeSeq(&a.List, alist)
- setNodeSeq(&a.Rlist, lr)
+ a.List.Set(alist)
+ a.Rlist.Set(lr)
typecheck(&a, Etop)
walkstmt(&a)
init.Append(a)
@@ -1962,15 +1960,14 @@
walkexprlistcheap(all.Slice(), init)
calls = append(calls, mkcall("printlock", nil, init))
-
- for it := nodeSeqIterate(all); !it.Done(); it.Next() {
+ for i1, n1 := range all.Slice() {
if notfirst {
calls = append(calls, mkcall("printsp", nil, init))
}
notfirst = op == OPRINTN
- n = it.N()
+ n = n1
if n.Op == OLITERAL {
switch n.Val().Ctype() {
case CTRUNE:
@@ -1988,7 +1985,7 @@
defaultlit(&n, Types[TINT64])
}
defaultlit(&n, nil)
- *it.P() = n
+ all.Slice()[i1] = n
if n.Type == nil || n.Type.Etype == TFORW {
continue
}
@@ -2045,7 +2042,7 @@
}
r = Nod(OCALL, on, nil)
- appendNodeSeqNode(&r.List, n)
+ r.List.Append(n)
calls = append(calls, r)
}
@@ -2061,7 +2058,7 @@
r = Nod(OEMPTY, nil, nil)
typecheck(&r, Etop)
walkexpr(&r, init)
- setNodeSeq(&r.Ninit, calls)
+ r.Ninit.Set(calls)
return r
}
@@ -2532,8 +2529,8 @@
if vmatch2(l, r.Right) {
return true
}
- for it := nodeSeqIterate(r.List); !it.Done(); it.Next() {
- if vmatch2(l, it.N()) {
+ for _, n := range r.List.Slice() {
+ if vmatch2(l, n) {
return true
}
}
@@ -2573,8 +2570,8 @@
if vmatch1(l.Right, r) {
return true
}
- for it := nodeSeqIterate(l.List); !it.Done(); it.Next() {
- if vmatch1(it.N(), r) {
+ for _, n := range l.List.Slice() {
+ if vmatch1(n, r) {
return true
}
}
@@ -2667,7 +2664,7 @@
n := fn.Type.Intuple
r := Nod(OCALL, fn, nil)
- setNodeSeq(&r.List, va[:n])
+ r.List.Set(va[:n])
if fn.Type.Outtuple > 0 {
typecheck(&r, Erv|Efnstruct)
} else {
@@ -2738,7 +2735,7 @@
func addstr(n *Node, init *Nodes) *Node {
// orderexpr rewrote OADDSTR to have a list of strings.
- c := nodeSeqLen(n.List)
+ c := n.List.Len()
if c < 2 {
Yyerror("addstr count %d too small", c)
@@ -2747,9 +2744,9 @@
buf := nodnil()
if n.Esc == EscNone {
sz := int64(0)
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- if it.N().Op == OLITERAL {
- sz += int64(len(it.N().Val().U.(string)))
+ for _, n1 := range n.List.Slice() {
+ if n1.Op == OLITERAL {
+ sz += int64(len(n1.Val().U.(string)))
}
}
@@ -2764,9 +2761,8 @@
// build list of string arguments
args := []*Node{buf}
-
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- args = append(args, conv(it.N(), Types[TSTRING]))
+ for _, n2 := range n.List.Slice() {
+ args = append(args, conv(n2, Types[TSTRING]))
}
var fn string
@@ -2785,7 +2781,7 @@
if prealloc[n] != nil {
prealloc[slice] = prealloc[n]
}
- setNodeSeq(&slice.List, args[1:]) // skip buf arg
+ slice.List.Set(args[1:]) // skip buf arg
args = []*Node{buf}
args = append(args, slice)
slice.Esc = EscNone
@@ -2793,7 +2789,7 @@
cat := syslook(fn)
r := Nod(OCALL, cat, nil)
- setNodeSeq(&r.List, args)
+ r.List.Set(args)
typecheck(&r, Erv)
walkexpr(&r, init)
r.Type = n.Type
@@ -2815,16 +2811,18 @@
// l2 is allowed to be a string.
func appendslice(n *Node, init *Nodes) *Node {
walkexprlistsafe(n.List.Slice(), init)
+ for i1 := range
// walkexprlistsafe will leave OINDEX (s[n]) alone if both s
// and n are name or literal, but those may index the slice we're
// modifying here. Fix explicitly.
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
- *it.P() = cheapexpr(it.N(), init)
+ n.List.Slice() {
+ n.List.Slice()[i1] = cheapexpr(n.List.Slice()[i1],
+ init)
}
- l1 := nodeSeqFirst(n.List)
- l2 := nodeSeqSecond(n.List)
+ l1 := n.List.First()
+ l2 := n.List.Second()
s := temp(l1.Type) // var s []T
var l []*Node
@@ -2934,7 +2932,7 @@
// }
// s
func walkappend(n *Node, init *Nodes, dst *Node) *Node {
- if !samesafeexpr(dst, nodeSeqFirst(n.List)) {
+ if !samesafeexpr(dst, n.List.First()) {
it := nodeSeqIterate(n.List)
*it.P() = safeexpr(it.N(), init)
walkexpr(it.P(), init)
@@ -2953,13 +2951,13 @@
*it.P() = cheapexpr(it.N(), init)
}
- nsrc := nodeSeqFirst(n.List)
+ nsrc := n.List.First()
// Resolve slice type of multi-valued return.
if Istype(nsrc.Type, TSTRUCT) {
nsrc.Type = nsrc.Type.Type.Type
}
- argc := nodeSeqLen(n.List) - 1
+ argc := n.List.Len() - 1
if argc < 1 {
return nsrc
}
@@ -3098,9 +3096,9 @@
n := newname(sym)
n.Class = PFUNC
ntype := Nod(OTFUNC, nil, nil)
- appendNodeSeqNode(&ntype.List, Nod(ODCLFIELD, nil, typenod(Ptrto(t))))
- appendNodeSeqNode(&ntype.List, Nod(ODCLFIELD, nil, typenod(Ptrto(t))))
- appendNodeSeqNode(&ntype.Rlist, Nod(ODCLFIELD, nil, typenod(Types[TBOOL])))
+ ntype.List.Append(Nod(ODCLFIELD, nil, typenod(Ptrto(t))))
+ ntype.List.Append(Nod(ODCLFIELD, nil, typenod(Ptrto(t))))
+ ntype.Rlist.Append(Nod(ODCLFIELD, nil, typenod(Types[TBOOL])))
typecheck(&ntype, Etype)
n.Type = ntype.Type
*needsize = 0
@@ -3153,9 +3151,9 @@
// x, ok := l.(type(r))
expr := Nod(OAS2, nil, nil)
- appendNodeSeqNode(&expr.List, x)
- appendNodeSeqNode(&expr.List, ok)
- appendNodeSeqNode(&expr.Rlist, a)
+ expr.List.Append(x)
+ expr.List.Append(ok)
+ expr.Rlist.Append(a)
typecheck(&expr, Etop)
walkexpr(&expr, init)
@@ -3285,10 +3283,10 @@
var needsize int
call := Nod(OCALL, eqfor(t, &needsize), nil)
- appendNodeSeqNode(&call.List, l)
- appendNodeSeqNode(&call.List, r)
+ call.List.Append(l)
+ call.List.Append(r)
if needsize != 0 {
- appendNodeSeqNode(&call.List, Nodintconst(t.Width))
+ call.List.Append(Nodintconst(t.Width))
}
r = call
if n.Op != OEQ {
@@ -3841,8 +3839,8 @@
}
func candiscardlist(l Nodes) bool {
- for it := nodeSeqIterate(l); !it.Done(); it.Next() {
- if !candiscard(it.N()) {
+ for _, n := range l.Slice() {
+ if !candiscard(n) {
return false
}
}
@@ -3955,7 +3953,7 @@
func walkprintfunc(np **Node, init *Nodes) {
n := *np
- if nodeSeqLen(n.Ninit) != 0 {
+ if n.Ninit.Len() != 0 {
walkstmtlist(n.Ninit.Slice())
init.AppendNodes(&n.Ninit)
}
@@ -3965,11 +3963,11 @@
var printargs []*Node
var a *Node
var buf string
- for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
+ for _, n1 := range n.List.Slice() {
buf = fmt.Sprintf("a%d", num)
num++
- a = Nod(ODCLFIELD, newname(Lookup(buf)), typenod(it.N().Type))
- appendNodeSeqNode(&t.List, a)
+ a = Nod(ODCLFIELD, newname(Lookup(buf)), typenod(n1.Type))
+ t.List.Append(a)
printargs = append(printargs, a.Left)
}
@@ -3986,7 +3984,7 @@
funchdr(fn)
a = Nod(n.Op, nil, nil)
- setNodeSeq(&a.List, printargs)
+ a.List.Set(printargs)
typecheck(&a, Etop)
walkstmt(&a)
@@ -4001,7 +3999,7 @@
a = Nod(OCALL, nil, nil)
a.Left = fn.Func.Nname
- setNodeSeq(&a.List, n.List)
+ a.List.Set(n.List.Slice())
typecheck(&a, Etop)
walkexpr(&a, init)
*np = a
