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