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

   1 // Copyright 2016 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package gc
   6
   7 import (
   8         "fmt"
   9         "os"
  10         "strconv"
  11         "strings"
  12         "unicode/utf8"
  13
  14         "cmd/compile/internal/syntax"
  15         "cmd/internal/obj"
  16         "cmd/internal/src"
  17 )
  18
  19 func parseFiles(filenames []string) uint {
  20         var lines uint
  21         var noders []*noder
  22
  23         for _, filename := range filenames {
  24                 p := &noder{err: make(chan syntax.Error)}
  25                 noders = append(noders, p)
  26
  27                 go func(filename string) {
  28                         defer close(p.err)
  29                         base := src.NewFileBase(filename, absFilename(filename))
  30
  31                         f, err := os.Open(filename)
  32                         if err != nil {
  33                                 p.error(syntax.Error{Pos: src.MakePos(base, 0, 0), Msg: err.Error()})
  34                                 return
  35                         }
  36                         defer f.Close()
  37
  38                         p.file, _ = syntax.Parse(base, f, p.error, p.pragma, 0) // errors are tracked via p.error
  39                 }(filename)
  40         }
  41
  42         for _, p := range noders {
  43                 for e := range p.err {
  44                         yyerrorpos(e.Pos, "%s", e.Msg)
  45                 }
  46
  47                 p.node()
  48                 lines += p.file.Lines
  49                 p.file = nil // release memory
  50
  51                 if nsyntaxerrors != 0 {
  52                         errorexit()
  53                 }
  54                 // Always run testdclstack here, even when debug_dclstack is not set, as a sanity measure.
  55                 testdclstack()
  56         }
  57
  58         return lines
  59 }
  60
  61 func yyerrorpos(pos src.Pos, format string, args ...interface{}) {
  62         yyerrorl(Ctxt.PosTable.XPos(pos), format, args...)
  63 }
  64
  65 var pathPrefix string
  66
  67 func absFilename(name string) string {
  68         return obj.AbsFile(Ctxt.Pathname, name, pathPrefix)
  69 }
  70
  71 // noder transforms package syntax's AST into a Node tree.
  72 type noder struct {
  73         file       *syntax.File
  74         linknames  []linkname
  75         pragcgobuf string
  76         err        chan syntax.Error
  77 }
  78
  79 // linkname records a //go:linkname directive.
  80 type linkname struct {
  81         pos    src.Pos
  82         local  string
  83         remote string
  84 }
  85
  86 func (p *noder) node() {
  87         block = 1
  88         iota_ = -1000000
  89         imported_unsafe = false
  90
  91         p.lineno(p.file.PkgName)
  92         mkpackage(p.file.PkgName.Value)
  93
  94         xtop = append(xtop, p.decls(p.file.DeclList)...)
  95
  96         for _, n := range p.linknames {
  97                 if imported_unsafe {
  98                         lookup(n.local).Linkname = n.remote
  99                 } else {
 100                         yyerrorpos(n.pos, "//go:linkname only allowed in Go files that import \"unsafe\"")
 101                 }
 102         }
 103
 104         pragcgobuf += p.pragcgobuf
 105
 106         // For compatibility with old code only (comparisons w/ toolstash):
 107         // The old line number tracking simply continued incrementing the
 108         // virtual line number (lexlineno) and using it also for lineno.
 109         // After processing the last function, the lineno was used for the
 110         // line number information of the initialization code (fninit).
 111         // It would be better to use an explicit "<autogenerated>" filename
 112         // for fninit and set lineno to NoPos here.
 113         // TODO(gri) fix this once we switched permanently to the new
 114         // position information.
 115         lineno = MakePos(p.file.Pos().Base(), uint(p.file.Lines), 0)
 116
 117         clearImports()
 118 }
 119
 120 func (p *noder) decls(decls []syntax.Decl) (l []*Node) {
 121         var lastConstGroup *syntax.Group
 122         var lastConstRHS []*Node
 123         var iotaVal int64
 124
 125         for _, decl := range decls {
 126                 p.lineno(decl)
 127                 switch decl := decl.(type) {
 128                 case *syntax.ImportDecl:
 129                         p.importDecl(decl)
 130
 131                 case *syntax.VarDecl:
 132                         l = append(l, p.varDecl(decl)...)
 133
 134                 case *syntax.ConstDecl:
 135                         // Tricky to handle golang.org/issue/15550 correctly.
 136
 137                         prevIota := iota_
 138
 139                         if decl.Group == nil || decl.Group != lastConstGroup {
 140                                 iotaVal = 0
 141                                 lastConstRHS = nil
 142                         }
 143
 144                         iota_ = iotaVal
 145                         lastconst = lastConstRHS
 146
 147                         l = append(l, p.constDecl(decl)...)
 148
 149                         lastConstRHS = lastconst
 150                         lastconst = nil
 151
 152                         iota_ = prevIota
 153                         iotaVal++
 154
 155                         lastConstGroup = decl.Group
 156
 157                 case *syntax.TypeDecl:
 158                         l = append(l, p.typeDecl(decl))
 159
 160                 case *syntax.FuncDecl:
 161                         l = append(l, p.funcDecl(decl))
 162
 163                 default:
 164                         panic("unhandled Decl")
 165                 }
 166         }
 167
 168         return
 169 }
 170
 171 func (p *noder) importDecl(imp *syntax.ImportDecl) {
 172         val := p.basicLit(imp.Path)
 173         importfile(&val, nil)
 174         ipkg := importpkg
 175         importpkg = nil
 176
 177         if ipkg == nil {
 178                 if nerrors == 0 {
 179                         Fatalf("phase error in import")
 180                 }
 181                 return
 182         }
 183
 184         ipkg.Direct = true
 185
 186         var my *Sym
 187         if imp.LocalPkgName != nil {
 188                 my = p.name(imp.LocalPkgName)
 189         } else {
 190                 my = lookup(ipkg.Name)
 191         }
 192
 193         pack := p.nod(imp, OPACK, nil, nil)
 194         pack.Sym = my
 195         pack.Name.Pkg = ipkg
 196
 197         if my.Name == "." {
 198                 importdot(ipkg, pack)
 199                 return
 200         }
 201         if my.Name == "init" {
 202                 yyerrorl(pack.Pos, "cannot import package as init - init must be a func")
 203                 return
 204         }
 205         if my.Name == "_" {
 206                 return
 207         }
 208         if my.Def != nil {
 209                 lineno = pack.Pos
 210                 redeclare(my, "as imported package name")
 211         }
 212         my.Def = pack
 213         my.Lastlineno = pack.Pos
 214         my.Block = 1 // at top level
 215 }
 216
 217 func (p *noder) varDecl(decl *syntax.VarDecl) []*Node {
 218         names := p.declNames(decl.NameList)
 219         typ := p.typeExprOrNil(decl.Type)
 220
 221         var exprs []*Node
 222         if decl.Values != nil {
 223                 exprs = p.exprList(decl.Values)
 224         }
 225
 226         p.lineno(decl)
 227         return variter(names, typ, exprs)
 228 }
 229
 230 func (p *noder) constDecl(decl *syntax.ConstDecl) []*Node {
 231         names := p.declNames(decl.NameList)
 232         typ := p.typeExprOrNil(decl.Type)
 233
 234         var exprs []*Node
 235         if decl.Values != nil {
 236                 exprs = p.exprList(decl.Values)
 237         }
 238
 239         return constiter(names, typ, exprs)
 240 }
 241
 242 func (p *noder) typeDecl(decl *syntax.TypeDecl) *Node {
 243         name := typedcl0(p.name(decl.Name))
 244
 245         // decl.Type may be nil but in that case we got a syntax error during parsing
 246         typ := p.typeExprOrNil(decl.Type)
 247
 248         return typedcl1(name, typ, syntax.Pragma(decl.Pragma), decl.Alias)
 249 }
 250
 251 func (p *noder) declNames(names []*syntax.Name) []*Node {
 252         var nodes []*Node
 253         for _, name := range names {
 254                 nodes = append(nodes, p.declName(name))
 255         }
 256         return nodes
 257 }
 258
 259 func (p *noder) declName(name *syntax.Name) *Node {
 260         // TODO(mdempsky): Set lineno?
 261         return dclname(p.name(name))
 262 }
 263
 264 func (p *noder) funcDecl(fun *syntax.FuncDecl) *Node {
 265         f := p.funcHeader(fun)
 266         if f == nil {
 267                 return nil
 268         }
 269
 270         var body []*Node
 271         if fun.Body != nil {
 272                 body = p.stmts(fun.Body)
 273                 if body == nil {
 274                         body = []*Node{p.nod(fun, OEMPTY, nil, nil)}
 275                 }
 276         }
 277
 278         pragma := fun.Pragma
 279
 280         f.Nbody.Set(body)
 281         f.Noescape = pragma&Noescape != 0
 282         if f.Noescape && len(body) != 0 {
 283                 yyerror("can only use //go:noescape with external func implementations")
 284         }
 285         f.Func.Pragma = pragma
 286         lineno = MakePos(fun.Pos().Base(), fun.EndLine, 0)
 287         f.Func.Endlineno = lineno
 288
 289         funcbody(f)
 290
 291         return f
 292 }
 293
 294 func (p *noder) funcHeader(fun *syntax.FuncDecl) *Node {
 295         name := p.name(fun.Name)
 296         t := p.signature(fun.Recv, fun.Type)
 297         f := p.nod(fun, ODCLFUNC, nil, nil)
 298
 299         if fun.Recv == nil {
 300                 // FunctionName Signature
 301                 if name.Name == "init" {
 302                         name = renameinit()
 303                         if t.List.Len() > 0 || t.Rlist.Len() > 0 {
 304                                 yyerror("func init must have no arguments and no return values")
 305                         }
 306                 }
 307
 308                 if localpkg.Name == "main" && name.Name == "main" {
 309                         if t.List.Len() > 0 || t.Rlist.Len() > 0 {
 310                                 yyerror("func main must have no arguments and no return values")
 311                         }
 312                 }
 313         } else {
 314                 f.Func.Shortname = name
 315                 name = nblank.Sym // filled in by typecheckfunc
 316         }
 317
 318         f.Func.Nname = newfuncname(name)
 319         f.Func.Nname.Name.Defn = f
 320         f.Func.Nname.Name.Param.Ntype = t // TODO: check if nname already has an ntype
 321
 322         if fun.Recv == nil {
 323                 declare(f.Func.Nname, PFUNC)
 324         }
 325
 326         funchdr(f)
 327         return f
 328 }
 329
 330 func (p *noder) signature(recv *syntax.Field, typ *syntax.FuncType) *Node {
 331         n := p.nod(typ, OTFUNC, nil, nil)
 332         if recv != nil {
 333                 n.Left = p.param(recv, false, false)
 334         }
 335         n.List.Set(p.params(typ.ParamList, true))
 336         n.Rlist.Set(p.params(typ.ResultList, false))
 337         return n
 338 }
 339
 340 func (p *noder) params(params []*syntax.Field, dddOk bool) []*Node {
 341         var nodes []*Node
 342         for i, param := range params {
 343                 p.lineno(param)
 344                 nodes = append(nodes, p.param(param, dddOk, i+1 == len(params)))
 345         }
 346         return nodes
 347 }
 348
 349 func (p *noder) param(param *syntax.Field, dddOk, final bool) *Node {
 350         var name *Node
 351         if param.Name != nil {
 352                 name = p.newname(param.Name)
 353         }
 354
 355         typ := p.typeExpr(param.Type)
 356         n := p.nod(param, ODCLFIELD, name, typ)
 357
 358         // rewrite ...T parameter
 359         if typ.Op == ODDD {
 360                 if !dddOk {
 361                         yyerror("cannot use ... in receiver or result parameter list")
 362                 } else if !final {
 363                         yyerror("can only use ... with final parameter in list")
 364                 }
 365                 typ.Op = OTARRAY
 366                 typ.Right = typ.Left
 367                 typ.Left = nil
 368                 n.Isddd = true
 369                 if n.Left != nil {
 370                         n.Left.Isddd = true
 371                 }
 372         }
 373
 374         return n
 375 }
 376
 377 func (p *noder) exprList(expr syntax.Expr) []*Node {
 378         if list, ok := expr.(*syntax.ListExpr); ok {
 379                 return p.exprs(list.ElemList)
 380         }
 381         return []*Node{p.expr(expr)}
 382 }
 383
 384 func (p *noder) exprs(exprs []syntax.Expr) []*Node {
 385         var nodes []*Node
 386         for _, expr := range exprs {
 387                 nodes = append(nodes, p.expr(expr))
 388         }
 389         return nodes
 390 }
 391
 392 func (p *noder) expr(expr syntax.Expr) *Node {
 393         p.lineno(expr)
 394         switch expr := expr.(type) {
 395         case nil:
 396                 return nil
 397         case *syntax.Name:
 398                 return p.mkname(expr)
 399         case *syntax.BasicLit:
 400                 return p.setlineno(expr, nodlit(p.basicLit(expr)))
 401
 402         case *syntax.CompositeLit:
 403                 n := p.nod(expr, OCOMPLIT, nil, nil)
 404                 if expr.Type != nil {
 405                         n.Right = p.expr(expr.Type)
 406                 }
 407                 l := p.exprs(expr.ElemList)
 408                 for i, e := range l {
 409                         l[i] = p.wrapname(expr.ElemList[i], e)
 410                 }
 411                 n.List.Set(l)
 412                 lineno = MakePos(expr.Pos().Base(), expr.EndLine, 0)
 413                 return n
 414         case *syntax.KeyValueExpr:
 415                 return p.nod(expr, OKEY, p.expr(expr.Key), p.wrapname(expr.Value, p.expr(expr.Value)))
 416         case *syntax.FuncLit:
 417                 closurehdr(p.typeExpr(expr.Type))
 418                 body := p.stmts(expr.Body)
 419                 lineno = MakePos(expr.Pos().Base(), expr.EndLine, 0)
 420                 return p.setlineno(expr, closurebody(body))
 421         case *syntax.ParenExpr:
 422                 return p.nod(expr, OPAREN, p.expr(expr.X), nil)
 423         case *syntax.SelectorExpr:
 424                 // parser.new_dotname
 425                 obj := p.expr(expr.X)
 426                 if obj.Op == OPACK {
 427                         obj.Used = true
 428                         return oldname(restrictlookup(expr.Sel.Value, obj.Name.Pkg))
 429                 }
 430                 return p.setlineno(expr, nodSym(OXDOT, obj, p.name(expr.Sel)))
 431         case *syntax.IndexExpr:
 432                 return p.nod(expr, OINDEX, p.expr(expr.X), p.expr(expr.Index))
 433         case *syntax.SliceExpr:
 434                 op := OSLICE
 435                 if expr.Full {
 436                         op = OSLICE3
 437                 }
 438                 n := p.nod(expr, op, p.expr(expr.X), nil)
 439                 var index [3]*Node
 440                 for i, x := range expr.Index {
 441                         if x != nil {
 442                                 index[i] = p.expr(x)
 443                         }
 444                 }
 445                 n.SetSliceBounds(index[0], index[1], index[2])
 446                 return n
 447         case *syntax.AssertExpr:
 448                 if expr.Type == nil {
 449                         panic("unexpected AssertExpr")
 450                 }
 451                 // TODO(mdempsky): parser.pexpr uses p.expr(), but
 452                 // seems like the type field should be parsed with
 453                 // ntype? Shrug, doesn't matter here.
 454                 return p.nod(expr, ODOTTYPE, p.expr(expr.X), p.expr(expr.Type))
 455         case *syntax.Operation:
 456                 x := p.expr(expr.X)
 457                 if expr.Y == nil {
 458                         if expr.Op == syntax.And {
 459                                 x = unparen(x) // TODO(mdempsky): Needed?
 460                                 if x.Op == OCOMPLIT {
 461                                         // Special case for &T{...}: turn into (*T){...}.
 462                                         // TODO(mdempsky): Switch back to p.nod after we
 463                                         // get rid of gcCompat.
 464                                         x.Right = nod(OIND, x.Right, nil)
 465                                         x.Right.Implicit = true
 466                                         return x
 467                                 }
 468                         }
 469                         return p.nod(expr, p.unOp(expr.Op), x, nil)
 470                 }
 471                 return p.nod(expr, p.binOp(expr.Op), x, p.expr(expr.Y))
 472         case *syntax.CallExpr:
 473                 n := p.nod(expr, OCALL, p.expr(expr.Fun), nil)
 474                 n.List.Set(p.exprs(expr.ArgList))
 475                 n.Isddd = expr.HasDots
 476                 return n
 477
 478         case *syntax.ArrayType:
 479                 var len *Node
 480                 if expr.Len != nil {
 481                         len = p.expr(expr.Len)
 482                 } else {
 483                         len = p.nod(expr, ODDD, nil, nil)
 484                 }
 485                 return p.nod(expr, OTARRAY, len, p.typeExpr(expr.Elem))
 486         case *syntax.SliceType:
 487                 return p.nod(expr, OTARRAY, nil, p.typeExpr(expr.Elem))
 488         case *syntax.DotsType:
 489                 return p.nod(expr, ODDD, p.typeExpr(expr.Elem), nil)
 490         case *syntax.StructType:
 491                 return p.structType(expr)
 492         case *syntax.InterfaceType:
 493                 return p.interfaceType(expr)
 494         case *syntax.FuncType:
 495                 return p.signature(nil, expr)
 496         case *syntax.MapType:
 497                 return p.nod(expr, OTMAP, p.typeExpr(expr.Key), p.typeExpr(expr.Value))
 498         case *syntax.ChanType:
 499                 n := p.nod(expr, OTCHAN, p.typeExpr(expr.Elem), nil)
 500                 n.Etype = EType(p.chanDir(expr.Dir))
 501                 return n
 502
 503         case *syntax.TypeSwitchGuard:
 504                 n := p.nod(expr, OTYPESW, nil, p.expr(expr.X))
 505                 if expr.Lhs != nil {
 506                         n.Left = p.declName(expr.Lhs)
 507                         if isblank(n.Left) {
 508                                 yyerror("invalid variable name %v in type switch", n.Left)
 509                         }
 510                 }
 511                 return n
 512         }
 513         panic("unhandled Expr")
 514 }
 515
 516 func (p *noder) typeExpr(typ syntax.Expr) *Node {
 517         // TODO(mdempsky): Be stricter? typecheck should handle errors anyway.
 518         return p.expr(typ)
 519 }
 520
 521 func (p *noder) typeExprOrNil(typ syntax.Expr) *Node {
 522         if typ != nil {
 523                 return p.expr(typ)
 524         }
 525         return nil
 526 }
 527
 528 func (p *noder) chanDir(dir syntax.ChanDir) ChanDir {
 529         switch dir {
 530         case 0:
 531                 return Cboth
 532         case syntax.SendOnly:
 533                 return Csend
 534         case syntax.RecvOnly:
 535                 return Crecv
 536         }
 537         panic("unhandled ChanDir")
 538 }
 539
 540 func (p *noder) structType(expr *syntax.StructType) *Node {
 541         var l []*Node
 542         for i, field := range expr.FieldList {
 543                 p.lineno(field)
 544                 var n *Node
 545                 if field.Name == nil {
 546                         n = p.embedded(field.Type)
 547                 } else {
 548                         n = p.nod(field, ODCLFIELD, p.newname(field.Name), p.typeExpr(field.Type))
 549                 }
 550                 if i < len(expr.TagList) && expr.TagList[i] != nil {
 551                         n.SetVal(p.basicLit(expr.TagList[i]))
 552                 }
 553                 l = append(l, n)
 554         }
 555
 556         p.lineno(expr)
 557         n := p.nod(expr, OTSTRUCT, nil, nil)
 558         n.List.Set(l)
 559         return n
 560 }
 561
 562 func (p *noder) interfaceType(expr *syntax.InterfaceType) *Node {
 563         var l []*Node
 564         for _, method := range expr.MethodList {
 565                 p.lineno(method)
 566                 var n *Node
 567                 if method.Name == nil {
 568                         n = p.nod(method, ODCLFIELD, nil, oldname(p.packname(method.Type)))
 569                 } else {
 570                         mname := p.newname(method.Name)
 571                         sig := p.typeExpr(method.Type)
 572                         sig.Left = fakethis()
 573                         n = p.nod(method, ODCLFIELD, mname, sig)
 574                         ifacedcl(n)
 575                 }
 576                 l = append(l, n)
 577         }
 578
 579         n := p.nod(expr, OTINTER, nil, nil)
 580         n.List.Set(l)
 581         return n
 582 }
 583
 584 func (p *noder) packname(expr syntax.Expr) *Sym {
 585         switch expr := expr.(type) {
 586         case *syntax.Name:
 587                 name := p.name(expr)
 588                 if n := oldname(name); n.Name != nil && n.Name.Pack != nil {
 589                         n.Name.Pack.Used = true
 590                 }
 591                 return name
 592         case *syntax.SelectorExpr:
 593                 name := p.name(expr.X.(*syntax.Name))
 594                 var pkg *Pkg
 595                 if name.Def == nil || name.Def.Op != OPACK {
 596                         yyerror("%v is not a package", name)
 597                         pkg = localpkg
 598                 } else {
 599                         name.Def.Used = true
 600                         pkg = name.Def.Name.Pkg
 601                 }
 602                 return restrictlookup(expr.Sel.Value, pkg)
 603         }
 604         panic(fmt.Sprintf("unexpected packname: %#v", expr))
 605 }
 606
 607 func (p *noder) embedded(typ syntax.Expr) *Node {
 608         op, isStar := typ.(*syntax.Operation)
 609         if isStar {
 610                 if op.Op != syntax.Mul || op.Y != nil {
 611                         panic("unexpected Operation")
 612                 }
 613                 typ = op.X
 614         }
 615         n := embedded(p.packname(typ), localpkg)
 616         if isStar {
 617                 n.Right = p.nod(op, OIND, n.Right, nil)
 618         }
 619         return n
 620 }
 621
 622 func (p *noder) stmts(stmts []syntax.Stmt) []*Node {
 623         var nodes []*Node
 624         for _, stmt := range stmts {
 625                 s := p.stmt(stmt)
 626                 if s == nil {
 627                 } else if s.Op == OBLOCK && s.Ninit.Len() == 0 {
 628                         nodes = append(nodes, s.List.Slice()...)
 629                 } else {
 630                         nodes = append(nodes, s)
 631                 }
 632         }
 633         return nodes
 634 }
 635
 636 func (p *noder) stmt(stmt syntax.Stmt) *Node {
 637         p.lineno(stmt)
 638         switch stmt := stmt.(type) {
 639         case *syntax.EmptyStmt:
 640                 return nil
 641         case *syntax.LabeledStmt:
 642                 return p.labeledStmt(stmt)
 643         case *syntax.BlockStmt:
 644                 return p.body(stmt.Body)
 645         case *syntax.ExprStmt:
 646                 return p.wrapname(stmt, p.expr(stmt.X))
 647         case *syntax.SendStmt:
 648                 return p.nod(stmt, OSEND, p.expr(stmt.Chan), p.expr(stmt.Value))
 649         case *syntax.DeclStmt:
 650                 return liststmt(p.decls(stmt.DeclList))
 651         case *syntax.AssignStmt:
 652                 if stmt.Op != 0 && stmt.Op != syntax.Def {
 653                         n := p.nod(stmt, OASOP, p.expr(stmt.Lhs), p.expr(stmt.Rhs))
 654                         n.Implicit = stmt.Rhs == syntax.ImplicitOne
 655                         n.Etype = EType(p.binOp(stmt.Op))
 656                         return n
 657                 }
 658
 659                 lhs := p.exprList(stmt.Lhs)
 660                 rhs := p.exprList(stmt.Rhs)
 661
 662                 n := p.nod(stmt, OAS, nil, nil) // assume common case
 663
 664                 if stmt.Op == syntax.Def {
 665                         n.Colas = true
 666                         colasdefn(lhs, n) // modifies lhs, call before using lhs[0] in common case
 667                 }
 668
 669                 if len(lhs) == 1 && len(rhs) == 1 {
 670                         // common case
 671                         n.Left = lhs[0]
 672                         n.Right = rhs[0]
 673                 } else {
 674                         n.Op = OAS2
 675                         n.List.Set(lhs)
 676                         n.Rlist.Set(rhs)
 677                 }
 678                 return n
 679
 680         case *syntax.BranchStmt:
 681                 var op Op
 682                 switch stmt.Tok {
 683                 case syntax.Break:
 684                         op = OBREAK
 685                 case syntax.Continue:
 686                         op = OCONTINUE
 687                 case syntax.Fallthrough:
 688                         op = OXFALL
 689                 case syntax.Goto:
 690                         op = OGOTO
 691                 default:
 692                         panic("unhandled BranchStmt")
 693                 }
 694                 n := p.nod(stmt, op, nil, nil)
 695                 if stmt.Label != nil {
 696                         n.Left = p.newname(stmt.Label)
 697                 }
 698                 if op == OGOTO {
 699                         n.Sym = dclstack // context, for goto restriction
 700                 }
 701                 if op == OXFALL {
 702                         n.Xoffset = int64(block)
 703                 }
 704                 return n
 705         case *syntax.CallStmt:
 706                 var op Op
 707                 switch stmt.Tok {
 708                 case syntax.Defer:
 709                         op = ODEFER
 710                 case syntax.Go:
 711                         op = OPROC
 712                 default:
 713                         panic("unhandled CallStmt")
 714                 }
 715                 return p.nod(stmt, op, p.expr(stmt.Call), nil)
 716         case *syntax.ReturnStmt:
 717                 var results []*Node
 718                 if stmt.Results != nil {
 719                         results = p.exprList(stmt.Results)
 720                 }
 721                 n := p.nod(stmt, ORETURN, nil, nil)
 722                 n.List.Set(results)
 723                 if n.List.Len() == 0 && Curfn != nil {
 724                         for _, ln := range Curfn.Func.Dcl {
 725                                 if ln.Class == PPARAM {
 726                                         continue
 727                                 }
 728                                 if ln.Class != PPARAMOUT {
 729                                         break
 730                                 }
 731                                 if ln.Sym.Def != ln {
 732                                         yyerror("%s is shadowed during return", ln.Sym.Name)
 733                                 }
 734                         }
 735                 }
 736                 return n
 737         case *syntax.IfStmt:
 738                 return p.ifStmt(stmt)
 739         case *syntax.ForStmt:
 740                 return p.forStmt(stmt)
 741         case *syntax.SwitchStmt:
 742                 return p.switchStmt(stmt)
 743         case *syntax.SelectStmt:
 744                 return p.selectStmt(stmt)
 745         }
 746         panic("unhandled Stmt")
 747 }
 748
 749 func (p *noder) body(body []syntax.Stmt) *Node {
 750         l := p.bodyList(body)
 751         if len(l) == 0 {
 752                 // TODO(mdempsky): Line number?
 753                 return nod(OEMPTY, nil, nil)
 754         }
 755         return liststmt(l)
 756 }
 757
 758 func (p *noder) bodyList(body []syntax.Stmt) []*Node {
 759         markdcl()
 760         nodes := p.stmts(body)
 761         popdcl()
 762         return nodes
 763 }
 764
 765 func (p *noder) ifStmt(stmt *syntax.IfStmt) *Node {
 766         markdcl()
 767         n := p.nod(stmt, OIF, nil, nil)
 768         if stmt.Init != nil {
 769                 n.Ninit.Set1(p.stmt(stmt.Init))
 770         }
 771         if stmt.Cond != nil {
 772                 n.Left = p.expr(stmt.Cond)
 773         }
 774         n.Nbody.Set(p.bodyList(stmt.Then))
 775         if stmt.Else != nil {
 776                 e := p.stmt(stmt.Else)
 777                 if e.Op == OBLOCK && e.Ninit.Len() == 0 {
 778                         n.Rlist.Set(e.List.Slice())
 779                 } else {
 780                         n.Rlist.Set1(e)
 781                 }
 782         }
 783         popdcl()
 784         return n
 785 }
 786
 787 func (p *noder) forStmt(stmt *syntax.ForStmt) *Node {
 788         markdcl()
 789         var n *Node
 790         if r, ok := stmt.Init.(*syntax.RangeClause); ok {
 791                 if stmt.Cond != nil || stmt.Post != nil {
 792                         panic("unexpected RangeClause")
 793                 }
 794
 795                 n = p.nod(r, ORANGE, nil, p.expr(r.X))
 796                 if r.Lhs != nil {
 797                         lhs := p.exprList(r.Lhs)
 798                         n.List.Set(lhs)
 799                         if r.Def {
 800                                 n.Colas = true
 801                                 colasdefn(lhs, n)
 802                         }
 803                 }
 804         } else {
 805                 n = p.nod(stmt, OFOR, nil, nil)
 806                 if stmt.Init != nil {
 807                         n.Ninit.Set1(p.stmt(stmt.Init))
 808                 }
 809                 if stmt.Cond != nil {
 810                         n.Left = p.expr(stmt.Cond)
 811                 }
 812                 if stmt.Post != nil {
 813                         n.Right = p.stmt(stmt.Post)
 814                 }
 815         }
 816         n.Nbody.Set(p.bodyList(stmt.Body))
 817         popdcl()
 818         return n
 819 }
 820
 821 func (p *noder) switchStmt(stmt *syntax.SwitchStmt) *Node {
 822         markdcl()
 823         n := p.nod(stmt, OSWITCH, nil, nil)
 824         if stmt.Init != nil {
 825                 n.Ninit.Set1(p.stmt(stmt.Init))
 826         }
 827         if stmt.Tag != nil {
 828                 n.Left = p.expr(stmt.Tag)
 829         }
 830
 831         tswitch := n.Left
 832         if tswitch != nil && (tswitch.Op != OTYPESW || tswitch.Left == nil) {
 833                 tswitch = nil
 834         }
 835
 836         n.List.Set(p.caseClauses(stmt.Body, tswitch))
 837
 838         popdcl()
 839         return n
 840 }
 841
 842 func (p *noder) caseClauses(clauses []*syntax.CaseClause, tswitch *Node) []*Node {
 843         var nodes []*Node
 844         for _, clause := range clauses {
 845                 p.lineno(clause)
 846                 markdcl()
 847                 n := p.nod(clause, OXCASE, nil, nil)
 848                 if clause.Cases != nil {
 849                         n.List.Set(p.exprList(clause.Cases))
 850                 }
 851                 if tswitch != nil {
 852                         nn := newname(tswitch.Left.Sym)
 853                         declare(nn, dclcontext)
 854                         n.Rlist.Set1(nn)
 855                         // keep track of the instances for reporting unused
 856                         nn.Name.Defn = tswitch
 857                 }
 858                 n.Xoffset = int64(block)
 859                 n.Nbody.Set(p.stmts(clause.Body))
 860                 popdcl()
 861                 nodes = append(nodes, n)
 862         }
 863         return nodes
 864 }
 865
 866 func (p *noder) selectStmt(stmt *syntax.SelectStmt) *Node {
 867         n := p.nod(stmt, OSELECT, nil, nil)
 868         n.List.Set(p.commClauses(stmt.Body))
 869         return n
 870 }
 871
 872 func (p *noder) commClauses(clauses []*syntax.CommClause) []*Node {
 873         var nodes []*Node
 874         for _, clause := range clauses {
 875                 p.lineno(clause)
 876                 markdcl()
 877                 n := p.nod(clause, OXCASE, nil, nil)
 878                 if clause.Comm != nil {
 879                         n.List.Set1(p.stmt(clause.Comm))
 880                 }
 881                 n.Xoffset = int64(block)
 882                 n.Nbody.Set(p.stmts(clause.Body))
 883                 popdcl()
 884                 nodes = append(nodes, n)
 885         }
 886         return nodes
 887 }
 888
 889 func (p *noder) labeledStmt(label *syntax.LabeledStmt) *Node {
 890         lhs := p.nod(label, OLABEL, p.newname(label.Label), nil)
 891         lhs.Sym = dclstack
 892
 893         var ls *Node
 894         if label.Stmt != nil { // TODO(mdempsky): Should always be present.
 895                 ls = p.stmt(label.Stmt)
 896         }
 897
 898         lhs.Name.Defn = ls
 899         l := []*Node{lhs}
 900         if ls != nil {
 901                 if ls.Op == OBLOCK && ls.Ninit.Len() == 0 {
 902                         l = append(l, ls.List.Slice()...)
 903                 } else {
 904                         l = append(l, ls)
 905                 }
 906         }
 907         return liststmt(l)
 908 }
 909
 910 var unOps = [...]Op{
 911         syntax.Recv: ORECV,
 912         syntax.Mul:  OIND,
 913         syntax.And:  OADDR,
 914
 915         syntax.Not: ONOT,
 916         syntax.Xor: OCOM,
 917         syntax.Add: OPLUS,
 918         syntax.Sub: OMINUS,
 919 }
 920
 921 func (p *noder) unOp(op syntax.Operator) Op {
 922         if uint64(op) >= uint64(len(unOps)) || unOps[op] == 0 {
 923                 panic("invalid Operator")
 924         }
 925         return unOps[op]
 926 }
 927
 928 var binOps = [...]Op{
 929         syntax.OrOr:   OOROR,
 930         syntax.AndAnd: OANDAND,
 931
 932         syntax.Eql: OEQ,
 933         syntax.Neq: ONE,
 934         syntax.Lss: OLT,
 935         syntax.Leq: OLE,
 936         syntax.Gtr: OGT,
 937         syntax.Geq: OGE,
 938
 939         syntax.Add: OADD,
 940         syntax.Sub: OSUB,
 941         syntax.Or:  OOR,
 942         syntax.Xor: OXOR,
 943
 944         syntax.Mul:    OMUL,
 945         syntax.Div:    ODIV,
 946         syntax.Rem:    OMOD,
 947         syntax.And:    OAND,
 948         syntax.AndNot: OANDNOT,
 949         syntax.Shl:    OLSH,
 950         syntax.Shr:    ORSH,
 951 }
 952
 953 func (p *noder) binOp(op syntax.Operator) Op {
 954         if uint64(op) >= uint64(len(binOps)) || binOps[op] == 0 {
 955                 panic("invalid Operator")
 956         }
 957         return binOps[op]
 958 }
 959
 960 func (p *noder) basicLit(lit *syntax.BasicLit) Val {
 961         // TODO: Don't try to convert if we had syntax errors (conversions may fail).
 962         //       Use dummy values so we can continue to compile. Eventually, use a
 963         //       form of "unknown" literals that are ignored during type-checking so
 964         //       we can continue type-checking w/o spurious follow-up errors.
 965         switch s := lit.Value; lit.Kind {
 966         case syntax.IntLit:
 967                 x := new(Mpint)
 968                 x.SetString(s)
 969                 return Val{U: x}
 970
 971         case syntax.FloatLit:
 972                 x := newMpflt()
 973                 x.SetString(s)
 974                 return Val{U: x}
 975
 976         case syntax.ImagLit:
 977                 x := new(Mpcplx)
 978                 x.Imag.SetString(strings.TrimSuffix(s, "i"))
 979                 return Val{U: x}
 980
 981         case syntax.RuneLit:
 982                 var r rune
 983                 if u, err := strconv.Unquote(s); err == nil && len(u) > 0 {
 984                         // Package syntax already reported any errors.
 985                         // Check for them again though because 0 is a
 986                         // better fallback value for invalid rune
 987                         // literals than 0xFFFD.
 988                         if len(u) == 1 {
 989                                 r = rune(u[0])
 990                         } else {
 991                                 r, _ = utf8.DecodeRuneInString(u)
 992                         }
 993                 }
 994                 x := new(Mpint)
 995                 x.SetInt64(int64(r))
 996                 x.Rune = true
 997                 return Val{U: x}
 998
 999         case syntax.StringLit:
1000                 if len(s) > 0 && s[0] == '`' {
1001                         // strip carriage returns from raw string
1002                         s = strings.Replace(s, "\r", "", -1)
1003                 }
1004                 // Ignore errors because package syntax already reported them.
1005                 u, _ := strconv.Unquote(s)
1006                 return Val{U: u}
1007
1008         default:
1009                 panic("unhandled BasicLit kind")
1010         }
1011 }
1012
1013 func (p *noder) name(name *syntax.Name) *Sym {
1014         return lookup(name.Value)
1015 }
1016
1017 func (p *noder) mkname(name *syntax.Name) *Node {
1018         // TODO(mdempsky): Set line number?
1019         return mkname(p.name(name))
1020 }
1021
1022 func (p *noder) newname(name *syntax.Name) *Node {
1023         // TODO(mdempsky): Set line number?
1024         return newname(p.name(name))
1025 }
1026
1027 func (p *noder) wrapname(n syntax.Node, x *Node) *Node {
1028         // These nodes do not carry line numbers.
1029         // Introduce a wrapper node to give them the correct line.
1030         switch x.Op {
1031         case OTYPE, OLITERAL:
1032                 if x.Sym == nil {
1033                         break
1034                 }
1035                 fallthrough
1036         case ONAME, ONONAME, OPACK:
1037                 x = p.nod(n, OPAREN, x, nil)
1038                 x.Implicit = true
1039         }
1040         return x
1041 }
1042
1043 func (p *noder) nod(orig syntax.Node, op Op, left, right *Node) *Node {
1044         return p.setlineno(orig, nod(op, left, right))
1045 }
1046
1047 func (p *noder) setlineno(src_ syntax.Node, dst *Node) *Node {
1048         pos := src_.Pos()
1049         if !pos.IsKnown() {
1050                 // TODO(mdempsky): Shouldn't happen. Fix package syntax.
1051                 return dst
1052         }
1053         dst.Pos = Ctxt.PosTable.XPos(pos)
1054         return dst
1055 }
1056
1057 func (p *noder) lineno(n syntax.Node) {
1058         if n == nil {
1059                 return
1060         }
1061         pos := n.Pos()
1062         if !pos.IsKnown() {
1063                 // TODO(mdempsky): Shouldn't happen. Fix package syntax.
1064                 return
1065         }
1066         lineno = Ctxt.PosTable.XPos(pos)
1067 }
1068
1069 func (p *noder) error(err error) {
1070         p.err <- err.(syntax.Error)
1071 }
1072
1073 func (p *noder) pragma(pos src.Pos, text string) syntax.Pragma {
1074         switch {
1075         case strings.HasPrefix(text, "line "):
1076                 // line directives are handled by syntax package
1077                 panic("unreachable")
1078
1079         case strings.HasPrefix(text, "go:linkname "):
1080                 f := strings.Fields(text)
1081                 if len(f) != 3 {
1082                         p.error(syntax.Error{Pos: pos, Msg: "usage: //go:linkname localname linkname"})
1083                         break
1084                 }
1085                 p.linknames = append(p.linknames, linkname{pos, f[1], f[2]})
1086
1087         case strings.HasPrefix(text, "go:cgo_"):
1088                 // TODO(gri): lineno = p.baseline + int32(line) - 1 // pragcgo may call yyerror
1089                 p.pragcgobuf += pragcgo(text)
1090                 fallthrough // because of //go:cgo_unsafe_args
1091         default:
1092                 verb := text
1093                 if i := strings.Index(text, " "); i >= 0 {
1094                         verb = verb[:i]
1095                 }
1096                 prag := pragmaValue(verb)
1097                 const runtimePragmas = Systemstack | Nowritebarrier | Nowritebarrierrec | Yeswritebarrierrec
1098                 if !compiling_runtime && prag&runtimePragmas != 0 {
1099                         p.error(syntax.Error{Pos: pos, Msg: fmt.Sprintf("//go:%s only allowed in runtime", verb)})
1100                 }
1101                 return prag
1102         }
1103
1104         return 0
1105 }
1106
1107 func mkname(sym *Sym) *Node {
1108         n := oldname(sym)
1109         if n.Name != nil && n.Name.Pack != nil {
1110                 n.Name.Pack.Used = true
1111         }
1112         return n
1113 }
1114
1115 func unparen(x *Node) *Node {
1116         for x.Op == OPAREN {
1117                 x = x.Left
1118         }
1119         return x
1120 }