OSDN Git Service

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