gcc/go/gofrontend/parse.cc

   1 // parse.cc -- Go frontend parser.
   2
   3 // Copyright 2009 The Go Authors. All rights reserved.
   4 // Use of this source code is governed by a BSD-style
   5 // license that can be found in the LICENSE file.
   6
   7 #include "go-system.h"
   8
   9 #include "lex.h"
  10 #include "gogo.h"
  11 #include "types.h"
  12 #include "statements.h"
  13 #include "expressions.h"
  14 #include "parse.h"
  15
  16 // Struct Parse::Enclosing_var_comparison.
  17
  18 // Return true if v1 should be considered to be less than v2.
  19
  20 bool
  21 Parse::Enclosing_var_comparison::operator()(const Enclosing_var& v1,
  22                                             const Enclosing_var& v2)
  23 {
  24   if (v1.var() == v2.var())
  25     return false;
  26
  27   const std::string& n1(v1.var()->name());
  28   const std::string& n2(v2.var()->name());
  29   int i = n1.compare(n2);
  30   if (i < 0)
  31     return true;
  32   else if (i > 0)
  33     return false;
  34
  35   // If we get here it means that a single nested function refers to
  36   // two different variables defined in enclosing functions, and both
  37   // variables have the same name.  I think this is impossible.
  38   go_unreachable();
  39 }
  40
  41 // Class Parse.
  42
  43 Parse::Parse(Lex* lex, Gogo* gogo)
  44   : lex_(lex),
  45     token_(Token::make_invalid_token(0)),
  46     unget_token_(Token::make_invalid_token(0)),
  47     unget_token_valid_(false),
  48     gogo_(gogo),
  49     break_stack_(NULL),
  50     continue_stack_(NULL),
  51     iota_(0),
  52     enclosing_vars_()
  53 {
  54 }
  55
  56 // Return the current token.
  57
  58 const Token*
  59 Parse::peek_token()
  60 {
  61   if (this->unget_token_valid_)
  62     return &this->unget_token_;
  63   if (this->token_.is_invalid())
  64     this->token_ = this->lex_->next_token();
  65   return &this->token_;
  66 }
  67
  68 // Advance to the next token and return it.
  69
  70 const Token*
  71 Parse::advance_token()
  72 {
  73   if (this->unget_token_valid_)
  74     {
  75       this->unget_token_valid_ = false;
  76       if (!this->token_.is_invalid())
  77         return &this->token_;
  78     }
  79   this->token_ = this->lex_->next_token();
  80   return &this->token_;
  81 }
  82
  83 // Push a token back on the input stream.
  84
  85 void
  86 Parse::unget_token(const Token& token)
  87 {
  88   go_assert(!this->unget_token_valid_);
  89   this->unget_token_ = token;
  90   this->unget_token_valid_ = true;
  91 }
  92
  93 // The location of the current token.
  94
  95 source_location
  96 Parse::location()
  97 {
  98   return this->peek_token()->location();
  99 }
 100
 101 // IdentifierList = identifier { "," identifier } .
 102
 103 void
 104 Parse::identifier_list(Typed_identifier_list* til)
 105 {
 106   const Token* token = this->peek_token();
 107   while (true)
 108     {
 109       if (!token->is_identifier())
 110         {
 111           error_at(this->location(), "expected identifier");
 112           return;
 113         }
 114       std::string name =
 115         this->gogo_->pack_hidden_name(token->identifier(),
 116                                       token->is_identifier_exported());
 117       til->push_back(Typed_identifier(name, NULL, token->location()));
 118       token = this->advance_token();
 119       if (!token->is_op(OPERATOR_COMMA))
 120         return;
 121       token = this->advance_token();
 122     }
 123 }
 124
 125 // ExpressionList = Expression { "," Expression } .
 126
 127 // If MAY_BE_SINK is true, the expressions in the list may be "_".
 128
 129 Expression_list*
 130 Parse::expression_list(Expression* first, bool may_be_sink)
 131 {
 132   Expression_list* ret = new Expression_list();
 133   if (first != NULL)
 134     ret->push_back(first);
 135   while (true)
 136     {
 137       ret->push_back(this->expression(PRECEDENCE_NORMAL, may_be_sink, true,
 138                                       NULL));
 139
 140       const Token* token = this->peek_token();
 141       if (!token->is_op(OPERATOR_COMMA))
 142         return ret;
 143
 144       // Most expression lists permit a trailing comma.
 145       source_location location = token->location();
 146       this->advance_token();
 147       if (!this->expression_may_start_here())
 148         {
 149           this->unget_token(Token::make_operator_token(OPERATOR_COMMA,
 150                                                        location));
 151           return ret;
 152         }
 153     }
 154 }
 155
 156 // QualifiedIdent = [ PackageName "." ] identifier .
 157 // PackageName = identifier .
 158
 159 // This sets *PNAME to the identifier and sets *PPACKAGE to the
 160 // package or NULL if there isn't one.  This returns true on success,
 161 // false on failure in which case it will have emitted an error
 162 // message.
 163
 164 bool
 165 Parse::qualified_ident(std::string* pname, Named_object** ppackage)
 166 {
 167   const Token* token = this->peek_token();
 168   if (!token->is_identifier())
 169     {
 170       error_at(this->location(), "expected identifier");
 171       return false;
 172     }
 173
 174   std::string name = token->identifier();
 175   bool is_exported = token->is_identifier_exported();
 176   name = this->gogo_->pack_hidden_name(name, is_exported);
 177
 178   token = this->advance_token();
 179   if (!token->is_op(OPERATOR_DOT))
 180     {
 181       *pname = name;
 182       *ppackage = NULL;
 183       return true;
 184     }
 185
 186   Named_object* package = this->gogo_->lookup(name, NULL);
 187   if (package == NULL || !package->is_package())
 188     {
 189       error_at(this->location(), "expected package");
 190       // We expect . IDENTIFIER; skip both.
 191       if (this->advance_token()->is_identifier())
 192         this->advance_token();
 193       return false;
 194     }
 195
 196   package->package_value()->set_used();
 197
 198   token = this->advance_token();
 199   if (!token->is_identifier())
 200     {
 201       error_at(this->location(), "expected identifier");
 202       return false;
 203     }
 204
 205   name = token->identifier();
 206
 207   if (name == "_")
 208     {
 209       error_at(this->location(), "invalid use of %<_%>");
 210       name = "blank";
 211     }
 212
 213   if (package->name() == this->gogo_->package_name())
 214     name = this->gogo_->pack_hidden_name(name,
 215                                          token->is_identifier_exported());
 216
 217   *pname = name;
 218   *ppackage = package;
 219
 220   this->advance_token();
 221
 222   return true;
 223 }
 224
 225 // Type = TypeName | TypeLit | "(" Type ")" .
 226 // TypeLit =
 227 //      ArrayType | StructType | PointerType | FunctionType | InterfaceType |
 228 //      SliceType | MapType | ChannelType .
 229
 230 Type*
 231 Parse::type()
 232 {
 233   const Token* token = this->peek_token();
 234   if (token->is_identifier())
 235     return this->type_name(true);
 236   else if (token->is_op(OPERATOR_LSQUARE))
 237     return this->array_type(false);
 238   else if (token->is_keyword(KEYWORD_CHAN)
 239            || token->is_op(OPERATOR_CHANOP))
 240     return this->channel_type();
 241   else if (token->is_keyword(KEYWORD_INTERFACE))
 242     return this->interface_type();
 243   else if (token->is_keyword(KEYWORD_FUNC))
 244     {
 245       source_location location = token->location();
 246       this->advance_token();
 247       Type* type = this->signature(NULL, location);
 248       if (type == NULL)
 249         return Type::make_error_type();
 250       return type;
 251     }
 252   else if (token->is_keyword(KEYWORD_MAP))
 253     return this->map_type();
 254   else if (token->is_keyword(KEYWORD_STRUCT))
 255     return this->struct_type();
 256   else if (token->is_op(OPERATOR_MULT))
 257     return this->pointer_type();
 258   else if (token->is_op(OPERATOR_LPAREN))
 259     {
 260       this->advance_token();
 261       Type* ret = this->type();
 262       if (this->peek_token()->is_op(OPERATOR_RPAREN))
 263         this->advance_token();
 264       else
 265         {
 266           if (!ret->is_error_type())
 267             error_at(this->location(), "expected %<)%>");
 268         }
 269       return ret;
 270     }
 271   else
 272     {
 273       error_at(token->location(), "expected type");
 274       return Type::make_error_type();
 275     }
 276 }
 277
 278 bool
 279 Parse::type_may_start_here()
 280 {
 281   const Token* token = this->peek_token();
 282   return (token->is_identifier()
 283           || token->is_op(OPERATOR_LSQUARE)
 284           || token->is_op(OPERATOR_CHANOP)
 285           || token->is_keyword(KEYWORD_CHAN)
 286           || token->is_keyword(KEYWORD_INTERFACE)
 287           || token->is_keyword(KEYWORD_FUNC)
 288           || token->is_keyword(KEYWORD_MAP)
 289           || token->is_keyword(KEYWORD_STRUCT)
 290           || token->is_op(OPERATOR_MULT)
 291           || token->is_op(OPERATOR_LPAREN));
 292 }
 293
 294 // TypeName = QualifiedIdent .
 295
 296 // If MAY_BE_NIL is true, then an identifier with the value of the
 297 // predefined constant nil is accepted, returning the nil type.
 298
 299 Type*
 300 Parse::type_name(bool issue_error)
 301 {
 302   source_location location = this->location();
 303
 304   std::string name;
 305   Named_object* package;
 306   if (!this->qualified_ident(&name, &package))
 307     return Type::make_error_type();
 308
 309   Named_object* named_object;
 310   if (package == NULL)
 311     named_object = this->gogo_->lookup(name, NULL);
 312   else
 313     {
 314       named_object = package->package_value()->lookup(name);
 315       if (named_object == NULL
 316           && issue_error
 317           && package->name() != this->gogo_->package_name())
 318         {
 319           // Check whether the name is there but hidden.
 320           std::string s = ('.' + package->package_value()->unique_prefix()
 321                            + '.' + package->package_value()->name()
 322                            + '.' + name);
 323           named_object = package->package_value()->lookup(s);
 324           if (named_object != NULL)
 325             {
 326               const std::string& packname(package->package_value()->name());
 327               error_at(location, "invalid reference to hidden type %<%s.%s%>",
 328                        Gogo::message_name(packname).c_str(),
 329                        Gogo::message_name(name).c_str());
 330               issue_error = false;
 331             }
 332         }
 333     }
 334
 335   bool ok = true;
 336   if (named_object == NULL)
 337     {
 338       if (package == NULL)
 339         named_object = this->gogo_->add_unknown_name(name, location);
 340       else
 341         {
 342           const std::string& packname(package->package_value()->name());
 343           error_at(location, "reference to undefined identifier %<%s.%s%>",
 344                    Gogo::message_name(packname).c_str(),
 345                    Gogo::message_name(name).c_str());
 346           issue_error = false;
 347           ok = false;
 348         }
 349     }
 350   else if (named_object->is_type())
 351     {
 352       if (!named_object->type_value()->is_visible())
 353         ok = false;
 354     }
 355   else if (named_object->is_unknown() || named_object->is_type_declaration())
 356     ;
 357   else
 358     ok = false;
 359
 360   if (!ok)
 361     {
 362       if (issue_error)
 363         error_at(location, "expected type");
 364       return Type::make_error_type();
 365     }
 366
 367   if (named_object->is_type())
 368     return named_object->type_value();
 369   else if (named_object->is_unknown() || named_object->is_type_declaration())
 370     return Type::make_forward_declaration(named_object);
 371   else
 372     go_unreachable();
 373 }
 374
 375 // ArrayType = "[" [ ArrayLength ] "]" ElementType .
 376 // ArrayLength = Expression .
 377 // ElementType = CompleteType .
 378
 379 Type*
 380 Parse::array_type(bool may_use_ellipsis)
 381 {
 382   go_assert(this->peek_token()->is_op(OPERATOR_LSQUARE));
 383   const Token* token = this->advance_token();
 384
 385   Expression* length = NULL;
 386   if (token->is_op(OPERATOR_RSQUARE))
 387     this->advance_token();
 388   else
 389     {
 390       if (!token->is_op(OPERATOR_ELLIPSIS))
 391         length = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
 392       else if (may_use_ellipsis)
 393         {
 394           // An ellipsis is used in composite literals to represent a
 395           // fixed array of the size of the number of elements.  We
 396           // use a length of nil to represent this, and change the
 397           // length when parsing the composite literal.
 398           length = Expression::make_nil(this->location());
 399           this->advance_token();
 400         }
 401       else
 402         {
 403           error_at(this->location(),
 404                    "use of %<[...]%> outside of array literal");
 405           length = Expression::make_error(this->location());
 406           this->advance_token();
 407         }
 408       if (!this->peek_token()->is_op(OPERATOR_RSQUARE))
 409         {
 410           error_at(this->location(), "expected %<]%>");
 411           return Type::make_error_type();
 412         }
 413       this->advance_token();
 414     }
 415
 416   Type* element_type = this->type();
 417
 418   return Type::make_array_type(element_type, length);
 419 }
 420
 421 // MapType = "map" "[" KeyType "]" ValueType .
 422 // KeyType = CompleteType .
 423 // ValueType = CompleteType .
 424
 425 Type*
 426 Parse::map_type()
 427 {
 428   source_location location = this->location();
 429   go_assert(this->peek_token()->is_keyword(KEYWORD_MAP));
 430   if (!this->advance_token()->is_op(OPERATOR_LSQUARE))
 431     {
 432       error_at(this->location(), "expected %<[%>");
 433       return Type::make_error_type();
 434     }
 435   this->advance_token();
 436
 437   Type* key_type = this->type();
 438
 439   if (!this->peek_token()->is_op(OPERATOR_RSQUARE))
 440     {
 441       error_at(this->location(), "expected %<]%>");
 442       return Type::make_error_type();
 443     }
 444   this->advance_token();
 445
 446   Type* value_type = this->type();
 447
 448   if (key_type->is_error_type() || value_type->is_error_type())
 449     return Type::make_error_type();
 450
 451   return Type::make_map_type(key_type, value_type, location);
 452 }
 453
 454 // StructType     = "struct" "{" { FieldDecl ";" } "}" .
 455
 456 Type*
 457 Parse::struct_type()
 458 {
 459   go_assert(this->peek_token()->is_keyword(KEYWORD_STRUCT));
 460   source_location location = this->location();
 461   if (!this->advance_token()->is_op(OPERATOR_LCURLY))
 462     {
 463       source_location token_loc = this->location();
 464       if (this->peek_token()->is_op(OPERATOR_SEMICOLON)
 465           && this->advance_token()->is_op(OPERATOR_LCURLY))
 466         error_at(token_loc, "unexpected semicolon or newline before %<{%>");
 467       else
 468         {
 469           error_at(this->location(), "expected %<{%>");
 470           return Type::make_error_type();
 471         }
 472     }
 473   this->advance_token();
 474
 475   Struct_field_list* sfl = new Struct_field_list;
 476   while (!this->peek_token()->is_op(OPERATOR_RCURLY))
 477     {
 478       this->field_decl(sfl);
 479       if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
 480         this->advance_token();
 481       else if (!this->peek_token()->is_op(OPERATOR_RCURLY))
 482         {
 483           error_at(this->location(), "expected %<;%> or %<}%> or newline");
 484           if (!this->skip_past_error(OPERATOR_RCURLY))
 485             return Type::make_error_type();
 486         }
 487     }
 488   this->advance_token();
 489
 490   for (Struct_field_list::const_iterator pi = sfl->begin();
 491        pi != sfl->end();
 492        ++pi)
 493     {
 494       if (pi->type()->is_error_type())
 495         return pi->type();
 496       for (Struct_field_list::const_iterator pj = pi + 1;
 497            pj != sfl->end();
 498            ++pj)
 499         {
 500           if (pi->field_name() == pj->field_name()
 501               && !Gogo::is_sink_name(pi->field_name()))
 502             error_at(pi->location(), "duplicate field name %<%s%>",
 503                      Gogo::message_name(pi->field_name()).c_str());
 504         }
 505     }
 506
 507   return Type::make_struct_type(sfl, location);
 508 }
 509
 510 // FieldDecl = (IdentifierList CompleteType | TypeName) [ Tag ] .
 511 // Tag = string_lit .
 512
 513 void
 514 Parse::field_decl(Struct_field_list* sfl)
 515 {
 516   const Token* token = this->peek_token();
 517   source_location location = token->location();
 518   bool is_anonymous;
 519   bool is_anonymous_pointer;
 520   if (token->is_op(OPERATOR_MULT))
 521     {
 522       is_anonymous = true;
 523       is_anonymous_pointer = true;
 524     }
 525   else if (token->is_identifier())
 526     {
 527       std::string id = token->identifier();
 528       bool is_id_exported = token->is_identifier_exported();
 529       source_location id_location = token->location();
 530       token = this->advance_token();
 531       is_anonymous = (token->is_op(OPERATOR_SEMICOLON)
 532                       || token->is_op(OPERATOR_RCURLY)
 533                       || token->is_op(OPERATOR_DOT)
 534                       || token->is_string());
 535       is_anonymous_pointer = false;
 536       this->unget_token(Token::make_identifier_token(id, is_id_exported,
 537                                                      id_location));
 538     }
 539   else
 540     {
 541       error_at(this->location(), "expected field name");
 542       while (!token->is_op(OPERATOR_SEMICOLON)
 543              && !token->is_op(OPERATOR_RCURLY)
 544              && !token->is_eof())
 545         token = this->advance_token();
 546       return;
 547     }
 548
 549   if (is_anonymous)
 550     {
 551       if (is_anonymous_pointer)
 552         {
 553           this->advance_token();
 554           if (!this->peek_token()->is_identifier())
 555             {
 556               error_at(this->location(), "expected field name");
 557               while (!token->is_op(OPERATOR_SEMICOLON)
 558                      && !token->is_op(OPERATOR_RCURLY)
 559                      && !token->is_eof())
 560                 token = this->advance_token();
 561               return;
 562             }
 563         }
 564       Type* type = this->type_name(true);
 565
 566       std::string tag;
 567       if (this->peek_token()->is_string())
 568         {
 569           tag = this->peek_token()->string_value();
 570           this->advance_token();
 571         }
 572
 573       if (!type->is_error_type())
 574         {
 575           if (is_anonymous_pointer)
 576             type = Type::make_pointer_type(type);
 577           sfl->push_back(Struct_field(Typed_identifier("", type, location)));
 578           if (!tag.empty())
 579             sfl->back().set_tag(tag);
 580         }
 581     }
 582   else
 583     {
 584       Typed_identifier_list til;
 585       while (true)
 586         {
 587           token = this->peek_token();
 588           if (!token->is_identifier())
 589             {
 590               error_at(this->location(), "expected identifier");
 591               return;
 592             }
 593           std::string name =
 594             this->gogo_->pack_hidden_name(token->identifier(),
 595                                           token->is_identifier_exported());
 596           til.push_back(Typed_identifier(name, NULL, token->location()));
 597           if (!this->advance_token()->is_op(OPERATOR_COMMA))
 598             break;
 599           this->advance_token();
 600         }
 601
 602       Type* type = this->type();
 603
 604       std::string tag;
 605       if (this->peek_token()->is_string())
 606         {
 607           tag = this->peek_token()->string_value();
 608           this->advance_token();
 609         }
 610
 611       for (Typed_identifier_list::iterator p = til.begin();
 612            p != til.end();
 613            ++p)
 614         {
 615           p->set_type(type);
 616           sfl->push_back(Struct_field(*p));
 617           if (!tag.empty())
 618             sfl->back().set_tag(tag);
 619         }
 620     }
 621 }
 622
 623 // PointerType = "*" Type .
 624
 625 Type*
 626 Parse::pointer_type()
 627 {
 628   go_assert(this->peek_token()->is_op(OPERATOR_MULT));
 629   this->advance_token();
 630   Type* type = this->type();
 631   if (type->is_error_type())
 632     return type;
 633   return Type::make_pointer_type(type);
 634 }
 635
 636 // ChannelType   = Channel | SendChannel | RecvChannel .
 637 // Channel       = "chan" ElementType .
 638 // SendChannel   = "chan" "<-" ElementType .
 639 // RecvChannel   = "<-" "chan" ElementType .
 640
 641 Type*
 642 Parse::channel_type()
 643 {
 644   const Token* token = this->peek_token();
 645   bool send = true;
 646   bool receive = true;
 647   if (token->is_op(OPERATOR_CHANOP))
 648     {
 649       if (!this->advance_token()->is_keyword(KEYWORD_CHAN))
 650         {
 651           error_at(this->location(), "expected %<chan%>");
 652           return Type::make_error_type();
 653         }
 654       send = false;
 655       this->advance_token();
 656     }
 657   else
 658     {
 659       go_assert(token->is_keyword(KEYWORD_CHAN));
 660       if (this->advance_token()->is_op(OPERATOR_CHANOP))
 661         {
 662           receive = false;
 663           this->advance_token();
 664         }
 665     }
 666
 667   // Better error messages for the common error of omitting the
 668   // channel element type.
 669   if (!this->type_may_start_here())
 670     {
 671       token = this->peek_token();
 672       if (token->is_op(OPERATOR_RCURLY))
 673         error_at(this->location(), "unexpected %<}%> in channel type");
 674       else if (token->is_op(OPERATOR_RPAREN))
 675         error_at(this->location(), "unexpected %<)%> in channel type");
 676       else if (token->is_op(OPERATOR_COMMA))
 677         error_at(this->location(), "unexpected comma in channel type");
 678       else
 679         error_at(this->location(), "expected channel element type");
 680       return Type::make_error_type();
 681     }
 682
 683   Type* element_type = this->type();
 684   return Type::make_channel_type(send, receive, element_type);
 685 }
 686
 687 // Give an error for a duplicate parameter or receiver name.
 688
 689 void
 690 Parse::check_signature_names(const Typed_identifier_list* params,
 691                              Parse::Names* names)
 692 {
 693   for (Typed_identifier_list::const_iterator p = params->begin();
 694        p != params->end();
 695        ++p)
 696     {
 697       if (p->name().empty() || Gogo::is_sink_name(p->name()))
 698         continue;
 699       std::pair<std::string, const Typed_identifier*> val =
 700         std::make_pair(p->name(), &*p);
 701       std::pair<Parse::Names::iterator, bool> ins = names->insert(val);
 702       if (!ins.second)
 703         {
 704           error_at(p->location(), "redefinition of %qs",
 705                    Gogo::message_name(p->name()).c_str());
 706           inform(ins.first->second->location(),
 707                  "previous definition of %qs was here",
 708                  Gogo::message_name(p->name()).c_str());
 709         }
 710     }
 711 }
 712
 713 // Signature      = Parameters [ Result ] .
 714
 715 // RECEIVER is the receiver if there is one, or NULL.  LOCATION is the
 716 // location of the start of the type.
 717
 718 // This returns NULL on a parse error.
 719
 720 Function_type*
 721 Parse::signature(Typed_identifier* receiver, source_location location)
 722 {
 723   bool is_varargs = false;
 724   Typed_identifier_list* params;
 725   bool params_ok = this->parameters(&params, &is_varargs);
 726
 727   Typed_identifier_list* results = NULL;
 728   if (this->peek_token()->is_op(OPERATOR_LPAREN)
 729       || this->type_may_start_here())
 730     {
 731       if (!this->result(&results))
 732         return NULL;
 733     }
 734
 735   if (!params_ok)
 736     return NULL;
 737
 738   Parse::Names names;
 739   if (params != NULL)
 740     this->check_signature_names(params, &names);
 741   if (results != NULL)
 742     this->check_signature_names(results, &names);
 743
 744   Function_type* ret = Type::make_function_type(receiver, params, results,
 745                                                 location);
 746   if (is_varargs)
 747     ret->set_is_varargs();
 748   return ret;
 749 }
 750
 751 // Parameters     = "(" [ ParameterList [ "," ] ] ")" .
 752
 753 // This returns false on a parse error.
 754
 755 bool
 756 Parse::parameters(Typed_identifier_list** pparams, bool* is_varargs)
 757 {
 758   *pparams = NULL;
 759
 760   if (!this->peek_token()->is_op(OPERATOR_LPAREN))
 761     {
 762       error_at(this->location(), "expected %<(%>");
 763       return false;
 764     }
 765
 766   Typed_identifier_list* params = NULL;
 767   bool saw_error = false;
 768
 769   const Token* token = this->advance_token();
 770   if (!token->is_op(OPERATOR_RPAREN))
 771     {
 772       params = this->parameter_list(is_varargs);
 773       if (params == NULL)
 774         saw_error = true;
 775       token = this->peek_token();
 776     }
 777
 778   // The optional trailing comma is picked up in parameter_list.
 779
 780   if (!token->is_op(OPERATOR_RPAREN))
 781     error_at(this->location(), "expected %<)%>");
 782   else
 783     this->advance_token();
 784
 785   if (saw_error)
 786     return false;
 787
 788   *pparams = params;
 789   return true;
 790 }
 791
 792 // ParameterList  = ParameterDecl { "," ParameterDecl } .
 793
 794 // This sets *IS_VARARGS if the list ends with an ellipsis.
 795 // IS_VARARGS will be NULL if varargs are not permitted.
 796
 797 // We pick up an optional trailing comma.
 798
 799 // This returns NULL if some error is seen.
 800
 801 Typed_identifier_list*
 802 Parse::parameter_list(bool* is_varargs)
 803 {
 804   source_location location = this->location();
 805   Typed_identifier_list* ret = new Typed_identifier_list();
 806
 807   bool saw_error = false;
 808
 809   // If we see an identifier and then a comma, then we don't know
 810   // whether we are looking at a list of identifiers followed by a
 811   // type, or a list of types given by name.  We have to do an
 812   // arbitrary lookahead to figure it out.
 813
 814   bool parameters_have_names;
 815   const Token* token = this->peek_token();
 816   if (!token->is_identifier())
 817     {
 818       // This must be a type which starts with something like '*'.
 819       parameters_have_names = false;
 820     }
 821   else
 822     {
 823       std::string name = token->identifier();
 824       bool is_exported = token->is_identifier_exported();
 825       source_location location = token->location();
 826       token = this->advance_token();
 827       if (!token->is_op(OPERATOR_COMMA))
 828         {
 829           if (token->is_op(OPERATOR_DOT))
 830             {
 831               // This is a qualified identifier, which must turn out
 832               // to be a type.
 833               parameters_have_names = false;
 834             }
 835           else if (token->is_op(OPERATOR_RPAREN))
 836             {
 837               // A single identifier followed by a parenthesis must be
 838               // a type name.
 839               parameters_have_names = false;
 840             }
 841           else
 842             {
 843               // An identifier followed by something other than a
 844               // comma or a dot or a right parenthesis must be a
 845               // parameter name followed by a type.
 846               parameters_have_names = true;
 847             }
 848
 849           this->unget_token(Token::make_identifier_token(name, is_exported,
 850                                                          location));
 851         }
 852       else
 853         {
 854           // An identifier followed by a comma may be the first in a
 855           // list of parameter names followed by a type, or it may be
 856           // the first in a list of types without parameter names.  To
 857           // find out we gather as many identifiers separated by
 858           // commas as we can.
 859           std::string id_name = this->gogo_->pack_hidden_name(name,
 860                                                               is_exported);
 861           ret->push_back(Typed_identifier(id_name, NULL, location));
 862           bool just_saw_comma = true;
 863           while (this->advance_token()->is_identifier())
 864             {
 865               name = this->peek_token()->identifier();
 866               is_exported = this->peek_token()->is_identifier_exported();
 867               location = this->peek_token()->location();
 868               id_name = this->gogo_->pack_hidden_name(name, is_exported);
 869               ret->push_back(Typed_identifier(id_name, NULL, location));
 870               if (!this->advance_token()->is_op(OPERATOR_COMMA))
 871                 {
 872                   just_saw_comma = false;
 873                   break;
 874                 }
 875             }
 876
 877           if (just_saw_comma)
 878             {
 879               // We saw ID1 "," ID2 "," followed by something which
 880               // was not an identifier.  We must be seeing the start
 881               // of a type, and ID1 and ID2 must be types, and the
 882               // parameters don't have names.
 883               parameters_have_names = false;
 884             }
 885           else if (this->peek_token()->is_op(OPERATOR_RPAREN))
 886             {
 887               // We saw ID1 "," ID2 ")".  ID1 and ID2 must be types,
 888               // and the parameters don't have names.
 889               parameters_have_names = false;
 890             }
 891           else if (this->peek_token()->is_op(OPERATOR_DOT))
 892             {
 893               // We saw ID1 "," ID2 ".".  ID2 must be a package name,
 894               // ID1 must be a type, and the parameters don't have
 895               // names.
 896               parameters_have_names = false;
 897               this->unget_token(Token::make_identifier_token(name, is_exported,
 898                                                              location));
 899               ret->pop_back();
 900               just_saw_comma = true;
 901             }
 902           else
 903             {
 904               // We saw ID1 "," ID2 followed by something other than
 905               // ",", ".", or ")".  We must be looking at the start of
 906               // a type, and ID1 and ID2 must be parameter names.
 907               parameters_have_names = true;
 908             }
 909
 910           if (parameters_have_names)
 911             {
 912               go_assert(!just_saw_comma);
 913               // We have just seen ID1, ID2 xxx.
 914               Type* type;
 915               if (!this->peek_token()->is_op(OPERATOR_ELLIPSIS))
 916                 type = this->type();
 917               else
 918                 {
 919                   error_at(this->location(), "%<...%> only permits one name");
 920                   saw_error = true;
 921                   this->advance_token();
 922                   type = this->type();
 923                 }
 924               for (size_t i = 0; i < ret->size(); ++i)
 925                 ret->set_type(i, type);
 926               if (!this->peek_token()->is_op(OPERATOR_COMMA))
 927                 return saw_error ? NULL : ret;
 928               if (this->advance_token()->is_op(OPERATOR_RPAREN))
 929                 return saw_error ? NULL : ret;
 930             }
 931           else
 932             {
 933               Typed_identifier_list* tret = new Typed_identifier_list();
 934               for (Typed_identifier_list::const_iterator p = ret->begin();
 935                    p != ret->end();
 936                    ++p)
 937                 {
 938                   Named_object* no = this->gogo_->lookup(p->name(), NULL);
 939                   Type* type;
 940                   if (no == NULL)
 941                     no = this->gogo_->add_unknown_name(p->name(),
 942                                                        p->location());
 943
 944                   if (no->is_type())
 945                     type = no->type_value();
 946                   else if (no->is_unknown() || no->is_type_declaration())
 947                     type = Type::make_forward_declaration(no);
 948                   else
 949                     {
 950                       error_at(p->location(), "expected %<%s%> to be a type",
 951                                Gogo::message_name(p->name()).c_str());
 952                       saw_error = true;
 953                       type = Type::make_error_type();
 954                     }
 955                   tret->push_back(Typed_identifier("", type, p->location()));
 956                 }
 957               delete ret;
 958               ret = tret;
 959               if (!just_saw_comma
 960                   || this->peek_token()->is_op(OPERATOR_RPAREN))
 961                 return saw_error ? NULL : ret;
 962             }
 963         }
 964     }
 965
 966   bool mix_error = false;
 967   this->parameter_decl(parameters_have_names, ret, is_varargs, &mix_error);
 968   while (this->peek_token()->is_op(OPERATOR_COMMA))
 969     {
 970       if (is_varargs != NULL && *is_varargs)
 971         {
 972           error_at(this->location(), "%<...%> must be last parameter");
 973           saw_error = true;
 974         }
 975       if (this->advance_token()->is_op(OPERATOR_RPAREN))
 976         break;
 977       this->parameter_decl(parameters_have_names, ret, is_varargs, &mix_error);
 978     }
 979   if (mix_error)
 980     {
 981       error_at(location, "invalid named/anonymous mix");
 982       saw_error = true;
 983     }
 984   if (saw_error)
 985     {
 986       delete ret;
 987       return NULL;
 988     }
 989   return ret;
 990 }
 991
 992 // ParameterDecl  = [ IdentifierList ] [ "..." ] Type .
 993
 994 void
 995 Parse::parameter_decl(bool parameters_have_names,
 996                       Typed_identifier_list* til,
 997                       bool* is_varargs,
 998                       bool* mix_error)
 999 {
1000   if (!parameters_have_names)
1001     {
1002       Type* type;
1003       source_location location = this->location();
1004       if (!this->peek_token()->is_identifier())
1005         {
1006           if (!this->peek_token()->is_op(OPERATOR_ELLIPSIS))
1007             type = this->type();
1008           else
1009             {
1010               if (is_varargs == NULL)
1011                 error_at(this->location(), "invalid use of %<...%>");
1012               else
1013                 *is_varargs = true;
1014               this->advance_token();
1015               if (is_varargs == NULL
1016                   && this->peek_token()->is_op(OPERATOR_RPAREN))
1017                 type = Type::make_error_type();
1018               else
1019                 {
1020                   Type* element_type = this->type();
1021                   type = Type::make_array_type(element_type, NULL);
1022                 }
1023             }
1024         }
1025       else
1026         {
1027           type = this->type_name(false);
1028           if (type->is_error_type()
1029               || (!this->peek_token()->is_op(OPERATOR_COMMA)
1030                   && !this->peek_token()->is_op(OPERATOR_RPAREN)))
1031             {
1032               *mix_error = true;
1033               while (!this->peek_token()->is_op(OPERATOR_COMMA)
1034                      && !this->peek_token()->is_op(OPERATOR_RPAREN))
1035                 this->advance_token();
1036             }
1037         }
1038       if (!type->is_error_type())
1039         til->push_back(Typed_identifier("", type, location));
1040     }
1041   else
1042     {
1043       size_t orig_count = til->size();
1044       if (this->peek_token()->is_identifier())
1045         this->identifier_list(til);
1046       else
1047         *mix_error = true;
1048       size_t new_count = til->size();
1049
1050       Type* type;
1051       if (!this->peek_token()->is_op(OPERATOR_ELLIPSIS))
1052         type = this->type();
1053       else
1054         {
1055           if (is_varargs == NULL)
1056             error_at(this->location(), "invalid use of %<...%>");
1057           else if (new_count > orig_count + 1)
1058             error_at(this->location(), "%<...%> only permits one name");
1059           else
1060             *is_varargs = true;
1061           this->advance_token();
1062           Type* element_type = this->type();
1063           type = Type::make_array_type(element_type, NULL);
1064         }
1065       for (size_t i = orig_count; i < new_count; ++i)
1066         til->set_type(i, type);
1067     }
1068 }
1069
1070 // Result         = Parameters | Type .
1071
1072 // This returns false on a parse error.
1073
1074 bool
1075 Parse::result(Typed_identifier_list** presults)
1076 {
1077   if (this->peek_token()->is_op(OPERATOR_LPAREN))
1078     return this->parameters(presults, NULL);
1079   else
1080     {
1081       source_location location = this->location();
1082       Type* type = this->type();
1083       if (type->is_error_type())
1084         {
1085           *presults = NULL;
1086           return false;
1087         }
1088       Typed_identifier_list* til = new Typed_identifier_list();
1089       til->push_back(Typed_identifier("", type, location));
1090       *presults = til;
1091       return true;
1092     }
1093 }
1094
1095 // Block = "{" [ StatementList ] "}" .
1096
1097 // Returns the location of the closing brace.
1098
1099 source_location
1100 Parse::block()
1101 {
1102   if (!this->peek_token()->is_op(OPERATOR_LCURLY))
1103     {
1104       source_location loc = this->location();
1105       if (this->peek_token()->is_op(OPERATOR_SEMICOLON)
1106           && this->advance_token()->is_op(OPERATOR_LCURLY))
1107         error_at(loc, "unexpected semicolon or newline before %<{%>");
1108       else
1109         {
1110           error_at(this->location(), "expected %<{%>");
1111           return UNKNOWN_LOCATION;
1112         }
1113     }
1114
1115   const Token* token = this->advance_token();
1116
1117   if (!token->is_op(OPERATOR_RCURLY))
1118     {
1119       this->statement_list();
1120       token = this->peek_token();
1121       if (!token->is_op(OPERATOR_RCURLY))
1122         {
1123           if (!token->is_eof() || !saw_errors())
1124             error_at(this->location(), "expected %<}%>");
1125
1126           // Skip ahead to the end of the block, in hopes of avoiding
1127           // lots of meaningless errors.
1128           source_location ret = token->location();
1129           int nest = 0;
1130           while (!token->is_eof())
1131             {
1132               if (token->is_op(OPERATOR_LCURLY))
1133                 ++nest;
1134               else if (token->is_op(OPERATOR_RCURLY))
1135                 {
1136                   --nest;
1137                   if (nest < 0)
1138                     {
1139                       this->advance_token();
1140                       break;
1141                     }
1142                 }
1143               token = this->advance_token();
1144               ret = token->location();
1145             }
1146           return ret;
1147         }
1148     }
1149
1150   source_location ret = token->location();
1151   this->advance_token();
1152   return ret;
1153 }
1154
1155 // InterfaceType      = "interface" "{" [ MethodSpecList ] "}" .
1156 // MethodSpecList     = MethodSpec { ";" MethodSpec } [ ";" ] .
1157
1158 Type*
1159 Parse::interface_type()
1160 {
1161   go_assert(this->peek_token()->is_keyword(KEYWORD_INTERFACE));
1162   source_location location = this->location();
1163
1164   if (!this->advance_token()->is_op(OPERATOR_LCURLY))
1165     {
1166       source_location token_loc = this->location();
1167       if (this->peek_token()->is_op(OPERATOR_SEMICOLON)
1168           && this->advance_token()->is_op(OPERATOR_LCURLY))
1169         error_at(token_loc, "unexpected semicolon or newline before %<{%>");
1170       else
1171         {
1172           error_at(this->location(), "expected %<{%>");
1173           return Type::make_error_type();
1174         }
1175     }
1176   this->advance_token();
1177
1178   Typed_identifier_list* methods = new Typed_identifier_list();
1179   if (!this->peek_token()->is_op(OPERATOR_RCURLY))
1180     {
1181       this->method_spec(methods);
1182       while (this->peek_token()->is_op(OPERATOR_SEMICOLON))
1183         {
1184           if (this->advance_token()->is_op(OPERATOR_RCURLY))
1185             break;
1186           this->method_spec(methods);
1187         }
1188       if (!this->peek_token()->is_op(OPERATOR_RCURLY))
1189         {
1190           error_at(this->location(), "expected %<}%>");
1191           while (!this->advance_token()->is_op(OPERATOR_RCURLY))
1192             {
1193               if (this->peek_token()->is_eof())
1194                 return Type::make_error_type();
1195             }
1196         }
1197     }
1198   this->advance_token();
1199
1200   if (methods->empty())
1201     {
1202       delete methods;
1203       methods = NULL;
1204     }
1205
1206   Interface_type* ret = Type::make_interface_type(methods, location);
1207   this->gogo_->record_interface_type(ret);
1208   return ret;
1209 }
1210
1211 // MethodSpec         = MethodName Signature | InterfaceTypeName .
1212 // MethodName         = identifier .
1213 // InterfaceTypeName  = TypeName .
1214
1215 void
1216 Parse::method_spec(Typed_identifier_list* methods)
1217 {
1218   const Token* token = this->peek_token();
1219   if (!token->is_identifier())
1220     {
1221       error_at(this->location(), "expected identifier");
1222       return;
1223     }
1224
1225   std::string name = token->identifier();
1226   bool is_exported = token->is_identifier_exported();
1227   source_location location = token->location();
1228
1229   if (this->advance_token()->is_op(OPERATOR_LPAREN))
1230     {
1231       // This is a MethodName.
1232       name = this->gogo_->pack_hidden_name(name, is_exported);
1233       Type* type = this->signature(NULL, location);
1234       if (type == NULL)
1235         return;
1236       methods->push_back(Typed_identifier(name, type, location));
1237     }
1238   else
1239     {
1240       this->unget_token(Token::make_identifier_token(name, is_exported,
1241                                                      location));
1242       Type* type = this->type_name(false);
1243       if (type->is_error_type()
1244           || (!this->peek_token()->is_op(OPERATOR_SEMICOLON)
1245               && !this->peek_token()->is_op(OPERATOR_RCURLY)))
1246         {
1247           if (this->peek_token()->is_op(OPERATOR_COMMA))
1248             error_at(this->location(),
1249                      "name list not allowed in interface type");
1250           else
1251             error_at(location, "expected signature or type name");
1252           token = this->peek_token();
1253           while (!token->is_eof()
1254                  && !token->is_op(OPERATOR_SEMICOLON)
1255                  && !token->is_op(OPERATOR_RCURLY))
1256             token = this->advance_token();
1257           return;
1258         }
1259       // This must be an interface type, but we can't check that now.
1260       // We check it and pull out the methods in
1261       // Interface_type::do_verify.
1262       methods->push_back(Typed_identifier("", type, location));
1263     }
1264 }
1265
1266 // Declaration = ConstDecl | TypeDecl | VarDecl | FunctionDecl | MethodDecl .
1267
1268 void
1269 Parse::declaration()
1270 {
1271   const Token* token = this->peek_token();
1272   if (token->is_keyword(KEYWORD_CONST))
1273     this->const_decl();
1274   else if (token->is_keyword(KEYWORD_TYPE))
1275     this->type_decl();
1276   else if (token->is_keyword(KEYWORD_VAR))
1277     this->var_decl();
1278   else if (token->is_keyword(KEYWORD_FUNC))
1279     this->function_decl();
1280   else
1281     {
1282       error_at(this->location(), "expected declaration");
1283       this->advance_token();
1284     }
1285 }
1286
1287 bool
1288 Parse::declaration_may_start_here()
1289 {
1290   const Token* token = this->peek_token();
1291   return (token->is_keyword(KEYWORD_CONST)
1292           || token->is_keyword(KEYWORD_TYPE)
1293           || token->is_keyword(KEYWORD_VAR)
1294           || token->is_keyword(KEYWORD_FUNC));
1295 }
1296
1297 // Decl<P> = P | "(" [ List<P> ] ")" .
1298
1299 void
1300 Parse::decl(void (Parse::*pfn)(void*), void* varg)
1301 {
1302   if (this->peek_token()->is_eof())
1303     {
1304       if (!saw_errors())
1305         error_at(this->location(), "unexpected end of file");
1306       return;
1307     }
1308
1309   if (!this->peek_token()->is_op(OPERATOR_LPAREN))
1310     (this->*pfn)(varg);
1311   else
1312     {
1313       if (!this->advance_token()->is_op(OPERATOR_RPAREN))
1314         {
1315           this->list(pfn, varg, true);
1316           if (!this->peek_token()->is_op(OPERATOR_RPAREN))
1317             {
1318               error_at(this->location(), "missing %<)%>");
1319               while (!this->advance_token()->is_op(OPERATOR_RPAREN))
1320                 {
1321                   if (this->peek_token()->is_eof())
1322                     return;
1323                 }
1324             }
1325         }
1326       this->advance_token();
1327     }
1328 }
1329
1330 // List<P> = P { ";" P } [ ";" ] .
1331
1332 // In order to pick up the trailing semicolon we need to know what
1333 // might follow.  This is either a '}' or a ')'.
1334
1335 void
1336 Parse::list(void (Parse::*pfn)(void*), void* varg, bool follow_is_paren)
1337 {
1338   (this->*pfn)(varg);
1339   Operator follow = follow_is_paren ? OPERATOR_RPAREN : OPERATOR_RCURLY;
1340   while (this->peek_token()->is_op(OPERATOR_SEMICOLON)
1341          || this->peek_token()->is_op(OPERATOR_COMMA))
1342     {
1343       if (this->peek_token()->is_op(OPERATOR_COMMA))
1344         error_at(this->location(), "unexpected comma");
1345       if (this->advance_token()->is_op(follow))
1346         break;
1347       (this->*pfn)(varg);
1348     }
1349 }
1350
1351 // ConstDecl      = "const" ( ConstSpec | "(" { ConstSpec ";" } ")" ) .
1352
1353 void
1354 Parse::const_decl()
1355 {
1356   go_assert(this->peek_token()->is_keyword(KEYWORD_CONST));
1357   this->advance_token();
1358   this->reset_iota();
1359
1360   Type* last_type = NULL;
1361   Expression_list* last_expr_list = NULL;
1362
1363   if (!this->peek_token()->is_op(OPERATOR_LPAREN))
1364     this->const_spec(&last_type, &last_expr_list);
1365   else
1366     {
1367       this->advance_token();
1368       while (!this->peek_token()->is_op(OPERATOR_RPAREN))
1369         {
1370           this->const_spec(&last_type, &last_expr_list);
1371           if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
1372             this->advance_token();
1373           else if (!this->peek_token()->is_op(OPERATOR_RPAREN))
1374             {
1375               error_at(this->location(), "expected %<;%> or %<)%> or newline");
1376               if (!this->skip_past_error(OPERATOR_RPAREN))
1377                 return;
1378             }
1379         }
1380       this->advance_token();
1381     }
1382
1383   if (last_expr_list != NULL)
1384     delete last_expr_list;
1385 }
1386
1387 // ConstSpec = IdentifierList [ [ CompleteType ] "=" ExpressionList ] .
1388
1389 void
1390 Parse::const_spec(Type** last_type, Expression_list** last_expr_list)
1391 {
1392   Typed_identifier_list til;
1393   this->identifier_list(&til);
1394
1395   Type* type = NULL;
1396   if (this->type_may_start_here())
1397     {
1398       type = this->type();
1399       *last_type = NULL;
1400       *last_expr_list = NULL;
1401     }
1402
1403   Expression_list *expr_list;
1404   if (!this->peek_token()->is_op(OPERATOR_EQ))
1405     {
1406       if (*last_expr_list == NULL)
1407         {
1408           error_at(this->location(), "expected %<=%>");
1409           return;
1410         }
1411       type = *last_type;
1412       expr_list = new Expression_list;
1413       for (Expression_list::const_iterator p = (*last_expr_list)->begin();
1414            p != (*last_expr_list)->end();
1415            ++p)
1416         expr_list->push_back((*p)->copy());
1417     }
1418   else
1419     {
1420       this->advance_token();
1421       expr_list = this->expression_list(NULL, false);
1422       *last_type = type;
1423       if (*last_expr_list != NULL)
1424         delete *last_expr_list;
1425       *last_expr_list = expr_list;
1426     }
1427
1428   Expression_list::const_iterator pe = expr_list->begin();
1429   for (Typed_identifier_list::iterator pi = til.begin();
1430        pi != til.end();
1431        ++pi, ++pe)
1432     {
1433       if (pe == expr_list->end())
1434         {
1435           error_at(this->location(), "not enough initializers");
1436           return;
1437         }
1438       if (type != NULL)
1439         pi->set_type(type);
1440
1441       if (!Gogo::is_sink_name(pi->name()))
1442         this->gogo_->add_constant(*pi, *pe, this->iota_value());
1443     }
1444   if (pe != expr_list->end())
1445     error_at(this->location(), "too many initializers");
1446
1447   this->increment_iota();
1448
1449   return;
1450 }
1451
1452 // TypeDecl = "type" Decl<TypeSpec> .
1453
1454 void
1455 Parse::type_decl()
1456 {
1457   go_assert(this->peek_token()->is_keyword(KEYWORD_TYPE));
1458   this->advance_token();
1459   this->decl(&Parse::type_spec, NULL);
1460 }
1461
1462 // TypeSpec = identifier Type .
1463
1464 void
1465 Parse::type_spec(void*)
1466 {
1467   const Token* token = this->peek_token();
1468   if (!token->is_identifier())
1469     {
1470       error_at(this->location(), "expected identifier");
1471       return;
1472     }
1473   std::string name = token->identifier();
1474   bool is_exported = token->is_identifier_exported();
1475   source_location location = token->location();
1476   token = this->advance_token();
1477
1478   // The scope of the type name starts at the point where the
1479   // identifier appears in the source code.  We implement this by
1480   // declaring the type before we read the type definition.
1481   Named_object* named_type = NULL;
1482   if (name != "_")
1483     {
1484       name = this->gogo_->pack_hidden_name(name, is_exported);
1485       named_type = this->gogo_->declare_type(name, location);
1486     }
1487
1488   Type* type;
1489   if (!this->peek_token()->is_op(OPERATOR_SEMICOLON))
1490     type = this->type();
1491   else
1492     {
1493       error_at(this->location(),
1494                "unexpected semicolon or newline in type declaration");
1495       type = Type::make_error_type();
1496       this->advance_token();
1497     }
1498
1499   if (type->is_error_type())
1500     {
1501       while (!this->peek_token()->is_op(OPERATOR_SEMICOLON)
1502              && !this->peek_token()->is_eof())
1503         this->advance_token();
1504     }
1505
1506   if (name != "_")
1507     {
1508       if (named_type->is_type_declaration())
1509         {
1510           Type* ftype = type->forwarded();
1511           if (ftype->forward_declaration_type() != NULL
1512               && (ftype->forward_declaration_type()->named_object()
1513                   == named_type))
1514             {
1515               error_at(location, "invalid recursive type");
1516               type = Type::make_error_type();
1517             }
1518
1519           this->gogo_->define_type(named_type,
1520                                    Type::make_named_type(named_type, type,
1521                                                          location));
1522           go_assert(named_type->package() == NULL);
1523         }
1524       else
1525         {
1526           // This will probably give a redefinition error.
1527           this->gogo_->add_type(name, type, location);
1528         }
1529     }
1530 }
1531
1532 // VarDecl = "var" Decl<VarSpec> .
1533
1534 void
1535 Parse::var_decl()
1536 {
1537   go_assert(this->peek_token()->is_keyword(KEYWORD_VAR));
1538   this->advance_token();
1539   this->decl(&Parse::var_spec, NULL);
1540 }
1541
1542 // VarSpec = IdentifierList
1543 //             ( CompleteType [ "=" ExpressionList ] | "=" ExpressionList ) .
1544
1545 void
1546 Parse::var_spec(void*)
1547 {
1548   // Get the variable names.
1549   Typed_identifier_list til;
1550   this->identifier_list(&til);
1551
1552   source_location location = this->location();
1553
1554   Type* type = NULL;
1555   Expression_list* init = NULL;
1556   if (!this->peek_token()->is_op(OPERATOR_EQ))
1557     {
1558       type = this->type();
1559       if (type->is_error_type())
1560         {
1561           while (!this->peek_token()->is_op(OPERATOR_EQ)
1562                  && !this->peek_token()->is_op(OPERATOR_SEMICOLON)
1563                  && !this->peek_token()->is_eof())
1564             this->advance_token();
1565         }
1566       if (this->peek_token()->is_op(OPERATOR_EQ))
1567         {
1568           this->advance_token();
1569           init = this->expression_list(NULL, false);
1570         }
1571     }
1572   else
1573     {
1574       this->advance_token();
1575       init = this->expression_list(NULL, false);
1576     }
1577
1578   this->init_vars(&til, type, init, false, location);
1579
1580   if (init != NULL)
1581     delete init;
1582 }
1583
1584 // Create variables.  TIL is a list of variable names.  If TYPE is not
1585 // NULL, it is the type of all the variables.  If INIT is not NULL, it
1586 // is an initializer list for the variables.
1587
1588 void
1589 Parse::init_vars(const Typed_identifier_list* til, Type* type,
1590                  Expression_list* init, bool is_coloneq,
1591                  source_location location)
1592 {
1593   // Check for an initialization which can yield multiple values.
1594   if (init != NULL && init->size() == 1 && til->size() > 1)
1595     {
1596       if (this->init_vars_from_call(til, type, *init->begin(), is_coloneq,
1597                                     location))
1598         return;
1599       if (this->init_vars_from_map(til, type, *init->begin(), is_coloneq,
1600                                    location))
1601         return;
1602       if (this->init_vars_from_receive(til, type, *init->begin(), is_coloneq,
1603                                        location))
1604         return;
1605       if (this->init_vars_from_type_guard(til, type, *init->begin(),
1606                                           is_coloneq, location))
1607         return;
1608     }
1609
1610   if (init != NULL && init->size() != til->size())
1611     {
1612       if (init->empty() || !init->front()->is_error_expression())
1613         error_at(location, "wrong number of initializations");
1614       init = NULL;
1615       if (type == NULL)
1616         type = Type::make_error_type();
1617     }
1618
1619   // Note that INIT was already parsed with the old name bindings, so
1620   // we don't have to worry that it will accidentally refer to the
1621   // newly declared variables.
1622
1623   Expression_list::const_iterator pexpr;
1624   if (init != NULL)
1625     pexpr = init->begin();
1626   bool any_new = false;
1627   for (Typed_identifier_list::const_iterator p = til->begin();
1628        p != til->end();
1629        ++p)
1630     {
1631       if (init != NULL)
1632         go_assert(pexpr != init->end());
1633       this->init_var(*p, type, init == NULL ? NULL : *pexpr, is_coloneq,
1634                      false, &any_new);
1635       if (init != NULL)
1636         ++pexpr;
1637     }
1638   if (init != NULL)
1639     go_assert(pexpr == init->end());
1640   if (is_coloneq && !any_new)
1641     error_at(location, "variables redeclared but no variable is new");
1642 }
1643
1644 // See if we need to initialize a list of variables from a function
1645 // call.  This returns true if we have set up the variables and the
1646 // initialization.
1647
1648 bool
1649 Parse::init_vars_from_call(const Typed_identifier_list* vars, Type* type,
1650                            Expression* expr, bool is_coloneq,
1651                            source_location location)
1652 {
1653   Call_expression* call = expr->call_expression();
1654   if (call == NULL)
1655     return false;
1656
1657   // This is a function call.  We can't check here whether it returns
1658   // the right number of values, but it might.  Declare the variables,
1659   // and then assign the results of the call to them.
1660
1661   unsigned int index = 0;
1662   bool any_new = false;
1663   for (Typed_identifier_list::const_iterator pv = vars->begin();
1664        pv != vars->end();
1665        ++pv, ++index)
1666     {
1667       Expression* init = Expression::make_call_result(call, index);
1668       this->init_var(*pv, type, init, is_coloneq, false, &any_new);
1669     }
1670
1671   if (is_coloneq && !any_new)
1672     error_at(location, "variables redeclared but no variable is new");
1673
1674   return true;
1675 }
1676
1677 // See if we need to initialize a pair of values from a map index
1678 // expression.  This returns true if we have set up the variables and
1679 // the initialization.
1680
1681 bool
1682 Parse::init_vars_from_map(const Typed_identifier_list* vars, Type* type,
1683                           Expression* expr, bool is_coloneq,
1684                           source_location location)
1685 {
1686   Index_expression* index = expr->index_expression();
1687   if (index == NULL)
1688     return false;
1689   if (vars->size() != 2)
1690     return false;
1691
1692   // This is an index which is being assigned to two variables.  It
1693   // must be a map index.  Declare the variables, and then assign the
1694   // results of the map index.
1695   bool any_new = false;
1696   Typed_identifier_list::const_iterator p = vars->begin();
1697   Expression* init = type == NULL ? index : NULL;
1698   Named_object* val_no = this->init_var(*p, type, init, is_coloneq,
1699                                         type == NULL, &any_new);
1700   if (type == NULL && any_new && val_no->is_variable())
1701     val_no->var_value()->set_type_from_init_tuple();
1702   Expression* val_var = Expression::make_var_reference(val_no, location);
1703
1704   ++p;
1705   Type* var_type = type;
1706   if (var_type == NULL)
1707     var_type = Type::lookup_bool_type();
1708   Named_object* no = this->init_var(*p, var_type, NULL, is_coloneq, false,
1709                                     &any_new);
1710   Expression* present_var = Expression::make_var_reference(no, location);
1711
1712   if (is_coloneq && !any_new)
1713     error_at(location, "variables redeclared but no variable is new");
1714
1715   Statement* s = Statement::make_tuple_map_assignment(val_var, present_var,
1716                                                       index, location);
1717
1718   if (!this->gogo_->in_global_scope())
1719     this->gogo_->add_statement(s);
1720   else if (!val_no->is_sink())
1721     {
1722       if (val_no->is_variable())
1723         val_no->var_value()->add_preinit_statement(this->gogo_, s);
1724     }
1725   else if (!no->is_sink())
1726     {
1727       if (no->is_variable())
1728         no->var_value()->add_preinit_statement(this->gogo_, s);
1729     }
1730   else
1731     {
1732       // Execute the map index expression just so that we can fail if
1733       // the map is nil.
1734       Named_object* dummy = this->create_dummy_global(Type::lookup_bool_type(),
1735                                                       NULL, location);
1736       dummy->var_value()->add_preinit_statement(this->gogo_, s);
1737     }
1738
1739   return true;
1740 }
1741
1742 // See if we need to initialize a pair of values from a receive
1743 // expression.  This returns true if we have set up the variables and
1744 // the initialization.
1745
1746 bool
1747 Parse::init_vars_from_receive(const Typed_identifier_list* vars, Type* type,
1748                               Expression* expr, bool is_coloneq,
1749                               source_location location)
1750 {
1751   Receive_expression* receive = expr->receive_expression();
1752   if (receive == NULL)
1753     return false;
1754   if (vars->size() != 2)
1755     return false;
1756
1757   // This is a receive expression which is being assigned to two
1758   // variables.  Declare the variables, and then assign the results of
1759   // the receive.
1760   bool any_new = false;
1761   Typed_identifier_list::const_iterator p = vars->begin();
1762   Expression* init = type == NULL ? receive : NULL;
1763   Named_object* val_no = this->init_var(*p, type, init, is_coloneq,
1764                                         type == NULL, &any_new);
1765   if (type == NULL && any_new && val_no->is_variable())
1766     val_no->var_value()->set_type_from_init_tuple();
1767   Expression* val_var = Expression::make_var_reference(val_no, location);
1768
1769   ++p;
1770   Type* var_type = type;
1771   if (var_type == NULL)
1772     var_type = Type::lookup_bool_type();
1773   Named_object* no = this->init_var(*p, var_type, NULL, is_coloneq, false,
1774                                     &any_new);
1775   Expression* received_var = Expression::make_var_reference(no, location);
1776
1777   if (is_coloneq && !any_new)
1778     error_at(location, "variables redeclared but no variable is new");
1779
1780   Statement* s = Statement::make_tuple_receive_assignment(val_var,
1781                                                           received_var,
1782                                                           receive->channel(),
1783                                                           false,
1784                                                           location);
1785
1786   if (!this->gogo_->in_global_scope())
1787     this->gogo_->add_statement(s);
1788   else if (!val_no->is_sink())
1789     {
1790       if (val_no->is_variable())
1791         val_no->var_value()->add_preinit_statement(this->gogo_, s);
1792     }
1793   else if (!no->is_sink())
1794     {
1795       if (no->is_variable())
1796         no->var_value()->add_preinit_statement(this->gogo_, s);
1797     }
1798   else
1799     {
1800       Named_object* dummy = this->create_dummy_global(Type::lookup_bool_type(),
1801                                                       NULL, location);
1802       dummy->var_value()->add_preinit_statement(this->gogo_, s);
1803     }
1804
1805   return true;
1806 }
1807
1808 // See if we need to initialize a pair of values from a type guard
1809 // expression.  This returns true if we have set up the variables and
1810 // the initialization.
1811
1812 bool
1813 Parse::init_vars_from_type_guard(const Typed_identifier_list* vars,
1814                                  Type* type, Expression* expr,
1815                                  bool is_coloneq, source_location location)
1816 {
1817   Type_guard_expression* type_guard = expr->type_guard_expression();
1818   if (type_guard == NULL)
1819     return false;
1820   if (vars->size() != 2)
1821     return false;
1822
1823   // This is a type guard expression which is being assigned to two
1824   // variables.  Declare the variables, and then assign the results of
1825   // the type guard.
1826   bool any_new = false;
1827   Typed_identifier_list::const_iterator p = vars->begin();
1828   Type* var_type = type;
1829   if (var_type == NULL)
1830     var_type = type_guard->type();
1831   Named_object* val_no = this->init_var(*p, var_type, NULL, is_coloneq, false,
1832                                         &any_new);
1833   Expression* val_var = Expression::make_var_reference(val_no, location);
1834
1835   ++p;
1836   var_type = type;
1837   if (var_type == NULL)
1838     var_type = Type::lookup_bool_type();
1839   Named_object* no = this->init_var(*p, var_type, NULL, is_coloneq, false,
1840                                     &any_new);
1841   Expression* ok_var = Expression::make_var_reference(no, location);
1842
1843   Expression* texpr = type_guard->expr();
1844   Type* t = type_guard->type();
1845   Statement* s = Statement::make_tuple_type_guard_assignment(val_var, ok_var,
1846                                                              texpr, t,
1847                                                              location);
1848
1849   if (is_coloneq && !any_new)
1850     error_at(location, "variables redeclared but no variable is new");
1851
1852   if (!this->gogo_->in_global_scope())
1853     this->gogo_->add_statement(s);
1854   else if (!val_no->is_sink())
1855     {
1856       if (val_no->is_variable())
1857         val_no->var_value()->add_preinit_statement(this->gogo_, s);
1858     }
1859   else if (!no->is_sink())
1860     {
1861       if (no->is_variable())
1862         no->var_value()->add_preinit_statement(this->gogo_, s);
1863     }
1864   else
1865     {
1866       Named_object* dummy = this->create_dummy_global(type, NULL, location);
1867       dummy->var_value()->add_preinit_statement(this->gogo_, s);
1868     }
1869
1870   return true;
1871 }
1872
1873 // Create a single variable.  If IS_COLONEQ is true, we permit
1874 // redeclarations in the same block, and we set *IS_NEW when we find a
1875 // new variable which is not a redeclaration.
1876
1877 Named_object*
1878 Parse::init_var(const Typed_identifier& tid, Type* type, Expression* init,
1879                 bool is_coloneq, bool type_from_init, bool* is_new)
1880 {
1881   source_location location = tid.location();
1882
1883   if (Gogo::is_sink_name(tid.name()))
1884     {
1885       if (!type_from_init && init != NULL)
1886         {
1887           if (!this->gogo_->in_global_scope())
1888             this->gogo_->add_statement(Statement::make_statement(init, true));
1889           else
1890             return this->create_dummy_global(type, init, location);
1891         }
1892       return this->gogo_->add_sink();
1893     }
1894
1895   if (is_coloneq)
1896     {
1897       Named_object* no = this->gogo_->lookup_in_block(tid.name());
1898       if (no != NULL
1899           && (no->is_variable() || no->is_result_variable()))
1900         {
1901           // INIT may be NULL even when IS_COLONEQ is true for cases
1902           // like v, ok := x.(int).
1903           if (!type_from_init && init != NULL)
1904             {
1905               Expression *v = Expression::make_var_reference(no, location);
1906               Statement *s = Statement::make_assignment(v, init, location);
1907               this->gogo_->add_statement(s);
1908             }
1909           return no;
1910         }
1911     }
1912   *is_new = true;
1913   Variable* var = new Variable(type, init, this->gogo_->in_global_scope(),
1914                                false, false, location);
1915   Named_object* no = this->gogo_->add_variable(tid.name(), var);
1916   if (!no->is_variable())
1917     {
1918       // The name is already defined, so we just gave an error.
1919       return this->gogo_->add_sink();
1920     }
1921   return no;
1922 }
1923
1924 // Create a dummy global variable to force an initializer to be run in
1925 // the right place.  This is used when a sink variable is initialized
1926 // at global scope.
1927
1928 Named_object*
1929 Parse::create_dummy_global(Type* type, Expression* init,
1930                            source_location location)
1931 {
1932   if (type == NULL && init == NULL)
1933     type = Type::lookup_bool_type();
1934   Variable* var = new Variable(type, init, true, false, false, location);
1935   static int count;
1936   char buf[30];
1937   snprintf(buf, sizeof buf, "_.%d", count);
1938   ++count;
1939   return this->gogo_->add_variable(buf, var);
1940 }
1941
1942 // SimpleVarDecl = identifier ":=" Expression .
1943
1944 // We've already seen the identifier.
1945
1946 // FIXME: We also have to implement
1947 //  IdentifierList ":=" ExpressionList
1948 // In order to support both "a, b := 1, 0" and "a, b = 1, 0" we accept
1949 // tuple assignments here as well.
1950
1951 // If P_RANGE_CLAUSE is not NULL, then this will recognize a
1952 // RangeClause.
1953
1954 // If P_TYPE_SWITCH is not NULL, this will recognize a type switch
1955 // guard (var := expr.("type") using the literal keyword "type").
1956
1957 void
1958 Parse::simple_var_decl_or_assignment(const std::string& name,
1959                                      source_location location,
1960                                      Range_clause* p_range_clause,
1961                                      Type_switch* p_type_switch)
1962 {
1963   Typed_identifier_list til;
1964   til.push_back(Typed_identifier(name, NULL, location));
1965
1966   // We've seen one identifier.  If we see a comma now, this could be
1967   // "a, *p = 1, 2".
1968   if (this->peek_token()->is_op(OPERATOR_COMMA))
1969     {
1970       go_assert(p_type_switch == NULL);
1971       while (true)
1972         {
1973           const Token* token = this->advance_token();
1974           if (!token->is_identifier())
1975             break;
1976
1977           std::string id = token->identifier();
1978           bool is_id_exported = token->is_identifier_exported();
1979           source_location id_location = token->location();
1980
1981           token = this->advance_token();
1982           if (!token->is_op(OPERATOR_COMMA))
1983             {
1984               if (token->is_op(OPERATOR_COLONEQ))
1985                 {
1986                   id = this->gogo_->pack_hidden_name(id, is_id_exported);
1987                   til.push_back(Typed_identifier(id, NULL, location));
1988                 }
1989               else
1990                 this->unget_token(Token::make_identifier_token(id,
1991                                                                is_id_exported,
1992                                                                id_location));
1993               break;
1994             }
1995
1996           id = this->gogo_->pack_hidden_name(id, is_id_exported);
1997           til.push_back(Typed_identifier(id, NULL, location));
1998         }
1999
2000       // We have a comma separated list of identifiers in TIL.  If the
2001       // next token is COLONEQ, then this is a simple var decl, and we
2002       // have the complete list of identifiers.  If the next token is
2003       // not COLONEQ, then the only valid parse is a tuple assignment.
2004       // The list of identifiers we have so far is really a list of
2005       // expressions.  There are more expressions following.
2006
2007       if (!this->peek_token()->is_op(OPERATOR_COLONEQ))
2008         {
2009           Expression_list* exprs = new Expression_list;
2010           for (Typed_identifier_list::const_iterator p = til.begin();
2011                p != til.end();
2012                ++p)
2013             exprs->push_back(this->id_to_expression(p->name(),
2014                                                     p->location()));
2015
2016           Expression_list* more_exprs = this->expression_list(NULL, true);
2017           for (Expression_list::const_iterator p = more_exprs->begin();
2018                p != more_exprs->end();
2019                ++p)
2020             exprs->push_back(*p);
2021           delete more_exprs;
2022
2023           this->tuple_assignment(exprs, p_range_clause);
2024           return;
2025         }
2026     }
2027
2028   go_assert(this->peek_token()->is_op(OPERATOR_COLONEQ));
2029   const Token* token = this->advance_token();
2030
2031   if (p_range_clause != NULL && token->is_keyword(KEYWORD_RANGE))
2032     {
2033       this->range_clause_decl(&til, p_range_clause);
2034       return;
2035     }
2036
2037   Expression_list* init;
2038   if (p_type_switch == NULL)
2039     init = this->expression_list(NULL, false);
2040   else
2041     {
2042       bool is_type_switch = false;
2043       Expression* expr = this->expression(PRECEDENCE_NORMAL, false, true,
2044                                           &is_type_switch);
2045       if (is_type_switch)
2046         {
2047           p_type_switch->found = true;
2048           p_type_switch->name = name;
2049           p_type_switch->location = location;
2050           p_type_switch->expr = expr;
2051           return;
2052         }
2053
2054       if (!this->peek_token()->is_op(OPERATOR_COMMA))
2055         {
2056           init = new Expression_list();
2057           init->push_back(expr);
2058         }
2059       else
2060         {
2061           this->advance_token();
2062           init = this->expression_list(expr, false);
2063         }
2064     }
2065
2066   this->init_vars(&til, NULL, init, true, location);
2067 }
2068
2069 // FunctionDecl = "func" identifier Signature [ Block ] .
2070 // MethodDecl = "func" Receiver identifier Signature [ Block ] .
2071
2072 // gcc extension:
2073 //   FunctionDecl = "func" identifier Signature
2074 //                    __asm__ "(" string_lit ")" .
2075 // This extension means a function whose real name is the identifier
2076 // inside the asm.
2077
2078 void
2079 Parse::function_decl()
2080 {
2081   go_assert(this->peek_token()->is_keyword(KEYWORD_FUNC));
2082   source_location location = this->location();
2083   const Token* token = this->advance_token();
2084
2085   Typed_identifier* rec = NULL;
2086   if (token->is_op(OPERATOR_LPAREN))
2087     {
2088       rec = this->receiver();
2089       token = this->peek_token();
2090     }
2091
2092   if (!token->is_identifier())
2093     {
2094       error_at(this->location(), "expected function name");
2095       return;
2096     }
2097
2098   std::string name =
2099     this->gogo_->pack_hidden_name(token->identifier(),
2100                                   token->is_identifier_exported());
2101
2102   this->advance_token();
2103
2104   Function_type* fntype = this->signature(rec, this->location());
2105   if (fntype == NULL)
2106     return;
2107
2108   Named_object* named_object = NULL;
2109
2110   if (this->peek_token()->is_keyword(KEYWORD_ASM))
2111     {
2112       if (!this->advance_token()->is_op(OPERATOR_LPAREN))
2113         {
2114           error_at(this->location(), "expected %<(%>");
2115           return;
2116         }
2117       token = this->advance_token();
2118       if (!token->is_string())
2119         {
2120           error_at(this->location(), "expected string");
2121           return;
2122         }
2123       std::string asm_name = token->string_value();
2124       if (!this->advance_token()->is_op(OPERATOR_RPAREN))
2125         {
2126           error_at(this->location(), "expected %<)%>");
2127           return;
2128         }
2129       this->advance_token();
2130       if (!Gogo::is_sink_name(name))
2131         {
2132           named_object = this->gogo_->declare_function(name, fntype, location);
2133           if (named_object->is_function_declaration())
2134             named_object->func_declaration_value()->set_asm_name(asm_name);
2135         }
2136     }
2137
2138   // Check for the easy error of a newline before the opening brace.
2139   if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
2140     {
2141       source_location semi_loc = this->location();
2142       if (this->advance_token()->is_op(OPERATOR_LCURLY))
2143         error_at(this->location(),
2144                  "unexpected semicolon or newline before %<{%>");
2145       else
2146         this->unget_token(Token::make_operator_token(OPERATOR_SEMICOLON,
2147                                                      semi_loc));
2148     }
2149
2150   if (!this->peek_token()->is_op(OPERATOR_LCURLY))
2151     {
2152       if (named_object == NULL && !Gogo::is_sink_name(name))
2153         this->gogo_->declare_function(name, fntype, location);
2154     }
2155   else
2156     {
2157       this->gogo_->start_function(name, fntype, true, location);
2158       source_location end_loc = this->block();
2159       this->gogo_->finish_function(end_loc);
2160     }
2161 }
2162
2163 // Receiver     = "(" [ identifier ] [ "*" ] BaseTypeName ")" .
2164 // BaseTypeName = identifier .
2165
2166 Typed_identifier*
2167 Parse::receiver()
2168 {
2169   go_assert(this->peek_token()->is_op(OPERATOR_LPAREN));
2170
2171   std::string name;
2172   const Token* token = this->advance_token();
2173   source_location location = token->location();
2174   if (!token->is_op(OPERATOR_MULT))
2175     {
2176       if (!token->is_identifier())
2177         {
2178           error_at(this->location(), "method has no receiver");
2179           while (!token->is_eof() && !token->is_op(OPERATOR_RPAREN))
2180             token = this->advance_token();
2181           if (!token->is_eof())
2182             this->advance_token();
2183           return NULL;
2184         }
2185       name = token->identifier();
2186       bool is_exported = token->is_identifier_exported();
2187       token = this->advance_token();
2188       if (!token->is_op(OPERATOR_DOT) && !token->is_op(OPERATOR_RPAREN))
2189         {
2190           // An identifier followed by something other than a dot or a
2191           // right parenthesis must be a receiver name followed by a
2192           // type.
2193           name = this->gogo_->pack_hidden_name(name, is_exported);
2194         }
2195       else
2196         {
2197           // This must be a type name.
2198           this->unget_token(Token::make_identifier_token(name, is_exported,
2199                                                          location));
2200           token = this->peek_token();
2201           name.clear();
2202         }
2203     }
2204
2205   // Here the receiver name is in NAME (it is empty if the receiver is
2206   // unnamed) and TOKEN is the first token in the type.
2207
2208   bool is_pointer = false;
2209   if (token->is_op(OPERATOR_MULT))
2210     {
2211       is_pointer = true;
2212       token = this->advance_token();
2213     }
2214
2215   if (!token->is_identifier())
2216     {
2217       error_at(this->location(), "expected receiver name or type");
2218       int c = token->is_op(OPERATOR_LPAREN) ? 1 : 0;
2219       while (!token->is_eof())
2220         {
2221           token = this->advance_token();
2222           if (token->is_op(OPERATOR_LPAREN))
2223             ++c;
2224           else if (token->is_op(OPERATOR_RPAREN))
2225             {
2226               if (c == 0)
2227                 break;
2228               --c;
2229             }
2230         }
2231       if (!token->is_eof())
2232         this->advance_token();
2233       return NULL;
2234     }
2235
2236   Type* type = this->type_name(true);
2237
2238   if (is_pointer && !type->is_error_type())
2239     type = Type::make_pointer_type(type);
2240
2241   if (this->peek_token()->is_op(OPERATOR_RPAREN))
2242     this->advance_token();
2243   else
2244     {
2245       if (this->peek_token()->is_op(OPERATOR_COMMA))
2246         error_at(this->location(), "method has multiple receivers");
2247       else
2248         error_at(this->location(), "expected %<)%>");
2249       while (!token->is_eof() && !token->is_op(OPERATOR_RPAREN))
2250         token = this->advance_token();
2251       if (!token->is_eof())
2252         this->advance_token();
2253       return NULL;
2254     }
2255
2256   return new Typed_identifier(name, type, location);
2257 }
2258
2259 // Operand    = Literal | QualifiedIdent | MethodExpr | "(" Expression ")" .
2260 // Literal    = BasicLit | CompositeLit | FunctionLit .
2261 // BasicLit   = int_lit | float_lit | imaginary_lit | char_lit | string_lit .
2262
2263 // If MAY_BE_SINK is true, this operand may be "_".
2264
2265 Expression*
2266 Parse::operand(bool may_be_sink)
2267 {
2268   const Token* token = this->peek_token();
2269   Expression* ret;
2270   switch (token->classification())
2271     {
2272     case Token::TOKEN_IDENTIFIER:
2273       {
2274         source_location location = token->location();
2275         std::string id = token->identifier();
2276         bool is_exported = token->is_identifier_exported();
2277         std::string packed = this->gogo_->pack_hidden_name(id, is_exported);
2278
2279         Named_object* in_function;
2280         Named_object* named_object = this->gogo_->lookup(packed, &in_function);
2281
2282         Package* package = NULL;
2283         if (named_object != NULL && named_object->is_package())
2284           {
2285             if (!this->advance_token()->is_op(OPERATOR_DOT)
2286                 || !this->advance_token()->is_identifier())
2287               {
2288                 error_at(location, "unexpected reference to package");
2289                 return Expression::make_error(location);
2290               }
2291             package = named_object->package_value();
2292             package->set_used();
2293             id = this->peek_token()->identifier();
2294             is_exported = this->peek_token()->is_identifier_exported();
2295             packed = this->gogo_->pack_hidden_name(id, is_exported);
2296             named_object = package->lookup(packed);
2297             location = this->location();
2298             go_assert(in_function == NULL);
2299           }
2300
2301         this->advance_token();
2302
2303         if (named_object != NULL
2304             && named_object->is_type()
2305             && !named_object->type_value()->is_visible())
2306           {
2307             go_assert(package != NULL);
2308             error_at(location, "invalid reference to hidden type %<%s.%s%>",
2309                      Gogo::message_name(package->name()).c_str(),
2310                      Gogo::message_name(id).c_str());
2311             return Expression::make_error(location);
2312           }
2313
2314
2315         if (named_object == NULL)
2316           {
2317             if (package != NULL)
2318               {
2319                 std::string n1 = Gogo::message_name(package->name());
2320                 std::string n2 = Gogo::message_name(id);
2321                 if (!is_exported)
2322                   error_at(location,
2323                            ("invalid reference to unexported identifier "
2324                             "%<%s.%s%>"),
2325                            n1.c_str(), n2.c_str());
2326                 else
2327                   error_at(location,
2328                            "reference to undefined identifier %<%s.%s%>",
2329                            n1.c_str(), n2.c_str());
2330                 return Expression::make_error(location);
2331               }
2332
2333             named_object = this->gogo_->add_unknown_name(packed, location);
2334           }
2335
2336         if (in_function != NULL
2337             && in_function != this->gogo_->current_function()
2338             && (named_object->is_variable()
2339                 || named_object->is_result_variable()))
2340           return this->enclosing_var_reference(in_function, named_object,
2341                                                location);
2342
2343         switch (named_object->classification())
2344           {
2345           case Named_object::NAMED_OBJECT_CONST:
2346             return Expression::make_const_reference(named_object, location);
2347           case Named_object::NAMED_OBJECT_TYPE:
2348             return Expression::make_type(named_object->type_value(), location);
2349           case Named_object::NAMED_OBJECT_TYPE_DECLARATION:
2350             {
2351               Type* t = Type::make_forward_declaration(named_object);
2352               return Expression::make_type(t, location);
2353             }
2354           case Named_object::NAMED_OBJECT_VAR:
2355           case Named_object::NAMED_OBJECT_RESULT_VAR:
2356             return Expression::make_var_reference(named_object, location);
2357           case Named_object::NAMED_OBJECT_SINK:
2358             if (may_be_sink)
2359               return Expression::make_sink(location);
2360             else
2361               {
2362                 error_at(location, "cannot use _ as value");
2363                 return Expression::make_error(location);
2364               }
2365           case Named_object::NAMED_OBJECT_FUNC:
2366           case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
2367             return Expression::make_func_reference(named_object, NULL,
2368                                                    location);
2369           case Named_object::NAMED_OBJECT_UNKNOWN:
2370             return Expression::make_unknown_reference(named_object, location);
2371           default:
2372             go_unreachable();
2373           }
2374       }
2375       go_unreachable();
2376
2377     case Token::TOKEN_STRING:
2378       ret = Expression::make_string(token->string_value(), token->location());
2379       this->advance_token();
2380       return ret;
2381
2382     case Token::TOKEN_INTEGER:
2383       ret = Expression::make_integer(token->integer_value(), NULL,
2384                                      token->location());
2385       this->advance_token();
2386       return ret;
2387
2388     case Token::TOKEN_FLOAT:
2389       ret = Expression::make_float(token->float_value(), NULL,
2390                                    token->location());
2391       this->advance_token();
2392       return ret;
2393
2394     case Token::TOKEN_IMAGINARY:
2395       {
2396         mpfr_t zero;
2397         mpfr_init_set_ui(zero, 0, GMP_RNDN);
2398         ret = Expression::make_complex(&zero, token->imaginary_value(),
2399                                        NULL, token->location());
2400         mpfr_clear(zero);
2401         this->advance_token();
2402         return ret;
2403       }
2404
2405     case Token::TOKEN_KEYWORD:
2406       switch (token->keyword())
2407         {
2408         case KEYWORD_FUNC:
2409           return this->function_lit();
2410         case KEYWORD_CHAN:
2411         case KEYWORD_INTERFACE:
2412         case KEYWORD_MAP:
2413         case KEYWORD_STRUCT:
2414           {
2415             source_location location = token->location();
2416             return Expression::make_type(this->type(), location);
2417           }
2418         default:
2419           break;
2420         }
2421       break;
2422
2423     case Token::TOKEN_OPERATOR:
2424       if (token->is_op(OPERATOR_LPAREN))
2425         {
2426           this->advance_token();
2427           ret = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
2428           if (!this->peek_token()->is_op(OPERATOR_RPAREN))
2429             error_at(this->location(), "missing %<)%>");
2430           else
2431             this->advance_token();
2432           return ret;
2433         }
2434       else if (token->is_op(OPERATOR_LSQUARE))
2435         {
2436           // Here we call array_type directly, as this is the only
2437           // case where an ellipsis is permitted for an array type.
2438           source_location location = token->location();
2439           return Expression::make_type(this->array_type(true), location);
2440         }
2441       break;
2442
2443     default:
2444       break;
2445     }
2446
2447   error_at(this->location(), "expected operand");
2448   return Expression::make_error(this->location());
2449 }
2450
2451 // Handle a reference to a variable in an enclosing function.  We add
2452 // it to a list of such variables.  We return a reference to a field
2453 // in a struct which will be passed on the static chain when calling
2454 // the current function.
2455
2456 Expression*
2457 Parse::enclosing_var_reference(Named_object* in_function, Named_object* var,
2458                                source_location location)
2459 {
2460   go_assert(var->is_variable() || var->is_result_variable());
2461
2462   Named_object* this_function = this->gogo_->current_function();
2463   Named_object* closure = this_function->func_value()->closure_var();
2464
2465   Enclosing_var ev(var, in_function, this->enclosing_vars_.size());
2466   std::pair<Enclosing_vars::iterator, bool> ins =
2467     this->enclosing_vars_.insert(ev);
2468   if (ins.second)
2469     {
2470       // This is a variable we have not seen before.  Add a new field
2471       // to the closure type.
2472       this_function->func_value()->add_closure_field(var, location);
2473     }
2474
2475   Expression* closure_ref = Expression::make_var_reference(closure,
2476                                                            location);
2477   closure_ref = Expression::make_unary(OPERATOR_MULT, closure_ref, location);
2478
2479   // The closure structure holds pointers to the variables, so we need
2480   // to introduce an indirection.
2481   Expression* e = Expression::make_field_reference(closure_ref,
2482                                                    ins.first->index(),
2483                                                    location);
2484   e = Expression::make_unary(OPERATOR_MULT, e, location);
2485   return e;
2486 }
2487
2488 // CompositeLit  = LiteralType LiteralValue .
2489 // LiteralType   = StructType | ArrayType | "[" "..." "]" ElementType |
2490 //                 SliceType | MapType | TypeName .
2491 // LiteralValue  = "{" [ ElementList [ "," ] ] "}" .
2492 // ElementList   = Element { "," Element } .
2493 // Element       = [ Key ":" ] Value .
2494 // Key           = FieldName | ElementIndex .
2495 // FieldName     = identifier .
2496 // ElementIndex  = Expression .
2497 // Value         = Expression | LiteralValue .
2498
2499 // We have already seen the type if there is one, and we are now
2500 // looking at the LiteralValue.  The case "[" "..."  "]" ElementType
2501 // will be seen here as an array type whose length is "nil".  The
2502 // DEPTH parameter is non-zero if this is an embedded composite
2503 // literal and the type was omitted.  It gives the number of steps up
2504 // to the type which was provided.  E.g., in [][]int{{1}} it will be
2505 // 1.  In [][][]int{{{1}}} it will be 2.
2506
2507 Expression*
2508 Parse::composite_lit(Type* type, int depth, source_location location)
2509 {
2510   go_assert(this->peek_token()->is_op(OPERATOR_LCURLY));
2511   this->advance_token();
2512
2513   if (this->peek_token()->is_op(OPERATOR_RCURLY))
2514     {
2515       this->advance_token();
2516       return Expression::make_composite_literal(type, depth, false, NULL,
2517                                                 location);
2518     }
2519
2520   bool has_keys = false;
2521   Expression_list* vals = new Expression_list;
2522   while (true)
2523     {
2524       Expression* val;
2525       bool is_type_omitted = false;
2526
2527       const Token* token = this->peek_token();
2528
2529       if (token->is_identifier())
2530         {
2531           std::string identifier = token->identifier();
2532           bool is_exported = token->is_identifier_exported();
2533           source_location location = token->location();
2534
2535           if (this->advance_token()->is_op(OPERATOR_COLON))
2536             {
2537               // This may be a field name.  We don't know for sure--it
2538               // could also be an expression for an array index.  We
2539               // don't want to parse it as an expression because may
2540               // trigger various errors, e.g., if this identifier
2541               // happens to be the name of a package.
2542               Gogo* gogo = this->gogo_;
2543               val = this->id_to_expression(gogo->pack_hidden_name(identifier,
2544                                                                   is_exported),
2545                                            location);
2546             }
2547           else
2548             {
2549               this->unget_token(Token::make_identifier_token(identifier,
2550                                                              is_exported,
2551                                                              location));
2552               val = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
2553             }
2554         }
2555       else if (!token->is_op(OPERATOR_LCURLY))
2556         val = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
2557       else
2558         {
2559           // This must be a composite literal inside another composite
2560           // literal, with the type omitted for the inner one.
2561           val = this->composite_lit(type, depth + 1, token->location());
2562           is_type_omitted = true;
2563         }
2564
2565       token = this->peek_token();
2566       if (!token->is_op(OPERATOR_COLON))
2567         {
2568           if (has_keys)
2569             vals->push_back(NULL);
2570         }
2571       else
2572         {
2573           if (is_type_omitted && !val->is_error_expression())
2574             {
2575               error_at(this->location(), "unexpected %<:%>");
2576               val = Expression::make_error(this->location());
2577             }
2578
2579           this->advance_token();
2580
2581           if (!has_keys && !vals->empty())
2582             {
2583               Expression_list* newvals = new Expression_list;
2584               for (Expression_list::const_iterator p = vals->begin();
2585                    p != vals->end();
2586                    ++p)
2587                 {
2588                   newvals->push_back(NULL);
2589                   newvals->push_back(*p);
2590                 }
2591               delete vals;
2592               vals = newvals;
2593             }
2594           has_keys = true;
2595
2596           if (val->unknown_expression() != NULL)
2597             val->unknown_expression()->set_is_composite_literal_key();
2598
2599           vals->push_back(val);
2600
2601           if (!token->is_op(OPERATOR_LCURLY))
2602             val = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
2603           else
2604             {
2605               // This must be a composite literal inside another
2606               // composite literal, with the type omitted for the
2607               // inner one.
2608               val = this->composite_lit(type, depth + 1, token->location());
2609             }
2610
2611           token = this->peek_token();
2612         }
2613
2614       vals->push_back(val);
2615
2616       if (token->is_op(OPERATOR_COMMA))
2617         {
2618           if (this->advance_token()->is_op(OPERATOR_RCURLY))
2619             {
2620               this->advance_token();
2621               break;
2622             }
2623         }
2624       else if (token->is_op(OPERATOR_RCURLY))
2625         {
2626           this->advance_token();
2627           break;
2628         }
2629       else
2630         {
2631           error_at(this->location(), "expected %<,%> or %<}%>");
2632
2633           int depth = 0;
2634           while (!token->is_eof()
2635                  && (depth > 0 || !token->is_op(OPERATOR_RCURLY)))
2636             {
2637               if (token->is_op(OPERATOR_LCURLY))
2638                 ++depth;
2639               else if (token->is_op(OPERATOR_RCURLY))
2640                 --depth;
2641               token = this->advance_token();
2642             }
2643           if (token->is_op(OPERATOR_RCURLY))
2644             this->advance_token();
2645
2646           return Expression::make_error(location);
2647         }
2648     }
2649
2650   return Expression::make_composite_literal(type, depth, has_keys, vals,
2651                                             location);
2652 }
2653
2654 // FunctionLit = "func" Signature Block .
2655
2656 Expression*
2657 Parse::function_lit()
2658 {
2659   source_location location = this->location();
2660   go_assert(this->peek_token()->is_keyword(KEYWORD_FUNC));
2661   this->advance_token();
2662
2663   Enclosing_vars hold_enclosing_vars;
2664   hold_enclosing_vars.swap(this->enclosing_vars_);
2665
2666   Function_type* type = this->signature(NULL, location);
2667   if (type == NULL)
2668     type = Type::make_function_type(NULL, NULL, NULL, location);
2669
2670   // For a function literal, the next token must be a '{'.  If we
2671   // don't see that, then we may have a type expression.
2672   if (!this->peek_token()->is_op(OPERATOR_LCURLY))
2673     return Expression::make_type(type, location);
2674
2675   Bc_stack* hold_break_stack = this->break_stack_;
2676   Bc_stack* hold_continue_stack = this->continue_stack_;
2677   this->break_stack_ = NULL;
2678   this->continue_stack_ = NULL;
2679
2680   Named_object* no = this->gogo_->start_function("", type, true, location);
2681
2682   source_location end_loc = this->block();
2683
2684   this->gogo_->finish_function(end_loc);
2685
2686   if (this->break_stack_ != NULL)
2687     delete this->break_stack_;
2688   if (this->continue_stack_ != NULL)
2689     delete this->continue_stack_;
2690   this->break_stack_ = hold_break_stack;
2691   this->continue_stack_ = hold_continue_stack;
2692
2693   hold_enclosing_vars.swap(this->enclosing_vars_);
2694
2695   Expression* closure = this->create_closure(no, &hold_enclosing_vars,
2696                                              location);
2697
2698   return Expression::make_func_reference(no, closure, location);
2699 }
2700
2701 // Create a closure for the nested function FUNCTION.  This is based
2702 // on ENCLOSING_VARS, which is a list of all variables defined in
2703 // enclosing functions and referenced from FUNCTION.  A closure is the
2704 // address of a struct which contains the addresses of all the
2705 // referenced variables.  This returns NULL if no closure is required.
2706
2707 Expression*
2708 Parse::create_closure(Named_object* function, Enclosing_vars* enclosing_vars,
2709                       source_location location)
2710 {
2711   if (enclosing_vars->empty())
2712     return NULL;
2713
2714   // Get the variables in order by their field index.
2715
2716   size_t enclosing_var_count = enclosing_vars->size();
2717   std::vector<Enclosing_var> ev(enclosing_var_count);
2718   for (Enclosing_vars::const_iterator p = enclosing_vars->begin();
2719        p != enclosing_vars->end();
2720        ++p)
2721     ev[p->index()] = *p;
2722
2723   // Build an initializer for a composite literal of the closure's
2724   // type.
2725
2726   Named_object* enclosing_function = this->gogo_->current_function();
2727   Expression_list* initializer = new Expression_list;
2728   for (size_t i = 0; i < enclosing_var_count; ++i)
2729     {
2730       go_assert(ev[i].index() == i);
2731       Named_object* var = ev[i].var();
2732       Expression* ref;
2733       if (ev[i].in_function() == enclosing_function)
2734         ref = Expression::make_var_reference(var, location);
2735       else
2736         ref = this->enclosing_var_reference(ev[i].in_function(), var,
2737                                             location);
2738       Expression* refaddr = Expression::make_unary(OPERATOR_AND, ref,
2739                                                    location);
2740       initializer->push_back(refaddr);
2741     }
2742
2743   Named_object* closure_var = function->func_value()->closure_var();
2744   Struct_type* st = closure_var->var_value()->type()->deref()->struct_type();
2745   Expression* cv = Expression::make_struct_composite_literal(st, initializer,
2746                                                              location);
2747   return Expression::make_heap_composite(cv, location);
2748 }
2749
2750 // PrimaryExpr = Operand { Selector | Index | Slice | TypeGuard | Call } .
2751
2752 // If MAY_BE_SINK is true, this expression may be "_".
2753
2754 // If MAY_BE_COMPOSITE_LIT is true, this expression may be a composite
2755 // literal.
2756
2757 // If IS_TYPE_SWITCH is not NULL, this will recognize a type switch
2758 // guard (var := expr.("type") using the literal keyword "type").
2759
2760 Expression*
2761 Parse::primary_expr(bool may_be_sink, bool may_be_composite_lit,
2762                     bool* is_type_switch)
2763 {
2764   source_location start_loc = this->location();
2765   bool is_parenthesized = this->peek_token()->is_op(OPERATOR_LPAREN);
2766
2767   Expression* ret = this->operand(may_be_sink);
2768
2769   // An unknown name followed by a curly brace must be a composite
2770   // literal, and the unknown name must be a type.
2771   if (may_be_composite_lit
2772       && !is_parenthesized
2773       && ret->unknown_expression() != NULL
2774       && this->peek_token()->is_op(OPERATOR_LCURLY))
2775     {
2776       Named_object* no = ret->unknown_expression()->named_object();
2777       Type* type = Type::make_forward_declaration(no);
2778       ret = Expression::make_type(type, ret->location());
2779     }
2780
2781   // We handle composite literals and type casts here, as it is the
2782   // easiest way to handle types which are in parentheses, as in
2783   // "((uint))(1)".
2784   if (ret->is_type_expression())
2785     {
2786       if (this->peek_token()->is_op(OPERATOR_LCURLY))
2787         {
2788           if (is_parenthesized)
2789             error_at(start_loc,
2790                      "cannot parenthesize type in composite literal");
2791           ret = this->composite_lit(ret->type(), 0, ret->location());
2792         }
2793       else if (this->peek_token()->is_op(OPERATOR_LPAREN))
2794         {
2795           source_location loc = this->location();
2796           this->advance_token();
2797           Expression* expr = this->expression(PRECEDENCE_NORMAL, false, true,
2798                                               NULL);
2799           if (this->peek_token()->is_op(OPERATOR_ELLIPSIS))
2800             {
2801               error_at(this->location(),
2802                        "invalid use of %<...%> in type conversion");
2803               this->advance_token();
2804             }
2805           if (!this->peek_token()->is_op(OPERATOR_RPAREN))
2806             error_at(this->location(), "expected %<)%>");
2807           else
2808             this->advance_token();
2809           if (expr->is_error_expression())
2810             ret = expr;
2811           else
2812             {
2813               Type* t = ret->type();
2814               if (t->classification() == Type::TYPE_ARRAY
2815                   && t->array_type()->length() != NULL
2816                   && t->array_type()->length()->is_nil_expression())
2817                 {
2818                   error_at(ret->location(),
2819                            "invalid use of %<...%> in type conversion");
2820                   ret = Expression::make_error(loc);
2821                 }
2822               else
2823                 ret = Expression::make_cast(t, expr, loc);
2824             }
2825         }
2826     }
2827
2828   while (true)
2829     {
2830       const Token* token = this->peek_token();
2831       if (token->is_op(OPERATOR_LPAREN))
2832         ret = this->call(this->verify_not_sink(ret));
2833       else if (token->is_op(OPERATOR_DOT))
2834         {
2835           ret = this->selector(this->verify_not_sink(ret), is_type_switch);
2836           if (is_type_switch != NULL && *is_type_switch)
2837             break;
2838         }
2839       else if (token->is_op(OPERATOR_LSQUARE))
2840         ret = this->index(this->verify_not_sink(ret));
2841       else
2842         break;
2843     }
2844
2845   return ret;
2846 }
2847
2848 // Selector = "." identifier .
2849 // TypeGuard = "." "(" QualifiedIdent ")" .
2850
2851 // Note that Operand can expand to QualifiedIdent, which contains a
2852 // ".".  That is handled directly in operand when it sees a package
2853 // name.
2854
2855 // If IS_TYPE_SWITCH is not NULL, this will recognize a type switch
2856 // guard (var := expr.("type") using the literal keyword "type").
2857
2858 Expression*
2859 Parse::selector(Expression* left, bool* is_type_switch)
2860 {
2861   go_assert(this->peek_token()->is_op(OPERATOR_DOT));
2862   source_location location = this->location();
2863
2864   const Token* token = this->advance_token();
2865   if (token->is_identifier())
2866     {
2867       // This could be a field in a struct, or a method in an
2868       // interface, or a method associated with a type.  We can't know
2869       // which until we have seen all the types.
2870       std::string name =
2871         this->gogo_->pack_hidden_name(token->identifier(),
2872                                       token->is_identifier_exported());
2873       if (token->identifier() == "_")
2874         {
2875           error_at(this->location(), "invalid use of %<_%>");
2876           name = this->gogo_->pack_hidden_name("blank", false);
2877         }
2878       this->advance_token();
2879       return Expression::make_selector(left, name, location);
2880     }
2881   else if (token->is_op(OPERATOR_LPAREN))
2882     {
2883       this->advance_token();
2884       Type* type = NULL;
2885       if (!this->peek_token()->is_keyword(KEYWORD_TYPE))
2886         type = this->type();
2887       else
2888         {
2889           if (is_type_switch != NULL)
2890             *is_type_switch = true;
2891           else
2892             {
2893               error_at(this->location(),
2894                        "use of %<.(type)%> outside type switch");
2895               type = Type::make_error_type();
2896             }
2897           this->advance_token();
2898         }
2899       if (!this->peek_token()->is_op(OPERATOR_RPAREN))
2900         error_at(this->location(), "missing %<)%>");
2901       else
2902         this->advance_token();
2903       if (is_type_switch != NULL && *is_type_switch)
2904         return left;
2905       return Expression::make_type_guard(left, type, location);
2906     }
2907   else
2908     {
2909       error_at(this->location(), "expected identifier or %<(%>");
2910       return left;
2911     }
2912 }
2913
2914 // Index          = "[" Expression "]" .
2915 // Slice          = "[" Expression ":" [ Expression ] "]" .
2916
2917 Expression*
2918 Parse::index(Expression* expr)
2919 {
2920   source_location location = this->location();
2921   go_assert(this->peek_token()->is_op(OPERATOR_LSQUARE));
2922   this->advance_token();
2923
2924   Expression* start;
2925   if (!this->peek_token()->is_op(OPERATOR_COLON))
2926     start = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
2927   else
2928     {
2929       mpz_t zero;
2930       mpz_init_set_ui(zero, 0);
2931       start = Expression::make_integer(&zero, NULL, location);
2932       mpz_clear(zero);
2933     }
2934
2935   Expression* end = NULL;
2936   if (this->peek_token()->is_op(OPERATOR_COLON))
2937     {
2938       // We use nil to indicate a missing high expression.
2939       if (this->advance_token()->is_op(OPERATOR_RSQUARE))
2940         end = Expression::make_nil(this->location());
2941       else
2942         end = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
2943     }
2944   if (!this->peek_token()->is_op(OPERATOR_RSQUARE))
2945     error_at(this->location(), "missing %<]%>");
2946   else
2947     this->advance_token();
2948   return Expression::make_index(expr, start, end, location);
2949 }
2950
2951 // Call           = "(" [ ArgumentList [ "," ] ] ")" .
2952 // ArgumentList   = ExpressionList [ "..." ] .
2953
2954 Expression*
2955 Parse::call(Expression* func)
2956 {
2957   go_assert(this->peek_token()->is_op(OPERATOR_LPAREN));
2958   Expression_list* args = NULL;
2959   bool is_varargs = false;
2960   const Token* token = this->advance_token();
2961   if (!token->is_op(OPERATOR_RPAREN))
2962     {
2963       args = this->expression_list(NULL, false);
2964       token = this->peek_token();
2965       if (token->is_op(OPERATOR_ELLIPSIS))
2966         {
2967           is_varargs = true;
2968           token = this->advance_token();
2969         }
2970     }
2971   if (token->is_op(OPERATOR_COMMA))
2972     token = this->advance_token();
2973   if (!token->is_op(OPERATOR_RPAREN))
2974     error_at(this->location(), "missing %<)%>");
2975   else
2976     this->advance_token();
2977   if (func->is_error_expression())
2978     return func;
2979   return Expression::make_call(func, args, is_varargs, func->location());
2980 }
2981
2982 // Return an expression for a single unqualified identifier.
2983
2984 Expression*
2985 Parse::id_to_expression(const std::string& name, source_location location)
2986 {
2987   Named_object* in_function;
2988   Named_object* named_object = this->gogo_->lookup(name, &in_function);
2989   if (named_object == NULL)
2990     named_object = this->gogo_->add_unknown_name(name, location);
2991
2992   if (in_function != NULL
2993       && in_function != this->gogo_->current_function()
2994       && (named_object->is_variable() || named_object->is_result_variable()))
2995     return this->enclosing_var_reference(in_function, named_object,
2996                                          location);
2997
2998   switch (named_object->classification())
2999     {
3000     case Named_object::NAMED_OBJECT_CONST:
3001       return Expression::make_const_reference(named_object, location);
3002     case Named_object::NAMED_OBJECT_VAR:
3003     case Named_object::NAMED_OBJECT_RESULT_VAR:
3004       return Expression::make_var_reference(named_object, location);
3005     case Named_object::NAMED_OBJECT_SINK:
3006       return Expression::make_sink(location);
3007     case Named_object::NAMED_OBJECT_FUNC:
3008     case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
3009       return Expression::make_func_reference(named_object, NULL, location);
3010     case Named_object::NAMED_OBJECT_UNKNOWN:
3011       return Expression::make_unknown_reference(named_object, location);
3012     case Named_object::NAMED_OBJECT_PACKAGE:
3013     case Named_object::NAMED_OBJECT_TYPE:
3014     case Named_object::NAMED_OBJECT_TYPE_DECLARATION:
3015       // These cases can arise for a field name in a composite
3016       // literal.
3017       return Expression::make_unknown_reference(named_object, location);
3018     default:
3019       error_at(this->location(), "unexpected type of identifier");
3020       return Expression::make_error(location);
3021     }
3022 }
3023
3024 // Expression = UnaryExpr { binary_op Expression } .
3025
3026 // PRECEDENCE is the precedence of the current operator.
3027
3028 // If MAY_BE_SINK is true, this expression may be "_".
3029
3030 // If MAY_BE_COMPOSITE_LIT is true, this expression may be a composite
3031 // literal.
3032
3033 // If IS_TYPE_SWITCH is not NULL, this will recognize a type switch
3034 // guard (var := expr.("type") using the literal keyword "type").
3035
3036 Expression*
3037 Parse::expression(Precedence precedence, bool may_be_sink,
3038                   bool may_be_composite_lit, bool* is_type_switch)
3039 {
3040   Expression* left = this->unary_expr(may_be_sink, may_be_composite_lit,
3041                                       is_type_switch);
3042
3043   while (true)
3044     {
3045       if (is_type_switch != NULL && *is_type_switch)
3046         return left;
3047
3048       const Token* token = this->peek_token();
3049       if (token->classification() != Token::TOKEN_OPERATOR)
3050         {
3051           // Not a binary_op.
3052           return left;
3053         }
3054
3055       Precedence right_precedence;
3056       switch (token->op())
3057         {
3058         case OPERATOR_OROR:
3059           right_precedence = PRECEDENCE_OROR;
3060           break;
3061         case OPERATOR_ANDAND:
3062           right_precedence = PRECEDENCE_ANDAND;
3063           break;
3064         case OPERATOR_EQEQ:
3065         case OPERATOR_NOTEQ:
3066         case OPERATOR_LT:
3067         case OPERATOR_LE:
3068         case OPERATOR_GT:
3069         case OPERATOR_GE:
3070           right_precedence = PRECEDENCE_RELOP;
3071           break;
3072         case OPERATOR_PLUS:
3073         case OPERATOR_MINUS:
3074         case OPERATOR_OR:
3075         case OPERATOR_XOR:
3076           right_precedence = PRECEDENCE_ADDOP;
3077           break;
3078         case OPERATOR_MULT:
3079         case OPERATOR_DIV:
3080         case OPERATOR_MOD:
3081         case OPERATOR_LSHIFT:
3082         case OPERATOR_RSHIFT:
3083         case OPERATOR_AND:
3084         case OPERATOR_BITCLEAR:
3085           right_precedence = PRECEDENCE_MULOP;
3086           break;
3087         default:
3088           right_precedence = PRECEDENCE_INVALID;
3089           break;
3090         }
3091
3092       if (right_precedence == PRECEDENCE_INVALID)
3093         {
3094           // Not a binary_op.
3095           return left;
3096         }
3097
3098       Operator op = token->op();
3099       source_location binop_location = token->location();
3100
3101       if (precedence >= right_precedence)
3102         {
3103           // We've already seen A * B, and we see + C.  We want to
3104           // return so that A * B becomes a group.
3105           return left;
3106         }
3107
3108       this->advance_token();
3109
3110       left = this->verify_not_sink(left);
3111       Expression* right = this->expression(right_precedence, false,
3112                                            may_be_composite_lit,
3113                                            NULL);
3114       left = Expression::make_binary(op, left, right, binop_location);
3115     }
3116 }
3117
3118 bool
3119 Parse::expression_may_start_here()
3120 {
3121   const Token* token = this->peek_token();
3122   switch (token->classification())
3123     {
3124     case Token::TOKEN_INVALID:
3125     case Token::TOKEN_EOF:
3126       return false;
3127     case Token::TOKEN_KEYWORD:
3128       switch (token->keyword())
3129         {
3130         case KEYWORD_CHAN:
3131         case KEYWORD_FUNC:
3132         case KEYWORD_MAP:
3133         case KEYWORD_STRUCT:
3134         case KEYWORD_INTERFACE:
3135           return true;
3136         default:
3137           return false;
3138         }
3139     case Token::TOKEN_IDENTIFIER:
3140       return true;
3141     case Token::TOKEN_STRING:
3142       return true;
3143     case Token::TOKEN_OPERATOR:
3144       switch (token->op())
3145         {
3146         case OPERATOR_PLUS:
3147         case OPERATOR_MINUS:
3148         case OPERATOR_NOT:
3149         case OPERATOR_XOR:
3150         case OPERATOR_MULT:
3151         case OPERATOR_CHANOP:
3152         case OPERATOR_AND:
3153         case OPERATOR_LPAREN:
3154         case OPERATOR_LSQUARE:
3155           return true;
3156         default:
3157           return false;
3158         }
3159     case Token::TOKEN_INTEGER:
3160     case Token::TOKEN_FLOAT:
3161     case Token::TOKEN_IMAGINARY:
3162       return true;
3163     default:
3164       go_unreachable();
3165     }
3166 }
3167
3168 // UnaryExpr = unary_op UnaryExpr | PrimaryExpr .
3169
3170 // If MAY_BE_SINK is true, this expression may be "_".
3171
3172 // If MAY_BE_COMPOSITE_LIT is true, this expression may be a composite
3173 // literal.
3174
3175 // If IS_TYPE_SWITCH is not NULL, this will recognize a type switch
3176 // guard (var := expr.("type") using the literal keyword "type").
3177
3178 Expression*
3179 Parse::unary_expr(bool may_be_sink, bool may_be_composite_lit,
3180                   bool* is_type_switch)
3181 {
3182   const Token* token = this->peek_token();
3183   if (token->is_op(OPERATOR_PLUS)
3184       || token->is_op(OPERATOR_MINUS)
3185       || token->is_op(OPERATOR_NOT)
3186       || token->is_op(OPERATOR_XOR)
3187       || token->is_op(OPERATOR_CHANOP)
3188       || token->is_op(OPERATOR_MULT)
3189       || token->is_op(OPERATOR_AND))
3190     {
3191       source_location location = token->location();
3192       Operator op = token->op();
3193       this->advance_token();
3194
3195       if (op == OPERATOR_CHANOP
3196           && this->peek_token()->is_keyword(KEYWORD_CHAN))
3197         {
3198           // This is "<- chan" which must be the start of a type.
3199           this->unget_token(Token::make_operator_token(op, location));
3200           return Expression::make_type(this->type(), location);
3201         }
3202
3203       Expression* expr = this->unary_expr(false, may_be_composite_lit, NULL);
3204       if (expr->is_error_expression())
3205         ;
3206       else if (op == OPERATOR_MULT && expr->is_type_expression())
3207         expr = Expression::make_type(Type::make_pointer_type(expr->type()),
3208                                      location);
3209       else if (op == OPERATOR_AND && expr->is_composite_literal())
3210         expr = Expression::make_heap_composite(expr, location);
3211       else if (op != OPERATOR_CHANOP)
3212         expr = Expression::make_unary(op, expr, location);
3213       else
3214         expr = Expression::make_receive(expr, location);
3215       return expr;
3216     }
3217   else
3218     return this->primary_expr(may_be_sink, may_be_composite_lit,
3219                               is_type_switch);
3220 }
3221
3222 // Statement =
3223 //      Declaration | LabeledStmt | SimpleStmt |
3224 //      GoStmt | ReturnStmt | BreakStmt | ContinueStmt | GotoStmt |
3225 //      FallthroughStmt | Block | IfStmt | SwitchStmt | SelectStmt | ForStmt |
3226 //      DeferStmt .
3227
3228 // LABEL is the label of this statement if it has one.
3229
3230 void
3231 Parse::statement(Label* label)
3232 {
3233   const Token* token = this->peek_token();
3234   switch (token->classification())
3235     {
3236     case Token::TOKEN_KEYWORD:
3237       {
3238         switch (token->keyword())
3239           {
3240           case KEYWORD_CONST:
3241           case KEYWORD_TYPE:
3242           case KEYWORD_VAR:
3243             this->declaration();
3244             break;
3245           case KEYWORD_FUNC:
3246           case KEYWORD_MAP:
3247           case KEYWORD_STRUCT:
3248           case KEYWORD_INTERFACE:
3249             this->simple_stat(true, NULL, NULL, NULL);
3250             break;
3251           case KEYWORD_GO:
3252           case KEYWORD_DEFER:
3253             this->go_or_defer_stat();
3254             break;
3255           case KEYWORD_RETURN:
3256             this->return_stat();
3257             break;
3258           case KEYWORD_BREAK:
3259             this->break_stat();
3260             break;
3261           case KEYWORD_CONTINUE:
3262             this->continue_stat();
3263             break;
3264           case KEYWORD_GOTO:
3265             this->goto_stat();
3266             break;
3267           case KEYWORD_IF:
3268             this->if_stat();
3269             break;
3270           case KEYWORD_SWITCH:
3271             this->switch_stat(label);
3272             break;
3273           case KEYWORD_SELECT:
3274             this->select_stat(label);
3275             break;
3276           case KEYWORD_FOR:
3277             this->for_stat(label);
3278             break;
3279           default:
3280             error_at(this->location(), "expected statement");
3281             this->advance_token();
3282             break;
3283           }
3284       }
3285       break;
3286
3287     case Token::TOKEN_IDENTIFIER:
3288       {
3289         std::string identifier = token->identifier();
3290         bool is_exported = token->is_identifier_exported();
3291         source_location location = token->location();
3292         if (this->advance_token()->is_op(OPERATOR_COLON))
3293           {
3294             this->advance_token();
3295             this->labeled_stmt(identifier, location);
3296           }
3297         else
3298           {
3299             this->unget_token(Token::make_identifier_token(identifier,
3300                                                            is_exported,
3301                                                            location));
3302             this->simple_stat(true, NULL, NULL, NULL);
3303           }
3304       }
3305       break;
3306
3307     case Token::TOKEN_OPERATOR:
3308       if (token->is_op(OPERATOR_LCURLY))
3309         {
3310           source_location location = token->location();
3311           this->gogo_->start_block(location);
3312           source_location end_loc = this->block();
3313           this->gogo_->add_block(this->gogo_->finish_block(end_loc),
3314                                  location);
3315         }
3316       else if (!token->is_op(OPERATOR_SEMICOLON))
3317         this->simple_stat(true, NULL, NULL, NULL);
3318       break;
3319
3320     case Token::TOKEN_STRING:
3321     case Token::TOKEN_INTEGER:
3322     case Token::TOKEN_FLOAT:
3323     case Token::TOKEN_IMAGINARY:
3324       this->simple_stat(true, NULL, NULL, NULL);
3325       break;
3326
3327     default:
3328       error_at(this->location(), "expected statement");
3329       this->advance_token();
3330       break;
3331     }
3332 }
3333
3334 bool
3335 Parse::statement_may_start_here()
3336 {
3337   const Token* token = this->peek_token();
3338   switch (token->classification())
3339     {
3340     case Token::TOKEN_KEYWORD:
3341       {
3342         switch (token->keyword())
3343           {
3344           case KEYWORD_CONST:
3345           case KEYWORD_TYPE:
3346           case KEYWORD_VAR:
3347           case KEYWORD_FUNC:
3348           case KEYWORD_MAP:
3349           case KEYWORD_STRUCT:
3350           case KEYWORD_INTERFACE:
3351           case KEYWORD_GO:
3352           case KEYWORD_DEFER:
3353           case KEYWORD_RETURN:
3354           case KEYWORD_BREAK:
3355           case KEYWORD_CONTINUE:
3356           case KEYWORD_GOTO:
3357           case KEYWORD_IF:
3358           case KEYWORD_SWITCH:
3359           case KEYWORD_SELECT:
3360           case KEYWORD_FOR:
3361             return true;
3362
3363           default:
3364             return false;
3365           }
3366       }
3367       break;
3368
3369     case Token::TOKEN_IDENTIFIER:
3370       return true;
3371
3372     case Token::TOKEN_OPERATOR:
3373       if (token->is_op(OPERATOR_LCURLY)
3374           || token->is_op(OPERATOR_SEMICOLON))
3375         return true;
3376       else
3377         return this->expression_may_start_here();
3378
3379     case Token::TOKEN_STRING:
3380     case Token::TOKEN_INTEGER:
3381     case Token::TOKEN_FLOAT:
3382     case Token::TOKEN_IMAGINARY:
3383       return true;
3384
3385     default:
3386       return false;
3387     }
3388 }
3389
3390 // LabeledStmt = Label ":" Statement .
3391 // Label       = identifier .
3392
3393 void
3394 Parse::labeled_stmt(const std::string& label_name, source_location location)
3395 {
3396   Label* label = this->gogo_->add_label_definition(label_name, location);
3397
3398   if (this->peek_token()->is_op(OPERATOR_RCURLY))
3399     {
3400       // This is a label at the end of a block.  A program is
3401       // permitted to omit a semicolon here.
3402       return;
3403     }
3404
3405   if (!this->statement_may_start_here())
3406     {
3407       // Mark the label as used to avoid a useless error about an
3408       // unused label.
3409       label->set_is_used();
3410
3411       error_at(location, "missing statement after label");
3412       this->unget_token(Token::make_operator_token(OPERATOR_SEMICOLON,
3413                                                    location));
3414       return;
3415     }
3416
3417   this->statement(label);
3418 }