cmd/compile: remove all remaining nodeSeq code

Passes toolstash -cmp.

Update #14473.

Change-Id: I2ac5c595d7af7a8da1a7e3945e6a753299446250
Reviewed-on: https://go-review.googlesource.com/20497
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>

src/cmd/compile/internal/gc/bimport.go

@@ -632,7 +632,7 @@ func (p *importer) node() *Node {
 		// if p.bool() {
 		// 	n.Left = p.node()
 		// } else {
-		// 	setNodeSeq(&n.List, p.nodeList())
+		// 	n.List.Set(p.nodeList())
 		// }
 		x := Nod(OCALL, p.typ().Nod, nil)
 		if p.bool() {

src/cmd/compile/internal/gc/closure.go

@@ -52,13 +52,13 @@ func closurehdr(ntype *Node) {
 	}
 }
 
-func closurebody(body *NodeList) *Node {
-	if body == nil {
-		body = list1(Nod(OEMPTY, nil, nil))
+func closurebody(body []*Node) *Node {
+	if len(body) == 0 {
+		body = []*Node{Nod(OEMPTY, nil, nil)}
 	}
 
 	func_ := Curfn
-	func_.Nbody.SetToNodeList(body)
+	func_.Nbody.Set(body)
 	func_.Func.Endlineno = lineno
 	funcbody(func_)
 
@@ -116,7 +116,7 @@ func typecheckclosure(func_ *Node, top int) {
 	}
 
 	// Create top-level function
-	xtop = list(xtop, makeclosure(func_))
+	xtop = append(xtop, makeclosure(func_))
 }
 
 // closurename returns name for OCLOSURE n.
@@ -616,7 +616,7 @@ func makepartialcall(fn *Node, t0 *Type, meth *Node) *Node {
 
 	typecheck(&xfunc, Etop)
 	sym.Def = xfunc
-	xtop = list(xtop, xfunc)
+	xtop = append(xtop, xfunc)
 	Curfn = savecurfn
 
 	return xfunc

src/cmd/compile/internal/gc/dcl.go

@@ -220,63 +220,59 @@ func addvar(n *Node, t *Type, ctxt Class) {
 
 // declare variables from grammar
 // new_name_list (type | [type] = expr_list)
-func variter(vl *NodeList, t *Node, el *NodeList) *NodeList {
-	var init *NodeList
-	doexpr := el != nil
+func variter(vl []*Node, t *Node, el []*Node) []*Node {
+	var init []*Node
+	doexpr := len(el) > 0
 
-	if count(el) == 1 && count(vl) > 1 {
-		e := el.N
+	if len(el) == 1 && len(vl) > 1 {
+		e := el[0]
 		as2 := Nod(OAS2, nil, nil)
-		setNodeSeq(&as2.List, vl)
+		as2.List.Set(vl)
 		as2.Rlist.Set([]*Node{e})
-		var v *Node
-		for ; vl != nil; vl = vl.Next {
-			v = vl.N
+		for _, v := range vl {
 			v.Op = ONAME
 			declare(v, dclcontext)
 			v.Name.Param.Ntype = t
 			v.Name.Defn = as2
 			if Funcdepth > 0 {
-				init = list(init, Nod(ODCL, v, nil))
+				init = append(init, Nod(ODCL, v, nil))
 			}
 		}
 
-		return list(init, as2)
+		return append(init, as2)
 	}
 
-	var v *Node
-	var e *Node
-	for ; vl != nil; vl = vl.Next {
+	for _, v := range vl {
+		var e *Node
 		if doexpr {
-			if el == nil {
+			if len(el) == 0 {
 				Yyerror("missing expression in var declaration")
 				break
 			}
 
-			e = el.N
-			el = el.Next
+			e = el[0]
+			el = el[1:]
 		} else {
 			e = nil
 		}
 
-		v = vl.N
 		v.Op = ONAME
 		declare(v, dclcontext)
 		v.Name.Param.Ntype = t
 
 		if e != nil || Funcdepth > 0 || isblank(v) {
 			if Funcdepth > 0 {
-				init = list(init, Nod(ODCL, v, nil))
+				init = append(init, Nod(ODCL, v, nil))
 			}
 			e = Nod(OAS, v, e)
-			init = list(init, e)
+			init = append(init, e)
 			if e.Right != nil {
 				v.Name.Defn = e
 			}
 		}
 	}
 
-	if el != nil {
+	if len(el) != 0 {
 		Yyerror("extra expression in var declaration")
 	}
 	return init
@@ -284,25 +280,24 @@ func variter(vl *NodeList, t *Node, el *NodeList) *NodeList {
 
 // declare constants from grammar
 // new_name_list [[type] = expr_list]
-func constiter(vl *NodeList, t *Node, cl *NodeList) *NodeList {
+func constiter(vl []*Node, t *Node, cl []*Node) []*Node {
 	lno := int32(0) // default is to leave line number alone in listtreecopy
-	if cl == nil {
+	if len(cl) == 0 {
 		if t != nil {
 			Yyerror("const declaration cannot have type without expression")
 		}
 		cl = lastconst
 		t = lasttype
-		lno = vl.N.Lineno
+		lno = vl[0].Lineno
 	} else {
 		lastconst = cl
 		lasttype = t
 	}
-	clcopy := listtreecopy(nodeSeqSlice(cl), lno)
+	clcopy := listtreecopy(cl, lno)
 
-	var v *Node
 	var c *Node
-	var vv *NodeList
-	for ; vl != nil; vl = vl.Next {
+	var vv []*Node
+	for _, v := range vl {
 		if len(clcopy) == 0 {
 			Yyerror("missing value in const declaration")
 			break
@@ -311,14 +306,13 @@ func constiter(vl *NodeList, t *Node, cl *NodeList) *NodeList {
 		c = clcopy[0]
 		clcopy = clcopy[1:]
 
-		v = vl.N
 		v.Op = OLITERAL
 		declare(v, dclcontext)
 
 		v.Name.Param.Ntype = t
 		v.Name.Defn = c
 
-		vv = list(vv, Nod(ODCLCONST, v, nil))
+		vv = append(vv, Nod(ODCLCONST, v, nil))
 	}
 
 	if len(clcopy) != 0 {
@@ -483,10 +477,10 @@ func colasdefn(left Nodes, defn *Node) {
 	}
 }
 
-func colas(left *NodeList, right *NodeList, lno int32) *Node {
+func colas(left []*Node, right []*Node, lno int32) *Node {
 	as := Nod(OAS2, nil, nil)
-	setNodeSeq(&as.List, left)
-	setNodeSeq(&as.Rlist, right)
+	as.List.Set(left)
+	as.Rlist.Set(right)
 	as.Colas = true
 	as.Lineno = lno
 	colasdefn(as.List, as)
@@ -1026,56 +1020,53 @@ func embedded(s *Sym, pkg *Pkg) *Node {
 }
 
 // check that the list of declarations is either all anonymous or all named
-func findtype(l *NodeList) *Node {
-	for ; l != nil; l = l.Next {
-		if l.N.Op == OKEY {
-			return l.N.Right
+func findtype(s []*Node) *Node {
+	for _, n := range s {
+		if n.Op == OKEY {
+			return n.Right
 		}
 	}
 	return nil
 }
 
-func checkarglist(all *NodeList, input int) *NodeList {
-	named := 0
-	for l := all; l != nil; l = l.Next {
-		if l.N.Op == OKEY {
-			named = 1
+func checkarglist(all []*Node, input int) []*Node {
+	named := false
+	for _, n := range all {
+		if n.Op == OKEY {
+			named = true
 			break
 		}
 	}
 
-	if named != 0 {
-		var n *Node
-		var l *NodeList
-		for l = all; l != nil; l = l.Next {
-			n = l.N
+	if named {
+		ok := true
+		for _, n := range all {
 			if n.Op != OKEY && n.Sym == nil {
 				Yyerror("mixed named and unnamed function parameters")
+				ok = false
 				break
 			}
 		}
 
-		if l == nil && n != nil && n.Op != OKEY {
+		if ok && len(all) > 0 && all[len(all)-1].Op != OKEY {
 			Yyerror("final function parameter must have type")
 		}
 	}
 
 	var nextt *Node
-	var t *Node
-	var n *Node
-	for l := all; l != nil; l = l.Next {
+	for i, n := range all {
 		// can cache result from findtype to avoid
 		// quadratic behavior here, but unlikely to matter.
-		n = l.N
 
-		if named != 0 {
+		var t *Node
+		if named {
 			if n.Op == OKEY {
 				t = n.Right
 				n = n.Left
 				nextt = nil
 			} else {
 				if nextt == nil {
-					nextt = findtype(l)
+					nextt = findtype(all[i:])
 				}
 				t = nextt
 			}
@@ -1107,7 +1098,7 @@ func checkarglist(all *NodeList, input int) *NodeList {
 		if n.Right != nil && n.Right.Op == ODDD {
 			if input == 0 {
 				Yyerror("cannot use ... in output argument list")
-			} else if l.Next != nil {
+			} else if i+1 < len(all) {
 				Yyerror("can only use ... as final argument in list")
 			}
 			n.Right.Op = OTARRAY
@@ -1119,7 +1110,7 @@ func checkarglist(all *NodeList, input int) *NodeList {
 			}
 		}
 
-		l.N = n
+		all[i] = n
 	}
 
 	return all
@@ -1181,11 +1172,11 @@ func functype0(t *Type, this *Node, in, out []*Node) {
 	if this != nil {
 		t.Thistuple = 1
 	}
-	t.Outtuple = nodeSeqLen(out)
-	t.Intuple = nodeSeqLen(in)
+	t.Outtuple = len(out)
+	t.Intuple = len(in)
 	t.Outnamed = false
-	if t.Outtuple > 0 && nodeSeqFirst(out).Left != nil && nodeSeqFirst(out).Left.Orig != nil {
-		s := nodeSeqFirst(out).Left.Orig.Sym
+	if t.Outtuple > 0 && out[0].Left != nil && out[0].Left.Orig != nil {
+		s := out[0].Left.Orig.Sym
 		if s != nil && (s.Name[0] != '~' || s.Name[1] != 'r') { // ~r%d is the name invented for an unnamed result
 			t.Outnamed = true
 		}

src/cmd/compile/internal/gc/esc.go

@@ -54,13 +54,13 @@ type bottomUpVisitor struct {
 // If recursive is false, the list consists of only a single function and its closures.
 // If recursive is true, the list may still contain only a single function,
 // if that function is itself recursive.
-func visitBottomUp(list *NodeList, analyze func(list []*Node, recursive bool)) {
+func visitBottomUp(list []*Node, analyze func(list []*Node, recursive bool)) {
 	var v bottomUpVisitor
 	v.analyze = analyze
 	v.nodeID = make(map[*Node]uint32)
-	for l := list; l != nil; l = l.Next {
-		if l.N.Op == ODCLFUNC && l.N.Func.FCurfn == nil {
-			v.visit(l.N)
+	for _, n := range list {
+		if n.Op == ODCLFUNC && n.Func.FCurfn == nil {
+			v.visit(n)
 		}
 	}
 }
@@ -183,7 +183,7 @@ func (v *bottomUpVisitor) visitcode(n *Node, min uint32) uint32 {
 // needs to be moved to the heap, and new(T) and slice
 // literals are always real allocations.
 
-func escapes(all *NodeList) {
+func escapes(all []*Node) {
 	visitBottomUp(all, escAnalyze)
 }
 

src/cmd/compile/internal/gc/fmt.go

@@ -1700,7 +1700,9 @@ func Nconv(n *Node, flag int) string {
 
 func (l *NodeList) String() string {
 	var n Nodes
-	n.Set(nodeSeqSlice(l))
+	for ll := l; ll != nil; ll = ll.Next {
+		n.Append(ll.N)
+	}
 	return Hconv(n, 0)
 }
 

src/cmd/compile/internal/gc/gen.go

@@ -439,7 +439,7 @@ func cgen_dottype(n *Node, res, resok *Node, wb bool) {
 		call := Nod(OCALLFUNC, fn, nil)
 		r1.Type = byteptr
 		r2.Type = byteptr
-		setNodeSeq(&call.List, list(list(list1(&r1), &r2), typename(n.Left.Type)))
+		call.List.Set([]*Node{&r1, &r2, typename(n.Left.Type)})
 		call.List.Set(ascompatte(OCALLFUNC, call, false, fn.Type.Params(), call.List.Slice(), 0, nil))
 		gen(call)
 		Regfree(&r1)
@@ -525,7 +525,7 @@ func Cgen_As2dottype(n, res, resok *Node) {
 	fn := syslook("panicdottype")
 	dowidth(fn.Type)
 	call := Nod(OCALLFUNC, fn, nil)
-	setNodeSeq(&call.List, list(list(list1(&r1), &r2), typename(n.Left.Type)))
+	call.List.Set([]*Node{&r1, &r2, typename(n.Left.Type)})
 	call.List.Set(ascompatte(OCALLFUNC, call, false, fn.Type.Params(), call.List.Slice(), 0, nil))
 	gen(call)
 	Regfree(&r1)

src/cmd/compile/internal/gc/go.go

@@ -346,7 +346,7 @@ var minfltval [NTYPE]*Mpflt
 
 var maxfltval [NTYPE]*Mpflt
 
-var xtop *NodeList
+var xtop []*Node
 
 var externdcl []*Node
 
@@ -364,7 +364,7 @@ var statuniqgen int // name generator for static temps
 
 var iota_ int32
 
-var lastconst *NodeList
+var lastconst []*Node
 
 var lasttype *Node
 

src/cmd/compile/internal/gc/init.go

@@ -88,13 +88,13 @@ func anyinit(n []*Node) bool {
 	return false
 }
 
-func fninit(n *NodeList) {
+func fninit(n []*Node) {
 	if Debug['A'] != 0 {
 		// sys.go or unsafe.go during compiler build
 		return
 	}
 
-	nf := initfix(nodeSeqSlice(n))
+	nf := initfix(n)
 	if !anyinit(nf) {
 		return
 	}

src/cmd/compile/internal/gc/inl.go

@@ -41,7 +41,7 @@ var inlfn *Node // function currently being inlined
 
 var inlretlabel *Node // target of the goto substituted in place of a return
 
-var inlretvars *NodeList // temp out variables
+var inlretvars []*Node // temp out variables
 
 // Get the function's package. For ordinary functions it's on the ->sym, but for imported methods
 // the ->sym can be re-used in the local package, so peel it off the receiver's type.
@@ -246,7 +246,7 @@ func ishairy(n *Node, budget *int) bool {
 // Any name-like node of non-local class is marked for re-export by adding it to
 // the exportlist.
 func inlcopylist(ll []*Node) []*Node {
-	s := make([]*Node, 0, nodeSeqLen(ll))
+	s := make([]*Node, 0, len(ll))
 	for _, n := range ll {
 		s = append(s, inlcopy(n))
 	}
@@ -607,11 +607,10 @@ func mkinlcall1(np **Node, fn *Node, isddd bool) {
 		}
 
 		ninit.Append(Nod(ODCL, m, nil))
-		inlretvars = list(inlretvars, m)
+		inlretvars = append(inlretvars, m)
 	}
 
 	// assign receiver.
-	var as *Node
 	if fn.Type.Thistuple != 0 && n.Left.Op == ODOTMETH {
 		// method call with a receiver.
 		t := fn.Type.Recv()
@@ -625,7 +624,7 @@ func mkinlcall1(np **Node, fn *Node, isddd bool) {
 		if t == nil {
 			Fatalf("method call unknown receiver type: %v", Nconv(n, obj.FmtSign))
 		}
-		as = Nod(OAS, tinlvar(t), n.Left.Left)
+		as := Nod(OAS, tinlvar(t), n.Left.Left)
 		if as != nil {
 			typecheck(&as, Etop)
 			ninit.Append(as)
@@ -670,7 +669,7 @@ func mkinlcall1(np **Node, fn *Node, isddd bool) {
 	}
 
 	// assign arguments to the parameters' temp names
-	as = Nod(OAS2, nil, nil)
+	as := Nod(OAS2, nil, nil)
 
 	as.Rlist.Set(n.List.Slice())
 	li := 0
@@ -779,8 +778,8 @@ func mkinlcall1(np **Node, fn *Node, isddd bool) {
 	}
 
 	// zero the outparams
-	for ll := inlretvars; ll != nil; ll = ll.Next {
-		as = Nod(OAS, ll.N, nil)
+	for _, n := range inlretvars {
+		as = Nod(OAS, n, nil)
 		typecheck(&as, Etop)
 		ninit.Append(as)
 	}
@@ -800,7 +799,7 @@ func mkinlcall1(np **Node, fn *Node, isddd bool) {
 
 	call.Ninit.Set(ninit.Slice())
 	call.Nbody.Set(body)
-	setNodeSeq(&call.Rlist, inlretvars)
+	call.Rlist.Set(inlretvars)
 	call.Type = n.Type
 	call.Typecheck = 1
 
@@ -940,12 +939,12 @@ func inlsubst(n *Node) *Node {
 
 		m.Ninit.Set(inlsubstlist(n.Ninit))
 
-		if inlretvars != nil && n.List.Len() != 0 {
+		if len(inlretvars) != 0 && 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 {
-				as.List.Append(ll.N)
+			for _, n := range inlretvars {
+				as.List.Append(n)
 			}
 			as.Rlist.Set(inlsubstlist(n.List))
 			typecheck(&as, Etop)

src/cmd/compile/internal/gc/lex.go

@@ -381,31 +381,35 @@ func Main() {
 	//   and methods but doesn't depend on any of it.
 	defercheckwidth()
 
-	for l := xtop; l != nil; l = l.Next {
-		if l.N.Op != ODCL && l.N.Op != OAS && l.N.Op != OAS2 {
-			typecheck(&l.N, Etop)
+	// Don't use range--typecheck can add closures to xtop.
+	for i := 0; i < len(xtop); i++ {
+		if xtop[i].Op != ODCL && xtop[i].Op != OAS && xtop[i].Op != OAS2 {
+			typecheck(&xtop[i], Etop)
 		}
 	}
 
 	// Phase 2: Variable assignments.
 	//   To check interface assignments, depends on phase 1.
-	for l := xtop; l != nil; l = l.Next {
-		if l.N.Op == ODCL || l.N.Op == OAS || l.N.Op == OAS2 {
-			typecheck(&l.N, Etop)
+
+	// Don't use range--typecheck can add closures to xtop.
+	for i := 0; i < len(xtop); i++ {
+		if xtop[i].Op == ODCL || xtop[i].Op == OAS || xtop[i].Op == OAS2 {
+			typecheck(&xtop[i], Etop)
 		}
 	}
 	resumecheckwidth()
 
 	// Phase 3: Type check function bodies.
-	for l := xtop; l != nil; l = l.Next {
-		if l.N.Op == ODCLFUNC || l.N.Op == OCLOSURE {
-			Curfn = l.N
+	// Don't use range--typecheck can add closures to xtop.
+	for i := 0; i < len(xtop); i++ {
+		if xtop[i].Op == ODCLFUNC || xtop[i].Op == OCLOSURE {
+			Curfn = xtop[i]
 			decldepth = 1
 			saveerrors()
-			typechecklist(l.N.Nbody.Slice(), Etop)
-			checkreturn(l.N)
+			typechecklist(Curfn.Nbody.Slice(), Etop)
+			checkreturn(Curfn)
 			if nerrors != 0 {
-				l.N.Nbody.Set(nil) // type errors; do not compile
+				Curfn.Nbody.Set(nil) // type errors; do not compile
 			}
 		}
 	}
@@ -413,10 +417,10 @@ func Main() {
 	// Phase 4: Decide how to capture closed variables.
 	// This needs to run before escape analysis,
 	// because variables captured by value do not escape.
-	for l := xtop; l != nil; l = l.Next {
-		if l.N.Op == ODCLFUNC && l.N.Func.Closure != nil {
-			Curfn = l.N
-			capturevars(l.N)
+	for _, n := range xtop {
+		if n.Op == ODCLFUNC && n.Func.Closure != nil {
+			Curfn = n
+			capturevars(n)
 		}
 	}
 
@@ -469,19 +473,20 @@ func Main() {
 	// Phase 7: Transform closure bodies to properly reference captured variables.
 	// This needs to happen before walk, because closures must be transformed
 	// before walk reaches a call of a closure.
-	for l := xtop; l != nil; l = l.Next {
-		if l.N.Op == ODCLFUNC && l.N.Func.Closure != nil {
-			Curfn = l.N
-			transformclosure(l.N)
+	for _, n := range xtop {
+		if n.Op == ODCLFUNC && n.Func.Closure != nil {
+			Curfn = n
+			transformclosure(n)
 		}
 	}
 
 	Curfn = nil
 
 	// Phase 8: Compile top level functions.
-	for l := xtop; l != nil; l = l.Next {
-		if l.N.Op == ODCLFUNC {
-			funccompile(l.N)
+	// Don't use range--walk can add functions to xtop.
+	for i := 0; i < len(xtop); i++ {
+		if xtop[i].Op == ODCLFUNC {
+			funccompile(xtop[i])
 		}
 	}
 

src/cmd/compile/internal/gc/order.go

@@ -331,7 +331,7 @@ func ismulticall(l Nodes) bool {
 
 // Copyret emits t1, t2, ... = n, where n is a function call,
 // and then returns the list t1, t2, ....
-func copyret(n *Node, order *Order) Nodes {
+func copyret(n *Node, order *Order) []*Node {
 	if n.Type.Etype != TSTRUCT || !n.Type.Funarg {
 		Fatalf("copyret %v %d", n.Type, n.Left.Type.Outtuple)
 	}
@@ -350,20 +350,16 @@ func copyret(n *Node, order *Order) Nodes {
 	typecheck(&as, Etop)
 	orderstmt(as, order)
 
-	var r Nodes
-	r.Set(l2)
-	return r
+	return l2
 }
 
-// Ordercallargs orders the list of call arguments l and returns the
-// ordered list.
-func ordercallargs(l Nodes, order *Order) Nodes {
-	if ismulticall(l) {
+// Ordercallargs orders the list of call arguments *l.
+func ordercallargs(l *Nodes, order *Order) {
+	if ismulticall(*l) {
 		// return f() where f() is multiple values.
-		return copyret(l.First(), order)
+		l.Set(copyret(l.First(), order))
 	} else {
-		orderexprlist(l, order)
-		return l
+		orderexprlist(*l, order)
 	}
 }
 
@@ -372,7 +368,7 @@ func ordercallargs(l Nodes, order *Order) Nodes {
 func ordercall(n *Node, order *Order) {
 	orderexpr(&n.Left, order, nil)
 	orderexpr(&n.Right, order, nil) // ODDDARG temp
-	setNodeSeq(&n.List, ordercallargs(n.List, order))
+	ordercallargs(&n.List, order)
 
 	if n.Op == OCALLFUNC {
 		t := n.Left.Type.Params().Type
@@ -779,7 +775,7 @@ func orderstmt(n *Node, order *Order) {
 		cleantemp(t, order)
 
 	case ORETURN:
-		setNodeSeq(&n.List, ordercallargs(n.List, order))
+		ordercallargs(&n.List, order)
 		order.out = append(order.out, n)
 
 	// Special: clean case temporaries in each block entry.
@@ -887,7 +883,7 @@ func orderstmt(n *Node, order *Order) {
 							n2.Ninit.Append(tmp2)
 						}
 
-						setNodeSeq(&r.List, list1(ordertemp(tmp1.Type, order, false)))
+						r.List.Set([]*Node{ordertemp(tmp1.Type, order, false)})
 						tmp2 = Nod(OAS, tmp1, r.List.First())
 						typecheck(&tmp2, Etop)
 						n2.Ninit.Append(tmp2)
@@ -1128,7 +1124,7 @@ func orderexpr(np **Node, order *Order, lhs *Node) {
 		}
 
 	case OAPPEND:
-		setNodeSeq(&n.List, ordercallargs(n.List, order))
+		ordercallargs(&n.List, order)
 		if lhs == nil || lhs.Op != ONAME && !samesafeexpr(lhs, n.List.First()) {
 			n = ordercopyexpr(n, n.Type, order, 0)
 		}

src/cmd/compile/internal/gc/parser.go

@@ -263,7 +263,7 @@ func (p *parser) file() {
 		p.want(';')
 	}
 
-	xtop = concat(xtop, p.xdcl_list())
+	xtop = append(xtop, p.xdcl_list()...)
 
 	p.want(EOF)
 }
@@ -427,12 +427,12 @@ func (p *parser) import_package() {
 // ConstDecl   = "const" ( ConstSpec | "(" { ConstSpec ";" } ")" ) .
 // TypeDecl    = "type" ( TypeSpec | "(" { TypeSpec ";" } ")" ) .
 // VarDecl     = "var" ( VarSpec | "(" { VarSpec ";" } ")" ) .
-func (p *parser) common_dcl() *NodeList {
+func (p *parser) common_dcl() []*Node {
 	if trace && Debug['x'] != 0 {
 		defer p.trace("common_dcl")()
 	}
 
-	var dcl func() *NodeList
+	var dcl func() []*Node
 	switch p.tok {
 	case LVAR:
 		dcl = p.vardcl
@@ -449,34 +449,34 @@ func (p *parser) common_dcl() *NodeList {
 	}
 
 	p.next()
-	var l *NodeList
+	var s []*Node
 	if p.got('(') {
 		for p.tok != EOF && p.tok != ')' {
-			l = concat(l, dcl())
+			s = append(s, dcl()...)
 			if !p.osemi(')') {
 				break
 			}
 		}
 		p.want(')')
 	} else {
-		l = dcl()
+		s = dcl()
 	}
 
 	iota_ = -100000
 	lastconst = nil
 
-	return l
+	return s
 }
 
 // VarSpec = IdentifierList ( Type [ "=" ExpressionList ] | "=" ExpressionList ) .
-func (p *parser) vardcl() *NodeList {
+func (p *parser) vardcl() []*Node {
 	if trace && Debug['x'] != 0 {
 		defer p.trace("vardcl")()
 	}
 
 	names := p.dcl_name_list()
 	var typ *Node
-	var exprs *NodeList
+	var exprs []*Node
 	if p.got('=') {
 		exprs = p.expr_list()
 	} else {
@@ -490,14 +490,14 @@ func (p *parser) vardcl() *NodeList {
 }
 
 // ConstSpec = IdentifierList [ [ Type ] "=" ExpressionList ] .
-func (p *parser) constdcl() *NodeList {
+func (p *parser) constdcl() []*Node {
 	if trace && Debug['x'] != 0 {
 		defer p.trace("constdcl")()
 	}
 
 	names := p.dcl_name_list()
 	var typ *Node
-	var exprs *NodeList
+	var exprs []*Node
 	if p.tok != EOF && p.tok != ';' && p.tok != ')' {
 		typ = p.try_ntype()
 		if p.got('=') {
@@ -509,7 +509,7 @@ func (p *parser) constdcl() *NodeList {
 }
 
 // TypeSpec = identifier Type .
-func (p *parser) typedcl() *NodeList {
+func (p *parser) typedcl() []*Node {
 	if trace && Debug['x'] != 0 {
 		defer p.trace("typedcl")()
 	}
@@ -523,7 +523,7 @@ func (p *parser) typedcl() *NodeList {
 		p.advance(';', ')')
 	}
 
-	return list1(typedcl1(name, typ, true))
+	return []*Node{typedcl1(name, typ, true)}
 }
 
 // SimpleStmt = EmptyStmt | ExpressionStmt | SendStmt | IncDecStmt | Assignment | ShortVarDecl .
@@ -543,9 +543,9 @@ func (p *parser) simple_stmt(labelOk, rangeOk bool) *Node {
 
 	lhs := p.expr_list()
 
-	if count(lhs) == 1 && p.tok != '=' && p.tok != LCOLAS && p.tok != LRANGE {
+	if len(lhs) == 1 && p.tok != '=' && p.tok != LCOLAS && p.tok != LRANGE {
 		// expr
-		lhs := lhs.N
+		lhs := lhs[0]
 		switch p.tok {
 		case LASOP:
 			// expr LASOP expr
@@ -606,7 +606,7 @@ func (p *parser) simple_stmt(labelOk, rangeOk bool) *Node {
 		if rangeOk && p.got(LRANGE) {
 			// expr_list '=' LRANGE expr
 			r := Nod(ORANGE, nil, p.expr())
-			setNodeSeq(&r.List, lhs)
+			r.List.Set(lhs)
 			r.Etype = 0 // := flag
 			return r
 		}
@@ -614,14 +614,14 @@ func (p *parser) simple_stmt(labelOk, rangeOk bool) *Node {
 		// expr_list '=' expr_list
 		rhs := p.expr_list()
 
-		if lhs.Next == nil && rhs.Next == nil {
+		if len(lhs) == 1 && len(rhs) == 1 {
 			// simple
-			return Nod(OAS, lhs.N, rhs.N)
+			return Nod(OAS, lhs[0], rhs[0])
 		}
 		// multiple
 		stmt := Nod(OAS2, nil, nil)
-		setNodeSeq(&stmt.List, lhs)
-		setNodeSeq(&stmt.Rlist, rhs)
+		stmt.List.Set(lhs)
+		stmt.Rlist.Set(rhs)
 		return stmt
 
 	case LCOLAS:
@@ -631,7 +631,7 @@ func (p *parser) simple_stmt(labelOk, rangeOk bool) *Node {
 		if rangeOk && p.got(LRANGE) {
 			// expr_list LCOLAS LRANGE expr
 			r := Nod(ORANGE, nil, p.expr())
-			setNodeSeq(&r.List, lhs)
+			r.List.Set(lhs)
 			r.Colas = true
 			colasdefn(r.List, r)
 			return r
@@ -640,17 +640,17 @@ func (p *parser) simple_stmt(labelOk, rangeOk bool) *Node {
 		// expr_list LCOLAS expr_list
 		rhs := p.expr_list()
 
-		if rhs.N.Op == OTYPESW {
-			ts := Nod(OTYPESW, nil, rhs.N.Right)
-			if rhs.Next != nil {
+		if rhs[0].Op == OTYPESW {
+			ts := Nod(OTYPESW, nil, rhs[0].Right)
+			if len(rhs) > 1 {
 				Yyerror("expr.(type) must be alone in list")
 			}
-			if lhs.Next != nil {
-				Yyerror("argument count mismatch: %d = %d", count(lhs), 1)
-			} else if (lhs.N.Op != ONAME && lhs.N.Op != OTYPE && lhs.N.Op != ONONAME && (lhs.N.Op != OLITERAL || lhs.N.Name == nil)) || isblank(lhs.N) {
-				Yyerror("invalid variable name %s in type switch", lhs.N)
+			if len(lhs) > 1 {
+				Yyerror("argument count mismatch: %d = %d", len(lhs), 1)
+			} else if (lhs[0].Op != ONAME && lhs[0].Op != OTYPE && lhs[0].Op != ONONAME && (lhs[0].Op != OLITERAL || lhs[0].Name == nil)) || isblank(lhs[0]) {
+				Yyerror("invalid variable name %s in type switch", lhs[0])
 			} else {
-				ts.Left = dclname(lhs.N.Sym)
+				ts.Left = dclname(lhs[0].Sym)
 			} // it's a colas, so must not re-use an oldname
 			return ts
 		}
@@ -720,7 +720,7 @@ func (p *parser) case_(tswitch *Node) *Node {
 			// done in casebody()
 			markdcl() // matching popdcl in caseblock
 			stmt := Nod(OXCASE, nil, nil)
-			setNodeSeq(&stmt.List, cases)
+			stmt.List.Set(cases)
 			if tswitch != nil {
 				if n := tswitch.Left; n != nil {
 					// type switch - declare variable
@@ -747,11 +747,11 @@ func (p *parser) case_(tswitch *Node) *Node {
 			markdcl() // matching popdcl in caseblock
 			stmt := Nod(OXCASE, nil, nil)
 			var n *Node
-			if cases.Next == nil {
-				n = Nod(OAS, cases.N, rhs)
+			if len(cases) == 1 {
+				n = Nod(OAS, cases[0], rhs)
 			} else {
 				n = Nod(OAS2, nil, nil)
-				setNodeSeq(&n.List, cases)
+				n.List.Set(cases)
 				n.Rlist.Set([]*Node{rhs})
 			}
 			stmt.List.Set([]*Node{n})
@@ -770,7 +770,7 @@ func (p *parser) case_(tswitch *Node) *Node {
 			// done in casebody()
 			markdcl() // matching popdcl in caseblock
 			stmt := Nod(OXCASE, nil, nil)
-			stmt.List.Set([]*Node{colas(cases, list1(rhs), lno)})
+			stmt.List.Set([]*Node{colas(cases, []*Node{rhs}, lno)})
 
 			p.want(':') // consume ':' after declaring select cases for correct lineno
 			return stmt
@@ -834,10 +834,10 @@ func (p *parser) compound_stmt(else_clause bool) *Node {
 	p.want('}')
 
 	var stmt *Node
-	if l == nil {
+	if len(l) == 0 {
 		stmt = Nod(OEMPTY, nil, nil)
 	} else {
-		stmt = liststmt(nodeSeqSlice(l))
+		stmt = liststmt(l)
 	}
 	popdcl()
 
@@ -856,7 +856,7 @@ func (p *parser) caseblock(tswitch *Node) *Node {
 
 	stmt := p.case_(tswitch) // does markdcl
 	stmt.Xoffset = int64(block)
-	stmt.Nbody.SetToNodeList(p.stmt_list())
+	stmt.Nbody.Set(p.stmt_list())
 
 	popdcl()
 
@@ -864,7 +864,7 @@ func (p *parser) caseblock(tswitch *Node) *Node {
 }
 
 // caseblock_list parses a superset of switch and select clause lists.
-func (p *parser) caseblock_list(tswitch *Node) (l *NodeList) {
+func (p *parser) caseblock_list(tswitch *Node) (l []*Node) {
 	if trace && Debug['x'] != 0 {
 		defer p.trace("caseblock_list")()
 	}
@@ -875,14 +875,14 @@ func (p *parser) caseblock_list(tswitch *Node) (l *NodeList) {
 	}
 
 	for p.tok != EOF && p.tok != '}' {
-		l = list(l, p.caseblock(tswitch))
+		l = append(l, p.caseblock(tswitch))
 	}
 	p.want('}')
 	return
 }
 
 // loop_body parses if and for statement bodies.
-func (p *parser) loop_body(context string) *NodeList {
+func (p *parser) loop_body(context string) []*Node {
 	if trace && Debug['x'] != 0 {
 		defer p.trace("loop_body")()
 	}
@@ -944,7 +944,7 @@ func (p *parser) for_body() *Node {
 	stmt := p.for_header()
 	body := p.loop_body("for clause")
 
-	stmt.Nbody.AppendNodeList(body)
+	stmt.Nbody.Append(body...)
 	return stmt
 }
 
@@ -1043,7 +1043,7 @@ func (p *parser) if_stmt() *Node {
 		Yyerror("missing condition in if statement")
 	}
 
-	stmt.Nbody.SetToNodeList(p.loop_body("if clause"))
+	stmt.Nbody.Set(p.loop_body("if clause"))
 
 	if p.got(LELSE) {
 		if p.tok == LIF {
@@ -1083,7 +1083,7 @@ func (p *parser) switch_stmt() *Node {
 		tswitch = nil
 	}
 
-	setNodeSeq(&hdr.List, p.caseblock_list(tswitch))
+	hdr.List.Set(p.caseblock_list(tswitch))
 	popdcl()
 
 	return hdr
@@ -1097,7 +1097,7 @@ func (p *parser) select_stmt() *Node {
 
 	p.want(LSELECT)
 	hdr := Nod(OSELECT, nil, nil)
-	setNodeSeq(&hdr.List, p.caseblock_list(nil))
+	hdr.List.Set(p.caseblock_list(nil))
 	return hdr
 }
 
@@ -1445,7 +1445,7 @@ loop:
 
 			// call or conversion
 			x = Nod(OCALL, x, nil)
-			setNodeSeq(&x.List, args)
+			x.List.Set(args)
 			x.Isddd = ddd
 
 		case '{':
@@ -1695,8 +1695,8 @@ func (p *parser) try_ntype() *Node {
 		result := p.fnres()
 		params = checkarglist(params, 1)
 		t := Nod(OTFUNC, nil, nil)
-		setNodeSeq(&t.List, params)
-		setNodeSeq(&t.Rlist, result)
+		t.List.Set(params)
+		t.Rlist.Set(result)
 		return t
 
 	case '[':
@@ -1810,9 +1810,9 @@ func (p *parser) structtype() *Node {
 
 	p.want(LSTRUCT)
 	p.want('{')
-	var l *NodeList
+	var l []*Node
 	for p.tok != EOF && p.tok != '}' {
-		l = concat(l, p.structdcl())
+		l = append(l, p.structdcl()...)
 		if !p.osemi('}') {
 			break
 		}
@@ -1820,7 +1820,7 @@ func (p *parser) structtype() *Node {
 	p.want('}')
 
 	t := Nod(OTSTRUCT, nil, nil)
-	setNodeSeq(&t.List, l)
+	t.List.Set(l)
 	return t
 }
 
@@ -1862,9 +1862,9 @@ func (p *parser) xfndcl() *Node {
 		return nil
 	}
 
-	f.Nbody.SetToNodeList(body)
+	f.Nbody.Set(body)
 	f.Noescape = p.pragma&Noescape != 0
-	if f.Noescape && body != nil {
+	if f.Noescape && len(body) != 0 {
 		Yyerror("can only use //go:noescape with external func implementations")
 	}
 	f.Func.Pragma = p.pragma
@@ -1896,20 +1896,20 @@ func (p *parser) fndcl(nointerface bool) *Node {
 
 		if name.Name == "init" {
 			name = renameinit()
-			if params != nil || result != nil {
+			if len(params) != 0 || len(result) != 0 {
 				Yyerror("func init must have no arguments and no return values")
 			}
 		}
 
 		if localpkg.Name == "main" && name.Name == "main" {
-			if params != nil || result != nil {
+			if len(params) != 0 || len(result) != 0 {
 				Yyerror("func main must have no arguments and no return values")
 			}
 		}
 
 		t := Nod(OTFUNC, nil, nil)
-		setNodeSeq(&t.List, params)
-		setNodeSeq(&t.Rlist, result)
+		t.List.Set(params)
+		t.Rlist.Set(result)
 
 		f := Nod(ODCLFUNC, nil, nil)
 		f.Func.Nname = newfuncname(name)
@@ -1930,25 +1930,25 @@ func (p *parser) fndcl(nointerface bool) *Node {
 		rparam = checkarglist(rparam, 0)
 		params = checkarglist(params, 1)
 
-		if rparam == nil {
+		if len(rparam) == 0 {
 			Yyerror("method has no receiver")
 			return nil
 		}
 
-		if rparam.Next != nil {
+		if len(rparam) > 1 {
 			Yyerror("method has multiple receivers")
 			return nil
 		}
 
-		rcvr := rparam.N
+		rcvr := rparam[0]
 		if rcvr.Op != ODCLFIELD {
 			Yyerror("bad receiver in method")
 			return nil
 		}
 
 		t := Nod(OTFUNC, rcvr, nil)
-		setNodeSeq(&t.List, params)
-		setNodeSeq(&t.Rlist, result)
+		t.List.Set(params)
+		t.Rlist.Set(result)
 
 		f := Nod(ODCLFUNC, nil, nil)
 		f.Func.Shortname = newfuncname(name)
@@ -1983,7 +1983,7 @@ func (p *parser) hidden_fndcl() *Node {
 		s5 := p.ohidden_funres()
 
 		s := s1
-		t := functype(nil, nodeSeqSlice(s3), nodeSeqSlice(s5))
+		t := functype(nil, s3, s5)
 
 		importsym(s, ONAME)
 		if s.Def != nil && s.Def.Op == ONAME {
@@ -2012,8 +2012,8 @@ func (p *parser) hidden_fndcl() *Node {
 		p.want(')')
 		s8 := p.ohidden_funres()
 
-		ss := methodname1(newname(s4), s2.N.Right)
-		ss.Type = functype(s2.N, nodeSeqSlice(s6), nodeSeqSlice(s8))
+		ss := methodname1(newname(s4), s2[0].Right)
+		ss.Type = functype(s2[0], s6, s8)
 
 		checkwidth(ss.Type)
 		addmethod(s4, ss.Type, false, false)
@@ -2029,7 +2029,7 @@ func (p *parser) hidden_fndcl() *Node {
 }
 
 // FunctionBody = Block .
-func (p *parser) fnbody() *NodeList {
+func (p *parser) fnbody() []*Node {
 	if trace && Debug['x'] != 0 {
 		defer p.trace("fnbody")()
 	}
@@ -2040,7 +2040,7 @@ func (p *parser) fnbody() *NodeList {
 		p.fnest--
 		p.want('}')
 		if body == nil {
-			body = list1(Nod(OEMPTY, nil, nil))
+			body = []*Node{Nod(OEMPTY, nil, nil)}
 		}
 		return body
 	}
@@ -2049,7 +2049,7 @@ func (p *parser) fnbody() *NodeList {
 }
 
 // Result = Parameters | Type .
-func (p *parser) fnres() *NodeList {
+func (p *parser) fnres() []*Node {
 	if trace && Debug['x'] != 0 {
 		defer p.trace("fnres")()
 	}
@@ -2060,7 +2060,7 @@ func (p *parser) fnres() *NodeList {
 	}
 
 	if result := p.try_ntype(); result != nil {
-		return list1(Nod(ODCLFIELD, nil, result))
+		return []*Node{Nod(ODCLFIELD, nil, result)}
 	}
 
 	return nil
@@ -2068,7 +2068,7 @@ func (p *parser) fnres() *NodeList {
 
 // Declaration  = ConstDecl | TypeDecl | VarDecl .
 // TopLevelDecl = Declaration | FunctionDecl | MethodDecl .
-func (p *parser) xdcl_list() (l *NodeList) {
+func (p *parser) xdcl_list() (l []*Node) {
 	if trace && Debug['x'] != 0 {
 		defer p.trace("xdcl_list")()
 	}
@@ -2077,13 +2077,13 @@ loop:
 	for p.tok != EOF {
 		switch p.tok {
 		case LVAR, LCONST, LTYPE:
-			l = concat(l, p.common_dcl())
+			l = append(l, p.common_dcl()...)
 
 		case LFUNC:
-			l = list(l, p.xfndcl())
+			l = append(l, p.xfndcl())
 
 		default:
-			if p.tok == '{' && l != nil && l.End.N.Op == ODCLFUNC && len(l.End.N.Nbody.Slice()) == 0 {
+			if p.tok == '{' && len(l) != 0 && l[len(l)-1].Op == ODCLFUNC && l[len(l)-1].Nbody.Len() == 0 {
 				// opening { of function declaration on next line
 				p.syntax_error("unexpected semicolon or newline before {")
 			} else {
@@ -2113,7 +2113,7 @@ loop:
 // FieldDecl      = (IdentifierList Type | AnonymousField) [ Tag ] .
 // AnonymousField = [ "*" ] TypeName .
 // Tag            = string_lit .
-func (p *parser) structdcl() *NodeList {
+func (p *parser) structdcl() []*Node {
 	if trace && Debug['x'] != 0 {
 		defer p.trace("structdcl")()
 	}
@@ -2132,7 +2132,7 @@ func (p *parser) structdcl() *NodeList {
 			tag := p.oliteral()
 
 			field.SetVal(tag)
-			return list1(field)
+			return []*Node{field}
 		}
 
 		// LNAME belongs to first *Sym of new_name_list
@@ -2152,7 +2152,7 @@ func (p *parser) structdcl() *NodeList {
 		typ := p.ntype()
 		tag := p.oliteral()
 
-		if l := fields; l == nil || l.N.Sym.Name == "?" {
+		if l := fields; len(l) == 0 || l[0].Sym.Name == "?" {
 			// ? symbol, during import (list1(nil) == nil)
 			n := typ
 			if n.Op == OIND {
@@ -2161,12 +2161,12 @@ func (p *parser) structdcl() *NodeList {
 			n = embedded(n.Sym, importpkg)
 			n.Right = typ
 			n.SetVal(tag)
-			return list1(n)
+			return []*Node{n}
 		}
 
-		for l := fields; l != nil; l = l.Next {
-			l.N = Nod(ODCLFIELD, l.N, typ)
-			l.N.SetVal(tag)
+		for i, n := range fields {
+			fields[i] = Nod(ODCLFIELD, n, typ)
+			fields[i].SetVal(tag)
 		}
 		return fields
 
@@ -2181,7 +2181,7 @@ func (p *parser) structdcl() *NodeList {
 			field.Right = Nod(OIND, field.Right, nil)
 			field.SetVal(tag)
 			Yyerror("cannot parenthesize embedded type")
-			return list1(field)
+			return []*Node{field}
 
 		} else {
 			// '(' embed ')' oliteral
@@ -2191,7 +2191,7 @@ func (p *parser) structdcl() *NodeList {
 
 			field.SetVal(tag)
 			Yyerror("cannot parenthesize embedded type")
-			return list1(field)
+			return []*Node{field}
 		}
 
 	case '*':
@@ -2205,7 +2205,7 @@ func (p *parser) structdcl() *NodeList {
 			field.Right = Nod(OIND, field.Right, nil)
 			field.SetVal(tag)
 			Yyerror("cannot parenthesize embedded type")
-			return list1(field)
+			return []*Node{field}
 
 		} else {
 			// '*' embed oliteral
@@ -2214,7 +2214,7 @@ func (p *parser) structdcl() *NodeList {
 
 			field.Right = Nod(OIND, field.Right, nil)
 			field.SetVal(tag)
-			return list1(field)
+			return []*Node{field}
 		}
 
 	default:
@@ -2363,8 +2363,8 @@ func (p *parser) indcl() *Node {
 	// without func keyword
 	params = checkarglist(params, 1)
 	t := Nod(OTFUNC, fakethis(), nil)
-	setNodeSeq(&t.List, params)
-	setNodeSeq(&t.Rlist, result)
+	t.List.Set(params)
+	t.Rlist.Set(result)
 
 	return t
 }
@@ -2420,7 +2420,7 @@ func (p *parser) arg_type() *Node {
 
 // Parameters    = "(" [ ParameterList [ "," ] ] ")" .
 // ParameterList = ParameterDecl { "," ParameterDecl } .
-func (p *parser) param_list() (l *NodeList) {
+func (p *parser) param_list() (l []*Node) {
 	if trace && Debug['x'] != 0 {
 		defer p.trace("param_list")()
 	}
@@ -2428,7 +2428,7 @@ func (p *parser) param_list() (l *NodeList) {
 	p.want('(')
 
 	for p.tok != EOF && p.tok != ')' {
-		l = list(l, p.arg_type())
+		l = append(l, p.arg_type())
 		if !p.ocomma(')') {
 			break
 		}
@@ -2457,7 +2457,7 @@ func (p *parser) stmt() *Node {
 		return p.compound_stmt(false)
 
 	case LVAR, LCONST, LTYPE:
-		return liststmt(nodeSeqSlice(p.common_dcl()))
+		return liststmt(p.common_dcl())
 
 	case LNAME, '@', '?', LLITERAL, LFUNC, '(', // operands
 		'[', LSTRUCT, LMAP, LCHAN, LINTERFACE, // composite types
@@ -2507,13 +2507,13 @@ func (p *parser) stmt() *Node {
 
 	case LRETURN:
 		p.next()
-		var results *NodeList
+		var results []*Node
 		if p.tok != ';' && p.tok != '}' {
 			results = p.expr_list()
 		}
 
 		stmt := Nod(ORETURN, nil, nil)
-		setNodeSeq(&stmt.List, results)
+		stmt.List.Set(results)
 		if stmt.List.Len() == 0 && Curfn != nil {
 			for _, ln := range Curfn.Func.Dcl {
 				if ln.Class == PPARAM {
@@ -2539,7 +2539,7 @@ func (p *parser) stmt() *Node {
 }
 
 // StatementList = { Statement ";" } .
-func (p *parser) stmt_list() (l *NodeList) {
+func (p *parser) stmt_list() (l []*Node) {
 	if trace && Debug['x'] != 0 {
 		defer p.trace("stmt_list")()
 	}
@@ -2549,10 +2549,11 @@ func (p *parser) stmt_list() (l *NodeList) {
 		if s == missing_stmt {
 			break
 		}
-		if s != nil && s.Op == OBLOCK && s.Ninit.Len() == 0 {
-			appendNodeSeq(&l, s.List)
+		if s == nil {
+		} else if s.Op == OBLOCK && s.Ninit.Len() == 0 {
+			l = append(l, s.List.Slice()...)
 		} else {
-			appendNodeSeqNode(&l, s)
+			l = append(l, s)
 		}
 		// customized version of osemi:
 		// ';' is optional before a closing ')' or '}'
@@ -2570,7 +2571,7 @@ func (p *parser) stmt_list() (l *NodeList) {
 // IdentifierList = identifier { "," identifier } .
 //
 // If first != nil we have the first symbol already.
-func (p *parser) new_name_list(first *Sym) *NodeList {
+func (p *parser) new_name_list(first *Sym) []*Node {
 	if trace && Debug['x'] != 0 {
 		defer p.trace("new_name_list")()
 	}
@@ -2578,41 +2579,48 @@ func (p *parser) new_name_list(first *Sym) *NodeList {
 	if first == nil {
 		first = p.sym() // may still be nil
 	}
-	l := list1(p.new_name(first))
+	var l []*Node
+	n := p.new_name(first)
+	if n != nil {
+		l = append(l, n)
+	}
 	for p.got(',') {
-		l = list(l, p.new_name(p.sym()))
+		n = p.new_name(p.sym())
+		if n != nil {
+			l = append(l, n)
+		}
 	}
 	return l
 }
 
 // IdentifierList = identifier { "," identifier } .
-func (p *parser) dcl_name_list() *NodeList {
+func (p *parser) dcl_name_list() []*Node {
 	if trace && Debug['x'] != 0 {
 		defer p.trace("dcl_name_list")()
 	}
 
-	l := list1(p.dcl_name())
+	s := []*Node{p.dcl_name()}
 	for p.got(',') {
-		l = list(l, p.dcl_name())
+		s = append(s, p.dcl_name())
 	}
-	return l
+	return s
 }
 
 // ExpressionList = Expression { "," Expression } .
-func (p *parser) expr_list() *NodeList {
+func (p *parser) expr_list() []*Node {
 	if trace && Debug['x'] != 0 {
 		defer p.trace("expr_list")()
 	}
 
-	l := list1(p.expr())
+	l := []*Node{p.expr()}
 	for p.got(',') {
-		l = list(l, p.expr())
+		l = append(l, p.expr())
 	}
 	return l
 }
 
 // Arguments = "(" [ ( ExpressionList | Type [ "," ExpressionList ] ) [ "..." ] [ "," ] ] ")" .
-func (p *parser) arg_list() (l *NodeList, ddd bool) {
+func (p *parser) arg_list() (l []*Node, ddd bool) {
 	if trace && Debug['x'] != 0 {
 		defer p.trace("arg_list")()
 	}
@@ -2621,7 +2629,7 @@ func (p *parser) arg_list() (l *NodeList, ddd bool) {
 	p.xnest++
 
 	for p.tok != EOF && p.tok != ')' && !ddd {
-		l = list(l, p.expr()) // expr_or_type
+		l = append(l, p.expr()) // expr_or_type
 		ddd = p.got(LDDD)
 		if !p.ocomma(')') {
 			break
@@ -2734,36 +2742,36 @@ func (p *parser) hidden_importsym() *Sym {
 	}
 }
 
-func (p *parser) ohidden_funarg_list() *NodeList {
+func (p *parser) ohidden_funarg_list() []*Node {
 	if trace && Debug['x'] != 0 {
 		defer p.trace("ohidden_funarg_list")()
 	}
 
-	var ss *NodeList
+	var ss []*Node
 	if p.tok != ')' {
 		ss = p.hidden_funarg_list()
 	}
 	return ss
 }
 
-func (p *parser) ohidden_structdcl_list() *NodeList {
+func (p *parser) ohidden_structdcl_list() []*Node {
 	if trace && Debug['x'] != 0 {
 		defer p.trace("ohidden_structdcl_list")()
 	}
 
-	var ss *NodeList
+	var ss []*Node
 	if p.tok != '}' {
 		ss = p.hidden_structdcl_list()
 	}
 	return ss
 }
 
-func (p *parser) ohidden_interfacedcl_list() *NodeList {
+func (p *parser) ohidden_interfacedcl_list() []*Node {
 	if trace && Debug['x'] != 0 {
 		defer p.trace("ohidden_interfacedcl_list")()
 	}
 
-	var ss *NodeList
+	var ss []*Node
 	if p.tok != '}' {
 		ss = p.hidden_interfacedcl_list()
 	}
@@ -2843,7 +2851,7 @@ func (p *parser) hidden_import() {
 			return
 		}
 
-		s2.Func.Inl.SetToNodeList(s3)
+		s2.Func.Inl.Set(s3)
 
 		funcbody(s2)
 		importlist = append(importlist, s2)
@@ -2973,7 +2981,7 @@ func (p *parser) hidden_type_misc() *Type {
 		s3 := p.ohidden_structdcl_list()
 		p.want('}')
 
-		return tostruct(nodeSeqSlice(s3))
+		return tostruct(s3)
 
 	case LINTERFACE:
 		// LINTERFACE '{' ohidden_interfacedcl_list '}'
@@ -2982,7 +2990,7 @@ func (p *parser) hidden_type_misc() *Type {
 		s3 := p.ohidden_interfacedcl_list()
 		p.want('}')
 
-		return tointerface(nodeSeqSlice(s3))
+		return tointerface(s3)
 
 	case '*':
 		// '*' hidden_type
@@ -3053,7 +3061,7 @@ func (p *parser) hidden_type_func() *Type {
 	p.want(')')
 	s5 := p.ohidden_funres()
 
-	return functype(nil, nodeSeqSlice(s3), nodeSeqSlice(s5))
+	return functype(nil, s3, s5)
 }
 
 func (p *parser) hidden_funarg() *Node {
@@ -3159,10 +3167,10 @@ func (p *parser) hidden_interfacedcl() *Node {
 	p.want(')')
 	s5 := p.ohidden_funres()
 
-	return Nod(ODCLFIELD, newname(s1), typenod(functype(fakethis(), nodeSeqSlice(s3), nodeSeqSlice(s5))))
+	return Nod(ODCLFIELD, newname(s1), typenod(functype(fakethis(), s3, s5)))
 }
 
-func (p *parser) ohidden_funres() *NodeList {
+func (p *parser) ohidden_funres() []*Node {
 	if trace && Debug['x'] != 0 {
 		defer p.trace("ohidden_funres")()
 	}
@@ -3176,7 +3184,7 @@ func (p *parser) ohidden_funres() *NodeList {
 	}
 }
 
-func (p *parser) hidden_funres() *NodeList {
+func (p *parser) hidden_funres() []*Node {
 	if trace && Debug['x'] != 0 {
 		defer p.trace("hidden_funres")()
 	}
@@ -3190,7 +3198,7 @@ func (p *parser) hidden_funres() *NodeList {
 
 	default:
 		s1 := p.hidden_type()
-		return list1(Nod(ODCLFIELD, nil, typenod(s1)))
+		return []*Node{Nod(ODCLFIELD, nil, typenod(s1))}
 	}
 }
 
@@ -3283,44 +3291,44 @@ func (p *parser) hidden_import_list() {
 	}
 }
 
-func (p *parser) hidden_funarg_list() *NodeList {
+func (p *parser) hidden_funarg_list() []*Node {
 	if trace && Debug['x'] != 0 {
 		defer p.trace("hidden_funarg_list")()
 	}
 
 	s1 := p.hidden_funarg()
-	ss := list1(s1)
+	ss := []*Node{s1}
 	for p.got(',') {
 		s3 := p.hidden_funarg()
-		ss = list(ss, s3)
+		ss = append(ss, s3)
 	}
 	return ss
 }
 
-func (p *parser) hidden_structdcl_list() *NodeList {
+func (p *parser) hidden_structdcl_list() []*Node {
 	if trace && Debug['x'] != 0 {
 		defer p.trace("hidden_structdcl_list")()
 	}
 
 	s1 := p.hidden_structdcl()
-	ss := list1(s1)
+	ss := []*Node{s1}
 	for p.got(';') {
 		s3 := p.hidden_structdcl()
-		ss = list(ss, s3)
+		ss = append(ss, s3)
 	}
 	return ss
 }
 
-func (p *parser) hidden_interfacedcl_list() *NodeList {
+func (p *parser) hidden_interfacedcl_list() []*Node {
 	if trace && Debug['x'] != 0 {
 		defer p.trace("hidden_interfacedcl_list")()
 	}
 
 	s1 := p.hidden_interfacedcl()
-	ss := list1(s1)
+	ss := []*Node{s1}
 	for p.got(';') {
 		s3 := p.hidden_interfacedcl()
-		ss = list(ss, s3)
+		ss = append(ss, s3)
 	}
 	return ss
 }

src/cmd/compile/internal/gc/select.go

@@ -208,7 +208,7 @@ func walkselect(sel *Node) {
 			dflt = sel.List.First()
 		} else {
 			dflt = sel.List.Second()
-			cas = nodeSeqFirst(sel.List.Slice())
+			cas = sel.List.First()
 		}
 
 		n := cas.Left

src/cmd/compile/internal/gc/subr.go

@@ -2215,8 +2215,8 @@ func listtreecopy(l []*Node, lineno int32) []*Node {
 func liststmt(l []*Node) *Node {
 	n := Nod(OBLOCK, nil, nil)
 	n.List.Set(l)
-	if nodeSeqLen(l) != 0 {
-		n.Lineno = nodeSeqFirst(l).Lineno
+	if len(l) != 0 {
+		n.Lineno = l[0].Lineno
 	}
 	return n
 }
@@ -2545,7 +2545,7 @@ func mkpkg(path string) *Pkg {
 }
 
 func addinit(np **Node, init []*Node) {
-	if nodeSeqLen(init) == 0 {
+	if len(init) == 0 {
 		return
 	}
 
@@ -2561,7 +2561,7 @@ func addinit(np **Node, init []*Node) {
 		*np = n
 	}
 
-	n.Ninit.Set(append(nodeSeqSlice(init), n.Ninit.Slice()...))
+	n.Ninit.Set(append(init, n.Ninit.Slice()...))
 	n.Ullman = UINF
 }
 

src/cmd/compile/internal/gc/syntax.go

@@ -455,21 +455,6 @@ 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.
-// This wastes memory and should be used as little as possible.
-func (n *Nodes) NodeList() *NodeList {
-	if n.slice == nil {
-		return nil
-	}
-	var ret *NodeList
-	for _, n := range *n.slice {
-		ret = list(ret, n)
-	}
-	return ret
-}
-
 // Set sets n to a slice.
 // This takes ownership of the slice.
 func (n *Nodes) Set(s []*Node) {
@@ -521,253 +506,3 @@ func (n *Nodes) AppendNodes(n2 *Nodes) {
 	}
 	n2.slice = nil
 }
-
-// SetToNodeList sets Nodes to the contents of a NodeList.
-func (n *Nodes) SetToNodeList(l *NodeList) {
-	s := make([]*Node, 0, count(l))
-	for ; l != nil; l = l.Next {
-		s = append(s, l.N)
-	}
-	n.Set(s)
-}
-
-// AppendNodeList appends the contents of a NodeList.
-func (n *Nodes) AppendNodeList(l *NodeList) {
-	if n.slice == nil {
-		n.SetToNodeList(l)
-	} else {
-		for ; l != nil; l = l.Next {
-			*n.slice = append(*n.slice, l.N)
-		}
-	}
-}
-
-// nodesOrNodeList must be either type Nodes or type *NodeList, or, in
-// some cases, []*Node. It exists during the transition from NodeList
-// to Nodes only and then should be deleted. See nodeSeqIterate to
-// return an iterator from a nodesOrNodeList.
-type nodesOrNodeList interface{}
-
-// nodesOrNodeListPtr must be type *Nodes or type **NodeList, or, in
-// some cases, *[]*Node. It exists during the transition from NodeList
-// to Nodes only, and then should be deleted. See setNodeSeq to assign
-// to a generic value.
-type nodesOrNodeListPtr interface{}
-
-// nodeSeqLen returns the length of a *NodeList, a Nodes, a []*Node, or nil.
-func nodeSeqLen(ns nodesOrNodeList) int {
-	switch ns := ns.(type) {
-	case *NodeList:
-		return count(ns)
-	case Nodes:
-		return len(ns.Slice())
-	case []*Node:
-		return len(ns)
-	case nil:
-		return 0
-	default:
-		panic("can't happen")
-	}
-}
-
-// nodeSeqFirst returns the first element of a *NodeList, a Nodes,
-// or a []*Node. It panics if the sequence is empty.
-func nodeSeqFirst(ns nodesOrNodeList) *Node {
-	switch ns := ns.(type) {
-	case *NodeList:
-		return ns.N
-	case Nodes:
-		return ns.Slice()[0]
-	case []*Node:
-		return ns[0]
-	default:
-		panic("can't happen")
-	}
-}
-
-// nodeSeqSecond returns the second element of a *NodeList, a Nodes,
-// or a []*Node. It panics if the sequence has fewer than two elements.
-func nodeSeqSecond(ns nodesOrNodeList) *Node {
-	switch ns := ns.(type) {
-	case *NodeList:
-		return ns.Next.N
-	case Nodes:
-		return ns.Slice()[1]
-	case []*Node:
-		return ns[1]
-	default:
-		panic("can't happen")
-	}
-}
-
-// nodeSeqSlice returns a []*Node containing the contents of a
-// *NodeList, a Nodes, or a []*Node.
-// This is an interim function during the transition from NodeList to Nodes.
-// TODO(iant): Remove when transition is complete.
-func nodeSeqSlice(ns nodesOrNodeList) []*Node {
-	switch ns := ns.(type) {
-	case *NodeList:
-		var s []*Node
-		for l := ns; l != nil; l = l.Next {
-			s = append(s, l.N)
-		}
-		return s
-	case Nodes:
-		return ns.Slice()
-	case []*Node:
-		return ns
-	default:
-		panic("can't happen")
-	}
-}
-
-// setNodeSeq implements *a = b.
-// a must have type **NodeList, *Nodes, or *[]*Node.
-// b must have type *NodeList, Nodes, []*Node, or nil.
-// This is an interim function during the transition from NodeList to Nodes.
-// TODO(iant): Remove when transition is complete.
-func setNodeSeq(a nodesOrNodeListPtr, b nodesOrNodeList) {
-	if b == nil {
-		switch a := a.(type) {
-		case **NodeList:
-			*a = nil
-		case *Nodes:
-			a.Set(nil)
-		case *[]*Node:
-			*a = nil
-		default:
-			panic("can't happen")
-		}
-		return
-	}
-
-	// Simplify b to either *NodeList or []*Node.
-	if n, ok := b.(Nodes); ok {
-		b = n.Slice()
-	}
-
-	if l, ok := a.(**NodeList); ok {
-		switch b := b.(type) {
-		case *NodeList:
-			*l = b
-		case []*Node:
-			var ll *NodeList
-			for _, n := range b {
-				ll = list(ll, n)
-			}
-			*l = ll
-		default:
-			panic("can't happen")
-		}
-	} else {
-		var s []*Node
-		switch b := b.(type) {
-		case *NodeList:
-			for l := b; l != nil; l = l.Next {
-				s = append(s, l.N)
-			}
-		case []*Node:
-			s = b
-		default:
-			panic("can't happen")
-		}
-
-		switch a := a.(type) {
-		case *Nodes:
-			a.Set(s)
-		case *[]*Node:
-			*a = s
-		default:
-			panic("can't happen")
-		}
-	}
-}
-
-// setNodeSeqNode sets the node sequence a to the node n.
-// a must have type **NodeList, *Nodes, or *[]*Node.
-// This is an interim function during the transition from NodeList to Nodes.
-// TODO(iant): Remove when transition is complete.
-func setNodeSeqNode(a nodesOrNodeListPtr, n *Node) {
-	switch a := a.(type) {
-	case **NodeList:
-		*a = list1(n)
-	case *Nodes:
-		a.Set([]*Node{n})
-	case *[]*Node:
-		*a = []*Node{n}
-	default:
-		panic("can't happen")
-	}
-}
-
-// appendNodeSeq appends the node sequence b to the node sequence a.
-// a must have type **NodeList, *Nodes, or *[]*Node.
-// b must have type *NodeList, Nodes, or []*Node.
-// This is an interim function during the transition from NodeList to Nodes.
-// TODO(iant): Remove when transition is complete.
-func appendNodeSeq(a nodesOrNodeListPtr, b nodesOrNodeList) {
-	// Simplify b to either *NodeList or []*Node.
-	if n, ok := b.(Nodes); ok {
-		b = n.Slice()
-	}
-
-	if l, ok := a.(**NodeList); ok {
-		switch b := b.(type) {
-		case *NodeList:
-			*l = concat(*l, b)
-		case []*Node:
-			for _, n := range b {
-				*l = list(*l, n)
-			}
-		default:
-			panic("can't happen")
-		}
-	} else {
-		var s []*Node
-		switch a := a.(type) {
-		case *Nodes:
-			s = a.Slice()
-		case *[]*Node:
-			s = *a
-		default:
-			panic("can't happen")
-		}
-
-		switch b := b.(type) {
-		case *NodeList:
-			for l := b; l != nil; l = l.Next {
-				s = append(s, l.N)
-			}
-		case []*Node:
-			s = append(s, b...)
-		default:
-			panic("can't happen")
-		}
-
-		switch a := a.(type) {
-		case *Nodes:
-			a.Set(s)
-		case *[]*Node:
-			*a = s
-		default:
-			panic("can't happen")
-		}
-	}
-}
-
-// appendNodeSeqNode appends n to the node sequence a.
-// a must have type **NodeList, *Nodes, or *[]*Node.
-// This is an interim function during the transition from NodeList to Nodes.
-// TODO(iant): Remove when transition is complete.
-func appendNodeSeqNode(a nodesOrNodeListPtr, n *Node) {
-	switch a := a.(type) {
-	case **NodeList:
-		*a = list(*a, n)
-	case *Nodes:
-		a.Append(n)
-	case *[]*Node:
-		*a = append(*a, n)
-	default:
-		panic("can't happen")
-	}
-}

src/cmd/compile/internal/gc/walk.go

@@ -878,7 +878,7 @@ opswitch:
 		if !isblank(n.List.Second()) {
 			r.Type.Type.Down.Type = n.List.Second().Type
 		}
-		setNodeSeq(&n.Rlist, list1(r))
+		n.Rlist.Set([]*Node{r})
 		n.Op = OAS2FUNC
 
 		// don't generate a = *var if a is _
@@ -1000,12 +1000,12 @@ opswitch:
 			break
 		}
 
-		var ll *NodeList
+		var ll []*Node
 		if !Isinter(n.Left.Type) {
-			ll = list(ll, typename(n.Left.Type))
+			ll = append(ll, typename(n.Left.Type))
 		}
 		if !isnilinter(n.Type) {
-			ll = list(ll, typename(n.Type))
+			ll = append(ll, typename(n.Type))
 		}
 		if !Isinter(n.Left.Type) && !isnilinter(n.Type) {
 			sym := Pkglookup(Tconv(n.Left.Type, obj.FmtLeft)+"."+Tconv(n.Type, obj.FmtLeft), itabpkg)
@@ -1022,7 +1022,7 @@ opswitch:
 
 			l := Nod(OADDR, sym.Def, nil)
 			l.Addable = true
-			ll = list(ll, l)
+			ll = append(ll, l)
 
 			if isdirectiface(n.Left.Type) {
 				// For pointer types, we can make a special form of optimization
@@ -1042,7 +1042,7 @@ opswitch:
 
 				fn := syslook("typ2Itab")
 				n1 = Nod(OCALL, fn, nil)
-				setNodeSeq(&n1.List, ll)
+				n1.List.Set(ll)
 				typecheck(&n1, Erv)
 				walkexpr(&n1, init)
 
@@ -1062,7 +1062,7 @@ opswitch:
 		}
 
 		if Isinter(n.Left.Type) {
-			ll = list(ll, n.Left)
+			ll = append(ll, n.Left)
 		} else {
 			// regular types are passed by reference to avoid C vararg calls
 			// orderexpr arranged for n.Left to be a temporary for all
@@ -1071,9 +1071,9 @@ opswitch:
 			// with non-interface cases, is not visible to orderstmt, so we
 			// have to fall back on allocating a temp here.
 			if islvalue(n.Left) {
-				ll = list(ll, Nod(OADDR, n.Left, nil))
+				ll = append(ll, Nod(OADDR, n.Left, nil))
 			} else {
-				ll = list(ll, Nod(OADDR, copyexpr(n.Left, n.Left.Type, init), nil))
+				ll = append(ll, Nod(OADDR, copyexpr(n.Left, n.Left.Type, init), nil))
 			}
 			dowidth(n.Left.Type)
 			r := nodnil()
@@ -1086,7 +1086,7 @@ opswitch:
 				r = Nod(OADDR, r.Left, nil)
 				typecheck(&r, Erv)
 			}
-			ll = list(ll, r)
+			ll = append(ll, r)
 		}
 
 		fn := syslook(convFuncName(n.Left.Type, n.Type))
@@ -1097,7 +1097,7 @@ opswitch:
 		}
 		dowidth(fn.Type)
 		n = Nod(OCALL, fn, nil)
-		setNodeSeq(&n.List, ll)
+		n.List.Set(ll)
 		typecheck(&n, Erv)
 		walkexpr(&n, init)
 
@@ -1678,7 +1678,7 @@ func ascompatee(op Op, nl, nr []*Node, init *Nodes) []*Node {
 		var nln, nrn Nodes
 		nln.Set(nl)
 		nrn.Set(nr)
-		Yyerror("error in shape across %v %v %v / %d %d [%s]", Hconv(nln, obj.FmtSign), Oconv(op, 0), Hconv(nrn, obj.FmtSign), nodeSeqLen(nl), nodeSeqLen(nr), Curfn.Func.Nname.Sym.Name)
+		Yyerror("error in shape across %v %v %v / %d %d [%s]", Hconv(nln, obj.FmtSign), Oconv(op, 0), Hconv(nrn, obj.FmtSign), len(nl), len(nr), Curfn.Func.Nname.Sym.Name)
 	}
 	return nn
 }
@@ -1766,7 +1766,7 @@ func mkdotargslice(lr0, nn []*Node, l *Type, fp int, init *Nodes, ddd *Node) []*
 	tslice.Bound = -1
 
 	var n *Node
-	if nodeSeqLen(lr0) == 0 {
+	if len(lr0) == 0 {
 		n = nodnil()
 		n.Type = tslice
 	} else {
@@ -1825,13 +1825,13 @@ func ascompatte(op Op, call *Node, isddd bool, nl *Type, lr []*Node, fp int, ini
 	lr0 := lr
 	l, savel := IterFields(nl)
 	var r *Node
-	if nodeSeqLen(lr) > 0 {
-		r = nodeSeqFirst(lr)
+	if len(lr) > 0 {
+		r = lr[0]
 	}
 	var nn []*Node
 
 	// f(g()) where g has multiple return values
-	if r != nil && nodeSeqLen(lr) <= 1 && r.Type.Etype == TSTRUCT && r.Type.Funarg {
+	if r != nil && len(lr) <= 1 && r.Type.Etype == TSTRUCT && r.Type.Funarg {
 		// optimization - can do block copy
 		if eqtypenoname(r.Type, nl) {
 			arg := nodarg(nl, fp)
@@ -1857,7 +1857,7 @@ func ascompatte(op Op, call *Node, isddd bool, nl *Type, lr []*Node, fp int, ini
 		walkstmt(&a)
 		init.Append(a)
 		lr = alist
-		r = nodeSeqFirst(lr)
+		r = lr[0]
 		l, savel = IterFields(nl)
 	}
 
@@ -2808,7 +2808,7 @@ func appendslice(n *Node, init *Nodes) *Node {
 	nif := Nod(OIF, nil, nil)
 
 	// n := len(s) + len(l2) - cap(s)
-	setNodeSeq(&nif.Ninit, list1(Nod(OAS, nt, Nod(OSUB, Nod(OADD, Nod(OLEN, s, nil), Nod(OLEN, l2, nil)), Nod(OCAP, s, nil)))))
+	nif.Ninit.Set([]*Node{Nod(OAS, nt, Nod(OSUB, Nod(OADD, Nod(OLEN, s, nil), Nod(OLEN, l2, nil)), Nod(OCAP, s, nil)))})
 
 	nif.Left = Nod(OGT, nt, Nodintconst(0))
 
@@ -3966,7 +3966,7 @@ func walkprintfunc(np **Node, init *Nodes) {
 
 	typecheck(&fn, Etop)
 	typechecklist(fn.Nbody.Slice(), Etop)
-	xtop = list(xtop, fn)
+	xtop = append(xtop, fn)
 	Curfn = oldfn
 
 	a = Nod(OCALL, nil, nil)