src/go/parser/parser.go

   1 // Copyright 2009 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 parser implements a parser for Go source files. Input may be
   6 // provided in a variety of forms (see the various Parse* functions); the
   7 // output is an abstract syntax tree (AST) representing the Go source. The
   8 // parser is invoked through one of the Parse* functions.
   9 //
  10 // The parser accepts a larger language than is syntactically permitted by
  11 // the Go spec, for simplicity, and for improved robustness in the presence
  12 // of syntax errors. For instance, in method declarations, the receiver is
  13 // treated like an ordinary parameter list and thus may contain multiple
  14 // entries where the spec permits exactly one. Consequently, the corresponding
  15 // field in the AST (ast.FuncDecl.Recv) field is not restricted to one entry.
  16 package parser
  17
  18 import (
  19         "fmt"
  20         "go/ast"
  21         "go/build/constraint"
  22         "go/internal/typeparams"
  23         "go/scanner"
  24         "go/token"
  25         "strings"
  26 )
  27
  28 // The parser structure holds the parser's internal state.
  29 type parser struct {
  30         file    *token.File
  31         errors  scanner.ErrorList
  32         scanner scanner.Scanner
  33
  34         // Tracing/debugging
  35         mode   Mode // parsing mode
  36         trace  bool // == (mode&Trace != 0)
  37         indent int  // indentation used for tracing output
  38
  39         // Comments
  40         comments    []*ast.CommentGroup
  41         leadComment *ast.CommentGroup // last lead comment
  42         lineComment *ast.CommentGroup // last line comment
  43         top         bool              // in top of file (before package clause)
  44         goVersion   string            // minimum Go version found in //go:build comment
  45
  46         // Next token
  47         pos token.Pos   // token position
  48         tok token.Token // one token look-ahead
  49         lit string      // token literal
  50
  51         // Error recovery
  52         // (used to limit the number of calls to parser.advance
  53         // w/o making scanning progress - avoids potential endless
  54         // loops across multiple parser functions during error recovery)
  55         syncPos token.Pos // last synchronization position
  56         syncCnt int       // number of parser.advance calls without progress
  57
  58         // Non-syntactic parser control
  59         exprLev int  // < 0: in control clause, >= 0: in expression
  60         inRhs   bool // if set, the parser is parsing a rhs expression
  61
  62         imports []*ast.ImportSpec // list of imports
  63
  64         // nestLev is used to track and limit the recursion depth
  65         // during parsing.
  66         nestLev int
  67 }
  68
  69 func (p *parser) init(fset *token.FileSet, filename string, src []byte, mode Mode) {
  70         p.file = fset.AddFile(filename, -1, len(src))
  71         eh := func(pos token.Position, msg string) { p.errors.Add(pos, msg) }
  72         p.scanner.Init(p.file, src, eh, scanner.ScanComments)
  73
  74         p.top = true
  75         p.mode = mode
  76         p.trace = mode&Trace != 0 // for convenience (p.trace is used frequently)
  77         p.next()
  78 }
  79
  80 // ----------------------------------------------------------------------------
  81 // Parsing support
  82
  83 func (p *parser) printTrace(a ...any) {
  84         const dots = ". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . "
  85         const n = len(dots)
  86         pos := p.file.Position(p.pos)
  87         fmt.Printf("%5d:%3d: ", pos.Line, pos.Column)
  88         i := 2 * p.indent
  89         for i > n {
  90                 fmt.Print(dots)
  91                 i -= n
  92         }
  93         // i <= n
  94         fmt.Print(dots[0:i])
  95         fmt.Println(a...)
  96 }
  97
  98 func trace(p *parser, msg string) *parser {
  99         p.printTrace(msg, "(")
 100         p.indent++
 101         return p
 102 }
 103
 104 // Usage pattern: defer un(trace(p, "..."))
 105 func un(p *parser) {
 106         p.indent--
 107         p.printTrace(")")
 108 }
 109
 110 // maxNestLev is the deepest we're willing to recurse during parsing
 111 const maxNestLev int = 1e5
 112
 113 func incNestLev(p *parser) *parser {
 114         p.nestLev++
 115         if p.nestLev > maxNestLev {
 116                 p.error(p.pos, "exceeded max nesting depth")
 117                 panic(bailout{})
 118         }
 119         return p
 120 }
 121
 122 // decNestLev is used to track nesting depth during parsing to prevent stack exhaustion.
 123 // It is used along with incNestLev in a similar fashion to how un and trace are used.
 124 func decNestLev(p *parser) {
 125         p.nestLev--
 126 }
 127
 128 // Advance to the next token.
 129 func (p *parser) next0() {
 130         // Because of one-token look-ahead, print the previous token
 131         // when tracing as it provides a more readable output. The
 132         // very first token (!p.pos.IsValid()) is not initialized
 133         // (it is token.ILLEGAL), so don't print it.
 134         if p.trace && p.pos.IsValid() {
 135                 s := p.tok.String()
 136                 switch {
 137                 case p.tok.IsLiteral():
 138                         p.printTrace(s, p.lit)
 139                 case p.tok.IsOperator(), p.tok.IsKeyword():
 140                         p.printTrace("\"" + s + "\"")
 141                 default:
 142                         p.printTrace(s)
 143                 }
 144         }
 145
 146         for {
 147                 p.pos, p.tok, p.lit = p.scanner.Scan()
 148                 if p.tok == token.COMMENT {
 149                         if p.top && strings.HasPrefix(p.lit, "//go:build") {
 150                                 if x, err := constraint.Parse(p.lit); err == nil {
 151                                         p.goVersion = constraint.GoVersion(x)
 152                                 }
 153                         }
 154                         if p.mode&ParseComments == 0 {
 155                                 continue
 156                         }
 157                 } else {
 158                         // Found a non-comment; top of file is over.
 159                         p.top = false
 160                 }
 161                 break
 162         }
 163 }
 164
 165 // Consume a comment and return it and the line on which it ends.
 166 func (p *parser) consumeComment() (comment *ast.Comment, endline int) {
 167         // /*-style comments may end on a different line than where they start.
 168         // Scan the comment for '\n' chars and adjust endline accordingly.
 169         endline = p.file.Line(p.pos)
 170         if p.lit[1] == '*' {
 171                 // don't use range here - no need to decode Unicode code points
 172                 for i := 0; i < len(p.lit); i++ {
 173                         if p.lit[i] == '\n' {
 174                                 endline++
 175                         }
 176                 }
 177         }
 178
 179         comment = &ast.Comment{Slash: p.pos, Text: p.lit}
 180         p.next0()
 181
 182         return
 183 }
 184
 185 // Consume a group of adjacent comments, add it to the parser's
 186 // comments list, and return it together with the line at which
 187 // the last comment in the group ends. A non-comment token or n
 188 // empty lines terminate a comment group.
 189 func (p *parser) consumeCommentGroup(n int) (comments *ast.CommentGroup, endline int) {
 190         var list []*ast.Comment
 191         endline = p.file.Line(p.pos)
 192         for p.tok == token.COMMENT && p.file.Line(p.pos) <= endline+n {
 193                 var comment *ast.Comment
 194                 comment, endline = p.consumeComment()
 195                 list = append(list, comment)
 196         }
 197
 198         // add comment group to the comments list
 199         comments = &ast.CommentGroup{List: list}
 200         p.comments = append(p.comments, comments)
 201
 202         return
 203 }
 204
 205 // Advance to the next non-comment token. In the process, collect
 206 // any comment groups encountered, and remember the last lead and
 207 // line comments.
 208 //
 209 // A lead comment is a comment group that starts and ends in a
 210 // line without any other tokens and that is followed by a non-comment
 211 // token on the line immediately after the comment group.
 212 //
 213 // A line comment is a comment group that follows a non-comment
 214 // token on the same line, and that has no tokens after it on the line
 215 // where it ends.
 216 //
 217 // Lead and line comments may be considered documentation that is
 218 // stored in the AST.
 219 func (p *parser) next() {
 220         p.leadComment = nil
 221         p.lineComment = nil
 222         prev := p.pos
 223         p.next0()
 224
 225         if p.tok == token.COMMENT {
 226                 var comment *ast.CommentGroup
 227                 var endline int
 228
 229                 if p.file.Line(p.pos) == p.file.Line(prev) {
 230                         // The comment is on same line as the previous token; it
 231                         // cannot be a lead comment but may be a line comment.
 232                         comment, endline = p.consumeCommentGroup(0)
 233                         if p.file.Line(p.pos) != endline || p.tok == token.SEMICOLON || p.tok == token.EOF {
 234                                 // The next token is on a different line, thus
 235                                 // the last comment group is a line comment.
 236                                 p.lineComment = comment
 237                         }
 238                 }
 239
 240                 // consume successor comments, if any
 241                 endline = -1
 242                 for p.tok == token.COMMENT {
 243                         comment, endline = p.consumeCommentGroup(1)
 244                 }
 245
 246                 if endline+1 == p.file.Line(p.pos) {
 247                         // The next token is following on the line immediately after the
 248                         // comment group, thus the last comment group is a lead comment.
 249                         p.leadComment = comment
 250                 }
 251         }
 252 }
 253
 254 // A bailout panic is raised to indicate early termination. pos and msg are
 255 // only populated when bailing out of object resolution.
 256 type bailout struct {
 257         pos token.Pos
 258         msg string
 259 }
 260
 261 func (p *parser) error(pos token.Pos, msg string) {
 262         if p.trace {
 263                 defer un(trace(p, "error: "+msg))
 264         }
 265
 266         epos := p.file.Position(pos)
 267
 268         // If AllErrors is not set, discard errors reported on the same line
 269         // as the last recorded error and stop parsing if there are more than
 270         // 10 errors.
 271         if p.mode&AllErrors == 0 {
 272                 n := len(p.errors)
 273                 if n > 0 && p.errors[n-1].Pos.Line == epos.Line {
 274                         return // discard - likely a spurious error
 275                 }
 276                 if n > 10 {
 277                         panic(bailout{})
 278                 }
 279         }
 280
 281         p.errors.Add(epos, msg)
 282 }
 283
 284 func (p *parser) errorExpected(pos token.Pos, msg string) {
 285         msg = "expected " + msg
 286         if pos == p.pos {
 287                 // the error happened at the current position;
 288                 // make the error message more specific
 289                 switch {
 290                 case p.tok == token.SEMICOLON && p.lit == "\n":
 291                         msg += ", found newline"
 292                 case p.tok.IsLiteral():
 293                         // print 123 rather than 'INT', etc.
 294                         msg += ", found " + p.lit
 295                 default:
 296                         msg += ", found '" + p.tok.String() + "'"
 297                 }
 298         }
 299         p.error(pos, msg)
 300 }
 301
 302 func (p *parser) expect(tok token.Token) token.Pos {
 303         pos := p.pos
 304         if p.tok != tok {
 305                 p.errorExpected(pos, "'"+tok.String()+"'")
 306         }
 307         p.next() // make progress
 308         return pos
 309 }
 310
 311 // expect2 is like expect, but it returns an invalid position
 312 // if the expected token is not found.
 313 func (p *parser) expect2(tok token.Token) (pos token.Pos) {
 314         if p.tok == tok {
 315                 pos = p.pos
 316         } else {
 317                 p.errorExpected(p.pos, "'"+tok.String()+"'")
 318         }
 319         p.next() // make progress
 320         return
 321 }
 322
 323 // expectClosing is like expect but provides a better error message
 324 // for the common case of a missing comma before a newline.
 325 func (p *parser) expectClosing(tok token.Token, context string) token.Pos {
 326         if p.tok != tok && p.tok == token.SEMICOLON && p.lit == "\n" {
 327                 p.error(p.pos, "missing ',' before newline in "+context)
 328                 p.next()
 329         }
 330         return p.expect(tok)
 331 }
 332
 333 // expectSemi consumes a semicolon and returns the applicable line comment.
 334 func (p *parser) expectSemi() (comment *ast.CommentGroup) {
 335         // semicolon is optional before a closing ')' or '}'
 336         if p.tok != token.RPAREN && p.tok != token.RBRACE {
 337                 switch p.tok {
 338                 case token.COMMA:
 339                         // permit a ',' instead of a ';' but complain
 340                         p.errorExpected(p.pos, "';'")
 341                         fallthrough
 342                 case token.SEMICOLON:
 343                         if p.lit == ";" {
 344                                 // explicit semicolon
 345                                 p.next()
 346                                 comment = p.lineComment // use following comments
 347                         } else {
 348                                 // artificial semicolon
 349                                 comment = p.lineComment // use preceding comments
 350                                 p.next()
 351                         }
 352                         return comment
 353                 default:
 354                         p.errorExpected(p.pos, "';'")
 355                         p.advance(stmtStart)
 356                 }
 357         }
 358         return nil
 359 }
 360
 361 func (p *parser) atComma(context string, follow token.Token) bool {
 362         if p.tok == token.COMMA {
 363                 return true
 364         }
 365         if p.tok != follow {
 366                 msg := "missing ','"
 367                 if p.tok == token.SEMICOLON && p.lit == "\n" {
 368                         msg += " before newline"
 369                 }
 370                 p.error(p.pos, msg+" in "+context)
 371                 return true // "insert" comma and continue
 372         }
 373         return false
 374 }
 375
 376 func assert(cond bool, msg string) {
 377         if !cond {
 378                 panic("go/parser internal error: " + msg)
 379         }
 380 }
 381
 382 // advance consumes tokens until the current token p.tok
 383 // is in the 'to' set, or token.EOF. For error recovery.
 384 func (p *parser) advance(to map[token.Token]bool) {
 385         for ; p.tok != token.EOF; p.next() {
 386                 if to[p.tok] {
 387                         // Return only if parser made some progress since last
 388                         // sync or if it has not reached 10 advance calls without
 389                         // progress. Otherwise consume at least one token to
 390                         // avoid an endless parser loop (it is possible that
 391                         // both parseOperand and parseStmt call advance and
 392                         // correctly do not advance, thus the need for the
 393                         // invocation limit p.syncCnt).
 394                         if p.pos == p.syncPos && p.syncCnt < 10 {
 395                                 p.syncCnt++
 396                                 return
 397                         }
 398                         if p.pos > p.syncPos {
 399                                 p.syncPos = p.pos
 400                                 p.syncCnt = 0
 401                                 return
 402                         }
 403                         // Reaching here indicates a parser bug, likely an
 404                         // incorrect token list in this function, but it only
 405                         // leads to skipping of possibly correct code if a
 406                         // previous error is present, and thus is preferred
 407                         // over a non-terminating parse.
 408                 }
 409         }
 410 }
 411
 412 var stmtStart = map[token.Token]bool{
 413         token.BREAK:       true,
 414         token.CONST:       true,
 415         token.CONTINUE:    true,
 416         token.DEFER:       true,
 417         token.FALLTHROUGH: true,
 418         token.FOR:         true,
 419         token.GO:          true,
 420         token.GOTO:        true,
 421         token.IF:          true,
 422         token.RETURN:      true,
 423         token.SELECT:      true,
 424         token.SWITCH:      true,
 425         token.TYPE:        true,
 426         token.VAR:         true,
 427 }
 428
 429 var declStart = map[token.Token]bool{
 430         token.IMPORT: true,
 431         token.CONST:  true,
 432         token.TYPE:   true,
 433         token.VAR:    true,
 434 }
 435
 436 var exprEnd = map[token.Token]bool{
 437         token.COMMA:     true,
 438         token.COLON:     true,
 439         token.SEMICOLON: true,
 440         token.RPAREN:    true,
 441         token.RBRACK:    true,
 442         token.RBRACE:    true,
 443 }
 444
 445 // safePos returns a valid file position for a given position: If pos
 446 // is valid to begin with, safePos returns pos. If pos is out-of-range,
 447 // safePos returns the EOF position.
 448 //
 449 // This is hack to work around "artificial" end positions in the AST which
 450 // are computed by adding 1 to (presumably valid) token positions. If the
 451 // token positions are invalid due to parse errors, the resulting end position
 452 // may be past the file's EOF position, which would lead to panics if used
 453 // later on.
 454 func (p *parser) safePos(pos token.Pos) (res token.Pos) {
 455         defer func() {
 456                 if recover() != nil {
 457                         res = token.Pos(p.file.Base() + p.file.Size()) // EOF position
 458                 }
 459         }()
 460         _ = p.file.Offset(pos) // trigger a panic if position is out-of-range
 461         return pos
 462 }
 463
 464 // ----------------------------------------------------------------------------
 465 // Identifiers
 466
 467 func (p *parser) parseIdent() *ast.Ident {
 468         pos := p.pos
 469         name := "_"
 470         if p.tok == token.IDENT {
 471                 name = p.lit
 472                 p.next()
 473         } else {
 474                 p.expect(token.IDENT) // use expect() error handling
 475         }
 476         return &ast.Ident{NamePos: pos, Name: name}
 477 }
 478
 479 func (p *parser) parseIdentList() (list []*ast.Ident) {
 480         if p.trace {
 481                 defer un(trace(p, "IdentList"))
 482         }
 483
 484         list = append(list, p.parseIdent())
 485         for p.tok == token.COMMA {
 486                 p.next()
 487                 list = append(list, p.parseIdent())
 488         }
 489
 490         return
 491 }
 492
 493 // ----------------------------------------------------------------------------
 494 // Common productions
 495
 496 // If lhs is set, result list elements which are identifiers are not resolved.
 497 func (p *parser) parseExprList() (list []ast.Expr) {
 498         if p.trace {
 499                 defer un(trace(p, "ExpressionList"))
 500         }
 501
 502         list = append(list, p.parseExpr())
 503         for p.tok == token.COMMA {
 504                 p.next()
 505                 list = append(list, p.parseExpr())
 506         }
 507
 508         return
 509 }
 510
 511 func (p *parser) parseList(inRhs bool) []ast.Expr {
 512         old := p.inRhs
 513         p.inRhs = inRhs
 514         list := p.parseExprList()
 515         p.inRhs = old
 516         return list
 517 }
 518
 519 // ----------------------------------------------------------------------------
 520 // Types
 521
 522 func (p *parser) parseType() ast.Expr {
 523         if p.trace {
 524                 defer un(trace(p, "Type"))
 525         }
 526
 527         typ := p.tryIdentOrType()
 528
 529         if typ == nil {
 530                 pos := p.pos
 531                 p.errorExpected(pos, "type")
 532                 p.advance(exprEnd)
 533                 return &ast.BadExpr{From: pos, To: p.pos}
 534         }
 535
 536         return typ
 537 }
 538
 539 func (p *parser) parseQualifiedIdent(ident *ast.Ident) ast.Expr {
 540         if p.trace {
 541                 defer un(trace(p, "QualifiedIdent"))
 542         }
 543
 544         typ := p.parseTypeName(ident)
 545         if p.tok == token.LBRACK {
 546                 typ = p.parseTypeInstance(typ)
 547         }
 548
 549         return typ
 550 }
 551
 552 // If the result is an identifier, it is not resolved.
 553 func (p *parser) parseTypeName(ident *ast.Ident) ast.Expr {
 554         if p.trace {
 555                 defer un(trace(p, "TypeName"))
 556         }
 557
 558         if ident == nil {
 559                 ident = p.parseIdent()
 560         }
 561
 562         if p.tok == token.PERIOD {
 563                 // ident is a package name
 564                 p.next()
 565                 sel := p.parseIdent()
 566                 return &ast.SelectorExpr{X: ident, Sel: sel}
 567         }
 568
 569         return ident
 570 }
 571
 572 // "[" has already been consumed, and lbrack is its position.
 573 // If len != nil it is the already consumed array length.
 574 func (p *parser) parseArrayType(lbrack token.Pos, len ast.Expr) *ast.ArrayType {
 575         if p.trace {
 576                 defer un(trace(p, "ArrayType"))
 577         }
 578
 579         if len == nil {
 580                 p.exprLev++
 581                 // always permit ellipsis for more fault-tolerant parsing
 582                 if p.tok == token.ELLIPSIS {
 583                         len = &ast.Ellipsis{Ellipsis: p.pos}
 584                         p.next()
 585                 } else if p.tok != token.RBRACK {
 586                         len = p.parseRhs()
 587                 }
 588                 p.exprLev--
 589         }
 590         if p.tok == token.COMMA {
 591                 // Trailing commas are accepted in type parameter
 592                 // lists but not in array type declarations.
 593                 // Accept for better error handling but complain.
 594                 p.error(p.pos, "unexpected comma; expecting ]")
 595                 p.next()
 596         }
 597         p.expect(token.RBRACK)
 598         elt := p.parseType()
 599         return &ast.ArrayType{Lbrack: lbrack, Len: len, Elt: elt}
 600 }
 601
 602 func (p *parser) parseArrayFieldOrTypeInstance(x *ast.Ident) (*ast.Ident, ast.Expr) {
 603         if p.trace {
 604                 defer un(trace(p, "ArrayFieldOrTypeInstance"))
 605         }
 606
 607         lbrack := p.expect(token.LBRACK)
 608         trailingComma := token.NoPos // if valid, the position of a trailing comma preceding the ']'
 609         var args []ast.Expr
 610         if p.tok != token.RBRACK {
 611                 p.exprLev++
 612                 args = append(args, p.parseRhs())
 613                 for p.tok == token.COMMA {
 614                         comma := p.pos
 615                         p.next()
 616                         if p.tok == token.RBRACK {
 617                                 trailingComma = comma
 618                                 break
 619                         }
 620                         args = append(args, p.parseRhs())
 621                 }
 622                 p.exprLev--
 623         }
 624         rbrack := p.expect(token.RBRACK)
 625
 626         if len(args) == 0 {
 627                 // x []E
 628                 elt := p.parseType()
 629                 return x, &ast.ArrayType{Lbrack: lbrack, Elt: elt}
 630         }
 631
 632         // x [P]E or x[P]
 633         if len(args) == 1 {
 634                 elt := p.tryIdentOrType()
 635                 if elt != nil {
 636                         // x [P]E
 637                         if trailingComma.IsValid() {
 638                                 // Trailing commas are invalid in array type fields.
 639                                 p.error(trailingComma, "unexpected comma; expecting ]")
 640                         }
 641                         return x, &ast.ArrayType{Lbrack: lbrack, Len: args[0], Elt: elt}
 642                 }
 643         }
 644
 645         // x[P], x[P1, P2], ...
 646         return nil, typeparams.PackIndexExpr(x, lbrack, args, rbrack)
 647 }
 648
 649 func (p *parser) parseFieldDecl() *ast.Field {
 650         if p.trace {
 651                 defer un(trace(p, "FieldDecl"))
 652         }
 653
 654         doc := p.leadComment
 655
 656         var names []*ast.Ident
 657         var typ ast.Expr
 658         switch p.tok {
 659         case token.IDENT:
 660                 name := p.parseIdent()
 661                 if p.tok == token.PERIOD || p.tok == token.STRING || p.tok == token.SEMICOLON || p.tok == token.RBRACE {
 662                         // embedded type
 663                         typ = name
 664                         if p.tok == token.PERIOD {
 665                                 typ = p.parseQualifiedIdent(name)
 666                         }
 667                 } else {
 668                         // name1, name2, ... T
 669                         names = []*ast.Ident{name}
 670                         for p.tok == token.COMMA {
 671                                 p.next()
 672                                 names = append(names, p.parseIdent())
 673                         }
 674                         // Careful dance: We don't know if we have an embedded instantiated
 675                         // type T[P1, P2, ...] or a field T of array type []E or [P]E.
 676                         if len(names) == 1 && p.tok == token.LBRACK {
 677                                 name, typ = p.parseArrayFieldOrTypeInstance(name)
 678                                 if name == nil {
 679                                         names = nil
 680                                 }
 681                         } else {
 682                                 // T P
 683                                 typ = p.parseType()
 684                         }
 685                 }
 686         case token.MUL:
 687                 star := p.pos
 688                 p.next()
 689                 if p.tok == token.LPAREN {
 690                         // *(T)
 691                         p.error(p.pos, "cannot parenthesize embedded type")
 692                         p.next()
 693                         typ = p.parseQualifiedIdent(nil)
 694                         // expect closing ')' but no need to complain if missing
 695                         if p.tok == token.RPAREN {
 696                                 p.next()
 697                         }
 698                 } else {
 699                         // *T
 700                         typ = p.parseQualifiedIdent(nil)
 701                 }
 702                 typ = &ast.StarExpr{Star: star, X: typ}
 703
 704         case token.LPAREN:
 705                 p.error(p.pos, "cannot parenthesize embedded type")
 706                 p.next()
 707                 if p.tok == token.MUL {
 708                         // (*T)
 709                         star := p.pos
 710                         p.next()
 711                         typ = &ast.StarExpr{Star: star, X: p.parseQualifiedIdent(nil)}
 712                 } else {
 713                         // (T)
 714                         typ = p.parseQualifiedIdent(nil)
 715                 }
 716                 // expect closing ')' but no need to complain if missing
 717                 if p.tok == token.RPAREN {
 718                         p.next()
 719                 }
 720
 721         default:
 722                 pos := p.pos
 723                 p.errorExpected(pos, "field name or embedded type")
 724                 p.advance(exprEnd)
 725                 typ = &ast.BadExpr{From: pos, To: p.pos}
 726         }
 727
 728         var tag *ast.BasicLit
 729         if p.tok == token.STRING {
 730                 tag = &ast.BasicLit{ValuePos: p.pos, Kind: p.tok, Value: p.lit}
 731                 p.next()
 732         }
 733
 734         comment := p.expectSemi()
 735
 736         field := &ast.Field{Doc: doc, Names: names, Type: typ, Tag: tag, Comment: comment}
 737         return field
 738 }
 739
 740 func (p *parser) parseStructType() *ast.StructType {
 741         if p.trace {
 742                 defer un(trace(p, "StructType"))
 743         }
 744
 745         pos := p.expect(token.STRUCT)
 746         lbrace := p.expect(token.LBRACE)
 747         var list []*ast.Field
 748         for p.tok == token.IDENT || p.tok == token.MUL || p.tok == token.LPAREN {
 749                 // a field declaration cannot start with a '(' but we accept
 750                 // it here for more robust parsing and better error messages
 751                 // (parseFieldDecl will check and complain if necessary)
 752                 list = append(list, p.parseFieldDecl())
 753         }
 754         rbrace := p.expect(token.RBRACE)
 755
 756         return &ast.StructType{
 757                 Struct: pos,
 758                 Fields: &ast.FieldList{
 759                         Opening: lbrace,
 760                         List:    list,
 761                         Closing: rbrace,
 762                 },
 763         }
 764 }
 765
 766 func (p *parser) parsePointerType() *ast.StarExpr {
 767         if p.trace {
 768                 defer un(trace(p, "PointerType"))
 769         }
 770
 771         star := p.expect(token.MUL)
 772         base := p.parseType()
 773
 774         return &ast.StarExpr{Star: star, X: base}
 775 }
 776
 777 func (p *parser) parseDotsType() *ast.Ellipsis {
 778         if p.trace {
 779                 defer un(trace(p, "DotsType"))
 780         }
 781
 782         pos := p.expect(token.ELLIPSIS)
 783         elt := p.parseType()
 784
 785         return &ast.Ellipsis{Ellipsis: pos, Elt: elt}
 786 }
 787
 788 type field struct {
 789         name *ast.Ident
 790         typ  ast.Expr
 791 }
 792
 793 func (p *parser) parseParamDecl(name *ast.Ident, typeSetsOK bool) (f field) {
 794         // TODO(rFindley) refactor to be more similar to paramDeclOrNil in the syntax
 795         // package
 796         if p.trace {
 797                 defer un(trace(p, "ParamDeclOrNil"))
 798         }
 799
 800         ptok := p.tok
 801         if name != nil {
 802                 p.tok = token.IDENT // force token.IDENT case in switch below
 803         } else if typeSetsOK && p.tok == token.TILDE {
 804                 // "~" ...
 805                 return field{nil, p.embeddedElem(nil)}
 806         }
 807
 808         switch p.tok {
 809         case token.IDENT:
 810                 // name
 811                 if name != nil {
 812                         f.name = name
 813                         p.tok = ptok
 814                 } else {
 815                         f.name = p.parseIdent()
 816                 }
 817                 switch p.tok {
 818                 case token.IDENT, token.MUL, token.ARROW, token.FUNC, token.CHAN, token.MAP, token.STRUCT, token.INTERFACE, token.LPAREN:
 819                         // name type
 820                         f.typ = p.parseType()
 821
 822                 case token.LBRACK:
 823                         // name "[" type1, ..., typeN "]" or name "[" n "]" type
 824                         f.name, f.typ = p.parseArrayFieldOrTypeInstance(f.name)
 825
 826                 case token.ELLIPSIS:
 827                         // name "..." type
 828                         f.typ = p.parseDotsType()
 829                         return // don't allow ...type "|" ...
 830
 831                 case token.PERIOD:
 832                         // name "." ...
 833                         f.typ = p.parseQualifiedIdent(f.name)
 834                         f.name = nil
 835
 836                 case token.TILDE:
 837                         if typeSetsOK {
 838                                 f.typ = p.embeddedElem(nil)
 839                                 return
 840                         }
 841
 842                 case token.OR:
 843                         if typeSetsOK {
 844                                 // name "|" typeset
 845                                 f.typ = p.embeddedElem(f.name)
 846                                 f.name = nil
 847                                 return
 848                         }
 849                 }
 850
 851         case token.MUL, token.ARROW, token.FUNC, token.LBRACK, token.CHAN, token.MAP, token.STRUCT, token.INTERFACE, token.LPAREN:
 852                 // type
 853                 f.typ = p.parseType()
 854
 855         case token.ELLIPSIS:
 856                 // "..." type
 857                 // (always accepted)
 858                 f.typ = p.parseDotsType()
 859                 return // don't allow ...type "|" ...
 860
 861         default:
 862                 // TODO(rfindley): this is incorrect in the case of type parameter lists
 863                 //                 (should be "']'" in that case)
 864                 p.errorExpected(p.pos, "')'")
 865                 p.advance(exprEnd)
 866         }
 867
 868         // [name] type "|"
 869         if typeSetsOK && p.tok == token.OR && f.typ != nil {
 870                 f.typ = p.embeddedElem(f.typ)
 871         }
 872
 873         return
 874 }
 875
 876 func (p *parser) parseParameterList(name0 *ast.Ident, typ0 ast.Expr, closing token.Token) (params []*ast.Field) {
 877         if p.trace {
 878                 defer un(trace(p, "ParameterList"))
 879         }
 880
 881         // Type parameters are the only parameter list closed by ']'.
 882         tparams := closing == token.RBRACK
 883         // Type set notation is ok in type parameter lists.
 884         typeSetsOK := tparams
 885
 886         pos := p.pos
 887         if name0 != nil {
 888                 pos = name0.Pos()
 889         }
 890
 891         var list []field
 892         var named int // number of parameters that have an explicit name and type
 893
 894         for name0 != nil || p.tok != closing && p.tok != token.EOF {
 895                 var par field
 896                 if typ0 != nil {
 897                         if typeSetsOK {
 898                                 typ0 = p.embeddedElem(typ0)
 899                         }
 900                         par = field{name0, typ0}
 901                 } else {
 902                         par = p.parseParamDecl(name0, typeSetsOK)
 903                 }
 904                 name0 = nil // 1st name was consumed if present
 905                 typ0 = nil  // 1st typ was consumed if present
 906                 if par.name != nil || par.typ != nil {
 907                         list = append(list, par)
 908                         if par.name != nil && par.typ != nil {
 909                                 named++
 910                         }
 911                 }
 912                 if !p.atComma("parameter list", closing) {
 913                         break
 914                 }
 915                 p.next()
 916         }
 917
 918         if len(list) == 0 {
 919                 return // not uncommon
 920         }
 921
 922         // TODO(gri) parameter distribution and conversion to []*ast.Field
 923         //           can be combined and made more efficient
 924
 925         // distribute parameter types
 926         if named == 0 {
 927                 // all unnamed => found names are type names
 928                 for i := 0; i < len(list); i++ {
 929                         par := &list[i]
 930                         if typ := par.name; typ != nil {
 931                                 par.typ = typ
 932                                 par.name = nil
 933                         }
 934                 }
 935                 if tparams {
 936                         p.error(pos, "type parameters must be named")
 937                 }
 938         } else if named != len(list) {
 939                 // some named => all must be named
 940                 ok := true
 941                 var typ ast.Expr
 942                 missingName := pos
 943                 for i := len(list) - 1; i >= 0; i-- {
 944                         if par := &list[i]; par.typ != nil {
 945                                 typ = par.typ
 946                                 if par.name == nil {
 947                                         ok = false
 948                                         missingName = par.typ.Pos()
 949                                         n := ast.NewIdent("_")
 950                                         n.NamePos = typ.Pos() // correct position
 951                                         par.name = n
 952                                 }
 953                         } else if typ != nil {
 954                                 par.typ = typ
 955                         } else {
 956                                 // par.typ == nil && typ == nil => we only have a par.name
 957                                 ok = false
 958                                 missingName = par.name.Pos()
 959                                 par.typ = &ast.BadExpr{From: par.name.Pos(), To: p.pos}
 960                         }
 961                 }
 962                 if !ok {
 963                         if tparams {
 964                                 p.error(missingName, "type parameters must be named")
 965                         } else {
 966                                 p.error(pos, "mixed named and unnamed parameters")
 967                         }
 968                 }
 969         }
 970
 971         // convert list []*ast.Field
 972         if named == 0 {
 973                 // parameter list consists of types only
 974                 for _, par := range list {
 975                         assert(par.typ != nil, "nil type in unnamed parameter list")
 976                         params = append(params, &ast.Field{Type: par.typ})
 977                 }
 978                 return
 979         }
 980
 981         // parameter list consists of named parameters with types
 982         var names []*ast.Ident
 983         var typ ast.Expr
 984         addParams := func() {
 985                 assert(typ != nil, "nil type in named parameter list")
 986                 field := &ast.Field{Names: names, Type: typ}
 987                 params = append(params, field)
 988                 names = nil
 989         }
 990         for _, par := range list {
 991                 if par.typ != typ {
 992                         if len(names) > 0 {
 993                                 addParams()
 994                         }
 995                         typ = par.typ
 996                 }
 997                 names = append(names, par.name)
 998         }
 999         if len(names) > 0 {
1000                 addParams()
1001         }
1002         return
1003 }
1004
1005 func (p *parser) parseParameters(acceptTParams bool) (tparams, params *ast.FieldList) {
1006         if p.trace {
1007                 defer un(trace(p, "Parameters"))
1008         }
1009
1010         if acceptTParams && p.tok == token.LBRACK {
1011                 opening := p.pos
1012                 p.next()
1013                 // [T any](params) syntax
1014                 list := p.parseParameterList(nil, nil, token.RBRACK)
1015                 rbrack := p.expect(token.RBRACK)
1016                 tparams = &ast.FieldList{Opening: opening, List: list, Closing: rbrack}
1017                 // Type parameter lists must not be empty.
1018                 if tparams.NumFields() == 0 {
1019                         p.error(tparams.Closing, "empty type parameter list")
1020                         tparams = nil // avoid follow-on errors
1021                 }
1022         }
1023
1024         opening := p.expect(token.LPAREN)
1025
1026         var fields []*ast.Field
1027         if p.tok != token.RPAREN {
1028                 fields = p.parseParameterList(nil, nil, token.RPAREN)
1029         }
1030
1031         rparen := p.expect(token.RPAREN)
1032         params = &ast.FieldList{Opening: opening, List: fields, Closing: rparen}
1033
1034         return
1035 }
1036
1037 func (p *parser) parseResult() *ast.FieldList {
1038         if p.trace {
1039                 defer un(trace(p, "Result"))
1040         }
1041
1042         if p.tok == token.LPAREN {
1043                 _, results := p.parseParameters(false)
1044                 return results
1045         }
1046
1047         typ := p.tryIdentOrType()
1048         if typ != nil {
1049                 list := make([]*ast.Field, 1)
1050                 list[0] = &ast.Field{Type: typ}
1051                 return &ast.FieldList{List: list}
1052         }
1053
1054         return nil
1055 }
1056
1057 func (p *parser) parseFuncType() *ast.FuncType {
1058         if p.trace {
1059                 defer un(trace(p, "FuncType"))
1060         }
1061
1062         pos := p.expect(token.FUNC)
1063         tparams, params := p.parseParameters(true)
1064         if tparams != nil {
1065                 p.error(tparams.Pos(), "function type must have no type parameters")
1066         }
1067         results := p.parseResult()
1068
1069         return &ast.FuncType{Func: pos, Params: params, Results: results}
1070 }
1071
1072 func (p *parser) parseMethodSpec() *ast.Field {
1073         if p.trace {
1074                 defer un(trace(p, "MethodSpec"))
1075         }
1076
1077         doc := p.leadComment
1078         var idents []*ast.Ident
1079         var typ ast.Expr
1080         x := p.parseTypeName(nil)
1081         if ident, _ := x.(*ast.Ident); ident != nil {
1082                 switch {
1083                 case p.tok == token.LBRACK:
1084                         // generic method or embedded instantiated type
1085                         lbrack := p.pos
1086                         p.next()
1087                         p.exprLev++
1088                         x := p.parseExpr()
1089                         p.exprLev--
1090                         if name0, _ := x.(*ast.Ident); name0 != nil && p.tok != token.COMMA && p.tok != token.RBRACK {
1091                                 // generic method m[T any]
1092                                 //
1093                                 // Interface methods do not have type parameters. We parse them for a
1094                                 // better error message and improved error recovery.
1095                                 _ = p.parseParameterList(name0, nil, token.RBRACK)
1096                                 _ = p.expect(token.RBRACK)
1097                                 p.error(lbrack, "interface method must have no type parameters")
1098
1099                                 // TODO(rfindley) refactor to share code with parseFuncType.
1100                                 _, params := p.parseParameters(false)
1101                                 results := p.parseResult()
1102                                 idents = []*ast.Ident{ident}
1103                                 typ = &ast.FuncType{
1104                                         Func:    token.NoPos,
1105                                         Params:  params,
1106                                         Results: results,
1107                                 }
1108                         } else {
1109                                 // embedded instantiated type
1110                                 // TODO(rfindley) should resolve all identifiers in x.
1111                                 list := []ast.Expr{x}
1112                                 if p.atComma("type argument list", token.RBRACK) {
1113                                         p.exprLev++
1114                                         p.next()
1115                                         for p.tok != token.RBRACK && p.tok != token.EOF {
1116                                                 list = append(list, p.parseType())
1117                                                 if !p.atComma("type argument list", token.RBRACK) {
1118                                                         break
1119                                                 }
1120                                                 p.next()
1121                                         }
1122                                         p.exprLev--
1123                                 }
1124                                 rbrack := p.expectClosing(token.RBRACK, "type argument list")
1125                                 typ = typeparams.PackIndexExpr(ident, lbrack, list, rbrack)
1126                         }
1127                 case p.tok == token.LPAREN:
1128                         // ordinary method
1129                         // TODO(rfindley) refactor to share code with parseFuncType.
1130                         _, params := p.parseParameters(false)
1131                         results := p.parseResult()
1132                         idents = []*ast.Ident{ident}
1133                         typ = &ast.FuncType{Func: token.NoPos, Params: params, Results: results}
1134                 default:
1135                         // embedded type
1136                         typ = x
1137                 }
1138         } else {
1139                 // embedded, possibly instantiated type
1140                 typ = x
1141                 if p.tok == token.LBRACK {
1142                         // embedded instantiated interface
1143                         typ = p.parseTypeInstance(typ)
1144                 }
1145         }
1146
1147         // Comment is added at the callsite: the field below may joined with
1148         // additional type specs using '|'.
1149         // TODO(rfindley) this should be refactored.
1150         // TODO(rfindley) add more tests for comment handling.
1151         return &ast.Field{Doc: doc, Names: idents, Type: typ}
1152 }
1153
1154 func (p *parser) embeddedElem(x ast.Expr) ast.Expr {
1155         if p.trace {
1156                 defer un(trace(p, "EmbeddedElem"))
1157         }
1158         if x == nil {
1159                 x = p.embeddedTerm()
1160         }
1161         for p.tok == token.OR {
1162                 t := new(ast.BinaryExpr)
1163                 t.OpPos = p.pos
1164                 t.Op = token.OR
1165                 p.next()
1166                 t.X = x
1167                 t.Y = p.embeddedTerm()
1168                 x = t
1169         }
1170         return x
1171 }
1172
1173 func (p *parser) embeddedTerm() ast.Expr {
1174         if p.trace {
1175                 defer un(trace(p, "EmbeddedTerm"))
1176         }
1177         if p.tok == token.TILDE {
1178                 t := new(ast.UnaryExpr)
1179                 t.OpPos = p.pos
1180                 t.Op = token.TILDE
1181                 p.next()
1182                 t.X = p.parseType()
1183                 return t
1184         }
1185
1186         t := p.tryIdentOrType()
1187         if t == nil {
1188                 pos := p.pos
1189                 p.errorExpected(pos, "~ term or type")
1190                 p.advance(exprEnd)
1191                 return &ast.BadExpr{From: pos, To: p.pos}
1192         }
1193
1194         return t
1195 }
1196
1197 func (p *parser) parseInterfaceType() *ast.InterfaceType {
1198         if p.trace {
1199                 defer un(trace(p, "InterfaceType"))
1200         }
1201
1202         pos := p.expect(token.INTERFACE)
1203         lbrace := p.expect(token.LBRACE)
1204
1205         var list []*ast.Field
1206
1207 parseElements:
1208         for {
1209                 switch {
1210                 case p.tok == token.IDENT:
1211                         f := p.parseMethodSpec()
1212                         if f.Names == nil {
1213                                 f.Type = p.embeddedElem(f.Type)
1214                         }
1215                         f.Comment = p.expectSemi()
1216                         list = append(list, f)
1217                 case p.tok == token.TILDE:
1218                         typ := p.embeddedElem(nil)
1219                         comment := p.expectSemi()
1220                         list = append(list, &ast.Field{Type: typ, Comment: comment})
1221                 default:
1222                         if t := p.tryIdentOrType(); t != nil {
1223                                 typ := p.embeddedElem(t)
1224                                 comment := p.expectSemi()
1225                                 list = append(list, &ast.Field{Type: typ, Comment: comment})
1226                         } else {
1227                                 break parseElements
1228                         }
1229                 }
1230         }
1231
1232         // TODO(rfindley): the error produced here could be improved, since we could
1233         // accept an identifier, 'type', or a '}' at this point.
1234         rbrace := p.expect(token.RBRACE)
1235
1236         return &ast.InterfaceType{
1237                 Interface: pos,
1238                 Methods: &ast.FieldList{
1239                         Opening: lbrace,
1240                         List:    list,
1241                         Closing: rbrace,
1242                 },
1243         }
1244 }
1245
1246 func (p *parser) parseMapType() *ast.MapType {
1247         if p.trace {
1248                 defer un(trace(p, "MapType"))
1249         }
1250
1251         pos := p.expect(token.MAP)
1252         p.expect(token.LBRACK)
1253         key := p.parseType()
1254         p.expect(token.RBRACK)
1255         value := p.parseType()
1256
1257         return &ast.MapType{Map: pos, Key: key, Value: value}
1258 }
1259
1260 func (p *parser) parseChanType() *ast.ChanType {
1261         if p.trace {
1262                 defer un(trace(p, "ChanType"))
1263         }
1264
1265         pos := p.pos
1266         dir := ast.SEND | ast.RECV
1267         var arrow token.Pos
1268         if p.tok == token.CHAN {
1269                 p.next()
1270                 if p.tok == token.ARROW {
1271                         arrow = p.pos
1272                         p.next()
1273                         dir = ast.SEND
1274                 }
1275         } else {
1276                 arrow = p.expect(token.ARROW)
1277                 p.expect(token.CHAN)
1278                 dir = ast.RECV
1279         }
1280         value := p.parseType()
1281
1282         return &ast.ChanType{Begin: pos, Arrow: arrow, Dir: dir, Value: value}
1283 }
1284
1285 func (p *parser) parseTypeInstance(typ ast.Expr) ast.Expr {
1286         if p.trace {
1287                 defer un(trace(p, "TypeInstance"))
1288         }
1289
1290         opening := p.expect(token.LBRACK)
1291         p.exprLev++
1292         var list []ast.Expr
1293         for p.tok != token.RBRACK && p.tok != token.EOF {
1294                 list = append(list, p.parseType())
1295                 if !p.atComma("type argument list", token.RBRACK) {
1296                         break
1297                 }
1298                 p.next()
1299         }
1300         p.exprLev--
1301
1302         closing := p.expectClosing(token.RBRACK, "type argument list")
1303
1304         if len(list) == 0 {
1305                 p.errorExpected(closing, "type argument list")
1306                 return &ast.IndexExpr{
1307                         X:      typ,
1308                         Lbrack: opening,
1309                         Index:  &ast.BadExpr{From: opening + 1, To: closing},
1310                         Rbrack: closing,
1311                 }
1312         }
1313
1314         return typeparams.PackIndexExpr(typ, opening, list, closing)
1315 }
1316
1317 func (p *parser) tryIdentOrType() ast.Expr {
1318         defer decNestLev(incNestLev(p))
1319
1320         switch p.tok {
1321         case token.IDENT:
1322                 typ := p.parseTypeName(nil)
1323                 if p.tok == token.LBRACK {
1324                         typ = p.parseTypeInstance(typ)
1325                 }
1326                 return typ
1327         case token.LBRACK:
1328                 lbrack := p.expect(token.LBRACK)
1329                 return p.parseArrayType(lbrack, nil)
1330         case token.STRUCT:
1331                 return p.parseStructType()
1332         case token.MUL:
1333                 return p.parsePointerType()
1334         case token.FUNC:
1335                 return p.parseFuncType()
1336         case token.INTERFACE:
1337                 return p.parseInterfaceType()
1338         case token.MAP:
1339                 return p.parseMapType()
1340         case token.CHAN, token.ARROW:
1341                 return p.parseChanType()
1342         case token.LPAREN:
1343                 lparen := p.pos
1344                 p.next()
1345                 typ := p.parseType()
1346                 rparen := p.expect(token.RPAREN)
1347                 return &ast.ParenExpr{Lparen: lparen, X: typ, Rparen: rparen}
1348         }
1349
1350         // no type found
1351         return nil
1352 }
1353
1354 // ----------------------------------------------------------------------------
1355 // Blocks
1356
1357 func (p *parser) parseStmtList() (list []ast.Stmt) {
1358         if p.trace {
1359                 defer un(trace(p, "StatementList"))
1360         }
1361
1362         for p.tok != token.CASE && p.tok != token.DEFAULT && p.tok != token.RBRACE && p.tok != token.EOF {
1363                 list = append(list, p.parseStmt())
1364         }
1365
1366         return
1367 }
1368
1369 func (p *parser) parseBody() *ast.BlockStmt {
1370         if p.trace {
1371                 defer un(trace(p, "Body"))
1372         }
1373
1374         lbrace := p.expect(token.LBRACE)
1375         list := p.parseStmtList()
1376         rbrace := p.expect2(token.RBRACE)
1377
1378         return &ast.BlockStmt{Lbrace: lbrace, List: list, Rbrace: rbrace}
1379 }
1380
1381 func (p *parser) parseBlockStmt() *ast.BlockStmt {
1382         if p.trace {
1383                 defer un(trace(p, "BlockStmt"))
1384         }
1385
1386         lbrace := p.expect(token.LBRACE)
1387         list := p.parseStmtList()
1388         rbrace := p.expect2(token.RBRACE)
1389
1390         return &ast.BlockStmt{Lbrace: lbrace, List: list, Rbrace: rbrace}
1391 }
1392
1393 // ----------------------------------------------------------------------------
1394 // Expressions
1395
1396 func (p *parser) parseFuncTypeOrLit() ast.Expr {
1397         if p.trace {
1398                 defer un(trace(p, "FuncTypeOrLit"))
1399         }
1400
1401         typ := p.parseFuncType()
1402         if p.tok != token.LBRACE {
1403                 // function type only
1404                 return typ
1405         }
1406
1407         p.exprLev++
1408         body := p.parseBody()
1409         p.exprLev--
1410
1411         return &ast.FuncLit{Type: typ, Body: body}
1412 }
1413
1414 // parseOperand may return an expression or a raw type (incl. array
1415 // types of the form [...]T). Callers must verify the result.
1416 func (p *parser) parseOperand() ast.Expr {
1417         if p.trace {
1418                 defer un(trace(p, "Operand"))
1419         }
1420
1421         switch p.tok {
1422         case token.IDENT:
1423                 x := p.parseIdent()
1424                 return x
1425
1426         case token.INT, token.FLOAT, token.IMAG, token.CHAR, token.STRING:
1427                 x := &ast.BasicLit{ValuePos: p.pos, Kind: p.tok, Value: p.lit}
1428                 p.next()
1429                 return x
1430
1431         case token.LPAREN:
1432                 lparen := p.pos
1433                 p.next()
1434                 p.exprLev++
1435                 x := p.parseRhs() // types may be parenthesized: (some type)
1436                 p.exprLev--
1437                 rparen := p.expect(token.RPAREN)
1438                 return &ast.ParenExpr{Lparen: lparen, X: x, Rparen: rparen}
1439
1440         case token.FUNC:
1441                 return p.parseFuncTypeOrLit()
1442         }
1443
1444         if typ := p.tryIdentOrType(); typ != nil { // do not consume trailing type parameters
1445                 // could be type for composite literal or conversion
1446                 _, isIdent := typ.(*ast.Ident)
1447                 assert(!isIdent, "type cannot be identifier")
1448                 return typ
1449         }
1450
1451         // we have an error
1452         pos := p.pos
1453         p.errorExpected(pos, "operand")
1454         p.advance(stmtStart)
1455         return &ast.BadExpr{From: pos, To: p.pos}
1456 }
1457
1458 func (p *parser) parseSelector(x ast.Expr) ast.Expr {
1459         if p.trace {
1460                 defer un(trace(p, "Selector"))
1461         }
1462
1463         sel := p.parseIdent()
1464
1465         return &ast.SelectorExpr{X: x, Sel: sel}
1466 }
1467
1468 func (p *parser) parseTypeAssertion(x ast.Expr) ast.Expr {
1469         if p.trace {
1470                 defer un(trace(p, "TypeAssertion"))
1471         }
1472
1473         lparen := p.expect(token.LPAREN)
1474         var typ ast.Expr
1475         if p.tok == token.TYPE {
1476                 // type switch: typ == nil
1477                 p.next()
1478         } else {
1479                 typ = p.parseType()
1480         }
1481         rparen := p.expect(token.RPAREN)
1482
1483         return &ast.TypeAssertExpr{X: x, Type: typ, Lparen: lparen, Rparen: rparen}
1484 }
1485
1486 func (p *parser) parseIndexOrSliceOrInstance(x ast.Expr) ast.Expr {
1487         if p.trace {
1488                 defer un(trace(p, "parseIndexOrSliceOrInstance"))
1489         }
1490
1491         lbrack := p.expect(token.LBRACK)
1492         if p.tok == token.RBRACK {
1493                 // empty index, slice or index expressions are not permitted;
1494                 // accept them for parsing tolerance, but complain
1495                 p.errorExpected(p.pos, "operand")
1496                 rbrack := p.pos
1497                 p.next()
1498                 return &ast.IndexExpr{
1499                         X:      x,
1500                         Lbrack: lbrack,
1501                         Index:  &ast.BadExpr{From: rbrack, To: rbrack},
1502                         Rbrack: rbrack,
1503                 }
1504         }
1505         p.exprLev++
1506
1507         const N = 3 // change the 3 to 2 to disable 3-index slices
1508         var args []ast.Expr
1509         var index [N]ast.Expr
1510         var colons [N - 1]token.Pos
1511         if p.tok != token.COLON {
1512                 // We can't know if we have an index expression or a type instantiation;
1513                 // so even if we see a (named) type we are not going to be in type context.
1514                 index[0] = p.parseRhs()
1515         }
1516         ncolons := 0
1517         switch p.tok {
1518         case token.COLON:
1519                 // slice expression
1520                 for p.tok == token.COLON && ncolons < len(colons) {
1521                         colons[ncolons] = p.pos
1522                         ncolons++
1523                         p.next()
1524                         if p.tok != token.COLON && p.tok != token.RBRACK && p.tok != token.EOF {
1525                                 index[ncolons] = p.parseRhs()
1526                         }
1527                 }
1528         case token.COMMA:
1529                 // instance expression
1530                 args = append(args, index[0])
1531                 for p.tok == token.COMMA {
1532                         p.next()
1533                         if p.tok != token.RBRACK && p.tok != token.EOF {
1534                                 args = append(args, p.parseType())
1535                         }
1536                 }
1537         }
1538
1539         p.exprLev--
1540         rbrack := p.expect(token.RBRACK)
1541
1542         if ncolons > 0 {
1543                 // slice expression
1544                 slice3 := false
1545                 if ncolons == 2 {
1546                         slice3 = true
1547                         // Check presence of middle and final index here rather than during type-checking
1548                         // to prevent erroneous programs from passing through gofmt (was issue 7305).
1549                         if index[1] == nil {
1550                                 p.error(colons[0], "middle index required in 3-index slice")
1551                                 index[1] = &ast.BadExpr{From: colons[0] + 1, To: colons[1]}
1552                         }
1553                         if index[2] == nil {
1554                                 p.error(colons[1], "final index required in 3-index slice")
1555                                 index[2] = &ast.BadExpr{From: colons[1] + 1, To: rbrack}
1556                         }
1557                 }
1558                 return &ast.SliceExpr{X: x, Lbrack: lbrack, Low: index[0], High: index[1], Max: index[2], Slice3: slice3, Rbrack: rbrack}
1559         }
1560
1561         if len(args) == 0 {
1562                 // index expression
1563                 return &ast.IndexExpr{X: x, Lbrack: lbrack, Index: index[0], Rbrack: rbrack}
1564         }
1565
1566         // instance expression
1567         return typeparams.PackIndexExpr(x, lbrack, args, rbrack)
1568 }
1569
1570 func (p *parser) parseCallOrConversion(fun ast.Expr) *ast.CallExpr {
1571         if p.trace {
1572                 defer un(trace(p, "CallOrConversion"))
1573         }
1574
1575         lparen := p.expect(token.LPAREN)
1576         p.exprLev++
1577         var list []ast.Expr
1578         var ellipsis token.Pos
1579         for p.tok != token.RPAREN && p.tok != token.EOF && !ellipsis.IsValid() {
1580                 list = append(list, p.parseRhs()) // builtins may expect a type: make(some type, ...)
1581                 if p.tok == token.ELLIPSIS {
1582                         ellipsis = p.pos
1583                         p.next()
1584                 }
1585                 if !p.atComma("argument list", token.RPAREN) {
1586                         break
1587                 }
1588                 p.next()
1589         }
1590         p.exprLev--
1591         rparen := p.expectClosing(token.RPAREN, "argument list")
1592
1593         return &ast.CallExpr{Fun: fun, Lparen: lparen, Args: list, Ellipsis: ellipsis, Rparen: rparen}
1594 }
1595
1596 func (p *parser) parseValue() ast.Expr {
1597         if p.trace {
1598                 defer un(trace(p, "Element"))
1599         }
1600
1601         if p.tok == token.LBRACE {
1602                 return p.parseLiteralValue(nil)
1603         }
1604
1605         x := p.parseExpr()
1606
1607         return x
1608 }
1609
1610 func (p *parser) parseElement() ast.Expr {
1611         if p.trace {
1612                 defer un(trace(p, "Element"))
1613         }
1614
1615         x := p.parseValue()
1616         if p.tok == token.COLON {
1617                 colon := p.pos
1618                 p.next()
1619                 x = &ast.KeyValueExpr{Key: x, Colon: colon, Value: p.parseValue()}
1620         }
1621
1622         return x
1623 }
1624
1625 func (p *parser) parseElementList() (list []ast.Expr) {
1626         if p.trace {
1627                 defer un(trace(p, "ElementList"))
1628         }
1629
1630         for p.tok != token.RBRACE && p.tok != token.EOF {
1631                 list = append(list, p.parseElement())
1632                 if !p.atComma("composite literal", token.RBRACE) {
1633                         break
1634                 }
1635                 p.next()
1636         }
1637
1638         return
1639 }
1640
1641 func (p *parser) parseLiteralValue(typ ast.Expr) ast.Expr {
1642         if p.trace {
1643                 defer un(trace(p, "LiteralValue"))
1644         }
1645
1646         lbrace := p.expect(token.LBRACE)
1647         var elts []ast.Expr
1648         p.exprLev++
1649         if p.tok != token.RBRACE {
1650                 elts = p.parseElementList()
1651         }
1652         p.exprLev--
1653         rbrace := p.expectClosing(token.RBRACE, "composite literal")
1654         return &ast.CompositeLit{Type: typ, Lbrace: lbrace, Elts: elts, Rbrace: rbrace}
1655 }
1656
1657 func (p *parser) parsePrimaryExpr(x ast.Expr) ast.Expr {
1658         if p.trace {
1659                 defer un(trace(p, "PrimaryExpr"))
1660         }
1661
1662         if x == nil {
1663                 x = p.parseOperand()
1664         }
1665         // We track the nesting here rather than at the entry for the function,
1666         // since it can iteratively produce a nested output, and we want to
1667         // limit how deep a structure we generate.
1668         var n int
1669         defer func() { p.nestLev -= n }()
1670         for n = 1; ; n++ {
1671                 incNestLev(p)
1672                 switch p.tok {
1673                 case token.PERIOD:
1674                         p.next()
1675                         switch p.tok {
1676                         case token.IDENT:
1677                                 x = p.parseSelector(x)
1678                         case token.LPAREN:
1679                                 x = p.parseTypeAssertion(x)
1680                         default:
1681                                 pos := p.pos
1682                                 p.errorExpected(pos, "selector or type assertion")
1683                                 // TODO(rFindley) The check for token.RBRACE below is a targeted fix
1684                                 //                to error recovery sufficient to make the x/tools tests to
1685                                 //                pass with the new parsing logic introduced for type
1686                                 //                parameters. Remove this once error recovery has been
1687                                 //                more generally reconsidered.
1688                                 if p.tok != token.RBRACE {
1689                                         p.next() // make progress
1690                                 }
1691                                 sel := &ast.Ident{NamePos: pos, Name: "_"}
1692                                 x = &ast.SelectorExpr{X: x, Sel: sel}
1693                         }
1694                 case token.LBRACK:
1695                         x = p.parseIndexOrSliceOrInstance(x)
1696                 case token.LPAREN:
1697                         x = p.parseCallOrConversion(x)
1698                 case token.LBRACE:
1699                         // operand may have returned a parenthesized complit
1700                         // type; accept it but complain if we have a complit
1701                         t := ast.Unparen(x)
1702                         // determine if '{' belongs to a composite literal or a block statement
1703                         switch t.(type) {
1704                         case *ast.BadExpr, *ast.Ident, *ast.SelectorExpr:
1705                                 if p.exprLev < 0 {
1706                                         return x
1707                                 }
1708                                 // x is possibly a composite literal type
1709                         case *ast.IndexExpr, *ast.IndexListExpr:
1710                                 if p.exprLev < 0 {
1711                                         return x
1712                                 }
1713                                 // x is possibly a composite literal type
1714                         case *ast.ArrayType, *ast.StructType, *ast.MapType:
1715                                 // x is a composite literal type
1716                         default:
1717                                 return x
1718                         }
1719                         if t != x {
1720                                 p.error(t.Pos(), "cannot parenthesize type in composite literal")
1721                                 // already progressed, no need to advance
1722                         }
1723                         x = p.parseLiteralValue(x)
1724                 default:
1725                         return x
1726                 }
1727         }
1728 }
1729
1730 func (p *parser) parseUnaryExpr() ast.Expr {
1731         defer decNestLev(incNestLev(p))
1732
1733         if p.trace {
1734                 defer un(trace(p, "UnaryExpr"))
1735         }
1736
1737         switch p.tok {
1738         case token.ADD, token.SUB, token.NOT, token.XOR, token.AND, token.TILDE:
1739                 pos, op := p.pos, p.tok
1740                 p.next()
1741                 x := p.parseUnaryExpr()
1742                 return &ast.UnaryExpr{OpPos: pos, Op: op, X: x}
1743
1744         case token.ARROW:
1745                 // channel type or receive expression
1746                 arrow := p.pos
1747                 p.next()
1748
1749                 // If the next token is token.CHAN we still don't know if it
1750                 // is a channel type or a receive operation - we only know
1751                 // once we have found the end of the unary expression. There
1752                 // are two cases:
1753                 //
1754                 //   <- type  => (<-type) must be channel type
1755                 //   <- expr  => <-(expr) is a receive from an expression
1756                 //
1757                 // In the first case, the arrow must be re-associated with
1758                 // the channel type parsed already:
1759                 //
1760                 //   <- (chan type)    =>  (<-chan type)
1761                 //   <- (chan<- type)  =>  (<-chan (<-type))
1762
1763                 x := p.parseUnaryExpr()
1764
1765                 // determine which case we have
1766                 if typ, ok := x.(*ast.ChanType); ok {
1767                         // (<-type)
1768
1769                         // re-associate position info and <-
1770                         dir := ast.SEND
1771                         for ok && dir == ast.SEND {
1772                                 if typ.Dir == ast.RECV {
1773                                         // error: (<-type) is (<-(<-chan T))
1774                                         p.errorExpected(typ.Arrow, "'chan'")
1775                                 }
1776                                 arrow, typ.Begin, typ.Arrow = typ.Arrow, arrow, arrow
1777                                 dir, typ.Dir = typ.Dir, ast.RECV
1778                                 typ, ok = typ.Value.(*ast.ChanType)
1779                         }
1780                         if dir == ast.SEND {
1781                                 p.errorExpected(arrow, "channel type")
1782                         }
1783
1784                         return x
1785                 }
1786
1787                 // <-(expr)
1788                 return &ast.UnaryExpr{OpPos: arrow, Op: token.ARROW, X: x}
1789
1790         case token.MUL:
1791                 // pointer type or unary "*" expression
1792                 pos := p.pos
1793                 p.next()
1794                 x := p.parseUnaryExpr()
1795                 return &ast.StarExpr{Star: pos, X: x}
1796         }
1797
1798         return p.parsePrimaryExpr(nil)
1799 }
1800
1801 func (p *parser) tokPrec() (token.Token, int) {
1802         tok := p.tok
1803         if p.inRhs && tok == token.ASSIGN {
1804                 tok = token.EQL
1805         }
1806         return tok, tok.Precedence()
1807 }
1808
1809 // parseBinaryExpr parses a (possibly) binary expression.
1810 // If x is non-nil, it is used as the left operand.
1811 //
1812 // TODO(rfindley): parseBinaryExpr has become overloaded. Consider refactoring.
1813 func (p *parser) parseBinaryExpr(x ast.Expr, prec1 int) ast.Expr {
1814         if p.trace {
1815                 defer un(trace(p, "BinaryExpr"))
1816         }
1817
1818         if x == nil {
1819                 x = p.parseUnaryExpr()
1820         }
1821         // We track the nesting here rather than at the entry for the function,
1822         // since it can iteratively produce a nested output, and we want to
1823         // limit how deep a structure we generate.
1824         var n int
1825         defer func() { p.nestLev -= n }()
1826         for n = 1; ; n++ {
1827                 incNestLev(p)
1828                 op, oprec := p.tokPrec()
1829                 if oprec < prec1 {
1830                         return x
1831                 }
1832                 pos := p.expect(op)
1833                 y := p.parseBinaryExpr(nil, oprec+1)
1834                 x = &ast.BinaryExpr{X: x, OpPos: pos, Op: op, Y: y}
1835         }
1836 }
1837
1838 // The result may be a type or even a raw type ([...]int).
1839 func (p *parser) parseExpr() ast.Expr {
1840         if p.trace {
1841                 defer un(trace(p, "Expression"))
1842         }
1843
1844         return p.parseBinaryExpr(nil, token.LowestPrec+1)
1845 }
1846
1847 func (p *parser) parseRhs() ast.Expr {
1848         old := p.inRhs
1849         p.inRhs = true
1850         x := p.parseExpr()
1851         p.inRhs = old
1852         return x
1853 }
1854
1855 // ----------------------------------------------------------------------------
1856 // Statements
1857
1858 // Parsing modes for parseSimpleStmt.
1859 const (
1860         basic = iota
1861         labelOk
1862         rangeOk
1863 )
1864
1865 // parseSimpleStmt returns true as 2nd result if it parsed the assignment
1866 // of a range clause (with mode == rangeOk). The returned statement is an
1867 // assignment with a right-hand side that is a single unary expression of
1868 // the form "range x". No guarantees are given for the left-hand side.
1869 func (p *parser) parseSimpleStmt(mode int) (ast.Stmt, bool) {
1870         if p.trace {
1871                 defer un(trace(p, "SimpleStmt"))
1872         }
1873
1874         x := p.parseList(false)
1875
1876         switch p.tok {
1877         case
1878                 token.DEFINE, token.ASSIGN, token.ADD_ASSIGN,
1879                 token.SUB_ASSIGN, token.MUL_ASSIGN, token.QUO_ASSIGN,
1880                 token.REM_ASSIGN, token.AND_ASSIGN, token.OR_ASSIGN,
1881                 token.XOR_ASSIGN, token.SHL_ASSIGN, token.SHR_ASSIGN, token.AND_NOT_ASSIGN:
1882                 // assignment statement, possibly part of a range clause
1883                 pos, tok := p.pos, p.tok
1884                 p.next()
1885                 var y []ast.Expr
1886                 isRange := false
1887                 if mode == rangeOk && p.tok == token.RANGE && (tok == token.DEFINE || tok == token.ASSIGN) {
1888                         pos := p.pos
1889                         p.next()
1890                         y = []ast.Expr{&ast.UnaryExpr{OpPos: pos, Op: token.RANGE, X: p.parseRhs()}}
1891                         isRange = true
1892                 } else {
1893                         y = p.parseList(true)
1894                 }
1895                 return &ast.AssignStmt{Lhs: x, TokPos: pos, Tok: tok, Rhs: y}, isRange
1896         }
1897
1898         if len(x) > 1 {
1899                 p.errorExpected(x[0].Pos(), "1 expression")
1900                 // continue with first expression
1901         }
1902
1903         switch p.tok {
1904         case token.COLON:
1905                 // labeled statement
1906                 colon := p.pos
1907                 p.next()
1908                 if label, isIdent := x[0].(*ast.Ident); mode == labelOk && isIdent {
1909                         // Go spec: The scope of a label is the body of the function
1910                         // in which it is declared and excludes the body of any nested
1911                         // function.
1912                         stmt := &ast.LabeledStmt{Label: label, Colon: colon, Stmt: p.parseStmt()}
1913                         return stmt, false
1914                 }
1915                 // The label declaration typically starts at x[0].Pos(), but the label
1916                 // declaration may be erroneous due to a token after that position (and
1917                 // before the ':'). If SpuriousErrors is not set, the (only) error
1918                 // reported for the line is the illegal label error instead of the token
1919                 // before the ':' that caused the problem. Thus, use the (latest) colon
1920                 // position for error reporting.
1921                 p.error(colon, "illegal label declaration")
1922                 return &ast.BadStmt{From: x[0].Pos(), To: colon + 1}, false
1923
1924         case token.ARROW:
1925                 // send statement
1926                 arrow := p.pos
1927                 p.next()
1928                 y := p.parseRhs()
1929                 return &ast.SendStmt{Chan: x[0], Arrow: arrow, Value: y}, false
1930
1931         case token.INC, token.DEC:
1932                 // increment or decrement
1933                 s := &ast.IncDecStmt{X: x[0], TokPos: p.pos, Tok: p.tok}
1934                 p.next()
1935                 return s, false
1936         }
1937
1938         // expression
1939         return &ast.ExprStmt{X: x[0]}, false
1940 }
1941
1942 func (p *parser) parseCallExpr(callType string) *ast.CallExpr {
1943         x := p.parseRhs() // could be a conversion: (some type)(x)
1944         if t := ast.Unparen(x); t != x {
1945                 p.error(x.Pos(), fmt.Sprintf("expression in %s must not be parenthesized", callType))
1946                 x = t
1947         }
1948         if call, isCall := x.(*ast.CallExpr); isCall {
1949                 return call
1950         }
1951         if _, isBad := x.(*ast.BadExpr); !isBad {
1952                 // only report error if it's a new one
1953                 p.error(p.safePos(x.End()), fmt.Sprintf("expression in %s must be function call", callType))
1954         }
1955         return nil
1956 }
1957
1958 func (p *parser) parseGoStmt() ast.Stmt {
1959         if p.trace {
1960                 defer un(trace(p, "GoStmt"))
1961         }
1962
1963         pos := p.expect(token.GO)
1964         call := p.parseCallExpr("go")
1965         p.expectSemi()
1966         if call == nil {
1967                 return &ast.BadStmt{From: pos, To: pos + 2} // len("go")
1968         }
1969
1970         return &ast.GoStmt{Go: pos, Call: call}
1971 }
1972
1973 func (p *parser) parseDeferStmt() ast.Stmt {
1974         if p.trace {
1975                 defer un(trace(p, "DeferStmt"))
1976         }
1977
1978         pos := p.expect(token.DEFER)
1979         call := p.parseCallExpr("defer")
1980         p.expectSemi()
1981         if call == nil {
1982                 return &ast.BadStmt{From: pos, To: pos + 5} // len("defer")
1983         }
1984
1985         return &ast.DeferStmt{Defer: pos, Call: call}
1986 }
1987
1988 func (p *parser) parseReturnStmt() *ast.ReturnStmt {
1989         if p.trace {
1990                 defer un(trace(p, "ReturnStmt"))
1991         }
1992
1993         pos := p.pos
1994         p.expect(token.RETURN)
1995         var x []ast.Expr
1996         if p.tok != token.SEMICOLON && p.tok != token.RBRACE {
1997                 x = p.parseList(true)
1998         }
1999         p.expectSemi()
2000
2001         return &ast.ReturnStmt{Return: pos, Results: x}
2002 }
2003
2004 func (p *parser) parseBranchStmt(tok token.Token) *ast.BranchStmt {
2005         if p.trace {
2006                 defer un(trace(p, "BranchStmt"))
2007         }
2008
2009         pos := p.expect(tok)
2010         var label *ast.Ident
2011         if tok != token.FALLTHROUGH && p.tok == token.IDENT {
2012                 label = p.parseIdent()
2013         }
2014         p.expectSemi()
2015
2016         return &ast.BranchStmt{TokPos: pos, Tok: tok, Label: label}
2017 }
2018
2019 func (p *parser) makeExpr(s ast.Stmt, want string) ast.Expr {
2020         if s == nil {
2021                 return nil
2022         }
2023         if es, isExpr := s.(*ast.ExprStmt); isExpr {
2024                 return es.X
2025         }
2026         found := "simple statement"
2027         if _, isAss := s.(*ast.AssignStmt); isAss {
2028                 found = "assignment"
2029         }
2030         p.error(s.Pos(), fmt.Sprintf("expected %s, found %s (missing parentheses around composite literal?)", want, found))
2031         return &ast.BadExpr{From: s.Pos(), To: p.safePos(s.End())}
2032 }
2033
2034 // parseIfHeader is an adjusted version of parser.header
2035 // in cmd/compile/internal/syntax/parser.go, which has
2036 // been tuned for better error handling.
2037 func (p *parser) parseIfHeader() (init ast.Stmt, cond ast.Expr) {
2038         if p.tok == token.LBRACE {
2039                 p.error(p.pos, "missing condition in if statement")
2040                 cond = &ast.BadExpr{From: p.pos, To: p.pos}
2041                 return
2042         }
2043         // p.tok != token.LBRACE
2044
2045         prevLev := p.exprLev
2046         p.exprLev = -1
2047
2048         if p.tok != token.SEMICOLON {
2049                 // accept potential variable declaration but complain
2050                 if p.tok == token.VAR {
2051                         p.next()
2052                         p.error(p.pos, "var declaration not allowed in if initializer")
2053                 }
2054                 init, _ = p.parseSimpleStmt(basic)
2055         }
2056
2057         var condStmt ast.Stmt
2058         var semi struct {
2059                 pos token.Pos
2060                 lit string // ";" or "\n"; valid if pos.IsValid()
2061         }
2062         if p.tok != token.LBRACE {
2063                 if p.tok == token.SEMICOLON {
2064                         semi.pos = p.pos
2065                         semi.lit = p.lit
2066                         p.next()
2067                 } else {
2068                         p.expect(token.SEMICOLON)
2069                 }
2070                 if p.tok != token.LBRACE {
2071                         condStmt, _ = p.parseSimpleStmt(basic)
2072                 }
2073         } else {
2074                 condStmt = init
2075                 init = nil
2076         }
2077
2078         if condStmt != nil {
2079                 cond = p.makeExpr(condStmt, "boolean expression")
2080         } else if semi.pos.IsValid() {
2081                 if semi.lit == "\n" {
2082                         p.error(semi.pos, "unexpected newline, expecting { after if clause")
2083                 } else {
2084                         p.error(semi.pos, "missing condition in if statement")
2085                 }
2086         }
2087
2088         // make sure we have a valid AST
2089         if cond == nil {
2090                 cond = &ast.BadExpr{From: p.pos, To: p.pos}
2091         }
2092
2093         p.exprLev = prevLev
2094         return
2095 }
2096
2097 func (p *parser) parseIfStmt() *ast.IfStmt {
2098         defer decNestLev(incNestLev(p))
2099
2100         if p.trace {
2101                 defer un(trace(p, "IfStmt"))
2102         }
2103
2104         pos := p.expect(token.IF)
2105
2106         init, cond := p.parseIfHeader()
2107         body := p.parseBlockStmt()
2108
2109         var else_ ast.Stmt
2110         if p.tok == token.ELSE {
2111                 p.next()
2112                 switch p.tok {
2113                 case token.IF:
2114                         else_ = p.parseIfStmt()
2115                 case token.LBRACE:
2116                         else_ = p.parseBlockStmt()
2117                         p.expectSemi()
2118                 default:
2119                         p.errorExpected(p.pos, "if statement or block")
2120                         else_ = &ast.BadStmt{From: p.pos, To: p.pos}
2121                 }
2122         } else {
2123                 p.expectSemi()
2124         }
2125
2126         return &ast.IfStmt{If: pos, Init: init, Cond: cond, Body: body, Else: else_}
2127 }
2128
2129 func (p *parser) parseCaseClause() *ast.CaseClause {
2130         if p.trace {
2131                 defer un(trace(p, "CaseClause"))
2132         }
2133
2134         pos := p.pos
2135         var list []ast.Expr
2136         if p.tok == token.CASE {
2137                 p.next()
2138                 list = p.parseList(true)
2139         } else {
2140                 p.expect(token.DEFAULT)
2141         }
2142
2143         colon := p.expect(token.COLON)
2144         body := p.parseStmtList()
2145
2146         return &ast.CaseClause{Case: pos, List: list, Colon: colon, Body: body}
2147 }
2148
2149 func isTypeSwitchAssert(x ast.Expr) bool {
2150         a, ok := x.(*ast.TypeAssertExpr)
2151         return ok && a.Type == nil
2152 }
2153
2154 func (p *parser) isTypeSwitchGuard(s ast.Stmt) bool {
2155         switch t := s.(type) {
2156         case *ast.ExprStmt:
2157                 // x.(type)
2158                 return isTypeSwitchAssert(t.X)
2159         case *ast.AssignStmt:
2160                 // v := x.(type)
2161                 if len(t.Lhs) == 1 && len(t.Rhs) == 1 && isTypeSwitchAssert(t.Rhs[0]) {
2162                         switch t.Tok {
2163                         case token.ASSIGN:
2164                                 // permit v = x.(type) but complain
2165                                 p.error(t.TokPos, "expected ':=', found '='")
2166                                 fallthrough
2167                         case token.DEFINE:
2168                                 return true
2169                         }
2170                 }
2171         }
2172         return false
2173 }
2174
2175 func (p *parser) parseSwitchStmt() ast.Stmt {
2176         if p.trace {
2177                 defer un(trace(p, "SwitchStmt"))
2178         }
2179
2180         pos := p.expect(token.SWITCH)
2181
2182         var s1, s2 ast.Stmt
2183         if p.tok != token.LBRACE {
2184                 prevLev := p.exprLev
2185                 p.exprLev = -1
2186                 if p.tok != token.SEMICOLON {
2187                         s2, _ = p.parseSimpleStmt(basic)
2188                 }
2189                 if p.tok == token.SEMICOLON {
2190                         p.next()
2191                         s1 = s2
2192                         s2 = nil
2193                         if p.tok != token.LBRACE {
2194                                 // A TypeSwitchGuard may declare a variable in addition
2195                                 // to the variable declared in the initial SimpleStmt.
2196                                 // Introduce extra scope to avoid redeclaration errors:
2197                                 //
2198                                 //      switch t := 0; t := x.(T) { ... }
2199                                 //
2200                                 // (this code is not valid Go because the first t
2201                                 // cannot be accessed and thus is never used, the extra
2202                                 // scope is needed for the correct error message).
2203                                 //
2204                                 // If we don't have a type switch, s2 must be an expression.
2205                                 // Having the extra nested but empty scope won't affect it.
2206                                 s2, _ = p.parseSimpleStmt(basic)
2207                         }
2208                 }
2209                 p.exprLev = prevLev
2210         }
2211
2212         typeSwitch := p.isTypeSwitchGuard(s2)
2213         lbrace := p.expect(token.LBRACE)
2214         var list []ast.Stmt
2215         for p.tok == token.CASE || p.tok == token.DEFAULT {
2216                 list = append(list, p.parseCaseClause())
2217         }
2218         rbrace := p.expect(token.RBRACE)
2219         p.expectSemi()
2220         body := &ast.BlockStmt{Lbrace: lbrace, List: list, Rbrace: rbrace}
2221
2222         if typeSwitch {
2223                 return &ast.TypeSwitchStmt{Switch: pos, Init: s1, Assign: s2, Body: body}
2224         }
2225
2226         return &ast.SwitchStmt{Switch: pos, Init: s1, Tag: p.makeExpr(s2, "switch expression"), Body: body}
2227 }
2228
2229 func (p *parser) parseCommClause() *ast.CommClause {
2230         if p.trace {
2231                 defer un(trace(p, "CommClause"))
2232         }
2233
2234         pos := p.pos
2235         var comm ast.Stmt
2236         if p.tok == token.CASE {
2237                 p.next()
2238                 lhs := p.parseList(false)
2239                 if p.tok == token.ARROW {
2240                         // SendStmt
2241                         if len(lhs) > 1 {
2242                                 p.errorExpected(lhs[0].Pos(), "1 expression")
2243                                 // continue with first expression
2244                         }
2245                         arrow := p.pos
2246                         p.next()
2247                         rhs := p.parseRhs()
2248                         comm = &ast.SendStmt{Chan: lhs[0], Arrow: arrow, Value: rhs}
2249                 } else {
2250                         // RecvStmt
2251                         if tok := p.tok; tok == token.ASSIGN || tok == token.DEFINE {
2252                                 // RecvStmt with assignment
2253                                 if len(lhs) > 2 {
2254                                         p.errorExpected(lhs[0].Pos(), "1 or 2 expressions")
2255                                         // continue with first two expressions
2256                                         lhs = lhs[0:2]
2257                                 }
2258                                 pos := p.pos
2259                                 p.next()
2260                                 rhs := p.parseRhs()
2261                                 comm = &ast.AssignStmt{Lhs: lhs, TokPos: pos, Tok: tok, Rhs: []ast.Expr{rhs}}
2262                         } else {
2263                                 // lhs must be single receive operation
2264                                 if len(lhs) > 1 {
2265                                         p.errorExpected(lhs[0].Pos(), "1 expression")
2266                                         // continue with first expression
2267                                 }
2268                                 comm = &ast.ExprStmt{X: lhs[0]}
2269                         }
2270                 }
2271         } else {
2272                 p.expect(token.DEFAULT)
2273         }
2274
2275         colon := p.expect(token.COLON)
2276         body := p.parseStmtList()
2277
2278         return &ast.CommClause{Case: pos, Comm: comm, Colon: colon, Body: body}
2279 }
2280
2281 func (p *parser) parseSelectStmt() *ast.SelectStmt {
2282         if p.trace {
2283                 defer un(trace(p, "SelectStmt"))
2284         }
2285
2286         pos := p.expect(token.SELECT)
2287         lbrace := p.expect(token.LBRACE)
2288         var list []ast.Stmt
2289         for p.tok == token.CASE || p.tok == token.DEFAULT {
2290                 list = append(list, p.parseCommClause())
2291         }
2292         rbrace := p.expect(token.RBRACE)
2293         p.expectSemi()
2294         body := &ast.BlockStmt{Lbrace: lbrace, List: list, Rbrace: rbrace}
2295
2296         return &ast.SelectStmt{Select: pos, Body: body}
2297 }
2298
2299 func (p *parser) parseForStmt() ast.Stmt {
2300         if p.trace {
2301                 defer un(trace(p, "ForStmt"))
2302         }
2303
2304         pos := p.expect(token.FOR)
2305
2306         var s1, s2, s3 ast.Stmt
2307         var isRange bool
2308         if p.tok != token.LBRACE {
2309                 prevLev := p.exprLev
2310                 p.exprLev = -1
2311                 if p.tok != token.SEMICOLON {
2312                         if p.tok == token.RANGE {
2313                                 // "for range x" (nil lhs in assignment)
2314                                 pos := p.pos
2315                                 p.next()
2316                                 y := []ast.Expr{&ast.UnaryExpr{OpPos: pos, Op: token.RANGE, X: p.parseRhs()}}
2317                                 s2 = &ast.AssignStmt{Rhs: y}
2318                                 isRange = true
2319                         } else {
2320                                 s2, isRange = p.parseSimpleStmt(rangeOk)
2321                         }
2322                 }
2323                 if !isRange && p.tok == token.SEMICOLON {
2324                         p.next()
2325                         s1 = s2
2326                         s2 = nil
2327                         if p.tok != token.SEMICOLON {
2328                                 s2, _ = p.parseSimpleStmt(basic)
2329                         }
2330                         p.expectSemi()
2331                         if p.tok != token.LBRACE {
2332                                 s3, _ = p.parseSimpleStmt(basic)
2333                         }
2334                 }
2335                 p.exprLev = prevLev
2336         }
2337
2338         body := p.parseBlockStmt()
2339         p.expectSemi()
2340
2341         if isRange {
2342                 as := s2.(*ast.AssignStmt)
2343                 // check lhs
2344                 var key, value ast.Expr
2345                 switch len(as.Lhs) {
2346                 case 0:
2347                         // nothing to do
2348                 case 1:
2349                         key = as.Lhs[0]
2350                 case 2:
2351                         key, value = as.Lhs[0], as.Lhs[1]
2352                 default:
2353                         p.errorExpected(as.Lhs[len(as.Lhs)-1].Pos(), "at most 2 expressions")
2354                         return &ast.BadStmt{From: pos, To: p.safePos(body.End())}
2355                 }
2356                 // parseSimpleStmt returned a right-hand side that
2357                 // is a single unary expression of the form "range x"
2358                 x := as.Rhs[0].(*ast.UnaryExpr).X
2359                 return &ast.RangeStmt{
2360                         For:    pos,
2361                         Key:    key,
2362                         Value:  value,
2363                         TokPos: as.TokPos,
2364                         Tok:    as.Tok,
2365                         Range:  as.Rhs[0].Pos(),
2366                         X:      x,
2367                         Body:   body,
2368                 }
2369         }
2370
2371         // regular for statement
2372         return &ast.ForStmt{
2373                 For:  pos,
2374                 Init: s1,
2375                 Cond: p.makeExpr(s2, "boolean or range expression"),
2376                 Post: s3,
2377                 Body: body,
2378         }
2379 }
2380
2381 func (p *parser) parseStmt() (s ast.Stmt) {
2382         defer decNestLev(incNestLev(p))
2383
2384         if p.trace {
2385                 defer un(trace(p, "Statement"))
2386         }
2387
2388         switch p.tok {
2389         case token.CONST, token.TYPE, token.VAR:
2390                 s = &ast.DeclStmt{Decl: p.parseDecl(stmtStart)}
2391         case
2392                 // tokens that may start an expression
2393                 token.IDENT, token.INT, token.FLOAT, token.IMAG, token.CHAR, token.STRING, token.FUNC, token.LPAREN, // operands
2394                 token.LBRACK, token.STRUCT, token.MAP, token.CHAN, token.INTERFACE, // composite types
2395                 token.ADD, token.SUB, token.MUL, token.AND, token.XOR, token.ARROW, token.NOT: // unary operators
2396                 s, _ = p.parseSimpleStmt(labelOk)
2397                 // because of the required look-ahead, labeled statements are
2398                 // parsed by parseSimpleStmt - don't expect a semicolon after
2399                 // them
2400                 if _, isLabeledStmt := s.(*ast.LabeledStmt); !isLabeledStmt {
2401                         p.expectSemi()
2402                 }
2403         case token.GO:
2404                 s = p.parseGoStmt()
2405         case token.DEFER:
2406                 s = p.parseDeferStmt()
2407         case token.RETURN:
2408                 s = p.parseReturnStmt()
2409         case token.BREAK, token.CONTINUE, token.GOTO, token.FALLTHROUGH:
2410                 s = p.parseBranchStmt(p.tok)
2411         case token.LBRACE:
2412                 s = p.parseBlockStmt()
2413                 p.expectSemi()
2414         case token.IF:
2415                 s = p.parseIfStmt()
2416         case token.SWITCH:
2417                 s = p.parseSwitchStmt()
2418         case token.SELECT:
2419                 s = p.parseSelectStmt()
2420         case token.FOR:
2421                 s = p.parseForStmt()
2422         case token.SEMICOLON:
2423                 // Is it ever possible to have an implicit semicolon
2424                 // producing an empty statement in a valid program?
2425                 // (handle correctly anyway)
2426                 s = &ast.EmptyStmt{Semicolon: p.pos, Implicit: p.lit == "\n"}
2427                 p.next()
2428         case token.RBRACE:
2429                 // a semicolon may be omitted before a closing "}"
2430                 s = &ast.EmptyStmt{Semicolon: p.pos, Implicit: true}
2431         default:
2432                 // no statement found
2433                 pos := p.pos
2434                 p.errorExpected(pos, "statement")
2435                 p.advance(stmtStart)
2436                 s = &ast.BadStmt{From: pos, To: p.pos}
2437         }
2438
2439         return
2440 }
2441
2442 // ----------------------------------------------------------------------------
2443 // Declarations
2444
2445 type parseSpecFunction func(doc *ast.CommentGroup, keyword token.Token, iota int) ast.Spec
2446
2447 func (p *parser) parseImportSpec(doc *ast.CommentGroup, _ token.Token, _ int) ast.Spec {
2448         if p.trace {
2449                 defer un(trace(p, "ImportSpec"))
2450         }
2451
2452         var ident *ast.Ident
2453         switch p.tok {
2454         case token.IDENT:
2455                 ident = p.parseIdent()
2456         case token.PERIOD:
2457                 ident = &ast.Ident{NamePos: p.pos, Name: "."}
2458                 p.next()
2459         }
2460
2461         pos := p.pos
2462         var path string
2463         if p.tok == token.STRING {
2464                 path = p.lit
2465                 p.next()
2466         } else if p.tok.IsLiteral() {
2467                 p.error(pos, "import path must be a string")
2468                 p.next()
2469         } else {
2470                 p.error(pos, "missing import path")
2471                 p.advance(exprEnd)
2472         }
2473         comment := p.expectSemi()
2474
2475         // collect imports
2476         spec := &ast.ImportSpec{
2477                 Doc:     doc,
2478                 Name:    ident,
2479                 Path:    &ast.BasicLit{ValuePos: pos, Kind: token.STRING, Value: path},
2480                 Comment: comment,
2481         }
2482         p.imports = append(p.imports, spec)
2483
2484         return spec
2485 }
2486
2487 func (p *parser) parseValueSpec(doc *ast.CommentGroup, keyword token.Token, iota int) ast.Spec {
2488         if p.trace {
2489                 defer un(trace(p, keyword.String()+"Spec"))
2490         }
2491
2492         idents := p.parseIdentList()
2493         var typ ast.Expr
2494         var values []ast.Expr
2495         switch keyword {
2496         case token.CONST:
2497                 // always permit optional type and initialization for more tolerant parsing
2498                 if p.tok != token.EOF && p.tok != token.SEMICOLON && p.tok != token.RPAREN {
2499                         typ = p.tryIdentOrType()
2500                         if p.tok == token.ASSIGN {
2501                                 p.next()
2502                                 values = p.parseList(true)
2503                         }
2504                 }
2505         case token.VAR:
2506                 if p.tok != token.ASSIGN {
2507                         typ = p.parseType()
2508                 }
2509                 if p.tok == token.ASSIGN {
2510                         p.next()
2511                         values = p.parseList(true)
2512                 }
2513         default:
2514                 panic("unreachable")
2515         }
2516         comment := p.expectSemi()
2517
2518         spec := &ast.ValueSpec{
2519                 Doc:     doc,
2520                 Names:   idents,
2521                 Type:    typ,
2522                 Values:  values,
2523                 Comment: comment,
2524         }
2525         return spec
2526 }
2527
2528 func (p *parser) parseGenericType(spec *ast.TypeSpec, openPos token.Pos, name0 *ast.Ident, typ0 ast.Expr) {
2529         if p.trace {
2530                 defer un(trace(p, "parseGenericType"))
2531         }
2532
2533         list := p.parseParameterList(name0, typ0, token.RBRACK)
2534         closePos := p.expect(token.RBRACK)
2535         spec.TypeParams = &ast.FieldList{Opening: openPos, List: list, Closing: closePos}
2536         // Let the type checker decide whether to accept type parameters on aliases:
2537         // see issue #46477.
2538         if p.tok == token.ASSIGN {
2539                 // type alias
2540                 spec.Assign = p.pos
2541                 p.next()
2542         }
2543         spec.Type = p.parseType()
2544 }
2545
2546 func (p *parser) parseTypeSpec(doc *ast.CommentGroup, _ token.Token, _ int) ast.Spec {
2547         if p.trace {
2548                 defer un(trace(p, "TypeSpec"))
2549         }
2550
2551         name := p.parseIdent()
2552         spec := &ast.TypeSpec{Doc: doc, Name: name}
2553
2554         if p.tok == token.LBRACK {
2555                 // spec.Name "[" ...
2556                 // array/slice type or type parameter list
2557                 lbrack := p.pos
2558                 p.next()
2559                 if p.tok == token.IDENT {
2560                         // We may have an array type or a type parameter list.
2561                         // In either case we expect an expression x (which may
2562                         // just be a name, or a more complex expression) which
2563                         // we can analyze further.
2564                         //
2565                         // A type parameter list may have a type bound starting
2566                         // with a "[" as in: P []E. In that case, simply parsing
2567                         // an expression would lead to an error: P[] is invalid.
2568                         // But since index or slice expressions are never constant
2569                         // and thus invalid array length expressions, if the name
2570                         // is followed by "[" it must be the start of an array or
2571                         // slice constraint. Only if we don't see a "[" do we
2572                         // need to parse a full expression. Notably, name <- x
2573                         // is not a concern because name <- x is a statement and
2574                         // not an expression.
2575                         var x ast.Expr = p.parseIdent()
2576                         if p.tok != token.LBRACK {
2577                                 // To parse the expression starting with name, expand
2578                                 // the call sequence we would get by passing in name
2579                                 // to parser.expr, and pass in name to parsePrimaryExpr.
2580                                 p.exprLev++
2581                                 lhs := p.parsePrimaryExpr(x)
2582                                 x = p.parseBinaryExpr(lhs, token.LowestPrec+1)
2583                                 p.exprLev--
2584                         }
2585                         // Analyze expression x. If we can split x into a type parameter
2586                         // name, possibly followed by a type parameter type, we consider
2587                         // this the start of a type parameter list, with some caveats:
2588                         // a single name followed by "]" tilts the decision towards an
2589                         // array declaration; a type parameter type that could also be
2590                         // an ordinary expression but which is followed by a comma tilts
2591                         // the decision towards a type parameter list.
2592                         if pname, ptype := extractName(x, p.tok == token.COMMA); pname != nil && (ptype != nil || p.tok != token.RBRACK) {
2593                                 // spec.Name "[" pname ...
2594                                 // spec.Name "[" pname ptype ...
2595                                 // spec.Name "[" pname ptype "," ...
2596                                 p.parseGenericType(spec, lbrack, pname, ptype) // ptype may be nil
2597                         } else {
2598                                 // spec.Name "[" pname "]" ...
2599                                 // spec.Name "[" x ...
2600                                 spec.Type = p.parseArrayType(lbrack, x)
2601                         }
2602                 } else {
2603                         // array type
2604                         spec.Type = p.parseArrayType(lbrack, nil)
2605                 }
2606         } else {
2607                 // no type parameters
2608                 if p.tok == token.ASSIGN {
2609                         // type alias
2610                         spec.Assign = p.pos
2611                         p.next()
2612                 }
2613                 spec.Type = p.parseType()
2614         }
2615
2616         spec.Comment = p.expectSemi()
2617
2618         return spec
2619 }
2620
2621 // extractName splits the expression x into (name, expr) if syntactically
2622 // x can be written as name expr. The split only happens if expr is a type
2623 // element (per the isTypeElem predicate) or if force is set.
2624 // If x is just a name, the result is (name, nil). If the split succeeds,
2625 // the result is (name, expr). Otherwise the result is (nil, x).
2626 // Examples:
2627 //
2628 //      x           force    name    expr
2629 //      ------------------------------------
2630 //      P*[]int     T/F      P       *[]int
2631 //      P*E         T        P       *E
2632 //      P*E         F        nil     P*E
2633 //      P([]int)    T/F      P       []int
2634 //      P(E)        T        P       E
2635 //      P(E)        F        nil     P(E)
2636 //      P*E|F|~G    T/F      P       *E|F|~G
2637 //      P*E|F|G     T        P       *E|F|G
2638 //      P*E|F|G     F        nil     P*E|F|G
2639 func extractName(x ast.Expr, force bool) (*ast.Ident, ast.Expr) {
2640         switch x := x.(type) {
2641         case *ast.Ident:
2642                 return x, nil
2643         case *ast.BinaryExpr:
2644                 switch x.Op {
2645                 case token.MUL:
2646                         if name, _ := x.X.(*ast.Ident); name != nil && (force || isTypeElem(x.Y)) {
2647                                 // x = name *x.Y
2648                                 return name, &ast.StarExpr{Star: x.OpPos, X: x.Y}
2649                         }
2650                 case token.OR:
2651                         if name, lhs := extractName(x.X, force || isTypeElem(x.Y)); name != nil && lhs != nil {
2652                                 // x = name lhs|x.Y
2653                                 op := *x
2654                                 op.X = lhs
2655                                 return name, &op
2656                         }
2657                 }
2658         case *ast.CallExpr:
2659                 if name, _ := x.Fun.(*ast.Ident); name != nil {
2660                         if len(x.Args) == 1 && x.Ellipsis == token.NoPos && (force || isTypeElem(x.Args[0])) {
2661                                 // x = name "(" x.ArgList[0] ")"
2662                                 return name, x.Args[0]
2663                         }
2664                 }
2665         }
2666         return nil, x
2667 }
2668
2669 // isTypeElem reports whether x is a (possibly parenthesized) type element expression.
2670 // The result is false if x could be a type element OR an ordinary (value) expression.
2671 func isTypeElem(x ast.Expr) bool {
2672         switch x := x.(type) {
2673         case *ast.ArrayType, *ast.StructType, *ast.FuncType, *ast.InterfaceType, *ast.MapType, *ast.ChanType:
2674                 return true
2675         case *ast.BinaryExpr:
2676                 return isTypeElem(x.X) || isTypeElem(x.Y)
2677         case *ast.UnaryExpr:
2678                 return x.Op == token.TILDE
2679         case *ast.ParenExpr:
2680                 return isTypeElem(x.X)
2681         }
2682         return false
2683 }
2684
2685 func (p *parser) parseGenDecl(keyword token.Token, f parseSpecFunction) *ast.GenDecl {
2686         if p.trace {
2687                 defer un(trace(p, "GenDecl("+keyword.String()+")"))
2688         }
2689
2690         doc := p.leadComment
2691         pos := p.expect(keyword)
2692         var lparen, rparen token.Pos
2693         var list []ast.Spec
2694         if p.tok == token.LPAREN {
2695                 lparen = p.pos
2696                 p.next()
2697                 for iota := 0; p.tok != token.RPAREN && p.tok != token.EOF; iota++ {
2698                         list = append(list, f(p.leadComment, keyword, iota))
2699                 }
2700                 rparen = p.expect(token.RPAREN)
2701                 p.expectSemi()
2702         } else {
2703                 list = append(list, f(nil, keyword, 0))
2704         }
2705
2706         return &ast.GenDecl{
2707                 Doc:    doc,
2708                 TokPos: pos,
2709                 Tok:    keyword,
2710                 Lparen: lparen,
2711                 Specs:  list,
2712                 Rparen: rparen,
2713         }
2714 }
2715
2716 func (p *parser) parseFuncDecl() *ast.FuncDecl {
2717         if p.trace {
2718                 defer un(trace(p, "FunctionDecl"))
2719         }
2720
2721         doc := p.leadComment
2722         pos := p.expect(token.FUNC)
2723
2724         var recv *ast.FieldList
2725         if p.tok == token.LPAREN {
2726                 _, recv = p.parseParameters(false)
2727         }
2728
2729         ident := p.parseIdent()
2730
2731         tparams, params := p.parseParameters(true)
2732         if recv != nil && tparams != nil {
2733                 // Method declarations do not have type parameters. We parse them for a
2734                 // better error message and improved error recovery.
2735                 p.error(tparams.Opening, "method must have no type parameters")
2736                 tparams = nil
2737         }
2738         results := p.parseResult()
2739
2740         var body *ast.BlockStmt
2741         switch p.tok {
2742         case token.LBRACE:
2743                 body = p.parseBody()
2744                 p.expectSemi()
2745         case token.SEMICOLON:
2746                 p.next()
2747                 if p.tok == token.LBRACE {
2748                         // opening { of function declaration on next line
2749                         p.error(p.pos, "unexpected semicolon or newline before {")
2750                         body = p.parseBody()
2751                         p.expectSemi()
2752                 }
2753         default:
2754                 p.expectSemi()
2755         }
2756
2757         decl := &ast.FuncDecl{
2758                 Doc:  doc,
2759                 Recv: recv,
2760                 Name: ident,
2761                 Type: &ast.FuncType{
2762                         Func:       pos,
2763                         TypeParams: tparams,
2764                         Params:     params,
2765                         Results:    results,
2766                 },
2767                 Body: body,
2768         }
2769         return decl
2770 }
2771
2772 func (p *parser) parseDecl(sync map[token.Token]bool) ast.Decl {
2773         if p.trace {
2774                 defer un(trace(p, "Declaration"))
2775         }
2776
2777         var f parseSpecFunction
2778         switch p.tok {
2779         case token.IMPORT:
2780                 f = p.parseImportSpec
2781
2782         case token.CONST, token.VAR:
2783                 f = p.parseValueSpec
2784
2785         case token.TYPE:
2786                 f = p.parseTypeSpec
2787
2788         case token.FUNC:
2789                 return p.parseFuncDecl()
2790
2791         default:
2792                 pos := p.pos
2793                 p.errorExpected(pos, "declaration")
2794                 p.advance(sync)
2795                 return &ast.BadDecl{From: pos, To: p.pos}
2796         }
2797
2798         return p.parseGenDecl(p.tok, f)
2799 }
2800
2801 // ----------------------------------------------------------------------------
2802 // Source files
2803
2804 func (p *parser) parseFile() *ast.File {
2805         if p.trace {
2806                 defer un(trace(p, "File"))
2807         }
2808
2809         // Don't bother parsing the rest if we had errors scanning the first token.
2810         // Likely not a Go source file at all.
2811         if p.errors.Len() != 0 {
2812                 return nil
2813         }
2814
2815         // package clause
2816         doc := p.leadComment
2817         pos := p.expect(token.PACKAGE)
2818         // Go spec: The package clause is not a declaration;
2819         // the package name does not appear in any scope.
2820         ident := p.parseIdent()
2821         if ident.Name == "_" && p.mode&DeclarationErrors != 0 {
2822                 p.error(p.pos, "invalid package name _")
2823         }
2824         p.expectSemi()
2825
2826         // Don't bother parsing the rest if we had errors parsing the package clause.
2827         // Likely not a Go source file at all.
2828         if p.errors.Len() != 0 {
2829                 return nil
2830         }
2831
2832         var decls []ast.Decl
2833         if p.mode&PackageClauseOnly == 0 {
2834                 // import decls
2835                 for p.tok == token.IMPORT {
2836                         decls = append(decls, p.parseGenDecl(token.IMPORT, p.parseImportSpec))
2837                 }
2838
2839                 if p.mode&ImportsOnly == 0 {
2840                         // rest of package body
2841                         prev := token.IMPORT
2842                         for p.tok != token.EOF {
2843                                 // Continue to accept import declarations for error tolerance, but complain.
2844                                 if p.tok == token.IMPORT && prev != token.IMPORT {
2845                                         p.error(p.pos, "imports must appear before other declarations")
2846                                 }
2847                                 prev = p.tok
2848
2849                                 decls = append(decls, p.parseDecl(declStart))
2850                         }
2851                 }
2852         }
2853
2854         f := &ast.File{
2855                 Doc:       doc,
2856                 Package:   pos,
2857                 Name:      ident,
2858                 Decls:     decls,
2859                 FileStart: token.Pos(p.file.Base()),
2860                 FileEnd:   token.Pos(p.file.Base() + p.file.Size()),
2861                 Imports:   p.imports,
2862                 Comments:  p.comments,
2863                 GoVersion: p.goVersion,
2864         }
2865         var declErr func(token.Pos, string)
2866         if p.mode&DeclarationErrors != 0 {
2867                 declErr = p.error
2868         }
2869         if p.mode&SkipObjectResolution == 0 {
2870                 resolveFile(f, p.file, declErr)
2871         }
2872
2873         return f
2874 }