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