mirror of
https://github.com/golang/go.git
synced 2025-12-08 06:10:04 +00:00
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>
This commit is contained in:
Ian Lance Taylor
parent
53900cea1b
commit
f444b8a80e
16 changed files with 283 additions and 547 deletions
|
|
@ -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
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue