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         ok = false;
 340       else
 341         named_object = this->gogo_->add_unknown_name(name, location);
 342     }
 343   else if (named_object->is_type())
 344     {
 345       if (!named_object->type_value()->is_visible())
 346         ok = false;
 347     }
 348   else if (named_object->is_unknown() || named_object->is_type_declaration())
 349     ;
 350   else
 351     ok = false;
 352
 353   if (!ok)
 354     {
 355       if (issue_error)
 356         error_at(location, "expected type");
 357       return Type::make_error_type();
 358     }
 359
 360   if (named_object->is_type())
 361     return named_object->type_value();
 362   else if (named_object->is_unknown() || named_object->is_type_declaration())
 363     return Type::make_forward_declaration(named_object);
 364   else
 365     go_unreachable();
 366 }
 367
 368 // ArrayType = "[" [ ArrayLength ] "]" ElementType .
 369 // ArrayLength = Expression .
 370 // ElementType = CompleteType .
 371
 372 Type*
 373 Parse::array_type(bool may_use_ellipsis)
 374 {
 375   go_assert(this->peek_token()->is_op(OPERATOR_LSQUARE));
 376   const Token* token = this->advance_token();
 377
 378   Expression* length = NULL;
 379   if (token->is_op(OPERATOR_RSQUARE))
 380     this->advance_token();
 381   else
 382     {
 383       if (!token->is_op(OPERATOR_ELLIPSIS))
 384         length = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
 385       else if (may_use_ellipsis)
 386         {
 387           // An ellipsis is used in composite literals to represent a
 388           // fixed array of the size of the number of elements.  We
 389           // use a length of nil to represent this, and change the
 390           // length when parsing the composite literal.
 391           length = Expression::make_nil(this->location());
 392           this->advance_token();
 393         }
 394       else
 395         {
 396           error_at(this->location(),
 397                    "use of %<[...]%> outside of array literal");
 398           length = Expression::make_error(this->location());
 399           this->advance_token();
 400         }
 401       if (!this->peek_token()->is_op(OPERATOR_RSQUARE))
 402         {
 403           error_at(this->location(), "expected %<]%>");
 404           return Type::make_error_type();
 405         }
 406       this->advance_token();
 407     }
 408
 409   Type* element_type = this->type();
 410
 411   return Type::make_array_type(element_type, length);
 412 }
 413
 414 // MapType = "map" "[" KeyType "]" ValueType .
 415 // KeyType = CompleteType .
 416 // ValueType = CompleteType .
 417
 418 Type*
 419 Parse::map_type()
 420 {
 421   source_location location = this->location();
 422   go_assert(this->peek_token()->is_keyword(KEYWORD_MAP));
 423   if (!this->advance_token()->is_op(OPERATOR_LSQUARE))
 424     {
 425       error_at(this->location(), "expected %<[%>");
 426       return Type::make_error_type();
 427     }
 428   this->advance_token();
 429
 430   Type* key_type = this->type();
 431
 432   if (!this->peek_token()->is_op(OPERATOR_RSQUARE))
 433     {
 434       error_at(this->location(), "expected %<]%>");
 435       return Type::make_error_type();
 436     }
 437   this->advance_token();
 438
 439   Type* value_type = this->type();
 440
 441   if (key_type->is_error_type() || value_type->is_error_type())
 442     return Type::make_error_type();
 443
 444   return Type::make_map_type(key_type, value_type, location);
 445 }
 446
 447 // StructType     = "struct" "{" { FieldDecl ";" } "}" .
 448
 449 Type*
 450 Parse::struct_type()
 451 {
 452   go_assert(this->peek_token()->is_keyword(KEYWORD_STRUCT));
 453   source_location location = this->location();
 454   if (!this->advance_token()->is_op(OPERATOR_LCURLY))
 455     {
 456       source_location token_loc = this->location();
 457       if (this->peek_token()->is_op(OPERATOR_SEMICOLON)
 458           && this->advance_token()->is_op(OPERATOR_LCURLY))
 459         error_at(token_loc, "unexpected semicolon or newline before %<{%>");
 460       else
 461         {
 462           error_at(this->location(), "expected %<{%>");
 463           return Type::make_error_type();
 464         }
 465     }
 466   this->advance_token();
 467
 468   Struct_field_list* sfl = new Struct_field_list;
 469   while (!this->peek_token()->is_op(OPERATOR_RCURLY))
 470     {
 471       this->field_decl(sfl);
 472       if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
 473         this->advance_token();
 474       else if (!this->peek_token()->is_op(OPERATOR_RCURLY))
 475         {
 476           error_at(this->location(), "expected %<;%> or %<}%> or newline");
 477           if (!this->skip_past_error(OPERATOR_RCURLY))
 478             return Type::make_error_type();
 479         }
 480     }
 481   this->advance_token();
 482
 483   for (Struct_field_list::const_iterator pi = sfl->begin();
 484        pi != sfl->end();
 485        ++pi)
 486     {
 487       if (pi->type()->is_error_type())
 488         return pi->type();
 489       for (Struct_field_list::const_iterator pj = pi + 1;
 490            pj != sfl->end();
 491            ++pj)
 492         {
 493           if (pi->field_name() == pj->field_name()
 494               && !Gogo::is_sink_name(pi->field_name()))
 495             error_at(pi->location(), "duplicate field name %<%s%>",
 496                      Gogo::message_name(pi->field_name()).c_str());
 497         }
 498     }
 499
 500   return Type::make_struct_type(sfl, location);
 501 }
 502
 503 // FieldDecl = (IdentifierList CompleteType | TypeName) [ Tag ] .
 504 // Tag = string_lit .
 505
 506 void
 507 Parse::field_decl(Struct_field_list* sfl)
 508 {
 509   const Token* token = this->peek_token();
 510   source_location location = token->location();
 511   bool is_anonymous;
 512   bool is_anonymous_pointer;
 513   if (token->is_op(OPERATOR_MULT))
 514     {
 515       is_anonymous = true;
 516       is_anonymous_pointer = true;
 517     }
 518   else if (token->is_identifier())
 519     {
 520       std::string id = token->identifier();
 521       bool is_id_exported = token->is_identifier_exported();
 522       source_location id_location = token->location();
 523       token = this->advance_token();
 524       is_anonymous = (token->is_op(OPERATOR_SEMICOLON)
 525                       || token->is_op(OPERATOR_RCURLY)
 526                       || token->is_op(OPERATOR_DOT)
 527                       || token->is_string());
 528       is_anonymous_pointer = false;
 529       this->unget_token(Token::make_identifier_token(id, is_id_exported,
 530                                                      id_location));
 531     }
 532   else
 533     {
 534       error_at(this->location(), "expected field name");
 535       while (!token->is_op(OPERATOR_SEMICOLON)
 536              && !token->is_op(OPERATOR_RCURLY)
 537              && !token->is_eof())
 538         token = this->advance_token();
 539       return;
 540     }
 541
 542   if (is_anonymous)
 543     {
 544       if (is_anonymous_pointer)
 545         {
 546           this->advance_token();
 547           if (!this->peek_token()->is_identifier())
 548             {
 549               error_at(this->location(), "expected field name");
 550               while (!token->is_op(OPERATOR_SEMICOLON)
 551                      && !token->is_op(OPERATOR_RCURLY)
 552                      && !token->is_eof())
 553                 token = this->advance_token();
 554               return;
 555             }
 556         }
 557       Type* type = this->type_name(true);
 558
 559       std::string tag;
 560       if (this->peek_token()->is_string())
 561         {
 562           tag = this->peek_token()->string_value();
 563           this->advance_token();
 564         }
 565
 566       if (!type->is_error_type())
 567         {
 568           if (is_anonymous_pointer)
 569             type = Type::make_pointer_type(type);
 570           sfl->push_back(Struct_field(Typed_identifier("", type, location)));
 571           if (!tag.empty())
 572             sfl->back().set_tag(tag);
 573         }
 574     }
 575   else
 576     {
 577       Typed_identifier_list til;
 578       while (true)
 579         {
 580           token = this->peek_token();
 581           if (!token->is_identifier())
 582             {
 583               error_at(this->location(), "expected identifier");
 584               return;
 585             }
 586           std::string name =
 587             this->gogo_->pack_hidden_name(token->identifier(),
 588                                           token->is_identifier_exported());
 589           til.push_back(Typed_identifier(name, NULL, token->location()));
 590           if (!this->advance_token()->is_op(OPERATOR_COMMA))
 591             break;
 592           this->advance_token();
 593         }
 594
 595       Type* type = this->type();
 596
 597       std::string tag;
 598       if (this->peek_token()->is_string())
 599         {
 600           tag = this->peek_token()->string_value();
 601           this->advance_token();
 602         }
 603
 604       for (Typed_identifier_list::iterator p = til.begin();
 605            p != til.end();
 606            ++p)
 607         {
 608           p->set_type(type);
 609           sfl->push_back(Struct_field(*p));
 610           if (!tag.empty())
 611             sfl->back().set_tag(tag);
 612         }
 613     }
 614 }
 615
 616 // PointerType = "*" Type .
 617
 618 Type*
 619 Parse::pointer_type()
 620 {
 621   go_assert(this->peek_token()->is_op(OPERATOR_MULT));
 622   this->advance_token();
 623   Type* type = this->type();
 624   if (type->is_error_type())
 625     return type;
 626   return Type::make_pointer_type(type);
 627 }
 628
 629 // ChannelType   = Channel | SendChannel | RecvChannel .
 630 // Channel       = "chan" ElementType .
 631 // SendChannel   = "chan" "<-" ElementType .
 632 // RecvChannel   = "<-" "chan" ElementType .
 633
 634 Type*
 635 Parse::channel_type()
 636 {
 637   const Token* token = this->peek_token();
 638   bool send = true;
 639   bool receive = true;
 640   if (token->is_op(OPERATOR_CHANOP))
 641     {
 642       if (!this->advance_token()->is_keyword(KEYWORD_CHAN))
 643         {
 644           error_at(this->location(), "expected %<chan%>");
 645           return Type::make_error_type();
 646         }
 647       send = false;
 648       this->advance_token();
 649     }
 650   else
 651     {
 652       go_assert(token->is_keyword(KEYWORD_CHAN));
 653       if (this->advance_token()->is_op(OPERATOR_CHANOP))
 654         {
 655           receive = false;
 656           this->advance_token();
 657         }
 658     }
 659
 660   // Better error messages for the common error of omitting the
 661   // channel element type.
 662   if (!this->type_may_start_here())
 663     {
 664       token = this->peek_token();
 665       if (token->is_op(OPERATOR_RCURLY))
 666         error_at(this->location(), "unexpected %<}%> in channel type");
 667       else if (token->is_op(OPERATOR_RPAREN))
 668         error_at(this->location(), "unexpected %<)%> in channel type");
 669       else if (token->is_op(OPERATOR_COMMA))
 670         error_at(this->location(), "unexpected comma in channel type");
 671       else
 672         error_at(this->location(), "expected channel element type");
 673       return Type::make_error_type();
 674     }
 675
 676   Type* element_type = this->type();
 677   return Type::make_channel_type(send, receive, element_type);
 678 }
 679
 680 // Signature      = Parameters [ Result ] .
 681
 682 // RECEIVER is the receiver if there is one, or NULL.  LOCATION is the
 683 // location of the start of the type.
 684
 685 // This returns NULL on a parse error.
 686
 687 Function_type*
 688 Parse::signature(Typed_identifier* receiver, source_location location)
 689 {
 690   bool is_varargs = false;
 691   Typed_identifier_list* params;
 692   bool params_ok = this->parameters(&params, &is_varargs);
 693
 694   Typed_identifier_list* result = NULL;
 695   if (this->peek_token()->is_op(OPERATOR_LPAREN)
 696       || this->type_may_start_here())
 697     {
 698       if (!this->result(&result))
 699         return NULL;
 700     }
 701
 702   if (!params_ok)
 703     return NULL;
 704
 705   Function_type* ret = Type::make_function_type(receiver, params, result,
 706                                                 location);
 707   if (is_varargs)
 708     ret->set_is_varargs();
 709   return ret;
 710 }
 711
 712 // Parameters     = "(" [ ParameterList [ "," ] ] ")" .
 713
 714 // This returns false on a parse error.
 715
 716 bool
 717 Parse::parameters(Typed_identifier_list** pparams, bool* is_varargs)
 718 {
 719   *pparams = NULL;
 720
 721   if (!this->peek_token()->is_op(OPERATOR_LPAREN))
 722     {
 723       error_at(this->location(), "expected %<(%>");
 724       return false;
 725     }
 726
 727   Typed_identifier_list* params = NULL;
 728   bool saw_error = false;
 729
 730   const Token* token = this->advance_token();
 731   if (!token->is_op(OPERATOR_RPAREN))
 732     {
 733       params = this->parameter_list(is_varargs);
 734       if (params == NULL)
 735         saw_error = true;
 736       token = this->peek_token();
 737     }
 738
 739   // The optional trailing comma is picked up in parameter_list.
 740
 741   if (!token->is_op(OPERATOR_RPAREN))
 742     error_at(this->location(), "expected %<)%>");
 743   else
 744     this->advance_token();
 745
 746   if (saw_error)
 747     return false;
 748
 749   *pparams = params;
 750   return true;
 751 }
 752
 753 // ParameterList  = ParameterDecl { "," ParameterDecl } .
 754
 755 // This sets *IS_VARARGS if the list ends with an ellipsis.
 756 // IS_VARARGS will be NULL if varargs are not permitted.
 757
 758 // We pick up an optional trailing comma.
 759
 760 // This returns NULL if some error is seen.
 761
 762 Typed_identifier_list*
 763 Parse::parameter_list(bool* is_varargs)
 764 {
 765   source_location location = this->location();
 766   Typed_identifier_list* ret = new Typed_identifier_list();
 767
 768   bool saw_error = false;
 769
 770   // If we see an identifier and then a comma, then we don't know
 771   // whether we are looking at a list of identifiers followed by a
 772   // type, or a list of types given by name.  We have to do an
 773   // arbitrary lookahead to figure it out.
 774
 775   bool parameters_have_names;
 776   const Token* token = this->peek_token();
 777   if (!token->is_identifier())
 778     {
 779       // This must be a type which starts with something like '*'.
 780       parameters_have_names = false;
 781     }
 782   else
 783     {
 784       std::string name = token->identifier();
 785       bool is_exported = token->is_identifier_exported();
 786       source_location location = token->location();
 787       token = this->advance_token();
 788       if (!token->is_op(OPERATOR_COMMA))
 789         {
 790           if (token->is_op(OPERATOR_DOT))
 791             {
 792               // This is a qualified identifier, which must turn out
 793               // to be a type.
 794               parameters_have_names = false;
 795             }
 796           else if (token->is_op(OPERATOR_RPAREN))
 797             {
 798               // A single identifier followed by a parenthesis must be
 799               // a type name.
 800               parameters_have_names = false;
 801             }
 802           else
 803             {
 804               // An identifier followed by something other than a
 805               // comma or a dot or a right parenthesis must be a
 806               // parameter name followed by a type.
 807               parameters_have_names = true;
 808             }
 809
 810           this->unget_token(Token::make_identifier_token(name, is_exported,
 811                                                          location));
 812         }
 813       else
 814         {
 815           // An identifier followed by a comma may be the first in a
 816           // list of parameter names followed by a type, or it may be
 817           // the first in a list of types without parameter names.  To
 818           // find out we gather as many identifiers separated by
 819           // commas as we can.
 820           std::string id_name = this->gogo_->pack_hidden_name(name,
 821                                                               is_exported);
 822           ret->push_back(Typed_identifier(id_name, NULL, location));
 823           bool just_saw_comma = true;
 824           while (this->advance_token()->is_identifier())
 825             {
 826               name = this->peek_token()->identifier();
 827               is_exported = this->peek_token()->is_identifier_exported();
 828               location = this->peek_token()->location();
 829               id_name = this->gogo_->pack_hidden_name(name, is_exported);
 830               ret->push_back(Typed_identifier(id_name, NULL, location));
 831               if (!this->advance_token()->is_op(OPERATOR_COMMA))
 832                 {
 833                   just_saw_comma = false;
 834                   break;
 835                 }
 836             }
 837
 838           if (just_saw_comma)
 839             {
 840               // We saw ID1 "," ID2 "," followed by something which
 841               // was not an identifier.  We must be seeing the start
 842               // of a type, and ID1 and ID2 must be types, and the
 843               // parameters don't have names.
 844               parameters_have_names = false;
 845             }
 846           else if (this->peek_token()->is_op(OPERATOR_RPAREN))
 847             {
 848               // We saw ID1 "," ID2 ")".  ID1 and ID2 must be types,
 849               // and the parameters don't have names.
 850               parameters_have_names = false;
 851             }
 852           else if (this->peek_token()->is_op(OPERATOR_DOT))
 853             {
 854               // We saw ID1 "," ID2 ".".  ID2 must be a package name,
 855               // ID1 must be a type, and the parameters don't have
 856               // names.
 857               parameters_have_names = false;
 858               this->unget_token(Token::make_identifier_token(name, is_exported,
 859                                                              location));
 860               ret->pop_back();
 861               just_saw_comma = true;
 862             }
 863           else
 864             {
 865               // We saw ID1 "," ID2 followed by something other than
 866               // ",", ".", or ")".  We must be looking at the start of
 867               // a type, and ID1 and ID2 must be parameter names.
 868               parameters_have_names = true;
 869             }
 870
 871           if (parameters_have_names)
 872             {
 873               go_assert(!just_saw_comma);
 874               // We have just seen ID1, ID2 xxx.
 875               Type* type;
 876               if (!this->peek_token()->is_op(OPERATOR_ELLIPSIS))
 877                 type = this->type();
 878               else
 879                 {
 880                   error_at(this->location(), "%<...%> only permits one name");
 881                   saw_error = true;
 882                   this->advance_token();
 883                   type = this->type();
 884                 }
 885               for (size_t i = 0; i < ret->size(); ++i)
 886                 ret->set_type(i, type);
 887               if (!this->peek_token()->is_op(OPERATOR_COMMA))
 888                 return saw_error ? NULL : ret;
 889               if (this->advance_token()->is_op(OPERATOR_RPAREN))
 890                 return saw_error ? NULL : ret;
 891             }
 892           else
 893             {
 894               Typed_identifier_list* tret = new Typed_identifier_list();
 895               for (Typed_identifier_list::const_iterator p = ret->begin();
 896                    p != ret->end();
 897                    ++p)
 898                 {
 899                   Named_object* no = this->gogo_->lookup(p->name(), NULL);
 900                   Type* type;
 901                   if (no == NULL)
 902                     no = this->gogo_->add_unknown_name(p->name(),
 903                                                        p->location());
 904
 905                   if (no->is_type())
 906                     type = no->type_value();
 907                   else if (no->is_unknown() || no->is_type_declaration())
 908                     type = Type::make_forward_declaration(no);
 909                   else
 910                     {
 911                       error_at(p->location(), "expected %<%s%> to be a type",
 912                                Gogo::message_name(p->name()).c_str());
 913                       saw_error = true;
 914                       type = Type::make_error_type();
 915                     }
 916                   tret->push_back(Typed_identifier("", type, p->location()));
 917                 }
 918               delete ret;
 919               ret = tret;
 920               if (!just_saw_comma
 921                   || this->peek_token()->is_op(OPERATOR_RPAREN))
 922                 return saw_error ? NULL : ret;
 923             }
 924         }
 925     }
 926
 927   bool mix_error = false;
 928   this->parameter_decl(parameters_have_names, ret, is_varargs, &mix_error);
 929   while (this->peek_token()->is_op(OPERATOR_COMMA))
 930     {
 931       if (is_varargs != NULL && *is_varargs)
 932         {
 933           error_at(this->location(), "%<...%> must be last parameter");
 934           saw_error = true;
 935         }
 936       if (this->advance_token()->is_op(OPERATOR_RPAREN))
 937         break;
 938       this->parameter_decl(parameters_have_names, ret, is_varargs, &mix_error);
 939     }
 940   if (mix_error)
 941     {
 942       error_at(location, "invalid named/anonymous mix");
 943       saw_error = true;
 944     }
 945   if (saw_error)
 946     {
 947       delete ret;
 948       return NULL;
 949     }
 950   return ret;
 951 }
 952
 953 // ParameterDecl  = [ IdentifierList ] [ "..." ] Type .
 954
 955 void
 956 Parse::parameter_decl(bool parameters_have_names,
 957                       Typed_identifier_list* til,
 958                       bool* is_varargs,
 959                       bool* mix_error)
 960 {
 961   if (!parameters_have_names)
 962     {
 963       Type* type;
 964       source_location location = this->location();
 965       if (!this->peek_token()->is_identifier())
 966         {
 967           if (!this->peek_token()->is_op(OPERATOR_ELLIPSIS))
 968             type = this->type();
 969           else
 970             {
 971               if (is_varargs == NULL)
 972                 error_at(this->location(), "invalid use of %<...%>");
 973               else
 974                 *is_varargs = true;
 975               this->advance_token();
 976               if (is_varargs == NULL
 977                   && this->peek_token()->is_op(OPERATOR_RPAREN))
 978                 type = Type::make_error_type();
 979               else
 980                 {
 981                   Type* element_type = this->type();
 982                   type = Type::make_array_type(element_type, NULL);
 983                 }
 984             }
 985         }
 986       else
 987         {
 988           type = this->type_name(false);
 989           if (type->is_error_type()
 990               || (!this->peek_token()->is_op(OPERATOR_COMMA)
 991                   && !this->peek_token()->is_op(OPERATOR_RPAREN)))
 992             {
 993               *mix_error = true;
 994               while (!this->peek_token()->is_op(OPERATOR_COMMA)
 995                      && !this->peek_token()->is_op(OPERATOR_RPAREN))
 996                 this->advance_token();
 997             }
 998         }
 999       if (!type->is_error_type())
1000         til->push_back(Typed_identifier("", type, location));
1001     }
1002   else
1003     {
1004       size_t orig_count = til->size();
1005       if (this->peek_token()->is_identifier())
1006         this->identifier_list(til);
1007       else
1008         *mix_error = true;
1009       size_t new_count = til->size();
1010
1011       Type* type;
1012       if (!this->peek_token()->is_op(OPERATOR_ELLIPSIS))
1013         type = this->type();
1014       else
1015         {
1016           if (is_varargs == NULL)
1017             error_at(this->location(), "invalid use of %<...%>");
1018           else if (new_count > orig_count + 1)
1019             error_at(this->location(), "%<...%> only permits one name");
1020           else
1021             *is_varargs = true;
1022           this->advance_token();
1023           Type* element_type = this->type();
1024           type = Type::make_array_type(element_type, NULL);
1025         }
1026       for (size_t i = orig_count; i < new_count; ++i)
1027         til->set_type(i, type);
1028     }
1029 }
1030
1031 // Result         = Parameters | Type .
1032
1033 // This returns false on a parse error.
1034
1035 bool
1036 Parse::result(Typed_identifier_list** presults)
1037 {
1038   if (this->peek_token()->is_op(OPERATOR_LPAREN))
1039     return this->parameters(presults, NULL);
1040   else
1041     {
1042       source_location location = this->location();
1043       Type* type = this->type();
1044       if (type->is_error_type())
1045         {
1046           *presults = NULL;
1047           return false;
1048         }
1049       Typed_identifier_list* til = new Typed_identifier_list();
1050       til->push_back(Typed_identifier("", type, location));
1051       *presults = til;
1052       return true;
1053     }
1054 }
1055
1056 // Block = "{" [ StatementList ] "}" .
1057
1058 // Returns the location of the closing brace.
1059
1060 source_location
1061 Parse::block()
1062 {
1063   if (!this->peek_token()->is_op(OPERATOR_LCURLY))
1064     {
1065       source_location loc = this->location();
1066       if (this->peek_token()->is_op(OPERATOR_SEMICOLON)
1067           && this->advance_token()->is_op(OPERATOR_LCURLY))
1068         error_at(loc, "unexpected semicolon or newline before %<{%>");
1069       else
1070         {
1071           error_at(this->location(), "expected %<{%>");
1072           return UNKNOWN_LOCATION;
1073         }
1074     }
1075
1076   const Token* token = this->advance_token();
1077
1078   if (!token->is_op(OPERATOR_RCURLY))
1079     {
1080       this->statement_list();
1081       token = this->peek_token();
1082       if (!token->is_op(OPERATOR_RCURLY))
1083         {
1084           if (!token->is_eof() || !saw_errors())
1085             error_at(this->location(), "expected %<}%>");
1086
1087           // Skip ahead to the end of the block, in hopes of avoiding
1088           // lots of meaningless errors.
1089           source_location ret = token->location();
1090           int nest = 0;
1091           while (!token->is_eof())
1092             {
1093               if (token->is_op(OPERATOR_LCURLY))
1094                 ++nest;
1095               else if (token->is_op(OPERATOR_RCURLY))
1096                 {
1097                   --nest;
1098                   if (nest < 0)
1099                     {
1100                       this->advance_token();
1101                       break;
1102                     }
1103                 }
1104               token = this->advance_token();
1105               ret = token->location();
1106             }
1107           return ret;
1108         }
1109     }
1110
1111   source_location ret = token->location();
1112   this->advance_token();
1113   return ret;
1114 }
1115
1116 // InterfaceType      = "interface" "{" [ MethodSpecList ] "}" .
1117 // MethodSpecList     = MethodSpec { ";" MethodSpec } [ ";" ] .
1118
1119 Type*
1120 Parse::interface_type()
1121 {
1122   go_assert(this->peek_token()->is_keyword(KEYWORD_INTERFACE));
1123   source_location location = this->location();
1124
1125   if (!this->advance_token()->is_op(OPERATOR_LCURLY))
1126     {
1127       source_location token_loc = this->location();
1128       if (this->peek_token()->is_op(OPERATOR_SEMICOLON)
1129           && this->advance_token()->is_op(OPERATOR_LCURLY))
1130         error_at(token_loc, "unexpected semicolon or newline before %<{%>");
1131       else
1132         {
1133           error_at(this->location(), "expected %<{%>");
1134           return Type::make_error_type();
1135         }
1136     }
1137   this->advance_token();
1138
1139   Typed_identifier_list* methods = new Typed_identifier_list();
1140   if (!this->peek_token()->is_op(OPERATOR_RCURLY))
1141     {
1142       this->method_spec(methods);
1143       while (this->peek_token()->is_op(OPERATOR_SEMICOLON))
1144         {
1145           if (this->advance_token()->is_op(OPERATOR_RCURLY))
1146             break;
1147           this->method_spec(methods);
1148         }
1149       if (!this->peek_token()->is_op(OPERATOR_RCURLY))
1150         {
1151           error_at(this->location(), "expected %<}%>");
1152           while (!this->advance_token()->is_op(OPERATOR_RCURLY))
1153             {
1154               if (this->peek_token()->is_eof())
1155                 return Type::make_error_type();
1156             }
1157         }
1158     }
1159   this->advance_token();
1160
1161   if (methods->empty())
1162     {
1163       delete methods;
1164       methods = NULL;
1165     }
1166
1167   Interface_type* ret = Type::make_interface_type(methods, location);
1168   this->gogo_->record_interface_type(ret);
1169   return ret;
1170 }
1171
1172 // MethodSpec         = MethodName Signature | InterfaceTypeName .
1173 // MethodName         = identifier .
1174 // InterfaceTypeName  = TypeName .
1175
1176 void
1177 Parse::method_spec(Typed_identifier_list* methods)
1178 {
1179   const Token* token = this->peek_token();
1180   if (!token->is_identifier())
1181     {
1182       error_at(this->location(), "expected identifier");
1183       return;
1184     }
1185
1186   std::string name = token->identifier();
1187   bool is_exported = token->is_identifier_exported();
1188   source_location location = token->location();
1189
1190   if (this->advance_token()->is_op(OPERATOR_LPAREN))
1191     {
1192       // This is a MethodName.
1193       name = this->gogo_->pack_hidden_name(name, is_exported);
1194       Type* type = this->signature(NULL, location);
1195       if (type == NULL)
1196         return;
1197       methods->push_back(Typed_identifier(name, type, location));
1198     }
1199   else
1200     {
1201       this->unget_token(Token::make_identifier_token(name, is_exported,
1202                                                      location));
1203       Type* type = this->type_name(false);
1204       if (type->is_error_type()
1205           || (!this->peek_token()->is_op(OPERATOR_SEMICOLON)
1206               && !this->peek_token()->is_op(OPERATOR_RCURLY)))
1207         {
1208           if (this->peek_token()->is_op(OPERATOR_COMMA))
1209             error_at(this->location(),
1210                      "name list not allowed in interface type");
1211           else
1212             error_at(location, "expected signature or type name");
1213           token = this->peek_token();
1214           while (!token->is_eof()
1215                  && !token->is_op(OPERATOR_SEMICOLON)
1216                  && !token->is_op(OPERATOR_RCURLY))
1217             token = this->advance_token();
1218           return;
1219         }
1220       // This must be an interface type, but we can't check that now.
1221       // We check it and pull out the methods in
1222       // Interface_type::do_verify.
1223       methods->push_back(Typed_identifier("", type, location));
1224     }
1225 }
1226
1227 // Declaration = ConstDecl | TypeDecl | VarDecl | FunctionDecl | MethodDecl .
1228
1229 void
1230 Parse::declaration()
1231 {
1232   const Token* token = this->peek_token();
1233   if (token->is_keyword(KEYWORD_CONST))
1234     this->const_decl();
1235   else if (token->is_keyword(KEYWORD_TYPE))
1236     this->type_decl();
1237   else if (token->is_keyword(KEYWORD_VAR))
1238     this->var_decl();
1239   else if (token->is_keyword(KEYWORD_FUNC))
1240     this->function_decl();
1241   else
1242     {
1243       error_at(this->location(), "expected declaration");
1244       this->advance_token();
1245     }
1246 }
1247
1248 bool
1249 Parse::declaration_may_start_here()
1250 {
1251   const Token* token = this->peek_token();
1252   return (token->is_keyword(KEYWORD_CONST)
1253           || token->is_keyword(KEYWORD_TYPE)
1254           || token->is_keyword(KEYWORD_VAR)
1255           || token->is_keyword(KEYWORD_FUNC));
1256 }
1257
1258 // Decl<P> = P | "(" [ List<P> ] ")" .
1259
1260 void
1261 Parse::decl(void (Parse::*pfn)(void*), void* varg)
1262 {
1263   if (!this->peek_token()->is_op(OPERATOR_LPAREN))
1264     (this->*pfn)(varg);
1265   else
1266     {
1267       if (!this->advance_token()->is_op(OPERATOR_RPAREN))
1268         {
1269           this->list(pfn, varg, true);
1270           if (!this->peek_token()->is_op(OPERATOR_RPAREN))
1271             {
1272               error_at(this->location(), "missing %<)%>");
1273               while (!this->advance_token()->is_op(OPERATOR_RPAREN))
1274                 {
1275                   if (this->peek_token()->is_eof())
1276                     return;
1277                 }
1278             }
1279         }
1280       this->advance_token();
1281     }
1282 }
1283
1284 // List<P> = P { ";" P } [ ";" ] .
1285
1286 // In order to pick up the trailing semicolon we need to know what
1287 // might follow.  This is either a '}' or a ')'.
1288
1289 void
1290 Parse::list(void (Parse::*pfn)(void*), void* varg, bool follow_is_paren)
1291 {
1292   (this->*pfn)(varg);
1293   Operator follow = follow_is_paren ? OPERATOR_RPAREN : OPERATOR_RCURLY;
1294   while (this->peek_token()->is_op(OPERATOR_SEMICOLON)
1295          || this->peek_token()->is_op(OPERATOR_COMMA))
1296     {
1297       if (this->peek_token()->is_op(OPERATOR_COMMA))
1298         error_at(this->location(), "unexpected comma");
1299       if (this->advance_token()->is_op(follow))
1300         break;
1301       (this->*pfn)(varg);
1302     }
1303 }
1304
1305 // ConstDecl      = "const" ( ConstSpec | "(" { ConstSpec ";" } ")" ) .
1306
1307 void
1308 Parse::const_decl()
1309 {
1310   go_assert(this->peek_token()->is_keyword(KEYWORD_CONST));
1311   this->advance_token();
1312   this->reset_iota();
1313
1314   Type* last_type = NULL;
1315   Expression_list* last_expr_list = NULL;
1316
1317   if (!this->peek_token()->is_op(OPERATOR_LPAREN))
1318     this->const_spec(&last_type, &last_expr_list);
1319   else
1320     {
1321       this->advance_token();
1322       while (!this->peek_token()->is_op(OPERATOR_RPAREN))
1323         {
1324           this->const_spec(&last_type, &last_expr_list);
1325           if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
1326             this->advance_token();
1327           else if (!this->peek_token()->is_op(OPERATOR_RPAREN))
1328             {
1329               error_at(this->location(), "expected %<;%> or %<)%> or newline");
1330               if (!this->skip_past_error(OPERATOR_RPAREN))
1331                 return;
1332             }
1333         }
1334       this->advance_token();
1335     }
1336
1337   if (last_expr_list != NULL)
1338     delete last_expr_list;
1339 }
1340
1341 // ConstSpec = IdentifierList [ [ CompleteType ] "=" ExpressionList ] .
1342
1343 void
1344 Parse::const_spec(Type** last_type, Expression_list** last_expr_list)
1345 {
1346   Typed_identifier_list til;
1347   this->identifier_list(&til);
1348
1349   Type* type = NULL;
1350   if (this->type_may_start_here())
1351     {
1352       type = this->type();
1353       *last_type = NULL;
1354       *last_expr_list = NULL;
1355     }
1356
1357   Expression_list *expr_list;
1358   if (!this->peek_token()->is_op(OPERATOR_EQ))
1359     {
1360       if (*last_expr_list == NULL)
1361         {
1362           error_at(this->location(), "expected %<=%>");
1363           return;
1364         }
1365       type = *last_type;
1366       expr_list = new Expression_list;
1367       for (Expression_list::const_iterator p = (*last_expr_list)->begin();
1368            p != (*last_expr_list)->end();
1369            ++p)
1370         expr_list->push_back((*p)->copy());
1371     }
1372   else
1373     {
1374       this->advance_token();
1375       expr_list = this->expression_list(NULL, false);
1376       *last_type = type;
1377       if (*last_expr_list != NULL)
1378         delete *last_expr_list;
1379       *last_expr_list = expr_list;
1380     }
1381
1382   Expression_list::const_iterator pe = expr_list->begin();
1383   for (Typed_identifier_list::iterator pi = til.begin();
1384        pi != til.end();
1385        ++pi, ++pe)
1386     {
1387       if (pe == expr_list->end())
1388         {
1389           error_at(this->location(), "not enough initializers");
1390           return;
1391         }
1392       if (type != NULL)
1393         pi->set_type(type);
1394
1395       if (!Gogo::is_sink_name(pi->name()))
1396         this->gogo_->add_constant(*pi, *pe, this->iota_value());
1397     }
1398   if (pe != expr_list->end())
1399     error_at(this->location(), "too many initializers");
1400
1401   this->increment_iota();
1402
1403   return;
1404 }
1405
1406 // TypeDecl = "type" Decl<TypeSpec> .
1407
1408 void
1409 Parse::type_decl()
1410 {
1411   go_assert(this->peek_token()->is_keyword(KEYWORD_TYPE));
1412   this->advance_token();
1413   this->decl(&Parse::type_spec, NULL);
1414 }
1415
1416 // TypeSpec = identifier Type .
1417
1418 void
1419 Parse::type_spec(void*)
1420 {
1421   const Token* token = this->peek_token();
1422   if (!token->is_identifier())
1423     {
1424       error_at(this->location(), "expected identifier");
1425       return;
1426     }
1427   std::string name = token->identifier();
1428   bool is_exported = token->is_identifier_exported();
1429   source_location location = token->location();
1430   token = this->advance_token();
1431
1432   // The scope of the type name starts at the point where the
1433   // identifier appears in the source code.  We implement this by
1434   // declaring the type before we read the type definition.
1435   Named_object* named_type = NULL;
1436   if (name != "_")
1437     {
1438       name = this->gogo_->pack_hidden_name(name, is_exported);
1439       named_type = this->gogo_->declare_type(name, location);
1440     }
1441
1442   Type* type;
1443   if (!this->peek_token()->is_op(OPERATOR_SEMICOLON))
1444     type = this->type();
1445   else
1446     {
1447       error_at(this->location(),
1448                "unexpected semicolon or newline in type declaration");
1449       type = Type::make_error_type();
1450       this->advance_token();
1451     }
1452
1453   if (type->is_error_type())
1454     {
1455       while (!this->peek_token()->is_op(OPERATOR_SEMICOLON)
1456              && !this->peek_token()->is_eof())
1457         this->advance_token();
1458     }
1459
1460   if (name != "_")
1461     {
1462       if (named_type->is_type_declaration())
1463         {
1464           Type* ftype = type->forwarded();
1465           if (ftype->forward_declaration_type() != NULL
1466               && (ftype->forward_declaration_type()->named_object()
1467                   == named_type))
1468             {
1469               error_at(location, "invalid recursive type");
1470               type = Type::make_error_type();
1471             }
1472
1473           this->gogo_->define_type(named_type,
1474                                    Type::make_named_type(named_type, type,
1475                                                          location));
1476           go_assert(named_type->package() == NULL);
1477         }
1478       else
1479         {
1480           // This will probably give a redefinition error.
1481           this->gogo_->add_type(name, type, location);
1482         }
1483     }
1484 }
1485
1486 // VarDecl = "var" Decl<VarSpec> .
1487
1488 void
1489 Parse::var_decl()
1490 {
1491   go_assert(this->peek_token()->is_keyword(KEYWORD_VAR));
1492   this->advance_token();
1493   this->decl(&Parse::var_spec, NULL);
1494 }
1495
1496 // VarSpec = IdentifierList
1497 //             ( CompleteType [ "=" ExpressionList ] | "=" ExpressionList ) .
1498
1499 void
1500 Parse::var_spec(void*)
1501 {
1502   // Get the variable names.
1503   Typed_identifier_list til;
1504   this->identifier_list(&til);
1505
1506   source_location location = this->location();
1507
1508   Type* type = NULL;
1509   Expression_list* init = NULL;
1510   if (!this->peek_token()->is_op(OPERATOR_EQ))
1511     {
1512       type = this->type();
1513       if (type->is_error_type())
1514         {
1515           while (!this->peek_token()->is_op(OPERATOR_EQ)
1516                  && !this->peek_token()->is_op(OPERATOR_SEMICOLON)
1517                  && !this->peek_token()->is_eof())
1518             this->advance_token();
1519         }
1520       if (this->peek_token()->is_op(OPERATOR_EQ))
1521         {
1522           this->advance_token();
1523           init = this->expression_list(NULL, false);
1524         }
1525     }
1526   else
1527     {
1528       this->advance_token();
1529       init = this->expression_list(NULL, false);
1530     }
1531
1532   this->init_vars(&til, type, init, false, location);
1533
1534   if (init != NULL)
1535     delete init;
1536 }
1537
1538 // Create variables.  TIL is a list of variable names.  If TYPE is not
1539 // NULL, it is the type of all the variables.  If INIT is not NULL, it
1540 // is an initializer list for the variables.
1541
1542 void
1543 Parse::init_vars(const Typed_identifier_list* til, Type* type,
1544                  Expression_list* init, bool is_coloneq,
1545                  source_location location)
1546 {
1547   // Check for an initialization which can yield multiple values.
1548   if (init != NULL && init->size() == 1 && til->size() > 1)
1549     {
1550       if (this->init_vars_from_call(til, type, *init->begin(), is_coloneq,
1551                                     location))
1552         return;
1553       if (this->init_vars_from_map(til, type, *init->begin(), is_coloneq,
1554                                    location))
1555         return;
1556       if (this->init_vars_from_receive(til, type, *init->begin(), is_coloneq,
1557                                        location))
1558         return;
1559       if (this->init_vars_from_type_guard(til, type, *init->begin(),
1560                                           is_coloneq, location))
1561         return;
1562     }
1563
1564   if (init != NULL && init->size() != til->size())
1565     {
1566       if (init->empty() || !init->front()->is_error_expression())
1567         error_at(location, "wrong number of initializations");
1568       init = NULL;
1569       if (type == NULL)
1570         type = Type::make_error_type();
1571     }
1572
1573   // Note that INIT was already parsed with the old name bindings, so
1574   // we don't have to worry that it will accidentally refer to the
1575   // newly declared variables.
1576
1577   Expression_list::const_iterator pexpr;
1578   if (init != NULL)
1579     pexpr = init->begin();
1580   bool any_new = false;
1581   for (Typed_identifier_list::const_iterator p = til->begin();
1582        p != til->end();
1583        ++p)
1584     {
1585       if (init != NULL)
1586         go_assert(pexpr != init->end());
1587       this->init_var(*p, type, init == NULL ? NULL : *pexpr, is_coloneq,
1588                      false, &any_new);
1589       if (init != NULL)
1590         ++pexpr;
1591     }
1592   if (init != NULL)
1593     go_assert(pexpr == init->end());
1594   if (is_coloneq && !any_new)
1595     error_at(location, "variables redeclared but no variable is new");
1596 }
1597
1598 // See if we need to initialize a list of variables from a function
1599 // call.  This returns true if we have set up the variables and the
1600 // initialization.
1601
1602 bool
1603 Parse::init_vars_from_call(const Typed_identifier_list* vars, Type* type,
1604                            Expression* expr, bool is_coloneq,
1605                            source_location location)
1606 {
1607   Call_expression* call = expr->call_expression();
1608   if (call == NULL)
1609     return false;
1610
1611   // This is a function call.  We can't check here whether it returns
1612   // the right number of values, but it might.  Declare the variables,
1613   // and then assign the results of the call to them.
1614
1615   unsigned int index = 0;
1616   bool any_new = false;
1617   for (Typed_identifier_list::const_iterator pv = vars->begin();
1618        pv != vars->end();
1619        ++pv, ++index)
1620     {
1621       Expression* init = Expression::make_call_result(call, index);
1622       this->init_var(*pv, type, init, is_coloneq, false, &any_new);
1623     }
1624
1625   if (is_coloneq && !any_new)
1626     error_at(location, "variables redeclared but no variable is new");
1627
1628   return true;
1629 }
1630
1631 // See if we need to initialize a pair of values from a map index
1632 // expression.  This returns true if we have set up the variables and
1633 // the initialization.
1634
1635 bool
1636 Parse::init_vars_from_map(const Typed_identifier_list* vars, Type* type,
1637                           Expression* expr, bool is_coloneq,
1638                           source_location location)
1639 {
1640   Index_expression* index = expr->index_expression();
1641   if (index == NULL)
1642     return false;
1643   if (vars->size() != 2)
1644     return false;
1645
1646   // This is an index which is being assigned to two variables.  It
1647   // must be a map index.  Declare the variables, and then assign the
1648   // results of the map index.
1649   bool any_new = false;
1650   Typed_identifier_list::const_iterator p = vars->begin();
1651   Expression* init = type == NULL ? index : NULL;
1652   Named_object* val_no = this->init_var(*p, type, init, is_coloneq,
1653                                         type == NULL, &any_new);
1654   if (type == NULL && any_new && val_no->is_variable())
1655     val_no->var_value()->set_type_from_init_tuple();
1656   Expression* val_var = Expression::make_var_reference(val_no, location);
1657
1658   ++p;
1659   Type* var_type = type;
1660   if (var_type == NULL)
1661     var_type = Type::lookup_bool_type();
1662   Named_object* no = this->init_var(*p, var_type, NULL, is_coloneq, false,
1663                                     &any_new);
1664   Expression* present_var = Expression::make_var_reference(no, location);
1665
1666   if (is_coloneq && !any_new)
1667     error_at(location, "variables redeclared but no variable is new");
1668
1669   Statement* s = Statement::make_tuple_map_assignment(val_var, present_var,
1670                                                       index, location);
1671
1672   if (!this->gogo_->in_global_scope())
1673     this->gogo_->add_statement(s);
1674   else if (!val_no->is_sink())
1675     {
1676       if (val_no->is_variable())
1677         val_no->var_value()->add_preinit_statement(this->gogo_, s);
1678     }
1679   else if (!no->is_sink())
1680     {
1681       if (no->is_variable())
1682         no->var_value()->add_preinit_statement(this->gogo_, s);
1683     }
1684   else
1685     {
1686       // Execute the map index expression just so that we can fail if
1687       // the map is nil.
1688       Named_object* dummy = this->create_dummy_global(Type::lookup_bool_type(),
1689                                                       NULL, location);
1690       dummy->var_value()->add_preinit_statement(this->gogo_, s);
1691     }
1692
1693   return true;
1694 }
1695
1696 // See if we need to initialize a pair of values from a receive
1697 // expression.  This returns true if we have set up the variables and
1698 // the initialization.
1699
1700 bool
1701 Parse::init_vars_from_receive(const Typed_identifier_list* vars, Type* type,
1702                               Expression* expr, bool is_coloneq,
1703                               source_location location)
1704 {
1705   Receive_expression* receive = expr->receive_expression();
1706   if (receive == NULL)
1707     return false;
1708   if (vars->size() != 2)
1709     return false;
1710
1711   // This is a receive expression which is being assigned to two
1712   // variables.  Declare the variables, and then assign the results of
1713   // the receive.
1714   bool any_new = false;
1715   Typed_identifier_list::const_iterator p = vars->begin();
1716   Expression* init = type == NULL ? receive : NULL;
1717   Named_object* val_no = this->init_var(*p, type, init, is_coloneq,
1718                                         type == NULL, &any_new);
1719   if (type == NULL && any_new && val_no->is_variable())
1720     val_no->var_value()->set_type_from_init_tuple();
1721   Expression* val_var = Expression::make_var_reference(val_no, location);
1722
1723   ++p;
1724   Type* var_type = type;
1725   if (var_type == NULL)
1726     var_type = Type::lookup_bool_type();
1727   Named_object* no = this->init_var(*p, var_type, NULL, is_coloneq, false,
1728                                     &any_new);
1729   Expression* received_var = Expression::make_var_reference(no, location);
1730
1731   if (is_coloneq && !any_new)
1732     error_at(location, "variables redeclared but no variable is new");
1733
1734   Statement* s = Statement::make_tuple_receive_assignment(val_var,
1735                                                           received_var,
1736                                                           receive->channel(),
1737                                                           false,
1738                                                           location);
1739
1740   if (!this->gogo_->in_global_scope())
1741     this->gogo_->add_statement(s);
1742   else if (!val_no->is_sink())
1743     {
1744       if (val_no->is_variable())
1745         val_no->var_value()->add_preinit_statement(this->gogo_, s);
1746     }
1747   else if (!no->is_sink())
1748     {
1749       if (no->is_variable())
1750         no->var_value()->add_preinit_statement(this->gogo_, s);
1751     }
1752   else
1753     {
1754       Named_object* dummy = this->create_dummy_global(Type::lookup_bool_type(),
1755                                                       NULL, location);
1756       dummy->var_value()->add_preinit_statement(this->gogo_, s);
1757     }
1758
1759   return true;
1760 }
1761
1762 // See if we need to initialize a pair of values from a type guard
1763 // expression.  This returns true if we have set up the variables and
1764 // the initialization.
1765
1766 bool
1767 Parse::init_vars_from_type_guard(const Typed_identifier_list* vars,
1768                                  Type* type, Expression* expr,
1769                                  bool is_coloneq, source_location location)
1770 {
1771   Type_guard_expression* type_guard = expr->type_guard_expression();
1772   if (type_guard == NULL)
1773     return false;
1774   if (vars->size() != 2)
1775     return false;
1776
1777   // This is a type guard expression which is being assigned to two
1778   // variables.  Declare the variables, and then assign the results of
1779   // the type guard.
1780   bool any_new = false;
1781   Typed_identifier_list::const_iterator p = vars->begin();
1782   Type* var_type = type;
1783   if (var_type == NULL)
1784     var_type = type_guard->type();
1785   Named_object* val_no = this->init_var(*p, var_type, NULL, is_coloneq, false,
1786                                         &any_new);
1787   Expression* val_var = Expression::make_var_reference(val_no, location);
1788
1789   ++p;
1790   var_type = type;
1791   if (var_type == NULL)
1792     var_type = Type::lookup_bool_type();
1793   Named_object* no = this->init_var(*p, var_type, NULL, is_coloneq, false,
1794                                     &any_new);
1795   Expression* ok_var = Expression::make_var_reference(no, location);
1796
1797   Expression* texpr = type_guard->expr();
1798   Type* t = type_guard->type();
1799   Statement* s = Statement::make_tuple_type_guard_assignment(val_var, ok_var,
1800                                                              texpr, t,
1801                                                              location);
1802
1803   if (is_coloneq && !any_new)
1804     error_at(location, "variables redeclared but no variable is new");
1805
1806   if (!this->gogo_->in_global_scope())
1807     this->gogo_->add_statement(s);
1808   else if (!val_no->is_sink())
1809     {
1810       if (val_no->is_variable())
1811         val_no->var_value()->add_preinit_statement(this->gogo_, s);
1812     }
1813   else if (!no->is_sink())
1814     {
1815       if (no->is_variable())
1816         no->var_value()->add_preinit_statement(this->gogo_, s);
1817     }
1818   else
1819     {
1820       Named_object* dummy = this->create_dummy_global(type, NULL, location);
1821       dummy->var_value()->add_preinit_statement(this->gogo_, s);
1822     }
1823
1824   return true;
1825 }
1826
1827 // Create a single variable.  If IS_COLONEQ is true, we permit
1828 // redeclarations in the same block, and we set *IS_NEW when we find a
1829 // new variable which is not a redeclaration.
1830
1831 Named_object*
1832 Parse::init_var(const Typed_identifier& tid, Type* type, Expression* init,
1833                 bool is_coloneq, bool type_from_init, bool* is_new)
1834 {
1835   source_location location = tid.location();
1836
1837   if (Gogo::is_sink_name(tid.name()))
1838     {
1839       if (!type_from_init && init != NULL)
1840         {
1841           if (!this->gogo_->in_global_scope())
1842             this->gogo_->add_statement(Statement::make_statement(init));
1843           else
1844             return this->create_dummy_global(type, init, location);
1845         }
1846       return this->gogo_->add_sink();
1847     }
1848
1849   if (is_coloneq)
1850     {
1851       Named_object* no = this->gogo_->lookup_in_block(tid.name());
1852       if (no != NULL
1853           && (no->is_variable() || no->is_result_variable()))
1854         {
1855           // INIT may be NULL even when IS_COLONEQ is true for cases
1856           // like v, ok := x.(int).
1857           if (!type_from_init && init != NULL)
1858             {
1859               Expression *v = Expression::make_var_reference(no, location);
1860               Statement *s = Statement::make_assignment(v, init, location);
1861               this->gogo_->add_statement(s);
1862             }
1863           return no;
1864         }
1865     }
1866   *is_new = true;
1867   Variable* var = new Variable(type, init, this->gogo_->in_global_scope(),
1868                                false, false, location);
1869   Named_object* no = this->gogo_->add_variable(tid.name(), var);
1870   if (!no->is_variable())
1871     {
1872       // The name is already defined, so we just gave an error.
1873       return this->gogo_->add_sink();
1874     }
1875   return no;
1876 }
1877
1878 // Create a dummy global variable to force an initializer to be run in
1879 // the right place.  This is used when a sink variable is initialized
1880 // at global scope.
1881
1882 Named_object*
1883 Parse::create_dummy_global(Type* type, Expression* init,
1884                            source_location location)
1885 {
1886   if (type == NULL && init == NULL)
1887     type = Type::lookup_bool_type();
1888   Variable* var = new Variable(type, init, true, false, false, location);
1889   static int count;
1890   char buf[30];
1891   snprintf(buf, sizeof buf, "_.%d", count);
1892   ++count;
1893   return this->gogo_->add_variable(buf, var);
1894 }
1895
1896 // SimpleVarDecl = identifier ":=" Expression .
1897
1898 // We've already seen the identifier.
1899
1900 // FIXME: We also have to implement
1901 //  IdentifierList ":=" ExpressionList
1902 // In order to support both "a, b := 1, 0" and "a, b = 1, 0" we accept
1903 // tuple assignments here as well.
1904
1905 // If P_RANGE_CLAUSE is not NULL, then this will recognize a
1906 // RangeClause.
1907
1908 // If P_TYPE_SWITCH is not NULL, this will recognize a type switch
1909 // guard (var := expr.("type") using the literal keyword "type").
1910
1911 void
1912 Parse::simple_var_decl_or_assignment(const std::string& name,
1913                                      source_location location,
1914                                      Range_clause* p_range_clause,
1915                                      Type_switch* p_type_switch)
1916 {
1917   Typed_identifier_list til;
1918   til.push_back(Typed_identifier(name, NULL, location));
1919
1920   // We've seen one identifier.  If we see a comma now, this could be
1921   // "a, *p = 1, 2".
1922   if (this->peek_token()->is_op(OPERATOR_COMMA))
1923     {
1924       go_assert(p_type_switch == NULL);
1925       while (true)
1926         {
1927           const Token* token = this->advance_token();
1928           if (!token->is_identifier())
1929             break;
1930
1931           std::string id = token->identifier();
1932           bool is_id_exported = token->is_identifier_exported();
1933           source_location id_location = token->location();
1934
1935           token = this->advance_token();
1936           if (!token->is_op(OPERATOR_COMMA))
1937             {
1938               if (token->is_op(OPERATOR_COLONEQ))
1939                 {
1940                   id = this->gogo_->pack_hidden_name(id, is_id_exported);
1941                   til.push_back(Typed_identifier(id, NULL, location));
1942                 }
1943               else
1944                 this->unget_token(Token::make_identifier_token(id,
1945                                                                is_id_exported,
1946                                                                id_location));
1947               break;
1948             }
1949
1950           id = this->gogo_->pack_hidden_name(id, is_id_exported);
1951           til.push_back(Typed_identifier(id, NULL, location));
1952         }
1953
1954       // We have a comma separated list of identifiers in TIL.  If the
1955       // next token is COLONEQ, then this is a simple var decl, and we
1956       // have the complete list of identifiers.  If the next token is
1957       // not COLONEQ, then the only valid parse is a tuple assignment.
1958       // The list of identifiers we have so far is really a list of
1959       // expressions.  There are more expressions following.
1960
1961       if (!this->peek_token()->is_op(OPERATOR_COLONEQ))
1962         {
1963           Expression_list* exprs = new Expression_list;
1964           for (Typed_identifier_list::const_iterator p = til.begin();
1965                p != til.end();
1966                ++p)
1967             exprs->push_back(this->id_to_expression(p->name(),
1968                                                     p->location()));
1969
1970           Expression_list* more_exprs = this->expression_list(NULL, true);
1971           for (Expression_list::const_iterator p = more_exprs->begin();
1972                p != more_exprs->end();
1973                ++p)
1974             exprs->push_back(*p);
1975           delete more_exprs;
1976
1977           this->tuple_assignment(exprs, p_range_clause);
1978           return;
1979         }
1980     }
1981
1982   go_assert(this->peek_token()->is_op(OPERATOR_COLONEQ));
1983   const Token* token = this->advance_token();
1984
1985   if (p_range_clause != NULL && token->is_keyword(KEYWORD_RANGE))
1986     {
1987       this->range_clause_decl(&til, p_range_clause);
1988       return;
1989     }
1990
1991   Expression_list* init;
1992   if (p_type_switch == NULL)
1993     init = this->expression_list(NULL, false);
1994   else
1995     {
1996       bool is_type_switch = false;
1997       Expression* expr = this->expression(PRECEDENCE_NORMAL, false, true,
1998                                           &is_type_switch);
1999       if (is_type_switch)
2000         {
2001           p_type_switch->found = true;
2002           p_type_switch->name = name;
2003           p_type_switch->location = location;
2004           p_type_switch->expr = expr;
2005           return;
2006         }
2007
2008       if (!this->peek_token()->is_op(OPERATOR_COMMA))
2009         {
2010           init = new Expression_list();
2011           init->push_back(expr);
2012         }
2013       else
2014         {
2015           this->advance_token();
2016           init = this->expression_list(expr, false);
2017         }
2018     }
2019
2020   this->init_vars(&til, NULL, init, true, location);
2021 }
2022
2023 // FunctionDecl = "func" identifier Signature [ Block ] .
2024 // MethodDecl = "func" Receiver identifier Signature [ Block ] .
2025
2026 // gcc extension:
2027 //   FunctionDecl = "func" identifier Signature
2028 //                    __asm__ "(" string_lit ")" .
2029 // This extension means a function whose real name is the identifier
2030 // inside the asm.
2031
2032 void
2033 Parse::function_decl()
2034 {
2035   go_assert(this->peek_token()->is_keyword(KEYWORD_FUNC));
2036   source_location location = this->location();
2037   const Token* token = this->advance_token();
2038
2039   Typed_identifier* rec = NULL;
2040   if (token->is_op(OPERATOR_LPAREN))
2041     {
2042       rec = this->receiver();
2043       token = this->peek_token();
2044     }
2045
2046   if (!token->is_identifier())
2047     {
2048       error_at(this->location(), "expected function name");
2049       return;
2050     }
2051
2052   std::string name =
2053     this->gogo_->pack_hidden_name(token->identifier(),
2054                                   token->is_identifier_exported());
2055
2056   this->advance_token();
2057
2058   Function_type* fntype = this->signature(rec, this->location());
2059   if (fntype == NULL)
2060     return;
2061
2062   Named_object* named_object = NULL;
2063
2064   if (this->peek_token()->is_keyword(KEYWORD_ASM))
2065     {
2066       if (!this->advance_token()->is_op(OPERATOR_LPAREN))
2067         {
2068           error_at(this->location(), "expected %<(%>");
2069           return;
2070         }
2071       token = this->advance_token();
2072       if (!token->is_string())
2073         {
2074           error_at(this->location(), "expected string");
2075           return;
2076         }
2077       std::string asm_name = token->string_value();
2078       if (!this->advance_token()->is_op(OPERATOR_RPAREN))
2079         {
2080           error_at(this->location(), "expected %<)%>");
2081           return;
2082         }
2083       this->advance_token();
2084       if (!Gogo::is_sink_name(name))
2085         {
2086           named_object = this->gogo_->declare_function(name, fntype, location);
2087           if (named_object->is_function_declaration())
2088             named_object->func_declaration_value()->set_asm_name(asm_name);
2089         }
2090     }
2091
2092   // Check for the easy error of a newline before the opening brace.
2093   if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
2094     {
2095       source_location semi_loc = this->location();
2096       if (this->advance_token()->is_op(OPERATOR_LCURLY))
2097         error_at(this->location(),
2098                  "unexpected semicolon or newline before %<{%>");
2099       else
2100         this->unget_token(Token::make_operator_token(OPERATOR_SEMICOLON,
2101                                                      semi_loc));
2102     }
2103
2104   if (!this->peek_token()->is_op(OPERATOR_LCURLY))
2105     {
2106       if (named_object == NULL && !Gogo::is_sink_name(name))
2107         this->gogo_->declare_function(name, fntype, location);
2108     }
2109   else
2110     {
2111       this->gogo_->start_function(name, fntype, true, location);
2112       source_location end_loc = this->block();
2113       this->gogo_->finish_function(end_loc);
2114     }
2115 }
2116
2117 // Receiver     = "(" [ identifier ] [ "*" ] BaseTypeName ")" .
2118 // BaseTypeName = identifier .
2119
2120 Typed_identifier*
2121 Parse::receiver()
2122 {
2123   go_assert(this->peek_token()->is_op(OPERATOR_LPAREN));
2124
2125   std::string name;
2126   const Token* token = this->advance_token();
2127   source_location location = token->location();
2128   if (!token->is_op(OPERATOR_MULT))
2129     {
2130       if (!token->is_identifier())
2131         {
2132           error_at(this->location(), "method has no receiver");
2133           while (!token->is_eof() && !token->is_op(OPERATOR_RPAREN))
2134             token = this->advance_token();
2135           if (!token->is_eof())
2136             this->advance_token();
2137           return NULL;
2138         }
2139       name = token->identifier();
2140       bool is_exported = token->is_identifier_exported();
2141       token = this->advance_token();
2142       if (!token->is_op(OPERATOR_DOT) && !token->is_op(OPERATOR_RPAREN))
2143         {
2144           // An identifier followed by something other than a dot or a
2145           // right parenthesis must be a receiver name followed by a
2146           // type.
2147           name = this->gogo_->pack_hidden_name(name, is_exported);
2148         }
2149       else
2150         {
2151           // This must be a type name.
2152           this->unget_token(Token::make_identifier_token(name, is_exported,
2153                                                          location));
2154           token = this->peek_token();
2155           name.clear();
2156         }
2157     }
2158
2159   // Here the receiver name is in NAME (it is empty if the receiver is
2160   // unnamed) and TOKEN is the first token in the type.
2161
2162   bool is_pointer = false;
2163   if (token->is_op(OPERATOR_MULT))
2164     {
2165       is_pointer = true;
2166       token = this->advance_token();
2167     }
2168
2169   if (!token->is_identifier())
2170     {
2171       error_at(this->location(), "expected receiver name or type");
2172       int c = token->is_op(OPERATOR_LPAREN) ? 1 : 0;
2173       while (!token->is_eof())
2174         {
2175           token = this->advance_token();
2176           if (token->is_op(OPERATOR_LPAREN))
2177             ++c;
2178           else if (token->is_op(OPERATOR_RPAREN))
2179             {
2180               if (c == 0)
2181                 break;
2182               --c;
2183             }
2184         }
2185       if (!token->is_eof())
2186         this->advance_token();
2187       return NULL;
2188     }
2189
2190   Type* type = this->type_name(true);
2191
2192   if (is_pointer && !type->is_error_type())
2193     type = Type::make_pointer_type(type);
2194
2195   if (this->peek_token()->is_op(OPERATOR_RPAREN))
2196     this->advance_token();
2197   else
2198     {
2199       if (this->peek_token()->is_op(OPERATOR_COMMA))
2200         error_at(this->location(), "method has multiple receivers");
2201       else
2202         error_at(this->location(), "expected %<)%>");
2203       while (!token->is_eof() && !token->is_op(OPERATOR_RPAREN))
2204         token = this->advance_token();
2205       if (!token->is_eof())
2206         this->advance_token();
2207       return NULL;
2208     }
2209
2210   return new Typed_identifier(name, type, location);
2211 }
2212
2213 // Operand    = Literal | QualifiedIdent | MethodExpr | "(" Expression ")" .
2214 // Literal    = BasicLit | CompositeLit | FunctionLit .
2215 // BasicLit   = int_lit | float_lit | imaginary_lit | char_lit | string_lit .
2216
2217 // If MAY_BE_SINK is true, this operand may be "_".
2218
2219 Expression*
2220 Parse::operand(bool may_be_sink)
2221 {
2222   const Token* token = this->peek_token();
2223   Expression* ret;
2224   switch (token->classification())
2225     {
2226     case Token::TOKEN_IDENTIFIER:
2227       {
2228         source_location location = token->location();
2229         std::string id = token->identifier();
2230         bool is_exported = token->is_identifier_exported();
2231         std::string packed = this->gogo_->pack_hidden_name(id, is_exported);
2232
2233         Named_object* in_function;
2234         Named_object* named_object = this->gogo_->lookup(packed, &in_function);
2235
2236         Package* package = NULL;
2237         if (named_object != NULL && named_object->is_package())
2238           {
2239             if (!this->advance_token()->is_op(OPERATOR_DOT)
2240                 || !this->advance_token()->is_identifier())
2241               {
2242                 error_at(location, "unexpected reference to package");
2243                 return Expression::make_error(location);
2244               }
2245             package = named_object->package_value();
2246             package->set_used();
2247             id = this->peek_token()->identifier();
2248             is_exported = this->peek_token()->is_identifier_exported();
2249             packed = this->gogo_->pack_hidden_name(id, is_exported);
2250             named_object = package->lookup(packed);
2251             location = this->location();
2252             go_assert(in_function == NULL);
2253           }
2254
2255         this->advance_token();
2256
2257         if (named_object != NULL
2258             && named_object->is_type()
2259             && !named_object->type_value()->is_visible())
2260           {
2261             go_assert(package != NULL);
2262             error_at(location, "invalid reference to hidden type %<%s.%s%>",
2263                      Gogo::message_name(package->name()).c_str(),
2264                      Gogo::message_name(id).c_str());
2265             return Expression::make_error(location);
2266           }
2267
2268
2269         if (named_object == NULL)
2270           {
2271             if (package != NULL)
2272               {
2273                 std::string n1 = Gogo::message_name(package->name());
2274                 std::string n2 = Gogo::message_name(id);
2275                 if (!is_exported)
2276                   error_at(location,
2277                            ("invalid reference to unexported identifier "
2278                             "%<%s.%s%>"),
2279                            n1.c_str(), n2.c_str());
2280                 else
2281                   error_at(location,
2282                            "reference to undefined identifier %<%s.%s%>",
2283                            n1.c_str(), n2.c_str());
2284                 return Expression::make_error(location);
2285               }
2286
2287             named_object = this->gogo_->add_unknown_name(packed, location);
2288           }
2289
2290         if (in_function != NULL
2291             && in_function != this->gogo_->current_function()
2292             && (named_object->is_variable()
2293                 || named_object->is_result_variable()))
2294           return this->enclosing_var_reference(in_function, named_object,
2295                                                location);
2296
2297         switch (named_object->classification())
2298           {
2299           case Named_object::NAMED_OBJECT_CONST:
2300             return Expression::make_const_reference(named_object, location);
2301           case Named_object::NAMED_OBJECT_TYPE:
2302             return Expression::make_type(named_object->type_value(), location);
2303           case Named_object::NAMED_OBJECT_TYPE_DECLARATION:
2304             {
2305               Type* t = Type::make_forward_declaration(named_object);
2306               return Expression::make_type(t, location);
2307             }
2308           case Named_object::NAMED_OBJECT_VAR:
2309           case Named_object::NAMED_OBJECT_RESULT_VAR:
2310             return Expression::make_var_reference(named_object, location);
2311           case Named_object::NAMED_OBJECT_SINK:
2312             if (may_be_sink)
2313               return Expression::make_sink(location);
2314             else
2315               {
2316                 error_at(location, "cannot use _ as value");
2317                 return Expression::make_error(location);
2318               }
2319           case Named_object::NAMED_OBJECT_FUNC:
2320           case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
2321             return Expression::make_func_reference(named_object, NULL,
2322                                                    location);
2323           case Named_object::NAMED_OBJECT_UNKNOWN:
2324             return Expression::make_unknown_reference(named_object, location);
2325           default:
2326             go_unreachable();
2327           }
2328       }
2329       go_unreachable();
2330
2331     case Token::TOKEN_STRING:
2332       ret = Expression::make_string(token->string_value(), token->location());
2333       this->advance_token();
2334       return ret;
2335
2336     case Token::TOKEN_INTEGER:
2337       ret = Expression::make_integer(token->integer_value(), NULL,
2338                                      token->location());
2339       this->advance_token();
2340       return ret;
2341
2342     case Token::TOKEN_FLOAT:
2343       ret = Expression::make_float(token->float_value(), NULL,
2344                                    token->location());
2345       this->advance_token();
2346       return ret;
2347
2348     case Token::TOKEN_IMAGINARY:
2349       {
2350         mpfr_t zero;
2351         mpfr_init_set_ui(zero, 0, GMP_RNDN);
2352         ret = Expression::make_complex(&zero, token->imaginary_value(),
2353                                        NULL, token->location());
2354         mpfr_clear(zero);
2355         this->advance_token();
2356         return ret;
2357       }
2358
2359     case Token::TOKEN_KEYWORD:
2360       switch (token->keyword())
2361         {
2362         case KEYWORD_FUNC:
2363           return this->function_lit();
2364         case KEYWORD_CHAN:
2365         case KEYWORD_INTERFACE:
2366         case KEYWORD_MAP:
2367         case KEYWORD_STRUCT:
2368           {
2369             source_location location = token->location();
2370             return Expression::make_type(this->type(), location);
2371           }
2372         default:
2373           break;
2374         }
2375       break;
2376
2377     case Token::TOKEN_OPERATOR:
2378       if (token->is_op(OPERATOR_LPAREN))
2379         {
2380           this->advance_token();
2381           ret = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
2382           if (!this->peek_token()->is_op(OPERATOR_RPAREN))
2383             error_at(this->location(), "missing %<)%>");
2384           else
2385             this->advance_token();
2386           return ret;
2387         }
2388       else if (token->is_op(OPERATOR_LSQUARE))
2389         {
2390           // Here we call array_type directly, as this is the only
2391           // case where an ellipsis is permitted for an array type.
2392           source_location location = token->location();
2393           return Expression::make_type(this->array_type(true), location);
2394         }
2395       break;
2396
2397     default:
2398       break;
2399     }
2400
2401   error_at(this->location(), "expected operand");
2402   return Expression::make_error(this->location());
2403 }
2404
2405 // Handle a reference to a variable in an enclosing function.  We add
2406 // it to a list of such variables.  We return a reference to a field
2407 // in a struct which will be passed on the static chain when calling
2408 // the current function.
2409
2410 Expression*
2411 Parse::enclosing_var_reference(Named_object* in_function, Named_object* var,
2412                                source_location location)
2413 {
2414   go_assert(var->is_variable() || var->is_result_variable());
2415
2416   Named_object* this_function = this->gogo_->current_function();
2417   Named_object* closure = this_function->func_value()->closure_var();
2418
2419   Enclosing_var ev(var, in_function, this->enclosing_vars_.size());
2420   std::pair<Enclosing_vars::iterator, bool> ins =
2421     this->enclosing_vars_.insert(ev);
2422   if (ins.second)
2423     {
2424       // This is a variable we have not seen before.  Add a new field
2425       // to the closure type.
2426       this_function->func_value()->add_closure_field(var, location);
2427     }
2428
2429   Expression* closure_ref = Expression::make_var_reference(closure,
2430                                                            location);
2431   closure_ref = Expression::make_unary(OPERATOR_MULT, closure_ref, location);
2432
2433   // The closure structure holds pointers to the variables, so we need
2434   // to introduce an indirection.
2435   Expression* e = Expression::make_field_reference(closure_ref,
2436                                                    ins.first->index(),
2437                                                    location);
2438   e = Expression::make_unary(OPERATOR_MULT, e, location);
2439   return e;
2440 }
2441
2442 // CompositeLit  = LiteralType LiteralValue .
2443 // LiteralType   = StructType | ArrayType | "[" "..." "]" ElementType |
2444 //                 SliceType | MapType | TypeName .
2445 // LiteralValue  = "{" [ ElementList [ "," ] ] "}" .
2446 // ElementList   = Element { "," Element } .
2447 // Element       = [ Key ":" ] Value .
2448 // Key           = FieldName | ElementIndex .
2449 // FieldName     = identifier .
2450 // ElementIndex  = Expression .
2451 // Value         = Expression | LiteralValue .
2452
2453 // We have already seen the type if there is one, and we are now
2454 // looking at the LiteralValue.  The case "[" "..."  "]" ElementType
2455 // will be seen here as an array type whose length is "nil".  The
2456 // DEPTH parameter is non-zero if this is an embedded composite
2457 // literal and the type was omitted.  It gives the number of steps up
2458 // to the type which was provided.  E.g., in [][]int{{1}} it will be
2459 // 1.  In [][][]int{{{1}}} it will be 2.
2460
2461 Expression*
2462 Parse::composite_lit(Type* type, int depth, source_location location)
2463 {
2464   go_assert(this->peek_token()->is_op(OPERATOR_LCURLY));
2465   this->advance_token();
2466
2467   if (this->peek_token()->is_op(OPERATOR_RCURLY))
2468     {
2469       this->advance_token();
2470       return Expression::make_composite_literal(type, depth, false, NULL,
2471                                                 location);
2472     }
2473
2474   bool has_keys = false;
2475   Expression_list* vals = new Expression_list;
2476   while (true)
2477     {
2478       Expression* val;
2479       bool is_type_omitted = false;
2480
2481       const Token* token = this->peek_token();
2482
2483       if (token->is_identifier())
2484         {
2485           std::string identifier = token->identifier();
2486           bool is_exported = token->is_identifier_exported();
2487           source_location location = token->location();
2488
2489           if (this->advance_token()->is_op(OPERATOR_COLON))
2490             {
2491               // This may be a field name.  We don't know for sure--it
2492               // could also be an expression for an array index.  We
2493               // don't want to parse it as an expression because may
2494               // trigger various errors, e.g., if this identifier
2495               // happens to be the name of a package.
2496               Gogo* gogo = this->gogo_;
2497               val = this->id_to_expression(gogo->pack_hidden_name(identifier,
2498                                                                   is_exported),
2499                                            location);
2500             }
2501           else
2502             {
2503               this->unget_token(Token::make_identifier_token(identifier,
2504                                                              is_exported,
2505                                                              location));
2506               val = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
2507             }
2508         }
2509       else if (!token->is_op(OPERATOR_LCURLY))
2510         val = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
2511       else
2512         {
2513           // This must be a composite literal inside another composite
2514           // literal, with the type omitted for the inner one.
2515           val = this->composite_lit(type, depth + 1, token->location());
2516           is_type_omitted = true;
2517         }
2518
2519       token = this->peek_token();
2520       if (!token->is_op(OPERATOR_COLON))
2521         {
2522           if (has_keys)
2523             vals->push_back(NULL);
2524         }
2525       else
2526         {
2527           if (is_type_omitted && !val->is_error_expression())
2528             {
2529               error_at(this->location(), "unexpected %<:%>");
2530               val = Expression::make_error(this->location());
2531             }
2532
2533           this->advance_token();
2534
2535           if (!has_keys && !vals->empty())
2536             {
2537               Expression_list* newvals = new Expression_list;
2538               for (Expression_list::const_iterator p = vals->begin();
2539                    p != vals->end();
2540                    ++p)
2541                 {
2542                   newvals->push_back(NULL);
2543                   newvals->push_back(*p);
2544                 }
2545               delete vals;
2546               vals = newvals;
2547             }
2548           has_keys = true;
2549
2550           if (val->unknown_expression() != NULL)
2551             val->unknown_expression()->set_is_composite_literal_key();
2552
2553           vals->push_back(val);
2554
2555           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
2560               // composite literal, with the type omitted for the
2561               // inner one.
2562               val = this->composite_lit(type, depth + 1, token->location());
2563             }
2564
2565           token = this->peek_token();
2566         }
2567
2568       vals->push_back(val);
2569
2570       if (token->is_op(OPERATOR_COMMA))
2571         {
2572           if (this->advance_token()->is_op(OPERATOR_RCURLY))
2573             {
2574               this->advance_token();
2575               break;
2576             }
2577         }
2578       else if (token->is_op(OPERATOR_RCURLY))
2579         {
2580           this->advance_token();
2581           break;
2582         }
2583       else
2584         {
2585           error_at(this->location(), "expected %<,%> or %<}%>");
2586
2587           int depth = 0;
2588           while (!token->is_eof()
2589                  && (depth > 0 || !token->is_op(OPERATOR_RCURLY)))
2590             {
2591               if (token->is_op(OPERATOR_LCURLY))
2592                 ++depth;
2593               else if (token->is_op(OPERATOR_RCURLY))
2594                 --depth;
2595               token = this->advance_token();
2596             }
2597           if (token->is_op(OPERATOR_RCURLY))
2598             this->advance_token();
2599
2600           return Expression::make_error(location);
2601         }
2602     }
2603
2604   return Expression::make_composite_literal(type, depth, has_keys, vals,
2605                                             location);
2606 }
2607
2608 // FunctionLit = "func" Signature Block .
2609
2610 Expression*
2611 Parse::function_lit()
2612 {
2613   source_location location = this->location();
2614   go_assert(this->peek_token()->is_keyword(KEYWORD_FUNC));
2615   this->advance_token();
2616
2617   Enclosing_vars hold_enclosing_vars;
2618   hold_enclosing_vars.swap(this->enclosing_vars_);
2619
2620   Function_type* type = this->signature(NULL, location);
2621   if (type == NULL)
2622     type = Type::make_function_type(NULL, NULL, NULL, location);
2623
2624   // For a function literal, the next token must be a '{'.  If we
2625   // don't see that, then we may have a type expression.
2626   if (!this->peek_token()->is_op(OPERATOR_LCURLY))
2627     return Expression::make_type(type, location);
2628
2629   Bc_stack* hold_break_stack = this->break_stack_;
2630   Bc_stack* hold_continue_stack = this->continue_stack_;
2631   this->break_stack_ = NULL;
2632   this->continue_stack_ = NULL;
2633
2634   Named_object* no = this->gogo_->start_function("", type, true, location);
2635
2636   source_location end_loc = this->block();
2637
2638   this->gogo_->finish_function(end_loc);
2639
2640   if (this->break_stack_ != NULL)
2641     delete this->break_stack_;
2642   if (this->continue_stack_ != NULL)
2643     delete this->continue_stack_;
2644   this->break_stack_ = hold_break_stack;
2645   this->continue_stack_ = hold_continue_stack;
2646
2647   hold_enclosing_vars.swap(this->enclosing_vars_);
2648
2649   Expression* closure = this->create_closure(no, &hold_enclosing_vars,
2650                                              location);
2651
2652   return Expression::make_func_reference(no, closure, location);
2653 }
2654
2655 // Create a closure for the nested function FUNCTION.  This is based
2656 // on ENCLOSING_VARS, which is a list of all variables defined in
2657 // enclosing functions and referenced from FUNCTION.  A closure is the
2658 // address of a struct which contains the addresses of all the
2659 // referenced variables.  This returns NULL if no closure is required.
2660
2661 Expression*
2662 Parse::create_closure(Named_object* function, Enclosing_vars* enclosing_vars,
2663                       source_location location)
2664 {
2665   if (enclosing_vars->empty())
2666     return NULL;
2667
2668   // Get the variables in order by their field index.
2669
2670   size_t enclosing_var_count = enclosing_vars->size();
2671   std::vector<Enclosing_var> ev(enclosing_var_count);
2672   for (Enclosing_vars::const_iterator p = enclosing_vars->begin();
2673        p != enclosing_vars->end();
2674        ++p)
2675     ev[p->index()] = *p;
2676
2677   // Build an initializer for a composite literal of the closure's
2678   // type.
2679
2680   Named_object* enclosing_function = this->gogo_->current_function();
2681   Expression_list* initializer = new Expression_list;
2682   for (size_t i = 0; i < enclosing_var_count; ++i)
2683     {
2684       go_assert(ev[i].index() == i);
2685       Named_object* var = ev[i].var();
2686       Expression* ref;
2687       if (ev[i].in_function() == enclosing_function)
2688         ref = Expression::make_var_reference(var, location);
2689       else
2690         ref = this->enclosing_var_reference(ev[i].in_function(), var,
2691                                             location);
2692       Expression* refaddr = Expression::make_unary(OPERATOR_AND, ref,
2693                                                    location);
2694       initializer->push_back(refaddr);
2695     }
2696
2697   Named_object* closure_var = function->func_value()->closure_var();
2698   Struct_type* st = closure_var->var_value()->type()->deref()->struct_type();
2699   Expression* cv = Expression::make_struct_composite_literal(st, initializer,
2700                                                              location);
2701   return Expression::make_heap_composite(cv, location);
2702 }
2703
2704 // PrimaryExpr = Operand { Selector | Index | Slice | TypeGuard | Call } .
2705
2706 // If MAY_BE_SINK is true, this expression may be "_".
2707
2708 // If MAY_BE_COMPOSITE_LIT is true, this expression may be a composite
2709 // literal.
2710
2711 // If IS_TYPE_SWITCH is not NULL, this will recognize a type switch
2712 // guard (var := expr.("type") using the literal keyword "type").
2713
2714 Expression*
2715 Parse::primary_expr(bool may_be_sink, bool may_be_composite_lit,
2716                     bool* is_type_switch)
2717 {
2718   source_location start_loc = this->location();
2719   bool is_parenthesized = this->peek_token()->is_op(OPERATOR_LPAREN);
2720
2721   Expression* ret = this->operand(may_be_sink);
2722
2723   // An unknown name followed by a curly brace must be a composite
2724   // literal, and the unknown name must be a type.
2725   if (may_be_composite_lit
2726       && !is_parenthesized
2727       && ret->unknown_expression() != NULL
2728       && this->peek_token()->is_op(OPERATOR_LCURLY))
2729     {
2730       Named_object* no = ret->unknown_expression()->named_object();
2731       Type* type = Type::make_forward_declaration(no);
2732       ret = Expression::make_type(type, ret->location());
2733     }
2734
2735   // We handle composite literals and type casts here, as it is the
2736   // easiest way to handle types which are in parentheses, as in
2737   // "((uint))(1)".
2738   if (ret->is_type_expression())
2739     {
2740       if (this->peek_token()->is_op(OPERATOR_LCURLY))
2741         {
2742           if (is_parenthesized)
2743             error_at(start_loc,
2744                      "cannot parenthesize type in composite literal");
2745           ret = this->composite_lit(ret->type(), 0, ret->location());
2746         }
2747       else if (this->peek_token()->is_op(OPERATOR_LPAREN))
2748         {
2749           source_location loc = this->location();
2750           this->advance_token();
2751           Expression* expr = this->expression(PRECEDENCE_NORMAL, false, true,
2752                                               NULL);
2753           if (this->peek_token()->is_op(OPERATOR_ELLIPSIS))
2754             {
2755               error_at(this->location(),
2756                        "invalid use of %<...%> in type conversion");
2757               this->advance_token();
2758             }
2759           if (!this->peek_token()->is_op(OPERATOR_RPAREN))
2760             error_at(this->location(), "expected %<)%>");
2761           else
2762             this->advance_token();
2763           if (expr->is_error_expression())
2764             ret = expr;
2765           else
2766             {
2767               Type* t = ret->type();
2768               if (t->classification() == Type::TYPE_ARRAY
2769                   && t->array_type()->length() != NULL
2770                   && t->array_type()->length()->is_nil_expression())
2771                 {
2772                   error_at(ret->location(),
2773                            "invalid use of %<...%> in type conversion");
2774                   ret = Expression::make_error(loc);
2775                 }
2776               else
2777                 ret = Expression::make_cast(t, expr, loc);
2778             }
2779         }
2780     }
2781
2782   while (true)
2783     {
2784       const Token* token = this->peek_token();
2785       if (token->is_op(OPERATOR_LPAREN))
2786         ret = this->call(this->verify_not_sink(ret));
2787       else if (token->is_op(OPERATOR_DOT))
2788         {
2789           ret = this->selector(this->verify_not_sink(ret), is_type_switch);
2790           if (is_type_switch != NULL && *is_type_switch)
2791             break;
2792         }
2793       else if (token->is_op(OPERATOR_LSQUARE))
2794         ret = this->index(this->verify_not_sink(ret));
2795       else
2796         break;
2797     }
2798
2799   return ret;
2800 }
2801
2802 // Selector = "." identifier .
2803 // TypeGuard = "." "(" QualifiedIdent ")" .
2804
2805 // Note that Operand can expand to QualifiedIdent, which contains a
2806 // ".".  That is handled directly in operand when it sees a package
2807 // name.
2808
2809 // If IS_TYPE_SWITCH is not NULL, this will recognize a type switch
2810 // guard (var := expr.("type") using the literal keyword "type").
2811
2812 Expression*
2813 Parse::selector(Expression* left, bool* is_type_switch)
2814 {
2815   go_assert(this->peek_token()->is_op(OPERATOR_DOT));
2816   source_location location = this->location();
2817
2818   const Token* token = this->advance_token();
2819   if (token->is_identifier())
2820     {
2821       // This could be a field in a struct, or a method in an
2822       // interface, or a method associated with a type.  We can't know
2823       // which until we have seen all the types.
2824       std::string name =
2825         this->gogo_->pack_hidden_name(token->identifier(),
2826                                       token->is_identifier_exported());
2827       if (token->identifier() == "_")
2828         {
2829           error_at(this->location(), "invalid use of %<_%>");
2830           name = this->gogo_->pack_hidden_name("blank", false);
2831         }
2832       this->advance_token();
2833       return Expression::make_selector(left, name, location);
2834     }
2835   else if (token->is_op(OPERATOR_LPAREN))
2836     {
2837       this->advance_token();
2838       Type* type = NULL;
2839       if (!this->peek_token()->is_keyword(KEYWORD_TYPE))
2840         type = this->type();
2841       else
2842         {
2843           if (is_type_switch != NULL)
2844             *is_type_switch = true;
2845           else
2846             {
2847               error_at(this->location(),
2848                        "use of %<.(type)%> outside type switch");
2849               type = Type::make_error_type();
2850             }
2851           this->advance_token();
2852         }
2853       if (!this->peek_token()->is_op(OPERATOR_RPAREN))
2854         error_at(this->location(), "missing %<)%>");
2855       else
2856         this->advance_token();
2857       if (is_type_switch != NULL && *is_type_switch)
2858         return left;
2859       return Expression::make_type_guard(left, type, location);
2860     }
2861   else
2862     {
2863       error_at(this->location(), "expected identifier or %<(%>");
2864       return left;
2865     }
2866 }
2867
2868 // Index          = "[" Expression "]" .
2869 // Slice          = "[" Expression ":" [ Expression ] "]" .
2870
2871 Expression*
2872 Parse::index(Expression* expr)
2873 {
2874   source_location location = this->location();
2875   go_assert(this->peek_token()->is_op(OPERATOR_LSQUARE));
2876   this->advance_token();
2877
2878   Expression* start;
2879   if (!this->peek_token()->is_op(OPERATOR_COLON))
2880     start = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
2881   else
2882     {
2883       mpz_t zero;
2884       mpz_init_set_ui(zero, 0);
2885       start = Expression::make_integer(&zero, NULL, location);
2886       mpz_clear(zero);
2887     }
2888
2889   Expression* end = NULL;
2890   if (this->peek_token()->is_op(OPERATOR_COLON))
2891     {
2892       // We use nil to indicate a missing high expression.
2893       if (this->advance_token()->is_op(OPERATOR_RSQUARE))
2894         end = Expression::make_nil(this->location());
2895       else
2896         end = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
2897     }
2898   if (!this->peek_token()->is_op(OPERATOR_RSQUARE))
2899     error_at(this->location(), "missing %<]%>");
2900   else
2901     this->advance_token();
2902   return Expression::make_index(expr, start, end, location);
2903 }
2904
2905 // Call           = "(" [ ArgumentList [ "," ] ] ")" .
2906 // ArgumentList   = ExpressionList [ "..." ] .
2907
2908 Expression*
2909 Parse::call(Expression* func)
2910 {
2911   go_assert(this->peek_token()->is_op(OPERATOR_LPAREN));
2912   Expression_list* args = NULL;
2913   bool is_varargs = false;
2914   const Token* token = this->advance_token();
2915   if (!token->is_op(OPERATOR_RPAREN))
2916     {
2917       args = this->expression_list(NULL, false);
2918       token = this->peek_token();
2919       if (token->is_op(OPERATOR_ELLIPSIS))
2920         {
2921           is_varargs = true;
2922           token = this->advance_token();
2923         }
2924     }
2925   if (token->is_op(OPERATOR_COMMA))
2926     token = this->advance_token();
2927   if (!token->is_op(OPERATOR_RPAREN))
2928     error_at(this->location(), "missing %<)%>");
2929   else
2930     this->advance_token();
2931   if (func->is_error_expression())
2932     return func;
2933   return Expression::make_call(func, args, is_varargs, func->location());
2934 }
2935
2936 // Return an expression for a single unqualified identifier.
2937
2938 Expression*
2939 Parse::id_to_expression(const std::string& name, source_location location)
2940 {
2941   Named_object* in_function;
2942   Named_object* named_object = this->gogo_->lookup(name, &in_function);
2943   if (named_object == NULL)
2944     named_object = this->gogo_->add_unknown_name(name, location);
2945
2946   if (in_function != NULL
2947       && in_function != this->gogo_->current_function()
2948       && (named_object->is_variable() || named_object->is_result_variable()))
2949     return this->enclosing_var_reference(in_function, named_object,
2950                                          location);
2951
2952   switch (named_object->classification())
2953     {
2954     case Named_object::NAMED_OBJECT_CONST:
2955       return Expression::make_const_reference(named_object, location);
2956     case Named_object::NAMED_OBJECT_VAR:
2957     case Named_object::NAMED_OBJECT_RESULT_VAR:
2958       return Expression::make_var_reference(named_object, location);
2959     case Named_object::NAMED_OBJECT_SINK:
2960       return Expression::make_sink(location);
2961     case Named_object::NAMED_OBJECT_FUNC:
2962     case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
2963       return Expression::make_func_reference(named_object, NULL, location);
2964     case Named_object::NAMED_OBJECT_UNKNOWN:
2965       return Expression::make_unknown_reference(named_object, location);
2966     case Named_object::NAMED_OBJECT_PACKAGE:
2967     case Named_object::NAMED_OBJECT_TYPE:
2968     case Named_object::NAMED_OBJECT_TYPE_DECLARATION:
2969       // These cases can arise for a field name in a composite
2970       // literal.
2971       return Expression::make_unknown_reference(named_object, location);
2972     default:
2973       error_at(this->location(), "unexpected type of identifier");
2974       return Expression::make_error(location);
2975     }
2976 }
2977
2978 // Expression = UnaryExpr { binary_op Expression } .
2979
2980 // PRECEDENCE is the precedence of the current operator.
2981
2982 // If MAY_BE_SINK is true, this expression may be "_".
2983
2984 // If MAY_BE_COMPOSITE_LIT is true, this expression may be a composite
2985 // literal.
2986
2987 // If IS_TYPE_SWITCH is not NULL, this will recognize a type switch
2988 // guard (var := expr.("type") using the literal keyword "type").
2989
2990 Expression*
2991 Parse::expression(Precedence precedence, bool may_be_sink,
2992                   bool may_be_composite_lit, bool* is_type_switch)
2993 {
2994   Expression* left = this->unary_expr(may_be_sink, may_be_composite_lit,
2995                                       is_type_switch);
2996
2997   while (true)
2998     {
2999       if (is_type_switch != NULL && *is_type_switch)
3000         return left;
3001
3002       const Token* token = this->peek_token();
3003       if (token->classification() != Token::TOKEN_OPERATOR)
3004         {
3005           // Not a binary_op.
3006           return left;
3007         }
3008
3009       Precedence right_precedence;
3010       switch (token->op())
3011         {
3012         case OPERATOR_OROR:
3013           right_precedence = PRECEDENCE_OROR;
3014           break;
3015         case OPERATOR_ANDAND:
3016           right_precedence = PRECEDENCE_ANDAND;
3017           break;
3018         case OPERATOR_EQEQ:
3019         case OPERATOR_NOTEQ:
3020         case OPERATOR_LT:
3021         case OPERATOR_LE:
3022         case OPERATOR_GT:
3023         case OPERATOR_GE:
3024           right_precedence = PRECEDENCE_RELOP;
3025           break;
3026         case OPERATOR_PLUS:
3027         case OPERATOR_MINUS:
3028         case OPERATOR_OR:
3029         case OPERATOR_XOR:
3030           right_precedence = PRECEDENCE_ADDOP;
3031           break;
3032         case OPERATOR_MULT:
3033         case OPERATOR_DIV:
3034         case OPERATOR_MOD:
3035         case OPERATOR_LSHIFT:
3036         case OPERATOR_RSHIFT:
3037         case OPERATOR_AND:
3038         case OPERATOR_BITCLEAR:
3039           right_precedence = PRECEDENCE_MULOP;
3040           break;
3041         default:
3042           right_precedence = PRECEDENCE_INVALID;
3043           break;
3044         }
3045
3046       if (right_precedence == PRECEDENCE_INVALID)
3047         {
3048           // Not a binary_op.
3049           return left;
3050         }
3051
3052       Operator op = token->op();
3053       source_location binop_location = token->location();
3054
3055       if (precedence >= right_precedence)
3056         {
3057           // We've already seen A * B, and we see + C.  We want to
3058           // return so that A * B becomes a group.
3059           return left;
3060         }
3061
3062       this->advance_token();
3063
3064       left = this->verify_not_sink(left);
3065       Expression* right = this->expression(right_precedence, false,
3066                                            may_be_composite_lit,
3067                                            NULL);
3068       left = Expression::make_binary(op, left, right, binop_location);
3069     }
3070 }
3071
3072 bool
3073 Parse::expression_may_start_here()
3074 {
3075   const Token* token = this->peek_token();
3076   switch (token->classification())
3077     {
3078     case Token::TOKEN_INVALID:
3079     case Token::TOKEN_EOF:
3080       return false;
3081     case Token::TOKEN_KEYWORD:
3082       switch (token->keyword())
3083         {
3084         case KEYWORD_CHAN:
3085         case KEYWORD_FUNC:
3086         case KEYWORD_MAP:
3087         case KEYWORD_STRUCT:
3088         case KEYWORD_INTERFACE:
3089           return true;
3090         default:
3091           return false;
3092         }
3093     case Token::TOKEN_IDENTIFIER:
3094       return true;
3095     case Token::TOKEN_STRING:
3096       return true;
3097     case Token::TOKEN_OPERATOR:
3098       switch (token->op())
3099         {
3100         case OPERATOR_PLUS:
3101         case OPERATOR_MINUS:
3102         case OPERATOR_NOT:
3103         case OPERATOR_XOR:
3104         case OPERATOR_MULT:
3105         case OPERATOR_CHANOP:
3106         case OPERATOR_AND:
3107         case OPERATOR_LPAREN:
3108         case OPERATOR_LSQUARE:
3109           return true;
3110         default:
3111           return false;
3112         }
3113     case Token::TOKEN_INTEGER:
3114     case Token::TOKEN_FLOAT:
3115     case Token::TOKEN_IMAGINARY:
3116       return true;
3117     default:
3118       go_unreachable();
3119     }
3120 }
3121
3122 // UnaryExpr = unary_op UnaryExpr | PrimaryExpr .
3123
3124 // If MAY_BE_SINK is true, this expression may be "_".
3125
3126 // If MAY_BE_COMPOSITE_LIT is true, this expression may be a composite
3127 // literal.
3128
3129 // If IS_TYPE_SWITCH is not NULL, this will recognize a type switch
3130 // guard (var := expr.("type") using the literal keyword "type").
3131
3132 Expression*
3133 Parse::unary_expr(bool may_be_sink, bool may_be_composite_lit,
3134                   bool* is_type_switch)
3135 {
3136   const Token* token = this->peek_token();
3137   if (token->is_op(OPERATOR_PLUS)
3138       || token->is_op(OPERATOR_MINUS)
3139       || token->is_op(OPERATOR_NOT)
3140       || token->is_op(OPERATOR_XOR)
3141       || token->is_op(OPERATOR_CHANOP)
3142       || token->is_op(OPERATOR_MULT)
3143       || token->is_op(OPERATOR_AND))
3144     {
3145       source_location location = token->location();
3146       Operator op = token->op();
3147       this->advance_token();
3148
3149       if (op == OPERATOR_CHANOP
3150           && this->peek_token()->is_keyword(KEYWORD_CHAN))
3151         {
3152           // This is "<- chan" which must be the start of a type.
3153           this->unget_token(Token::make_operator_token(op, location));
3154           return Expression::make_type(this->type(), location);
3155         }
3156
3157       Expression* expr = this->unary_expr(false, may_be_composite_lit, NULL);
3158       if (expr->is_error_expression())
3159         ;
3160       else if (op == OPERATOR_MULT && expr->is_type_expression())
3161         expr = Expression::make_type(Type::make_pointer_type(expr->type()),
3162                                      location);
3163       else if (op == OPERATOR_AND && expr->is_composite_literal())
3164         expr = Expression::make_heap_composite(expr, location);
3165       else if (op != OPERATOR_CHANOP)
3166         expr = Expression::make_unary(op, expr, location);
3167       else
3168         expr = Expression::make_receive(expr, location);
3169       return expr;
3170     }
3171   else
3172     return this->primary_expr(may_be_sink, may_be_composite_lit,
3173                               is_type_switch);
3174 }
3175
3176 // Statement =
3177 //      Declaration | LabeledStmt | SimpleStmt |
3178 //      GoStmt | ReturnStmt | BreakStmt | ContinueStmt | GotoStmt |
3179 //      FallthroughStmt | Block | IfStmt | SwitchStmt | SelectStmt | ForStmt |
3180 //      DeferStmt .
3181
3182 // LABEL is the label of this statement if it has one.
3183
3184 void
3185 Parse::statement(Label* label)
3186 {
3187   const Token* token = this->peek_token();
3188   switch (token->classification())
3189     {
3190     case Token::TOKEN_KEYWORD:
3191       {
3192         switch (token->keyword())
3193           {
3194           case KEYWORD_CONST:
3195           case KEYWORD_TYPE:
3196           case KEYWORD_VAR:
3197             this->declaration();
3198             break;
3199           case KEYWORD_FUNC:
3200           case KEYWORD_MAP:
3201           case KEYWORD_STRUCT:
3202           case KEYWORD_INTERFACE:
3203             this->simple_stat(true, NULL, NULL, NULL);
3204             break;
3205           case KEYWORD_GO:
3206           case KEYWORD_DEFER:
3207             this->go_or_defer_stat();
3208             break;
3209           case KEYWORD_RETURN:
3210             this->return_stat();
3211             break;
3212           case KEYWORD_BREAK:
3213             this->break_stat();
3214             break;
3215           case KEYWORD_CONTINUE:
3216             this->continue_stat();
3217             break;
3218           case KEYWORD_GOTO:
3219             this->goto_stat();
3220             break;
3221           case KEYWORD_IF:
3222             this->if_stat();
3223             break;
3224           case KEYWORD_SWITCH:
3225             this->switch_stat(label);
3226             break;
3227           case KEYWORD_SELECT:
3228             this->select_stat(label);
3229             break;
3230           case KEYWORD_FOR:
3231             this->for_stat(label);
3232             break;
3233           default:
3234             error_at(this->location(), "expected statement");
3235             this->advance_token();
3236             break;
3237           }
3238       }
3239       break;
3240
3241     case Token::TOKEN_IDENTIFIER:
3242       {
3243         std::string identifier = token->identifier();
3244         bool is_exported = token->is_identifier_exported();
3245         source_location location = token->location();
3246         if (this->advance_token()->is_op(OPERATOR_COLON))
3247           {
3248             this->advance_token();
3249             this->labeled_stmt(identifier, location);
3250           }
3251         else
3252           {
3253             this->unget_token(Token::make_identifier_token(identifier,
3254                                                            is_exported,
3255                                                            location));
3256             this->simple_stat(true, NULL, NULL, NULL);
3257           }
3258       }
3259       break;
3260
3261     case Token::TOKEN_OPERATOR:
3262       if (token->is_op(OPERATOR_LCURLY))
3263         {
3264           source_location location = token->location();
3265           this->gogo_->start_block(location);
3266           source_location end_loc = this->block();
3267           this->gogo_->add_block(this->gogo_->finish_block(end_loc),
3268                                  location);
3269         }
3270       else if (!token->is_op(OPERATOR_SEMICOLON))
3271         this->simple_stat(true, NULL, NULL, NULL);
3272       break;
3273
3274     case Token::TOKEN_STRING:
3275     case Token::TOKEN_INTEGER:
3276     case Token::TOKEN_FLOAT:
3277     case Token::TOKEN_IMAGINARY:
3278       this->simple_stat(true, NULL, NULL, NULL);
3279       break;
3280
3281     default:
3282       error_at(this->location(), "expected statement");
3283       this->advance_token();
3284       break;
3285     }
3286 }
3287
3288 bool
3289 Parse::statement_may_start_here()
3290 {
3291   const Token* token = this->peek_token();
3292   switch (token->classification())
3293     {
3294     case Token::TOKEN_KEYWORD:
3295       {
3296         switch (token->keyword())
3297           {
3298           case KEYWORD_CONST:
3299           case KEYWORD_TYPE:
3300           case KEYWORD_VAR:
3301           case KEYWORD_FUNC:
3302           case KEYWORD_MAP:
3303           case KEYWORD_STRUCT:
3304           case KEYWORD_INTERFACE:
3305           case KEYWORD_GO:
3306           case KEYWORD_DEFER:
3307           case KEYWORD_RETURN:
3308           case KEYWORD_BREAK:
3309           case KEYWORD_CONTINUE:
3310           case KEYWORD_GOTO:
3311           case KEYWORD_IF:
3312           case KEYWORD_SWITCH:
3313           case KEYWORD_SELECT:
3314           case KEYWORD_FOR:
3315             return true;
3316
3317           default:
3318             return false;
3319           }
3320       }
3321       break;
3322
3323     case Token::TOKEN_IDENTIFIER:
3324       return true;
3325
3326     case Token::TOKEN_OPERATOR:
3327       if (token->is_op(OPERATOR_LCURLY)
3328           || token->is_op(OPERATOR_SEMICOLON))
3329         return true;
3330       else
3331         return this->expression_may_start_here();
3332
3333     case Token::TOKEN_STRING:
3334     case Token::TOKEN_INTEGER:
3335     case Token::TOKEN_FLOAT:
3336     case Token::TOKEN_IMAGINARY:
3337       return true;
3338
3339     default:
3340       return false;
3341     }
3342 }
3343
3344 // LabeledStmt = Label ":" Statement .
3345 // Label       = identifier .
3346
3347 void
3348 Parse::labeled_stmt(const std::string& label_name, source_location location)
3349 {
3350   Label* label = this->gogo_->add_label_definition(label_name, location);
3351
3352   if (this->peek_token()->is_op(OPERATOR_RCURLY))
3353     {
3354       // This is a label at the end of a block.  A program is
3355       // permitted to omit a semicolon here.
3356       return;
3357     }
3358
3359   if (!this->statement_may_start_here())
3360     {
3361       // Mark the label as used to avoid a useless error about an
3362       // unused label.
3363       label->set_is_used();
3364
3365       error_at(location, "missing statement after label");
3366       this->unget_token(Token::make_operator_token(OPERATOR_SEMICOLON,
3367                                                    location));
3368       return;
3369     }
3370
3371   this->statement(label);
3372 }
3373
3374 // SimpleStmt = EmptyStmt | ExpressionStmt | SendStmt | IncDecStmt |
3375 //      Assignment | ShortVarDecl .
3376
3377 // EmptyStmt was handled in Parse::statement.
3378
3379 // In order to make this work for if and switch statements, if
3380 // RETURN_EXP is not NULL, and we see an ExpressionStat, we return the
3381 // expression rather than adding an expression statement to the
3382 // current block.  If we see something other than an ExpressionStat,
3383 // we add the statement, set *RETURN_EXP to true if we saw a send
3384 // statement, and return NULL.  The handling of send statements is for
3385 // better error messages.
3386
3387 // If P_RANGE_CLAUSE is not NULL, then this will recognize a
3388 // RangeClause.
3389
3390 // If P_TYPE_SWITCH is not NULL, this will recognize a type switch
3391 // guard (var := expr.("type") using the literal keyword "type").
3392
3393 Expression*
3394 Parse::simple_stat(bool may_be_composite_lit, bool* return_exp,
3395                    Range_clause* p_range_clause, Type_switch* p_type_switch)
3396 {
3397   const Token* token = this->peek_token();
3398
3399   // An identifier follow by := is a SimpleVarDecl.
3400   if (token->is_identifier())
3401     {
3402       std::string identifier = token->identifier();
3403       bool is_exported = token->is_identifier_exported();
3404       source_location location = token->location();
3405
3406       token = this->advance_token();
3407       if (token->is_op(OPERATOR_COLONEQ)
3408           || token->is_op(OPERATOR_COMMA))
3409         {
3410           identifier = this->gogo_->pack_hidden_name(identifier, is_exported);
3411           this->simple_var_decl_or_assignment(identifier, location,
3412                                               p_range_clause,
3413                                               (token->is_op(OPERATOR_COLONEQ)
3414                                                ? p_type_switch
3415                                                : NULL));
3416           return NULL;
3417         }
3418
3419       this->unget_token(Token::make_identifier_token(identifier, is_exported,
3420                                                      location));
3421     }
3422
3423   Expression* exp = this->expression(PRECEDENCE_NORMAL, true,
3424                                      may_be_composite_lit,
3425                                      (p_type_switch == NULL
3426                                       ? NULL
3427                                       : &p_type_switch->found));
3428   if (p_type_switch != NULL && p_type_switch->found)
3429     {
3430       p_type_switch->name.clear();
3431       p_type_switch->location = exp->location();
3432       p_type_switch->expr = this->verify_not_sink(exp);
3433       return NULL;
3434     }
3435   token = this->peek_token();
3436   if (token->is_op(OPERATOR_CHANOP))
3437     {
3438       this->send_stmt(this->verify_not_sink(exp));
3439       if (return_exp != NULL)
3440         *return_exp = true;
3441     }
3442   else if (token->is_op(OPERATOR_PLUSPLUS)
3443            || token->is_op(OPERATOR_MINUSMINUS))
3444     this->inc_dec_stat(this->verify_not_sink(exp));
3445   else if (token->is_op(OPERATOR_COMMA)
3446            || token->is_op(OPERATOR_EQ))
3447     this->assignment(exp, p_range_clause);
3448   else if (token->is_op(OPERATOR_PLUSEQ)
3449            || token->is_op(OPERATOR_MINUSEQ)
3450            || token->is_op(OPERATOR_OREQ)
3451            || token->is_op(OPERATOR_XOREQ)
3452            || token->is_op(OPERATOR_MULTEQ)
3453            || token->is_op(OPERATOR_DIVEQ)
3454            || token->is_op(OPERATOR_MODEQ)
3455            || token->is_op(OPERATOR_LSHIFTEQ)
3456            || token->is_op(OPERATOR_RSHIFTEQ)
3457            || token->is_op(OPERATOR_ANDEQ)
3458            || token->is_op(OPERATOR_BITCLEAREQ))
3459     this->assignment(this->verify_not_sink(exp), p_range_clause);
3460   else if (return_exp != NULL)
3461     return this->verify_not_sink(exp);
3462   else
3463     this->expression_stat(this->verify_not_sink(exp));
3464
3465   return NULL;
3466 }
3467
3468 bool
3469 Parse::simple_stat_may_start_here()
3470 {
3471   return this->expression_may_start_here();
3472 }
3473
3474 // Parse { Statement ";" } which is used in a few places.  The list of
3475 // statements may end with a right curly brace, in which case the
3476 // semicolon may be omitted.
3477
3478 void
3479 Parse::statement_list()
3480 {
3481   while (this->statement_may_start_here())
3482     {
3483       this->statement(NULL);
3484       if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
3485         this->advance_token();
3486       else if (this->peek_token()->is_op(OPERATOR_RCURLY))
3487         break;
3488       else
3489         {
3490           if (!this->peek_token()->is_eof() || !saw_errors())
3491             error_at(this->location(), "expected %<;%> or %<}%> or newline");
3492           if (!this->skip_past_error(OPERATOR_RCURLY))
3493             return;
3494         }
3495     }
3496 }
3497
3498 bool
3499 Parse::statement_list_may_start_here()
3500 {
3501   return this->statement_may_start_here();
3502 }
3503
3504 // ExpressionStat = Expression .
3505
3506 void
3507 Parse::expression_stat(Expression* exp)
3508 {
3509   exp->discarding_value();
3510   this->gogo_->add_statement(Statement::make_statement(exp));
3511 }
3512
3513 // SendStmt = Channel "&lt;-" Expression .
3514 // Channel  = Expression .
3515
3516 void
3517 Parse::send_stmt(Expression* channel)
3518 {
3519   go_assert(this->peek_token()->is_op(OPERATOR_CHANOP));
3520   source_location loc = this->location();
3521   this->advance_token();
3522   Expression* val = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
3523   Statement* s = Statement::make_send_statement(channel, val, loc);
3524   this->gogo_->add_statement(s);
3525 }
3526
3527 // IncDecStat = Expression ( "++" | "--" ) .
3528
3529 void
3530 Parse::inc_dec_stat(Expression* exp)
3531 {
3532   const Token* token = this->peek_token();
3533
3534   // Lvalue maps require special handling.
3535   if (exp->index_expression() != NULL)
3536     exp->index_expression()->set_is_lvalue();
3537
3538   if (token->is_op(OPERATOR_PLUSPLUS))
3539     this->gogo_->add_statement(Statement::make_inc_statement(exp));
3540   else if (token->is_op(OPERATOR_MINUSMINUS))
3541     this->gogo_->add_statement(Statement::make_dec_statement(exp));
3542   else
3543     go_unreachable();
3544   this->advance_token();
3545 }
3546
3547 // Assignment = ExpressionList assign_op ExpressionList .
3548
3549 // EXP is an expression that we have already parsed.
3550
3551 // If RANGE_CLAUSE is not NULL, then this will recognize a
3552 // RangeClause.
3553
3554 void
3555 Parse::assignment(Expression* expr, Range_clause* p_range_clause)
3556 {
3557   Expression_list* vars;
3558   if (!this->peek_token()->is_op(OPERATOR_COMMA))
3559     {
3560       vars = new Expression_list();
3561       vars->push_back(expr);
3562     }
3563   else
3564     {
3565       this->advance_token();
3566       vars = this->expression_list(expr, true);
3567     }
3568
3569   this->tuple_assignment(vars, p_range_clause);
3570 }
3571
3572 // An assignment statement.  LHS is the list of expressions which
3573 // appear on the left hand side.
3574
3575 // If RANGE_CLAUSE is not NULL, then this will recognize a
3576 // RangeClause.
3577
3578 void
3579 Parse::tuple_assignment(Expression_list* lhs, Range_clause* p_range_clause)
3580 {
3581   const Token* token = this->peek_token();
3582   if (!token->is_op(OPERATOR_EQ)
3583       && !token->is_op(OPERATOR_PLUSEQ)
3584       && !token->is_op(OPERATOR_MINUSEQ)
3585       && !token->is_op(OPERATOR_OREQ)
3586       && !token->is_op(OPERATOR_XOREQ)
3587       && !token->is_op(OPERATOR_MULTEQ)
3588       && !token->is_op(OPERATOR_DIVEQ)
3589       && !token->is_op(OPERATOR_MODEQ)
3590       && !token->is_op(OPERATOR_LSHIFTEQ)
3591       && !token->is_op(OPERATOR_RSHIFTEQ)
3592       && !token->is_op(OPERATOR_ANDEQ)
3593       && !token->is_op(OPERATOR_BITCLEAREQ))
3594     {
3595       error_at(this->location(), "expected assignment operator");
3596       return;
3597     }
3598   Operator op = token->op();
3599   source_location location = token->location();
3600
3601   token = this->advance_token();
3602
3603   if (p_range_clause != NULL && token->is_keyword(KEYWORD_RANGE))
3604     {
3605       if (op != OPERATOR_EQ)
3606         error_at(this->location(), "range clause requires %<=%>");
3607       this->range_clause_expr(lhs, p_range_clause);
3608       return;
3609     }
3610
3611   Expression_list* vals = this->expression_list(NULL, false);
3612
3613   // We've parsed everything; check for errors.
3614   if (lhs == NULL || vals == NULL)
3615     return;
3616   for (Expression_list::const_iterator pe = lhs->begin();
3617        pe != lhs->end();
3618        ++pe)
3619     {
3620       if ((*pe)->is_error_expression())
3621         return;
3622       if (op != OPERATOR_EQ && (*pe)->is_sink_expression())
3623         error_at((*pe)->location(), "cannot use _ as value");
3624     }
3625   for (Expression_list::const_iterator pe = vals->begin();
3626        pe != vals->end();
3627        ++pe)
3628     {
3629       if ((*pe)->is_error_expression())
3630         return;
3631     }
3632
3633   // Map expressions act differently when they are lvalues.
3634   for (Expression_list::iterator plv = lhs->begin();
3635        plv != lhs->end();
3636        ++plv)
3637     if ((*plv)->index_expression() != NULL)
3638       (*plv)->index_expression()->set_is_lvalue();
3639
3640   Call_expression* call;
3641   Index_expression* map_index;
3642   Receive_expression* receive;
3643   Type_guard_expression* type_guard;
3644   if (lhs->size() == vals->size())
3645     {
3646       Statement* s;
3647       if (lhs->size() > 1)
3648         {
3649           if (op != OPERATOR_EQ)
3650             error_at(location, "multiple values only permitted with %<=%>");
3651           s = Statement::make_tuple_assignment(lhs, vals, location);
3652         }
3653       else
3654         {
3655           if (op == OPERATOR_EQ)
3656             s = Statement::make_assignment(lhs->front(), vals->front(),
3657                                            location);
3658           else
3659             s = Statement::make_assignment_operation(op, lhs->front(),
3660                                                      vals->front(), location);
3661           delete lhs;
3662           delete vals;
3663         }
3664       this->gogo_->add_statement(s);
3665     }
3666   else if (vals->size() == 1
3667            && (call = (*vals->begin())->call_expression()) != NULL)
3668     {
3669       if (op != OPERATOR_EQ)
3670         error_at(location, "multiple results only permitted with %<=%>");
3671       delete vals;
3672       vals = new Expression_list;
3673       for (unsigned int i = 0; i < lhs->size(); ++i)
3674         vals->push_back(Expression::make_call_result(call, i));
3675       Statement* s = Statement::make_tuple_assignment(lhs, vals, location);
3676       this->gogo_->add_statement(s);
3677     }
3678   else if (lhs->size() == 2
3679            && vals->size() == 1
3680            && (map_index = (*vals->begin())->index_expression()) != NULL)
3681     {
3682       if (op != OPERATOR_EQ)
3683         error_at(location, "two values from map requires %<=%>");
3684       Expression* val = lhs->front();
3685       Expression* present = lhs->back();
3686       Statement* s = Statement::make_tuple_map_assignment(val, present,
3687                                                           map_index, location);
3688       this->gogo_->add_statement(s);
3689     }
3690   else if (lhs->size() == 1
3691            && vals->size() == 2
3692            && (map_index = lhs->front()->index_expression()) != NULL)
3693     {
3694       if (op != OPERATOR_EQ)
3695         error_at(location, "assigning tuple to map index requires %<=%>");
3696       Expression* val = vals->front();
3697       Expression* should_set = vals->back();
3698       Statement* s = Statement::make_map_assignment(map_index, val, should_set,
3699                                                     location);
3700       this->gogo_->add_statement(s);
3701     }
3702   else if (lhs->size() == 2
3703            && vals->size() == 1
3704            && (receive = (*vals->begin())->receive_expression()) != NULL)
3705     {
3706       if (op != OPERATOR_EQ)
3707         error_at(location, "two values from receive requires %<=%>");
3708       Expression* val = lhs->front();
3709       Expression* success = lhs->back();
3710       Expression* channel = receive->channel();
3711       Statement* s = Statement::make_tuple_receive_assignment(val, success,
3712                                                               channel,
3713                                                               false,
3714                                                               location);
3715       this->gogo_->add_statement(s);
3716     }
3717   else if (lhs->size() == 2
3718            && vals->size() == 1
3719            && (type_guard = (*vals->begin())->type_guard_expression()) != NULL)
3720     {
3721       if (op != OPERATOR_EQ)
3722         error_at(location, "two values from type guard requires %<=%>");
3723       Expression* val = lhs->front();
3724       Expression* ok = lhs->back();
3725       Expression* expr = type_guard->expr();
3726       Type* type = type_guard->type();
3727       Statement* s = Statement::make_tuple_type_guard_assignment(val, ok,
3728                                                                  expr, type,
3729                                                                  location);
3730       this->gogo_->add_statement(s);
3731     }
3732   else
3733     {
3734       error_at(location, "number of variables does not match number of values");
3735     }
3736 }
3737
3738 // GoStat = "go" Expression .
3739 // DeferStat = "defer" Expression .
3740
3741 void
3742 Parse::go_or_defer_stat()
3743 {
3744   go_assert(this->peek_token()->is_keyword(KEYWORD_GO)
3745              || this->peek_token()->is_keyword(KEYWORD_DEFER));
3746   bool is_go = this->peek_token()->is_keyword(KEYWORD_GO);
3747   source_location stat_location = this->location();
3748   this->advance_token();
3749   source_location expr_location = this->location();
3750   Expression* expr = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
3751   Call_expression* call_expr = expr->call_expression();
3752   if (call_expr == NULL)
3753     {
3754       error_at(expr_location, "expected call expression");
3755       return;
3756     }
3757
3758   // Make it easier to simplify go/defer statements by putting every
3759   // statement in its own block.
3760   this->gogo_->start_block(stat_location);
3761   Statement* stat;
3762   if (is_go)
3763     stat = Statement::make_go_statement(call_expr, stat_location);
3764   else
3765     stat = Statement::make_defer_statement(call_expr, stat_location);
3766   this->gogo_->add_statement(stat);
3767   this->gogo_->add_block(this->gogo_->finish_block(stat_location),
3768                          stat_location);
3769 }
3770
3771 // ReturnStat = "return" [ ExpressionList ] .
3772
3773 void
3774 Parse::return_stat()
3775 {
3776   go_assert(this->peek_token()->is_keyword(KEYWORD_RETURN));
3777   source_location location = this->location();
3778   this->advance_token();
3779   Expression_list* vals = NULL;
3780   if (this->expression_may_start_here())
3781     vals = this->expression_list(NULL, false);
3782   this->gogo_->add_statement(Statement::make_return_statement(vals, location));
3783 }
3784
3785 // IfStmt    = "if" [ SimpleStmt ";" ] Expression Block [ "else" Statement ] .
3786
3787 void
3788 Parse::if_stat()
3789 {
3790   go_assert(this->peek_token()->is_keyword(KEYWORD_IF));
3791   source_location location = this->location();
3792   this->advance_token();
3793
3794   this->gogo_->start_block(location);
3795
3796   bool saw_simple_stat = false;
3797   Expression* cond = NULL;
3798   bool saw_send_stmt;
3799   if (this->simple_stat_may_start_here())
3800     {
3801       cond = this->simple_stat(false, &saw_send_stmt, NULL, NULL);
3802       saw_simple_stat = true;
3803     }
3804   if (cond != NULL && this->peek_token()->is_op(OPERATOR_SEMICOLON))
3805     {
3806       // The SimpleStat is an expression statement.
3807       this->expression_stat(cond);
3808       cond = NULL;
3809     }
3810   if (cond == NULL)
3811     {
3812       if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
3813         this->advance_token();
3814       else if (saw_simple_stat)
3815         {
3816           if (saw_send_stmt)
3817             error_at(this->location(),
3818                      ("send statement used as value; "
3819                       "use select for non-blocking send"));
3820           else
3821             error_at(this->location(),
3822                      "expected %<;%> after statement in if expression");
3823           if (!this->expression_may_start_here())
3824             cond = Expression::make_error(this->location());
3825         }
3826       if (cond == NULL && this->peek_token()->is_op(OPERATOR_LCURLY))
3827         {
3828           error_at(this->location(),
3829                    "missing condition in if statement");
3830           cond = Expression::make_error(this->location());
3831         }
3832       if (cond == NULL)
3833         cond = this->expression(PRECEDENCE_NORMAL, false, false, NULL);
3834     }
3835
3836   this->gogo_->start_block(this->location());
3837   source_location end_loc = this->block();
3838   Block* then_block = this->gogo_->finish_block(end_loc);
3839
3840   // Check for the easy error of a newline before "else".
3841   if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
3842     {
3843       source_location semi_loc = this->location();
3844       if (this->advance_token()->is_keyword(KEYWORD_ELSE))
3845         error_at(this->location(),
3846                  "unexpected semicolon or newline before %<else%>");
3847       else
3848         this->unget_token(Token::make_operator_token(OPERATOR_SEMICOLON,
3849                                                      semi_loc));
3850     }
3851
3852   Block* else_block = NULL;
3853   if (this->peek_token()->is_keyword(KEYWORD_ELSE))
3854     {
3855       this->advance_token();
3856       // We create a block to gather the statement.
3857       this->gogo_->start_block(this->location());
3858       this->statement(NULL);
3859       else_block = this->gogo_->finish_block(this->location());
3860     }
3861
3862   this->gogo_->add_statement(Statement::make_if_statement(cond, then_block,
3863                                                           else_block,
3864                                                           location));
3865
3866   this->gogo_->add_block(this->gogo_->finish_block(this->location()),
3867                          location);
3868 }
3869
3870 // SwitchStmt = ExprSwitchStmt | TypeSwitchStmt .
3871 // ExprSwitchStmt = "switch" [ [ SimpleStat ] ";" ] [ Expression ]
3872 //                      "{" { ExprCaseClause } "}" .
3873 // TypeSwitchStmt  = "switch" [ [ SimpleStat ] ";" ] TypeSwitchGuard
3874 //                      "{" { TypeCaseClause } "}" .
3875 // TypeSwitchGuard = [ identifier ":=" ] Expression "." "(" "type" ")" .
3876
3877 void
3878 Parse::switch_stat(Label* label)
3879 {
3880   go_assert(this->peek_token()->is_keyword(KEYWORD_SWITCH));
3881   source_location location = this->location();
3882   this->advance_token();
3883
3884   this->gogo_->start_block(location);
3885
3886   bool saw_simple_stat = false;
3887   Expression* switch_val = NULL;
3888   bool saw_send_stmt;
3889   Type_switch type_switch;
3890   if (this->simple_stat_may_start_here())
3891     {
3892       switch_val = this->simple_stat(false, &saw_send_stmt, NULL,
3893                                      &type_switch);
3894       saw_simple_stat = true;
3895     }
3896   if (switch_val != NULL && this->peek_token()->is_op(OPERATOR_SEMICOLON))
3897     {
3898       // The SimpleStat is an expression statement.
3899       this->expression_stat(switch_val);
3900       switch_val = NULL;
3901     }
3902   if (switch_val == NULL && !type_switch.found)
3903     {
3904       if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
3905         this->advance_token();
3906       else if (saw_simple_stat)
3907         {
3908           if (saw_send_stmt)
3909             error_at(this->location(),
3910                      ("send statement used as value; "
3911                       "use select for non-blocking send"));
3912           else
3913             error_at(this->location(),
3914                      "expected %<;%> after statement in switch expression");
3915         }
3916       if (!this->peek_token()->is_op(OPERATOR_LCURLY))
3917         {
3918           if (this->peek_token()->is_identifier())
3919             {
3920               const Token* token = this->peek_token();
3921               std::string identifier = token->identifier();
3922               bool is_exported = token->is_identifier_exported();
3923               source_location id_loc = token->location();
3924
3925               token = this->advance_token();
3926               bool is_coloneq = token->is_op(OPERATOR_COLONEQ);
3927               this->unget_token(Token::make_identifier_token(identifier,
3928                                                              is_exported,
3929                                                              id_loc));
3930               if (is_coloneq)
3931                 {
3932                   // This must be a TypeSwitchGuard.
3933                   switch_val = this->simple_stat(false, &saw_send_stmt, NULL,
3934                                                  &type_switch);
3935                   if (!type_switch.found)
3936                     {
3937                       if (switch_val == NULL
3938                           || !switch_val->is_error_expression())
3939                         {
3940                           error_at(id_loc, "expected type switch assignment");
3941                           switch_val = Expression::make_error(id_loc);
3942                         }
3943                     }
3944                 }
3945             }
3946           if (switch_val == NULL && !type_switch.found)
3947             {
3948               switch_val = this->expression(PRECEDENCE_NORMAL, false, false,
3949                                             &type_switch.found);
3950               if (type_switch.found)
3951                 {
3952                   type_switch.name.clear();
3953                   type_switch.expr = switch_val;
3954                   type_switch.location = switch_val->location();
3955                 }
3956             }
3957         }
3958     }
3959
3960   if (!this->peek_token()->is_op(OPERATOR_LCURLY))
3961     {
3962       source_location token_loc = this->location();
3963       if (this->peek_token()->is_op(OPERATOR_SEMICOLON)
3964           && this->advance_token()->is_op(OPERATOR_LCURLY))
3965         error_at(token_loc, "unexpected semicolon or newline before %<{%>");
3966       else if (this->peek_token()->is_op(OPERATOR_COLONEQ))
3967         {
3968           error_at(token_loc, "invalid variable name");
3969           this->advance_token();
3970           this->expression(PRECEDENCE_NORMAL, false, false,
3971                            &type_switch.found);
3972           if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
3973             this->advance_token();
3974           if (!this->peek_token()->is_op(OPERATOR_LCURLY))
3975             return;
3976           if (type_switch.found)
3977             type_switch.expr = Expression::make_error(location);
3978         }
3979       else
3980         {
3981           error_at(this->location(), "expected %<{%>");
3982           this->gogo_->add_block(this->gogo_->finish_block(this->location()),
3983                                  location);
3984           return;
3985         }
3986     }
3987   this->advance_token();
3988
3989   Statement* statement;
3990   if (type_switch.found)
3991     statement = this->type_switch_body(label, type_switch, location);
3992   else
3993     statement = this->expr_switch_body(label, switch_val, location);
3994
3995   if (statement != NULL)
3996     this->gogo_->add_statement(statement);
3997
3998   this->gogo_->add_block(this->gogo_->finish_block(this->location()),
3999                          location);
4000 }
4001
4002 // The body of an expression switch.
4003 //   "{" { ExprCaseClause } "}"
4004
4005 Statement*
4006 Parse::expr_switch_body(Label* label, Expression* switch_val,
4007                         source_location location)
4008 {
4009   Switch_statement* statement = Statement::make_switch_statement(switch_val,
4010                                                                  location);
4011
4012   this->push_break_statement(statement, label);
4013
4014   Case_clauses* case_clauses = new Case_clauses();
4015   bool saw_default = false;
4016   while (!this->peek_token()->is_op(OPERATOR_RCURLY))
4017     {
4018       if (this->peek_token()->is_eof())
4019         {
4020           if (!saw_errors())
4021             error_at(this->location(), "missing %<}%>");
4022           return NULL;
4023         }
4024       this->expr_case_clause(case_clauses, &saw_default);
4025     }
4026   this->advance_token();
4027
4028   statement->add_clauses(case_clauses);
4029
4030   this->pop_break_statement();
4031
4032   return statement;
4033 }
4034
4035 // ExprCaseClause = ExprSwitchCase ":" [ StatementList ] .
4036 // FallthroughStat = "fallthrough" .
4037
4038 void
4039 Parse::expr_case_clause(Case_clauses* clauses, bool* saw_default)
4040 {
4041   source_location location = this->location();
4042
4043   bool is_default = false;
4044   Expression_list* vals = this->expr_switch_case(&is_default);
4045
4046   if (!this->peek_token()->is_op(OPERATOR_COLON))
4047     {
4048       if (!saw_errors())
4049         error_at(this->location(), "expected %<:%>");
4050       return;
4051     }
4052   else
4053     this->advance_token();
4054
4055   Block* statements = NULL;
4056   if (this->statement_list_may_start_here())
4057     {
4058       this->gogo_->start_block(this->location());
4059       this->statement_list();
4060       statements = this->gogo_->finish_block(this->location());
4061     }
4062
4063   bool is_fallthrough = false;
4064   if (this->peek_token()->is_keyword(KEYWORD_FALLTHROUGH))
4065     {
4066       is_fallthrough = true;
4067       if (this->advance_token()->is_op(OPERATOR_SEMICOLON))
4068         this->advance_token();
4069     }
4070
4071   if (is_default)
4072     {
4073       if (*saw_default)
4074         {
4075           error_at(location, "multiple defaults in switch");
4076           return;
4077         }
4078       *saw_default = true;
4079     }
4080
4081   if (is_default || vals != NULL)
4082     clauses->add(vals, is_default, statements, is_fallthrough, location);
4083 }
4084
4085 // ExprSwitchCase = "case" ExpressionList | "default" .
4086
4087 Expression_list*
4088 Parse::expr_switch_case(bool* is_default)
4089 {
4090   const Token* token = this->peek_token();
4091   if (token->is_keyword(KEYWORD_CASE))
4092     {
4093       this->advance_token();
4094       return this->expression_list(NULL, false);
4095     }
4096   else if (token->is_keyword(KEYWORD_DEFAULT))
4097     {
4098       this->advance_token();
4099       *is_default = true;
4100       return NULL;
4101     }
4102   else
4103     {
4104       if (!saw_errors())
4105         error_at(this->location(), "expected %<case%> or %<default%>");
4106       if (!token->is_op(OPERATOR_RCURLY))
4107         this->advance_token();
4108       return NULL;
4109     }
4110 }
4111
4112 // The body of a type switch.
4113 //   "{" { TypeCaseClause } "}" .
4114
4115 Statement*
4116 Parse::type_switch_body(Label* label, const Type_switch& type_switch,
4117                         source_location location)
4118 {
4119   Named_object* switch_no = NULL;
4120   if (!type_switch.name.empty())
4121     {
4122       Variable* switch_var = new Variable(NULL, type_switch.expr, false, false,
4123                                           false, type_switch.location);
4124       switch_no = this->gogo_->add_variable(type_switch.name, switch_var);
4125     }
4126
4127   Type_switch_statement* statement =
4128     Statement::make_type_switch_statement(switch_no,
4129                                           (switch_no == NULL
4130                                            ? type_switch.expr
4131                                            : NULL),
4132                                           location);
4133
4134   this->push_break_statement(statement, label);
4135
4136   Type_case_clauses* case_clauses = new Type_case_clauses();
4137   bool saw_default = false;
4138   while (!this->peek_token()->is_op(OPERATOR_RCURLY))
4139     {
4140       if (this->peek_token()->is_eof())
4141         {
4142           error_at(this->location(), "missing %<}%>");
4143           return NULL;
4144         }
4145       this->type_case_clause(switch_no, case_clauses, &saw_default);
4146     }
4147   this->advance_token();
4148
4149   statement->add_clauses(case_clauses);
4150
4151   this->pop_break_statement();
4152
4153   return statement;
4154 }
4155
4156 // TypeCaseClause  = TypeSwitchCase ":" [ StatementList ] .
4157
4158 void
4159 Parse::type_case_clause(Named_object* switch_no, Type_case_clauses* clauses,
4160                         bool* saw_default)
4161 {
4162   source_location location = this->location();
4163
4164   std::vector<Type*> types;
4165   bool is_default = false;
4166   this->type_switch_case(&types, &is_default);
4167
4168   if (!this->peek_token()->is_op(OPERATOR_COLON))
4169     error_at(this->location(), "expected %<:%>");
4170   else
4171     this->advance_token();
4172
4173   Block* statements = NULL;
4174   if (this->statement_list_may_start_here())
4175     {
4176       this->gogo_->start_block(this->location());
4177       if (switch_no != NULL && types.size() == 1)
4178         {
4179           Type* type = types.front();
4180           Expression* init = Expression::make_var_reference(switch_no,
4181                                                             location);
4182           init = Expression::make_type_guard(init, type, location);
4183           Variable* v = new Variable(type, init, false, false, false,
4184                                      location);
4185           v->set_is_type_switch_var();
4186           this->gogo_->add_variable(switch_no->name(), v);
4187         }
4188       this->statement_list();
4189       statements = this->gogo_->finish_block(this->location());
4190     }
4191
4192   if (this->peek_token()->is_keyword(KEYWORD_FALLTHROUGH))
4193     {
4194       error_at(this->location(),
4195                "fallthrough is not permitted in a type switch");
4196       if (this->advance_token()->is_op(OPERATOR_SEMICOLON))
4197         this->advance_token();
4198     }
4199
4200   if (is_default)
4201     {
4202       go_assert(types.empty());
4203       if (*saw_default)
4204         {
4205           error_at(location, "multiple defaults in type switch");
4206           return;
4207         }
4208       *saw_default = true;
4209       clauses->add(NULL, false, true, statements, location);
4210     }
4211   else if (!types.empty())
4212     {
4213       for (std::vector<Type*>::const_iterator p = types.begin();
4214            p + 1 != types.end();
4215            ++p)
4216         clauses->add(*p, true, false, NULL, location);
4217       clauses->add(types.back(), false, false, statements, location);
4218     }
4219   else
4220     clauses->add(Type::make_error_type(), false, false, statements, location);
4221 }
4222
4223 // TypeSwitchCase  = "case" type | "default"
4224
4225 // We accept a comma separated list of types.
4226
4227 void
4228 Parse::type_switch_case(std::vector<Type*>* types, bool* is_default)
4229 {
4230   const Token* token = this->peek_token();
4231   if (token->is_keyword(KEYWORD_CASE))
4232     {
4233       this->advance_token();
4234       while (true)
4235         {
4236           Type* t = this->type();
4237           if (!t->is_error_type())
4238             types->push_back(t);
4239           if (!this->peek_token()->is_op(OPERATOR_COMMA))
4240             break;
4241           this->advance_token();
4242         }
4243     }
4244   else if (token->is_keyword(KEYWORD_DEFAULT))
4245     {
4246       this->advance_token();
4247       *is_default = true;
4248     }
4249   else
4250     {
4251       error_at(this->location(), "expected %<case%> or %<default%>");
4252       if (!token->is_op(OPERATOR_RCURLY))
4253         this->advance_token();
4254     }
4255 }
4256
4257 // SelectStat = "select" "{" { CommClause } "}" .
4258
4259 void
4260 Parse::select_stat(Label* label)
4261 {
4262   go_assert(this->peek_token()->is_keyword(KEYWORD_SELECT));
4263   source_location location = this->location();
4264   const Token* token = this->advance_token();
4265
4266   if (!token->is_op(OPERATOR_LCURLY))
4267     {
4268       source_location token_loc = token->location();
4269       if (token->is_op(OPERATOR_SEMICOLON)
4270           && this->advance_token()->is_op(OPERATOR_LCURLY))
4271         error_at(token_loc, "unexpected semicolon or newline before %<{%>");
4272       else
4273         {
4274           error_at(this->location(), "expected %<{%>");
4275           return;
4276         }
4277     }
4278   this->advance_token();
4279
4280   Select_statement* statement = Statement::make_select_statement(location);
4281
4282   this->push_break_statement(statement, label);
4283
4284   Select_clauses* select_clauses = new Select_clauses();
4285   bool saw_default = false;
4286   while (!this->peek_token()->is_op(OPERATOR_RCURLY))
4287     {
4288       if (this->peek_token()->is_eof())
4289         {
4290           error_at(this->location(), "expected %<}%>");
4291           return;
4292         }
4293       this->comm_clause(select_clauses, &saw_default);
4294     }
4295
4296   this->advance_token();
4297
4298   statement->add_clauses(select_clauses);
4299
4300   this->pop_break_statement();
4301
4302   this->gogo_->add_statement(statement);
4303 }
4304
4305 // CommClause = CommCase ":" { Statement ";" } .
4306
4307 void
4308 Parse::comm_clause(Select_clauses* clauses, bool* saw_default)
4309 {
4310   source_location location = this->location();
4311   bool is_send = false;
4312   Expression* channel = NULL;
4313   Expression* val = NULL;
4314   Expression* closed = NULL;
4315   std::string varname;
4316   std::string closedname;
4317   bool is_default = false;
4318   bool got_case = this->comm_case(&is_send, &channel, &val, &closed,
4319                                   &varname, &closedname, &is_default);
4320
4321   if (!is_send
4322       && varname.empty()
4323       && closedname.empty()
4324       && val != NULL
4325       && val->index_expression() != NULL)
4326     val->index_expression()->set_is_lvalue();
4327
4328   if (this->peek_token()->is_op(OPERATOR_COLON))
4329     this->advance_token();
4330   else
4331     error_at(this->location(), "expected colon");
4332
4333   this->gogo_->start_block(this->location());
4334
4335   Named_object* var = NULL;
4336   if (!varname.empty())
4337     {
4338       // FIXME: LOCATION is slightly wrong here.
4339       Variable* v = new Variable(NULL, channel, false, false, false,
4340                                  location);
4341       v->set_type_from_chan_element();
4342       var = this->gogo_->add_variable(varname, v);
4343     }
4344
4345   Named_object* closedvar = NULL;
4346   if (!closedname.empty())
4347     {
4348       // FIXME: LOCATION is slightly wrong here.
4349       Variable* v = new Variable(Type::lookup_bool_type(), NULL,
4350                                  false, false, false, location);
4351       closedvar = this->gogo_->add_variable(closedname, v);
4352     }
4353
4354   this->statement_list();
4355
4356   Block* statements = this->gogo_->finish_block(this->location());
4357
4358   if (is_default)
4359     {
4360       if (*saw_default)
4361         {
4362           error_at(location, "multiple defaults in select");
4363           return;
4364         }
4365       *saw_default = true;
4366     }
4367
4368   if (got_case)
4369     clauses->add(is_send, channel, val, closed, var, closedvar, is_default,
4370                  statements, location);
4371   else if (statements != NULL)
4372     {
4373       // Add the statements to make sure that any names they define
4374       // are traversed.
4375       this->gogo_->add_block(statements, location);
4376     }
4377 }
4378
4379 // CommCase   = "case" ( SendStmt | RecvStmt ) | "default" .
4380
4381 bool
4382 Parse::comm_case(bool* is_send, Expression** channel, Expression** val,
4383                  Expression** closed, std::string* varname,
4384                  std::string* closedname, bool* is_default)
4385 {
4386   const Token* token = this->peek_token();
4387   if (token->is_keyword(KEYWORD_DEFAULT))
4388     {
4389       this->advance_token();
4390       *is_default = true;
4391     }
4392   else if (token->is_keyword(KEYWORD_CASE))
4393     {
4394       this->advance_token();
4395       if (!this->send_or_recv_stmt(is_send, channel, val, closed, varname,
4396                                    closedname))
4397         return false;
4398     }
4399   else
4400     {
4401       error_at(this->location(), "expected %<case%> or %<default%>");
4402       if (!token->is_op(OPERATOR_RCURLY))
4403         this->advance_token();
4404       return false;
4405     }
4406
4407   return true;
4408 }
4409
4410 // RecvStmt   = [ Expression [ "," Expression ] ( "=" | ":=" ) ] RecvExpr .
4411 // RecvExpr   = Expression .
4412
4413 bool
4414 Parse::send_or_recv_stmt(bool* is_send, Expression** channel, Expression** val,
4415                          Expression** closed, std::string* varname,
4416                          std::string* closedname)
4417 {
4418   const Token* token = this->peek_token();
4419   bool saw_comma = false;
4420   bool closed_is_id = false;
4421   if (token->is_identifier())
4422     {
4423       Gogo* gogo = this->gogo_;
4424       std::string recv_var = token->identifier();
4425       bool is_rv_exported = token->is_identifier_exported();
4426       source_location recv_var_loc = token->location();
4427       token = this->advance_token();
4428       if (token->is_op(OPERATOR_COLONEQ))
4429         {
4430           // case rv := <-c:
4431           if (!this->advance_token()->is_op(OPERATOR_CHANOP))
4432             {
4433               error_at(this->location(), "expected %<<-%>");
4434               return false;
4435             }
4436           if (recv_var == "_")
4437             {
4438               error_at(recv_var_loc,
4439                        "no new variables on left side of %<:=%>");
4440               recv_var = "blank";
4441             }
4442           *is_send = false;
4443           *varname = gogo->pack_hidden_name(recv_var, is_rv_exported);
4444           this->advance_token();
4445           *channel = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
4446           return true;
4447         }
4448       else if (token->is_op(OPERATOR_COMMA))
4449         {
4450           token = this->advance_token();
4451           if (token->is_identifier())
4452             {
4453               std::string recv_closed = token->identifier();
4454               bool is_rc_exported = token->is_identifier_exported();
4455               source_location recv_closed_loc = token->location();
4456               closed_is_id = true;
4457
4458               token = this->advance_token();
4459               if (token->is_op(OPERATOR_COLONEQ))
4460                 {
4461                   // case rv, rc := <-c:
4462                   if (!this->advance_token()->is_op(OPERATOR_CHANOP))
4463                     {
4464                       error_at(this->location(), "expected %<<-%>");
4465                       return false;
4466                     }
4467                   if (recv_var == "_" && recv_closed == "_")
4468                     {
4469                       error_at(recv_var_loc,
4470                                "no new variables on left side of %<:=%>");
4471                       recv_var = "blank";
4472                     }
4473                   *is_send = false;
4474                   if (recv_var != "_")
4475                     *varname = gogo->pack_hidden_name(recv_var,
4476                                                       is_rv_exported);
4477                   if (recv_closed != "_")
4478                     *closedname = gogo->pack_hidden_name(recv_closed,
4479                                                          is_rc_exported);
4480                   this->advance_token();
4481                   *channel = this->expression(PRECEDENCE_NORMAL, false, true,
4482                                               NULL);
4483                   return true;
4484                 }
4485
4486               this->unget_token(Token::make_identifier_token(recv_closed,
4487                                                              is_rc_exported,
4488                                                              recv_closed_loc));
4489             }
4490
4491           *val = this->id_to_expression(gogo->pack_hidden_name(recv_var,
4492                                                                is_rv_exported),
4493                                         recv_var_loc);
4494           saw_comma = true;
4495         }
4496       else
4497         this->unget_token(Token::make_identifier_token(recv_var,
4498                                                        is_rv_exported,
4499                                                        recv_var_loc));
4500     }
4501
4502   // If SAW_COMMA is false, then we are looking at the start of the
4503   // send or receive expression.  If SAW_COMMA is true, then *VAL is
4504   // set and we just read a comma.
4505
4506   Expression* e;
4507   if (saw_comma || !this->peek_token()->is_op(OPERATOR_CHANOP))
4508     e = this->expression(PRECEDENCE_NORMAL, true, true, NULL);
4509   else
4510     {
4511       // case <-c:
4512       *is_send = false;
4513       this->advance_token();
4514       *channel = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
4515
4516       // The next token should be ':'.  If it is '<-', then we have
4517       // case <-c <- v:
4518       // which is to say, send on a channel received from a channel.
4519       if (!this->peek_token()->is_op(OPERATOR_CHANOP))
4520         return true;
4521
4522       e = Expression::make_receive(*channel, (*channel)->location());
4523     }
4524
4525   if (this->peek_token()->is_op(OPERATOR_EQ))
4526     {
4527       if (!this->advance_token()->is_op(OPERATOR_CHANOP))
4528         {
4529           error_at(this->location(), "missing %<<-%>");
4530           return false;
4531         }
4532       *is_send = false;
4533       this->advance_token();
4534       *channel = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
4535       if (saw_comma)
4536         {
4537           // case v, e = <-c:
4538           // *VAL is already set.
4539           if (!e->is_sink_expression())
4540             *closed = e;
4541         }
4542       else
4543         {
4544           // case v = <-c:
4545           if (!e->is_sink_expression())
4546             *val = e;
4547         }
4548       return true;
4549     }
4550
4551   if (saw_comma)
4552     {
4553       if (closed_is_id)
4554         error_at(this->location(), "expected %<=%> or %<:=%>");
4555       else
4556         error_at(this->location(), "expected %<=%>");
4557       return false;
4558     }
4559
4560   if (this->peek_token()->is_op(OPERATOR_CHANOP))
4561     {
4562       // case c <- v:
4563       *is_send = true;
4564       *channel = this->verify_not_sink(e);
4565       this->advance_token();
4566       *val = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
4567       return true;
4568     }
4569
4570   error_at(this->location(), "expected %<<-%> or %<=%>");
4571   return false;
4572 }
4573
4574 // ForStat = "for" [ Condition | ForClause | RangeClause ] Block .
4575 // Condition = Expression .
4576
4577 void
4578 Parse::for_stat(Label* label)
4579 {
4580   go_assert(this->peek_token()->is_keyword(KEYWORD_FOR));
4581   source_location location = this->location();
4582   const Token* token = this->advance_token();
4583
4584   // Open a block to hold any variables defined in the init statement
4585   // of the for statement.
4586   this->gogo_->start_block(location);
4587
4588   Block* init = NULL;
4589   Expression* cond = NULL;
4590   Block* post = NULL;
4591   Range_clause range_clause;
4592
4593   if (!token->is_op(OPERATOR_LCURLY))
4594     {
4595       if (token->is_keyword(KEYWORD_VAR))
4596         {
4597           error_at(this->location(),
4598                    "var declaration not allowed in for initializer");
4599           this->var_decl();
4600         }
4601
4602       if (token->is_op(OPERATOR_SEMICOLON))
4603         this->for_clause(&cond, &post);
4604       else
4605         {
4606           // We might be looking at a Condition, an InitStat, or a
4607           // RangeClause.
4608           bool saw_send_stmt;
4609           cond = this->simple_stat(false, &saw_send_stmt, &range_clause, NULL);
4610           if (!this->peek_token()->is_op(OPERATOR_SEMICOLON))
4611             {
4612               if (cond == NULL && !range_clause.found)
4613                 {
4614                   if (saw_send_stmt)
4615                     error_at(this->location(),
4616                              ("send statement used as value; "
4617                               "use select for non-blocking send"));
4618                   else
4619                     error_at(this->location(), "parse error in for statement");
4620                 }
4621             }
4622           else
4623             {
4624               if (range_clause.found)
4625                 error_at(this->location(), "parse error after range clause");
4626
4627               if (cond != NULL)
4628                 {
4629                   // COND is actually an expression statement for
4630                   // InitStat at the start of a ForClause.
4631                   this->expression_stat(cond);
4632                   cond = NULL;
4633                 }
4634
4635               this->for_clause(&cond, &post);
4636             }
4637         }
4638     }
4639
4640   // Build the For_statement and note that it is the current target
4641   // for break and continue statements.
4642
4643   For_statement* sfor;
4644   For_range_statement* srange;
4645   Statement* s;
4646   if (!range_clause.found)
4647     {
4648       sfor = Statement::make_for_statement(init, cond, post, location);
4649       s = sfor;
4650       srange = NULL;
4651     }
4652   else
4653     {
4654       srange = Statement::make_for_range_statement(range_clause.index,
4655                                                    range_clause.value,
4656                                                    range_clause.range,
4657                                                    location);
4658       s = srange;
4659       sfor = NULL;
4660     }
4661
4662   this->push_break_statement(s, label);
4663   this->push_continue_statement(s, label);
4664
4665   // Gather the block of statements in the loop and add them to the
4666   // For_statement.
4667
4668   this->gogo_->start_block(this->location());
4669   source_location end_loc = this->block();
4670   Block* statements = this->gogo_->finish_block(end_loc);
4671
4672   if (sfor != NULL)
4673     sfor->add_statements(statements);
4674   else
4675     srange->add_statements(statements);
4676
4677   // This is no longer the break/continue target.
4678   this->pop_break_statement();
4679   this->pop_continue_statement();
4680
4681   // Add the For_statement to the list of statements, and close out
4682   // the block we started to hold any variables defined in the for
4683   // statement.
4684
4685   this->gogo_->add_statement(s);
4686
4687   this->gogo_->add_block(this->gogo_->finish_block(this->location()),
4688                          location);
4689 }
4690
4691 // ForClause = [ InitStat ] ";" [ Condition ] ";" [ PostStat ] .
4692 // InitStat = SimpleStat .
4693 // PostStat = SimpleStat .
4694
4695 // We have already read InitStat at this point.
4696
4697 void
4698 Parse::for_clause(Expression** cond, Block** post)
4699 {
4700   go_assert(this->peek_token()->is_op(OPERATOR_SEMICOLON));
4701   this->advance_token();
4702   if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
4703     *cond = NULL;
4704   else if (this->peek_token()->is_op(OPERATOR_LCURLY))
4705     {
4706       error_at(this->location(),
4707                "unexpected semicolon or newline before %<{%>");
4708       *cond = NULL;
4709       *post = NULL;
4710       return;
4711     }
4712   else
4713     *cond = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
4714   if (!this->peek_token()->is_op(OPERATOR_SEMICOLON))
4715     error_at(this->location(), "expected semicolon");
4716   else
4717     this->advance_token();
4718
4719   if (this->peek_token()->is_op(OPERATOR_LCURLY))
4720     *post = NULL;
4721   else
4722     {
4723       this->gogo_->start_block(this->location());
4724       this->simple_stat(false, NULL, NULL, NULL);
4725       *post = this->gogo_->finish_block(this->location());
4726     }
4727 }
4728
4729 // RangeClause = IdentifierList ( "=" | ":=" ) "range" Expression .
4730
4731 // This is the := version.  It is called with a list of identifiers.
4732
4733 void
4734 Parse::range_clause_decl(const Typed_identifier_list* til,
4735                          Range_clause* p_range_clause)
4736 {
4737   go_assert(this->peek_token()->is_keyword(KEYWORD_RANGE));
4738   source_location location = this->location();
4739
4740   p_range_clause->found = true;
4741
4742   go_assert(til->size() >= 1);
4743   if (til->size() > 2)
4744     error_at(this->location(), "too many variables for range clause");
4745
4746   this->advance_token();
4747   Expression* expr = this->expression(PRECEDENCE_NORMAL, false, false, NULL);
4748   p_range_clause->range = expr;
4749
4750   bool any_new = false;
4751
4752   const Typed_identifier* pti = &til->front();
4753   Named_object* no = this->init_var(*pti, NULL, expr, true, true, &any_new);
4754   if (any_new && no->is_variable())
4755     no->var_value()->set_type_from_range_index();
4756   p_range_clause->index = Expression::make_var_reference(no, location);
4757
4758   if (til->size() == 1)
4759     p_range_clause->value = NULL;
4760   else
4761     {
4762       pti = &til->back();
4763       bool is_new = false;
4764       no = this->init_var(*pti, NULL, expr, true, true, &is_new);
4765       if (is_new && no->is_variable())
4766         no->var_value()->set_type_from_range_value();
4767       if (is_new)
4768         any_new = true;
4769       p_range_clause->value = Expression::make_var_reference(no, location);
4770     }
4771
4772   if (!any_new)
4773     error_at(location, "variables redeclared but no variable is new");
4774 }
4775
4776 // The = version of RangeClause.  This is called with a list of
4777 // expressions.
4778
4779 void
4780 Parse::range_clause_expr(const Expression_list* vals,
4781                          Range_clause* p_range_clause)
4782 {
4783   go_assert(this->peek_token()->is_keyword(KEYWORD_RANGE));
4784
4785   p_range_clause->found = true;
4786
4787   go_assert(vals->size() >= 1);
4788   if (vals->size() > 2)
4789     error_at(this->location(), "too many variables for range clause");
4790
4791   this->advance_token();
4792   p_range_clause->range = this->expression(PRECEDENCE_NORMAL, false, false,
4793                                            NULL);
4794
4795   p_range_clause->index = vals->front();
4796   if (vals->size() == 1)
4797     p_range_clause->value = NULL;
4798   else
4799     p_range_clause->value = vals->back();
4800 }
4801
4802 // Push a statement on the break stack.
4803
4804 void
4805 Parse::push_break_statement(Statement* enclosing, Label* label)
4806 {
4807   if (this->break_stack_ == NULL)
4808     this->break_stack_ = new Bc_stack();
4809   this->break_stack_->push_back(std::make_pair(enclosing, label));
4810 }
4811
4812 // Push a statement on the continue stack.
4813
4814 void
4815 Parse::push_continue_statement(Statement* enclosing, Label* label)
4816 {
4817   if (this->continue_stack_ == NULL)
4818     this->continue_stack_ = new Bc_stack();
4819   this->continue_stack_->push_back(std::make_pair(enclosing, label));
4820 }
4821
4822 // Pop the break stack.
4823
4824 void
4825 Parse::pop_break_statement()
4826 {
4827   this->break_stack_->pop_back();
4828 }
4829
4830 // Pop the continue stack.
4831
4832 void
4833 Parse::pop_continue_statement()
4834 {
4835   this->continue_stack_->pop_back();
4836 }
4837
4838 // Find a break or continue statement given a label name.
4839
4840 Statement*
4841 Parse::find_bc_statement(const Bc_stack* bc_stack, const std::string& label)
4842 {
4843   if (bc_stack == NULL)
4844     return NULL;
4845   for (Bc_stack::const_reverse_iterator p = bc_stack->rbegin();
4846        p != bc_stack->rend();
4847        ++p)
4848     {
4849       if (p->second != NULL && p->second->name() == label)
4850         {
4851           p->second->set_is_used();
4852           return p->first;
4853         }
4854     }
4855   return NULL;
4856 }
4857
4858 // BreakStat = "break" [ identifier ] .
4859
4860 void
4861 Parse::break_stat()
4862 {
4863   go_assert(this->peek_token()->is_keyword(KEYWORD_BREAK));
4864   source_location location = this->location();
4865
4866   const Token* token = this->advance_token();
4867   Statement* enclosing;
4868   if (!token->is_identifier())
4869     {
4870       if (this->break_stack_ == NULL || this->break_stack_->empty())
4871         {
4872           error_at(this->location(),
4873                    "break statement not within for or switch or select");
4874           return;
4875         }
4876       enclosing = this->break_stack_->back().first;
4877     }
4878   else
4879     {
4880       enclosing = this->find_bc_statement(this->break_stack_,
4881                                           token->identifier());
4882       if (enclosing == NULL)
4883         {
4884           // If there is a label with this name, mark it as used to
4885           // avoid a useless error about an unused label.
4886           this->gogo_->add_label_reference(token->identifier());
4887
4888           error_at(token->location(), "invalid break label %qs",
4889                    Gogo::message_name(token->identifier()).c_str());
4890           this->advance_token();
4891           return;
4892         }
4893       this->advance_token();
4894     }
4895
4896   Unnamed_label* label;
4897   if (enclosing->classification() == Statement::STATEMENT_FOR)
4898     label = enclosing->for_statement()->break_label();
4899   else if (enclosing->classification() == Statement::STATEMENT_FOR_RANGE)
4900     label = enclosing->for_range_statement()->break_label();
4901   else if (enclosing->classification() == Statement::STATEMENT_SWITCH)
4902     label = enclosing->switch_statement()->break_label();
4903   else if (enclosing->classification() == Statement::STATEMENT_TYPE_SWITCH)
4904     label = enclosing->type_switch_statement()->break_label();
4905   else if (enclosing->classification() == Statement::STATEMENT_SELECT)
4906     label = enclosing->select_statement()->break_label();
4907   else
4908     go_unreachable();
4909
4910   this->gogo_->add_statement(Statement::make_break_statement(label,
4911                                                              location));
4912 }
4913
4914 // ContinueStat = "continue" [ identifier ] .
4915
4916 void
4917 Parse::continue_stat()
4918 {
4919   go_assert(this->peek_token()->is_keyword(KEYWORD_CONTINUE));
4920   source_location location = this->location();
4921
4922   const Token* token = this->advance_token();
4923   Statement* enclosing;
4924   if (!token->is_identifier())
4925     {
4926       if (this->continue_stack_ == NULL || this->continue_stack_->empty())
4927         {
4928           error_at(this->location(), "continue statement not within for");
4929           return;
4930         }
4931       enclosing = this->continue_stack_->back().first;
4932     }
4933   else
4934     {
4935       enclosing = this->find_bc_statement(this->continue_stack_,
4936                                           token->identifier());
4937       if (enclosing == NULL)
4938         {
4939           // If there is a label with this name, mark it as used to
4940           // avoid a useless error about an unused label.
4941           this->gogo_->add_label_reference(token->identifier());
4942
4943           error_at(token->location(), "invalid continue label %qs",
4944                    Gogo::message_name(token->identifier()).c_str());
4945           this->advance_token();
4946           return;
4947         }
4948       this->advance_token();
4949     }
4950
4951   Unnamed_label* label;
4952   if (enclosing->classification() == Statement::STATEMENT_FOR)
4953     label = enclosing->for_statement()->continue_label();
4954   else if (enclosing->classification() == Statement::STATEMENT_FOR_RANGE)
4955     label = enclosing->for_range_statement()->continue_label();
4956   else
4957     go_unreachable();
4958
4959   this->gogo_->add_statement(Statement::make_continue_statement(label,
4960                                                                 location));
4961 }
4962
4963 // GotoStat = "goto" identifier .
4964
4965 void
4966 Parse::goto_stat()
4967 {
4968   go_assert(this->peek_token()->is_keyword(KEYWORD_GOTO));
4969   source_location location = this->location();
4970   const Token* token = this->advance_token();
4971   if (!token->is_identifier())
4972     error_at(this->location(), "expected label for goto");
4973   else
4974     {
4975       Label* label = this->gogo_->add_label_reference(token->identifier());
4976       Statement* s = Statement::make_goto_statement(label, location);
4977       this->gogo_->add_statement(s);
4978       this->advance_token();
4979     }
4980 }
4981
4982 // PackageClause = "package" PackageName .
4983
4984 void
4985 Parse::package_clause()
4986 {
4987   const Token* token = this->peek_token();
4988   source_location location = token->location();
4989   std::string name;
4990   if (!token->is_keyword(KEYWORD_PACKAGE))
4991     {
4992       error_at(this->location(), "program must start with package clause");
4993       name = "ERROR";
4994     }
4995   else
4996     {
4997       token = this->advance_token();
4998       if (token->is_identifier())
4999         {
5000           name = token->identifier();
5001           if (name == "_")
5002             {
5003               error_at(this->location(), "invalid package name _");
5004               name = "blank";
5005             }
5006           this->advance_token();
5007         }
5008       else
5009         {
5010           error_at(this->location(), "package name must be an identifier");
5011           name = "ERROR";
5012         }
5013     }
5014   this->gogo_->set_package_name(name, location);
5015 }
5016
5017 // ImportDecl = "import" Decl<ImportSpec> .
5018
5019 void
5020 Parse::import_decl()
5021 {
5022   go_assert(this->peek_token()->is_keyword(KEYWORD_IMPORT));
5023   this->advance_token();
5024   this->decl(&Parse::import_spec, NULL);
5025 }
5026
5027 // ImportSpec = [ "." | PackageName ] PackageFileName .
5028
5029 void
5030 Parse::import_spec(void*)
5031 {
5032   const Token* token = this->peek_token();
5033   source_location location = token->location();
5034
5035   std::string local_name;
5036   bool is_local_name_exported = false;
5037   if (token->is_op(OPERATOR_DOT))
5038     {
5039       local_name = ".";
5040       token = this->advance_token();
5041     }
5042   else if (token->is_identifier())
5043     {
5044       local_name = token->identifier();
5045       is_local_name_exported = token->is_identifier_exported();
5046       token = this->advance_token();
5047     }
5048
5049   if (!token->is_string())
5050     {
5051       error_at(this->location(), "missing import package name");
5052       return;
5053     }
5054
5055   this->gogo_->import_package(token->string_value(), local_name,
5056                               is_local_name_exported, location);
5057
5058   this->advance_token();
5059 }
5060
5061 // SourceFile       = PackageClause ";" { ImportDecl ";" }
5062 //                      { TopLevelDecl ";" } .
5063
5064 void
5065 Parse::program()
5066 {
5067   this->package_clause();
5068
5069   const Token* token = this->peek_token();
5070   if (token->is_op(OPERATOR_SEMICOLON))
5071     token = this->advance_token();
5072   else
5073     error_at(this->location(),
5074              "expected %<;%> or newline after package clause");
5075
5076   while (token->is_keyword(KEYWORD_IMPORT))
5077     {
5078       this->import_decl();
5079       token = this->peek_token();
5080       if (token->is_op(OPERATOR_SEMICOLON))
5081         token = this->advance_token();
5082       else
5083         error_at(this->location(),
5084                  "expected %<;%> or newline after import declaration");
5085     }
5086
5087   while (!token->is_eof())
5088     {
5089       if (this->declaration_may_start_here())
5090         this->declaration();
5091       else
5092         {
5093           error_at(this->location(), "expected declaration");
5094           do
5095             this->advance_token();
5096           while (!this->peek_token()->is_eof()
5097                  && !this->peek_token()->is_op(OPERATOR_SEMICOLON)
5098                  && !this->peek_token()->is_op(OPERATOR_RCURLY));
5099           if (!this->peek_token()->is_eof()
5100               && !this->peek_token()->is_op(OPERATOR_SEMICOLON))
5101             this->advance_token();
5102         }
5103       token = this->peek_token();
5104       if (token->is_op(OPERATOR_SEMICOLON))
5105         token = this->advance_token();
5106       else if (!token->is_eof() || !saw_errors())
5107         {
5108           if (token->is_op(OPERATOR_CHANOP))
5109             error_at(this->location(),
5110                      ("send statement used as value; "
5111                       "use select for non-blocking send"));
5112           else
5113             error_at(this->location(),
5114                      "expected %<;%> or newline after top level declaration");
5115           this->skip_past_error(OPERATOR_INVALID);
5116         }
5117     }
5118 }
5119
5120 // Reset the current iota value.
5121
5122 void
5123 Parse::reset_iota()
5124 {
5125   this->iota_ = 0;
5126 }
5127
5128 // Return the current iota value.
5129
5130 int
5131 Parse::iota_value()
5132 {
5133   return this->iota_;
5134 }
5135
5136 // Increment the current iota value.
5137
5138 void
5139 Parse::increment_iota()
5140 {
5141   ++this->iota_;
5142 }
5143
5144 // Skip forward to a semicolon or OP.  OP will normally be
5145 // OPERATOR_RPAREN or OPERATOR_RCURLY.  If we find a semicolon, move
5146 // past it and return.  If we find OP, it will be the next token to
5147 // read.  Return true if we are OK, false if we found EOF.
5148
5149 bool
5150 Parse::skip_past_error(Operator op)
5151 {
5152   const Token* token = this->peek_token();
5153   while (!token->is_op(op))
5154     {
5155       if (token->is_eof())
5156         return false;
5157       if (token->is_op(OPERATOR_SEMICOLON))
5158         {
5159           this->advance_token();
5160           return true;
5161         }
5162       token = this->advance_token();
5163     }
5164   return true;
5165 }
5166
5167 // Check that an expression is not a sink.
5168
5169 Expression*
5170 Parse::verify_not_sink(Expression* expr)
5171 {
5172   if (expr->is_sink_expression())
5173     {
5174       error_at(expr->location(), "cannot use _ as value");
5175       expr = Expression::make_error(expr->location());
5176     }
5177   return expr;
5178 }