OSDN Git Service

ab2bb7cf29d036a340450c9a0565aefd61d373e3
[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()->pkgpath()
327                            + '.' + name);
328           named_object = package->package_value()->lookup(s);
329           if (named_object != NULL)
330             {
331               Package* p = package->package_value();
332               const std::string& packname(p->package_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()->package_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.  But we do have to worry about a mix of
1635   // newly declared variables and old variables if the old variables
1636   // appear in the initializations.
1637
1638   Expression_list::const_iterator pexpr;
1639   if (init != NULL)
1640     pexpr = init->begin();
1641   bool any_new = false;
1642   Expression_list* vars = new Expression_list();
1643   Expression_list* vals = new Expression_list();
1644   for (Typed_identifier_list::const_iterator p = til->begin();
1645        p != til->end();
1646        ++p)
1647     {
1648       if (init != NULL)
1649         go_assert(pexpr != init->end());
1650       this->init_var(*p, type, init == NULL ? NULL : *pexpr, is_coloneq,
1651                      false, &any_new, vars, vals);
1652       if (init != NULL)
1653         ++pexpr;
1654     }
1655   if (init != NULL)
1656     go_assert(pexpr == init->end());
1657   if (is_coloneq && !any_new)
1658     error_at(location, "variables redeclared but no variable is new");
1659   this->finish_init_vars(vars, vals, location);
1660 }
1661
1662 // See if we need to initialize a list of variables from a function
1663 // call.  This returns true if we have set up the variables and the
1664 // initialization.
1665
1666 bool
1667 Parse::init_vars_from_call(const Typed_identifier_list* vars, Type* type,
1668                            Expression* expr, bool is_coloneq,
1669                            Location location)
1670 {
1671   Call_expression* call = expr->call_expression();
1672   if (call == NULL)
1673     return false;
1674
1675   // This is a function call.  We can't check here whether it returns
1676   // the right number of values, but it might.  Declare the variables,
1677   // and then assign the results of the call to them.
1678
1679   Named_object* first_var = NULL;
1680   unsigned int index = 0;
1681   bool any_new = false;
1682   Expression_list* ivars = new Expression_list();
1683   Expression_list* ivals = new Expression_list();
1684   for (Typed_identifier_list::const_iterator pv = vars->begin();
1685        pv != vars->end();
1686        ++pv, ++index)
1687     {
1688       Expression* init = Expression::make_call_result(call, index);
1689       Named_object* no = this->init_var(*pv, type, init, is_coloneq, false,
1690                                         &any_new, ivars, ivals);
1691
1692       if (this->gogo_->in_global_scope() && no->is_variable())
1693         {
1694           if (first_var == NULL)
1695             first_var = no;
1696           else
1697             {
1698               // The subsequent vars have an implicit dependency on
1699               // the first one, so that everything gets initialized in
1700               // the right order and so that we detect cycles
1701               // correctly.
1702               this->gogo_->record_var_depends_on(no->var_value(), first_var);
1703             }
1704         }
1705     }
1706
1707   if (is_coloneq && !any_new)
1708     error_at(location, "variables redeclared but no variable is new");
1709
1710   this->finish_init_vars(ivars, ivals, location);
1711
1712   return true;
1713 }
1714
1715 // See if we need to initialize a pair of values from a map index
1716 // expression.  This returns true if we have set up the variables and
1717 // the initialization.
1718
1719 bool
1720 Parse::init_vars_from_map(const Typed_identifier_list* vars, Type* type,
1721                           Expression* expr, bool is_coloneq,
1722                           Location location)
1723 {
1724   Index_expression* index = expr->index_expression();
1725   if (index == NULL)
1726     return false;
1727   if (vars->size() != 2)
1728     return false;
1729
1730   // This is an index which is being assigned to two variables.  It
1731   // must be a map index.  Declare the variables, and then assign the
1732   // results of the map index.
1733   bool any_new = false;
1734   Typed_identifier_list::const_iterator p = vars->begin();
1735   Expression* init = type == NULL ? index : NULL;
1736   Named_object* val_no = this->init_var(*p, type, init, is_coloneq,
1737                                         type == NULL, &any_new, NULL, NULL);
1738   if (type == NULL && any_new && val_no->is_variable())
1739     val_no->var_value()->set_type_from_init_tuple();
1740   Expression* val_var = Expression::make_var_reference(val_no, location);
1741
1742   ++p;
1743   Type* var_type = type;
1744   if (var_type == NULL)
1745     var_type = Type::lookup_bool_type();
1746   Named_object* no = this->init_var(*p, var_type, NULL, is_coloneq, false,
1747                                     &any_new, NULL, NULL);
1748   Expression* present_var = Expression::make_var_reference(no, location);
1749
1750   if (is_coloneq && !any_new)
1751     error_at(location, "variables redeclared but no variable is new");
1752
1753   Statement* s = Statement::make_tuple_map_assignment(val_var, present_var,
1754                                                       index, location);
1755
1756   if (!this->gogo_->in_global_scope())
1757     this->gogo_->add_statement(s);
1758   else if (!val_no->is_sink())
1759     {
1760       if (val_no->is_variable())
1761         val_no->var_value()->add_preinit_statement(this->gogo_, s);
1762     }
1763   else if (!no->is_sink())
1764     {
1765       if (no->is_variable())
1766         no->var_value()->add_preinit_statement(this->gogo_, s);
1767     }
1768   else
1769     {
1770       // Execute the map index expression just so that we can fail if
1771       // the map is nil.
1772       Named_object* dummy = this->create_dummy_global(Type::lookup_bool_type(),
1773                                                       NULL, location);
1774       dummy->var_value()->add_preinit_statement(this->gogo_, s);
1775     }
1776
1777   return true;
1778 }
1779
1780 // See if we need to initialize a pair of values from a receive
1781 // expression.  This returns true if we have set up the variables and
1782 // the initialization.
1783
1784 bool
1785 Parse::init_vars_from_receive(const Typed_identifier_list* vars, Type* type,
1786                               Expression* expr, bool is_coloneq,
1787                               Location location)
1788 {
1789   Receive_expression* receive = expr->receive_expression();
1790   if (receive == NULL)
1791     return false;
1792   if (vars->size() != 2)
1793     return false;
1794
1795   // This is a receive expression which is being assigned to two
1796   // variables.  Declare the variables, and then assign the results of
1797   // the receive.
1798   bool any_new = false;
1799   Typed_identifier_list::const_iterator p = vars->begin();
1800   Expression* init = type == NULL ? receive : NULL;
1801   Named_object* val_no = this->init_var(*p, type, init, is_coloneq,
1802                                         type == NULL, &any_new, NULL, NULL);
1803   if (type == NULL && any_new && val_no->is_variable())
1804     val_no->var_value()->set_type_from_init_tuple();
1805   Expression* val_var = Expression::make_var_reference(val_no, location);
1806
1807   ++p;
1808   Type* var_type = type;
1809   if (var_type == NULL)
1810     var_type = Type::lookup_bool_type();
1811   Named_object* no = this->init_var(*p, var_type, NULL, is_coloneq, false,
1812                                     &any_new, NULL, NULL);
1813   Expression* received_var = Expression::make_var_reference(no, location);
1814
1815   if (is_coloneq && !any_new)
1816     error_at(location, "variables redeclared but no variable is new");
1817
1818   Statement* s = Statement::make_tuple_receive_assignment(val_var,
1819                                                           received_var,
1820                                                           receive->channel(),
1821                                                           location);
1822
1823   if (!this->gogo_->in_global_scope())
1824     this->gogo_->add_statement(s);
1825   else if (!val_no->is_sink())
1826     {
1827       if (val_no->is_variable())
1828         val_no->var_value()->add_preinit_statement(this->gogo_, s);
1829     }
1830   else if (!no->is_sink())
1831     {
1832       if (no->is_variable())
1833         no->var_value()->add_preinit_statement(this->gogo_, s);
1834     }
1835   else
1836     {
1837       Named_object* dummy = this->create_dummy_global(Type::lookup_bool_type(),
1838                                                       NULL, location);
1839       dummy->var_value()->add_preinit_statement(this->gogo_, s);
1840     }
1841
1842   return true;
1843 }
1844
1845 // See if we need to initialize a pair of values from a type guard
1846 // expression.  This returns true if we have set up the variables and
1847 // the initialization.
1848
1849 bool
1850 Parse::init_vars_from_type_guard(const Typed_identifier_list* vars,
1851                                  Type* type, Expression* expr,
1852                                  bool is_coloneq, Location location)
1853 {
1854   Type_guard_expression* type_guard = expr->type_guard_expression();
1855   if (type_guard == NULL)
1856     return false;
1857   if (vars->size() != 2)
1858     return false;
1859
1860   // This is a type guard expression which is being assigned to two
1861   // variables.  Declare the variables, and then assign the results of
1862   // the type guard.
1863   bool any_new = false;
1864   Typed_identifier_list::const_iterator p = vars->begin();
1865   Type* var_type = type;
1866   if (var_type == NULL)
1867     var_type = type_guard->type();
1868   Named_object* val_no = this->init_var(*p, var_type, NULL, is_coloneq, false,
1869                                         &any_new, NULL, NULL);
1870   Expression* val_var = Expression::make_var_reference(val_no, location);
1871
1872   ++p;
1873   var_type = type;
1874   if (var_type == NULL)
1875     var_type = Type::lookup_bool_type();
1876   Named_object* no = this->init_var(*p, var_type, NULL, is_coloneq, false,
1877                                     &any_new, NULL, NULL);
1878   Expression* ok_var = Expression::make_var_reference(no, location);
1879
1880   Expression* texpr = type_guard->expr();
1881   Type* t = type_guard->type();
1882   Statement* s = Statement::make_tuple_type_guard_assignment(val_var, ok_var,
1883                                                              texpr, t,
1884                                                              location);
1885
1886   if (is_coloneq && !any_new)
1887     error_at(location, "variables redeclared but no variable is new");
1888
1889   if (!this->gogo_->in_global_scope())
1890     this->gogo_->add_statement(s);
1891   else if (!val_no->is_sink())
1892     {
1893       if (val_no->is_variable())
1894         val_no->var_value()->add_preinit_statement(this->gogo_, s);
1895     }
1896   else if (!no->is_sink())
1897     {
1898       if (no->is_variable())
1899         no->var_value()->add_preinit_statement(this->gogo_, s);
1900     }
1901   else
1902     {
1903       Named_object* dummy = this->create_dummy_global(type, NULL, location);
1904       dummy->var_value()->add_preinit_statement(this->gogo_, s);
1905     }
1906
1907   return true;
1908 }
1909
1910 // Create a single variable.  If IS_COLONEQ is true, we permit
1911 // redeclarations in the same block, and we set *IS_NEW when we find a
1912 // new variable which is not a redeclaration.
1913
1914 Named_object*
1915 Parse::init_var(const Typed_identifier& tid, Type* type, Expression* init,
1916                 bool is_coloneq, bool type_from_init, bool* is_new,
1917                 Expression_list* vars, Expression_list* vals)
1918 {
1919   Location location = tid.location();
1920
1921   if (Gogo::is_sink_name(tid.name()))
1922     {
1923       if (!type_from_init && init != NULL)
1924         {
1925           if (this->gogo_->in_global_scope())
1926             return this->create_dummy_global(type, init, location);
1927           else if (type == NULL)
1928             this->gogo_->add_statement(Statement::make_statement(init, true));
1929           else
1930             {
1931               // With both a type and an initializer, create a dummy
1932               // variable so that we will check whether the
1933               // initializer can be assigned to the type.
1934               Variable* var = new Variable(type, init, false, false, false,
1935                                            location);
1936               var->set_is_used();
1937               static int count;
1938               char buf[30];
1939               snprintf(buf, sizeof buf, "sink$%d", count);
1940               ++count;
1941               return this->gogo_->add_variable(buf, var);
1942             }
1943         }
1944       if (type != NULL)
1945         this->gogo_->add_type_to_verify(type);
1946       return this->gogo_->add_sink();
1947     }
1948
1949   if (is_coloneq)
1950     {
1951       Named_object* no = this->gogo_->lookup_in_block(tid.name());
1952       if (no != NULL
1953           && (no->is_variable() || no->is_result_variable()))
1954         {
1955           // INIT may be NULL even when IS_COLONEQ is true for cases
1956           // like v, ok := x.(int).
1957           if (!type_from_init && init != NULL)
1958             {
1959               go_assert(vars != NULL && vals != NULL);
1960               vars->push_back(Expression::make_var_reference(no, location));
1961               vals->push_back(init);
1962             }
1963           return no;
1964         }
1965     }
1966   *is_new = true;
1967   Variable* var = new Variable(type, init, this->gogo_->in_global_scope(),
1968                                false, false, location);
1969   Named_object* no = this->gogo_->add_variable(tid.name(), var);
1970   if (!no->is_variable())
1971     {
1972       // The name is already defined, so we just gave an error.
1973       return this->gogo_->add_sink();
1974     }
1975   return no;
1976 }
1977
1978 // Create a dummy global variable to force an initializer to be run in
1979 // the right place.  This is used when a sink variable is initialized
1980 // at global scope.
1981
1982 Named_object*
1983 Parse::create_dummy_global(Type* type, Expression* init,
1984                            Location location)
1985 {
1986   if (type == NULL && init == NULL)
1987     type = Type::lookup_bool_type();
1988   Variable* var = new Variable(type, init, true, false, false, location);
1989   static int count;
1990   char buf[30];
1991   snprintf(buf, sizeof buf, "_.%d", count);
1992   ++count;
1993   return this->gogo_->add_variable(buf, var);
1994 }
1995
1996 // Finish the variable initialization by executing any assignments to
1997 // existing variables when using :=.  These must be done as a tuple
1998 // assignment in case of something like n, a, b := 1, b, a.
1999
2000 void
2001 Parse::finish_init_vars(Expression_list* vars, Expression_list* vals,
2002                         Location location)
2003 {
2004   if (vars->empty())
2005     {
2006       delete vars;
2007       delete vals;
2008     }
2009   else if (vars->size() == 1)
2010     {
2011       go_assert(!this->gogo_->in_global_scope());
2012       this->gogo_->add_statement(Statement::make_assignment(vars->front(),
2013                                                             vals->front(),
2014                                                             location));
2015       delete vars;
2016       delete vals;
2017     }
2018   else
2019     {
2020       go_assert(!this->gogo_->in_global_scope());
2021       this->gogo_->add_statement(Statement::make_tuple_assignment(vars, vals,
2022                                                                   location));
2023     }
2024 }
2025
2026 // SimpleVarDecl = identifier ":=" Expression .
2027
2028 // We've already seen the identifier.
2029
2030 // FIXME: We also have to implement
2031 //  IdentifierList ":=" ExpressionList
2032 // In order to support both "a, b := 1, 0" and "a, b = 1, 0" we accept
2033 // tuple assignments here as well.
2034
2035 // If MAY_BE_COMPOSITE_LIT is true, the expression on the right hand
2036 // side may be a composite literal.
2037
2038 // If P_RANGE_CLAUSE is not NULL, then this will recognize a
2039 // RangeClause.
2040
2041 // If P_TYPE_SWITCH is not NULL, this will recognize a type switch
2042 // guard (var := expr.("type") using the literal keyword "type").
2043
2044 void
2045 Parse::simple_var_decl_or_assignment(const std::string& name,
2046                                      Location location,
2047                                      bool may_be_composite_lit,
2048                                      Range_clause* p_range_clause,
2049                                      Type_switch* p_type_switch)
2050 {
2051   Typed_identifier_list til;
2052   til.push_back(Typed_identifier(name, NULL, location));
2053
2054   // We've seen one identifier.  If we see a comma now, this could be
2055   // "a, *p = 1, 2".
2056   if (this->peek_token()->is_op(OPERATOR_COMMA))
2057     {
2058       go_assert(p_type_switch == NULL);
2059       while (true)
2060         {
2061           const Token* token = this->advance_token();
2062           if (!token->is_identifier())
2063             break;
2064
2065           std::string id = token->identifier();
2066           bool is_id_exported = token->is_identifier_exported();
2067           Location id_location = token->location();
2068
2069           token = this->advance_token();
2070           if (!token->is_op(OPERATOR_COMMA))
2071             {
2072               if (token->is_op(OPERATOR_COLONEQ))
2073                 {
2074                   id = this->gogo_->pack_hidden_name(id, is_id_exported);
2075                   til.push_back(Typed_identifier(id, NULL, location));
2076                 }
2077               else
2078                 this->unget_token(Token::make_identifier_token(id,
2079                                                                is_id_exported,
2080                                                                id_location));
2081               break;
2082             }
2083
2084           id = this->gogo_->pack_hidden_name(id, is_id_exported);
2085           til.push_back(Typed_identifier(id, NULL, location));
2086         }
2087
2088       // We have a comma separated list of identifiers in TIL.  If the
2089       // next token is COLONEQ, then this is a simple var decl, and we
2090       // have the complete list of identifiers.  If the next token is
2091       // not COLONEQ, then the only valid parse is a tuple assignment.
2092       // The list of identifiers we have so far is really a list of
2093       // expressions.  There are more expressions following.
2094
2095       if (!this->peek_token()->is_op(OPERATOR_COLONEQ))
2096         {
2097           Expression_list* exprs = new Expression_list;
2098           for (Typed_identifier_list::const_iterator p = til.begin();
2099                p != til.end();
2100                ++p)
2101             exprs->push_back(this->id_to_expression(p->name(),
2102                                                     p->location()));
2103
2104           Expression_list* more_exprs =
2105             this->expression_list(NULL, true, may_be_composite_lit);
2106           for (Expression_list::const_iterator p = more_exprs->begin();
2107                p != more_exprs->end();
2108                ++p)
2109             exprs->push_back(*p);
2110           delete more_exprs;
2111
2112           this->tuple_assignment(exprs, may_be_composite_lit, p_range_clause);
2113           return;
2114         }
2115     }
2116
2117   go_assert(this->peek_token()->is_op(OPERATOR_COLONEQ));
2118   const Token* token = this->advance_token();
2119
2120   if (p_range_clause != NULL && token->is_keyword(KEYWORD_RANGE))
2121     {
2122       this->range_clause_decl(&til, p_range_clause);
2123       return;
2124     }
2125
2126   Expression_list* init;
2127   if (p_type_switch == NULL)
2128     init = this->expression_list(NULL, false, may_be_composite_lit);
2129   else
2130     {
2131       bool is_type_switch = false;
2132       Expression* expr = this->expression(PRECEDENCE_NORMAL, false,
2133                                           may_be_composite_lit,
2134                                           &is_type_switch);
2135       if (is_type_switch)
2136         {
2137           p_type_switch->found = true;
2138           p_type_switch->name = name;
2139           p_type_switch->location = location;
2140           p_type_switch->expr = expr;
2141           return;
2142         }
2143
2144       if (!this->peek_token()->is_op(OPERATOR_COMMA))
2145         {
2146           init = new Expression_list();
2147           init->push_back(expr);
2148         }
2149       else
2150         {
2151           this->advance_token();
2152           init = this->expression_list(expr, false, may_be_composite_lit);
2153         }
2154     }
2155
2156   this->init_vars(&til, NULL, init, true, location);
2157 }
2158
2159 // FunctionDecl = "func" identifier Signature [ Block ] .
2160 // MethodDecl = "func" Receiver identifier Signature [ Block ] .
2161
2162 // Deprecated gcc extension:
2163 //   FunctionDecl = "func" identifier Signature
2164 //                    __asm__ "(" string_lit ")" .
2165 // This extension means a function whose real name is the identifier
2166 // inside the asm.  This extension will be removed at some future
2167 // date.  It has been replaced with //extern comments.
2168
2169 void
2170 Parse::function_decl()
2171 {
2172   go_assert(this->peek_token()->is_keyword(KEYWORD_FUNC));
2173   Location location = this->location();
2174   std::string extern_name = this->lex_->extern_name();
2175   const Token* token = this->advance_token();
2176
2177   Typed_identifier* rec = NULL;
2178   if (token->is_op(OPERATOR_LPAREN))
2179     {
2180       rec = this->receiver();
2181       token = this->peek_token();
2182     }
2183
2184   if (!token->is_identifier())
2185     {
2186       error_at(this->location(), "expected function name");
2187       return;
2188     }
2189
2190   std::string name =
2191     this->gogo_->pack_hidden_name(token->identifier(),
2192                                   token->is_identifier_exported());
2193
2194   this->advance_token();
2195
2196   Function_type* fntype = this->signature(rec, this->location());
2197
2198   Named_object* named_object = NULL;
2199
2200   if (this->peek_token()->is_keyword(KEYWORD_ASM))
2201     {
2202       if (!this->advance_token()->is_op(OPERATOR_LPAREN))
2203         {
2204           error_at(this->location(), "expected %<(%>");
2205           return;
2206         }
2207       token = this->advance_token();
2208       if (!token->is_string())
2209         {
2210           error_at(this->location(), "expected string");
2211           return;
2212         }
2213       std::string asm_name = token->string_value();
2214       if (!this->advance_token()->is_op(OPERATOR_RPAREN))
2215         {
2216           error_at(this->location(), "expected %<)%>");
2217           return;
2218         }
2219       this->advance_token();
2220       if (!Gogo::is_sink_name(name))
2221         {
2222           named_object = this->gogo_->declare_function(name, fntype, location);
2223           if (named_object->is_function_declaration())
2224             named_object->func_declaration_value()->set_asm_name(asm_name);
2225         }
2226     }
2227
2228   // Check for the easy error of a newline before the opening brace.
2229   if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
2230     {
2231       Location semi_loc = this->location();
2232       if (this->advance_token()->is_op(OPERATOR_LCURLY))
2233         error_at(this->location(),
2234                  "unexpected semicolon or newline before %<{%>");
2235       else
2236         this->unget_token(Token::make_operator_token(OPERATOR_SEMICOLON,
2237                                                      semi_loc));
2238     }
2239
2240   if (!this->peek_token()->is_op(OPERATOR_LCURLY))
2241     {
2242       if (named_object == NULL && !Gogo::is_sink_name(name))
2243         {
2244           if (fntype == NULL)
2245             this->gogo_->add_erroneous_name(name);
2246           else
2247             {
2248               named_object = this->gogo_->declare_function(name, fntype,
2249                                                            location);
2250               if (!extern_name.empty()
2251                   && named_object->is_function_declaration())
2252                 {
2253                   Function_declaration* fd =
2254                     named_object->func_declaration_value();
2255                   fd->set_asm_name(extern_name);
2256                 }
2257             }
2258         }
2259     }
2260   else
2261     {
2262       bool hold_is_erroneous_function = this->is_erroneous_function_;
2263       if (fntype == NULL)
2264         {
2265           fntype = Type::make_function_type(NULL, NULL, NULL, location);
2266           this->is_erroneous_function_ = true;
2267           if (!Gogo::is_sink_name(name))
2268             this->gogo_->add_erroneous_name(name);
2269           name = this->gogo_->pack_hidden_name("_", false);
2270         }
2271       this->gogo_->start_function(name, fntype, true, location);
2272       Location end_loc = this->block();
2273       this->gogo_->finish_function(end_loc);
2274       this->is_erroneous_function_ = hold_is_erroneous_function;
2275     }
2276 }
2277
2278 // Receiver     = "(" [ identifier ] [ "*" ] BaseTypeName ")" .
2279 // BaseTypeName = identifier .
2280
2281 Typed_identifier*
2282 Parse::receiver()
2283 {
2284   go_assert(this->peek_token()->is_op(OPERATOR_LPAREN));
2285
2286   std::string name;
2287   const Token* token = this->advance_token();
2288   Location location = token->location();
2289   if (!token->is_op(OPERATOR_MULT))
2290     {
2291       if (!token->is_identifier())
2292         {
2293           error_at(this->location(), "method has no receiver");
2294           this->gogo_->mark_locals_used();
2295           while (!token->is_eof() && !token->is_op(OPERATOR_RPAREN))
2296             token = this->advance_token();
2297           if (!token->is_eof())
2298             this->advance_token();
2299           return NULL;
2300         }
2301       name = token->identifier();
2302       bool is_exported = token->is_identifier_exported();
2303       token = this->advance_token();
2304       if (!token->is_op(OPERATOR_DOT) && !token->is_op(OPERATOR_RPAREN))
2305         {
2306           // An identifier followed by something other than a dot or a
2307           // right parenthesis must be a receiver name followed by a
2308           // type.
2309           name = this->gogo_->pack_hidden_name(name, is_exported);
2310         }
2311       else
2312         {
2313           // This must be a type name.
2314           this->unget_token(Token::make_identifier_token(name, is_exported,
2315                                                          location));
2316           token = this->peek_token();
2317           name.clear();
2318         }
2319     }
2320
2321   // Here the receiver name is in NAME (it is empty if the receiver is
2322   // unnamed) and TOKEN is the first token in the type.
2323
2324   bool is_pointer = false;
2325   if (token->is_op(OPERATOR_MULT))
2326     {
2327       is_pointer = true;
2328       token = this->advance_token();
2329     }
2330
2331   if (!token->is_identifier())
2332     {
2333       error_at(this->location(), "expected receiver name or type");
2334       this->gogo_->mark_locals_used();
2335       int c = token->is_op(OPERATOR_LPAREN) ? 1 : 0;
2336       while (!token->is_eof())
2337         {
2338           token = this->advance_token();
2339           if (token->is_op(OPERATOR_LPAREN))
2340             ++c;
2341           else if (token->is_op(OPERATOR_RPAREN))
2342             {
2343               if (c == 0)
2344                 break;
2345               --c;
2346             }
2347         }
2348       if (!token->is_eof())
2349         this->advance_token();
2350       return NULL;
2351     }
2352
2353   Type* type = this->type_name(true);
2354
2355   if (is_pointer && !type->is_error_type())
2356     type = Type::make_pointer_type(type);
2357
2358   if (this->peek_token()->is_op(OPERATOR_RPAREN))
2359     this->advance_token();
2360   else
2361     {
2362       if (this->peek_token()->is_op(OPERATOR_COMMA))
2363         error_at(this->location(), "method has multiple receivers");
2364       else
2365         error_at(this->location(), "expected %<)%>");
2366       this->gogo_->mark_locals_used();
2367       while (!token->is_eof() && !token->is_op(OPERATOR_RPAREN))
2368         token = this->advance_token();
2369       if (!token->is_eof())
2370         this->advance_token();
2371       return NULL;
2372     }
2373
2374   return new Typed_identifier(name, type, location);
2375 }
2376
2377 // Operand    = Literal | QualifiedIdent | MethodExpr | "(" Expression ")" .
2378 // Literal    = BasicLit | CompositeLit | FunctionLit .
2379 // BasicLit   = int_lit | float_lit | imaginary_lit | char_lit | string_lit .
2380
2381 // If MAY_BE_SINK is true, this operand may be "_".
2382
2383 Expression*
2384 Parse::operand(bool may_be_sink)
2385 {
2386   const Token* token = this->peek_token();
2387   Expression* ret;
2388   switch (token->classification())
2389     {
2390     case Token::TOKEN_IDENTIFIER:
2391       {
2392         Location location = token->location();
2393         std::string id = token->identifier();
2394         bool is_exported = token->is_identifier_exported();
2395         std::string packed = this->gogo_->pack_hidden_name(id, is_exported);
2396
2397         Named_object* in_function;
2398         Named_object* named_object = this->gogo_->lookup(packed, &in_function);
2399
2400         Package* package = NULL;
2401         if (named_object != NULL && named_object->is_package())
2402           {
2403             if (!this->advance_token()->is_op(OPERATOR_DOT)
2404                 || !this->advance_token()->is_identifier())
2405               {
2406                 error_at(location, "unexpected reference to package");
2407                 return Expression::make_error(location);
2408               }
2409             package = named_object->package_value();
2410             package->set_used();
2411             id = this->peek_token()->identifier();
2412             is_exported = this->peek_token()->is_identifier_exported();
2413             packed = this->gogo_->pack_hidden_name(id, is_exported);
2414             named_object = package->lookup(packed);
2415             location = this->location();
2416             go_assert(in_function == NULL);
2417           }
2418
2419         this->advance_token();
2420
2421         if (named_object != NULL
2422             && named_object->is_type()
2423             && !named_object->type_value()->is_visible())
2424           {
2425             go_assert(package != NULL);
2426             error_at(location, "invalid reference to hidden type %<%s.%s%>",
2427                      Gogo::message_name(package->package_name()).c_str(),
2428                      Gogo::message_name(id).c_str());
2429             return Expression::make_error(location);
2430           }
2431
2432
2433         if (named_object == NULL)
2434           {
2435             if (package != NULL)
2436               {
2437                 std::string n1 = Gogo::message_name(package->package_name());
2438                 std::string n2 = Gogo::message_name(id);
2439                 if (!is_exported)
2440                   error_at(location,
2441                            ("invalid reference to unexported identifier "
2442                             "%<%s.%s%>"),
2443                            n1.c_str(), n2.c_str());
2444                 else
2445                   error_at(location,
2446                            "reference to undefined identifier %<%s.%s%>",
2447                            n1.c_str(), n2.c_str());
2448                 return Expression::make_error(location);
2449               }
2450
2451             named_object = this->gogo_->add_unknown_name(packed, location);
2452           }
2453
2454         if (in_function != NULL
2455             && in_function != this->gogo_->current_function()
2456             && (named_object->is_variable()
2457                 || named_object->is_result_variable()))
2458           return this->enclosing_var_reference(in_function, named_object,
2459                                                location);
2460
2461         switch (named_object->classification())
2462           {
2463           case Named_object::NAMED_OBJECT_CONST:
2464             return Expression::make_const_reference(named_object, location);
2465           case Named_object::NAMED_OBJECT_TYPE:
2466             return Expression::make_type(named_object->type_value(), location);
2467           case Named_object::NAMED_OBJECT_TYPE_DECLARATION:
2468             {
2469               Type* t = Type::make_forward_declaration(named_object);
2470               return Expression::make_type(t, location);
2471             }
2472           case Named_object::NAMED_OBJECT_VAR:
2473           case Named_object::NAMED_OBJECT_RESULT_VAR:
2474             this->mark_var_used(named_object);
2475             return Expression::make_var_reference(named_object, location);
2476           case Named_object::NAMED_OBJECT_SINK:
2477             if (may_be_sink)
2478               return Expression::make_sink(location);
2479             else
2480               {
2481                 error_at(location, "cannot use _ as value");
2482                 return Expression::make_error(location);
2483               }
2484           case Named_object::NAMED_OBJECT_FUNC:
2485           case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
2486             return Expression::make_func_reference(named_object, NULL,
2487                                                    location);
2488           case Named_object::NAMED_OBJECT_UNKNOWN:
2489             {
2490               Unknown_expression* ue =
2491                 Expression::make_unknown_reference(named_object, location);
2492               if (this->is_erroneous_function_)
2493                 ue->set_no_error_message();
2494               return ue;
2495             }
2496           case Named_object::NAMED_OBJECT_ERRONEOUS:
2497             return Expression::make_error(location);
2498           default:
2499             go_unreachable();
2500           }
2501       }
2502       go_unreachable();
2503
2504     case Token::TOKEN_STRING:
2505       ret = Expression::make_string(token->string_value(), token->location());
2506       this->advance_token();
2507       return ret;
2508
2509     case Token::TOKEN_CHARACTER:
2510       ret = Expression::make_character(token->character_value(), NULL,
2511                                        token->location());
2512       this->advance_token();
2513       return ret;
2514
2515     case Token::TOKEN_INTEGER:
2516       ret = Expression::make_integer(token->integer_value(), NULL,
2517                                      token->location());
2518       this->advance_token();
2519       return ret;
2520
2521     case Token::TOKEN_FLOAT:
2522       ret = Expression::make_float(token->float_value(), NULL,
2523                                    token->location());
2524       this->advance_token();
2525       return ret;
2526
2527     case Token::TOKEN_IMAGINARY:
2528       {
2529         mpfr_t zero;
2530         mpfr_init_set_ui(zero, 0, GMP_RNDN);
2531         ret = Expression::make_complex(&zero, token->imaginary_value(),
2532                                        NULL, token->location());
2533         mpfr_clear(zero);
2534         this->advance_token();
2535         return ret;
2536       }
2537
2538     case Token::TOKEN_KEYWORD:
2539       switch (token->keyword())
2540         {
2541         case KEYWORD_FUNC:
2542           return this->function_lit();
2543         case KEYWORD_CHAN:
2544         case KEYWORD_INTERFACE:
2545         case KEYWORD_MAP:
2546         case KEYWORD_STRUCT:
2547           {
2548             Location location = token->location();
2549             return Expression::make_type(this->type(), location);
2550           }
2551         default:
2552           break;
2553         }
2554       break;
2555
2556     case Token::TOKEN_OPERATOR:
2557       if (token->is_op(OPERATOR_LPAREN))
2558         {
2559           this->advance_token();
2560           ret = this->expression(PRECEDENCE_NORMAL, may_be_sink, true, NULL);
2561           if (!this->peek_token()->is_op(OPERATOR_RPAREN))
2562             error_at(this->location(), "missing %<)%>");
2563           else
2564             this->advance_token();
2565           return ret;
2566         }
2567       else if (token->is_op(OPERATOR_LSQUARE))
2568         {
2569           // Here we call array_type directly, as this is the only
2570           // case where an ellipsis is permitted for an array type.
2571           Location location = token->location();
2572           return Expression::make_type(this->array_type(true), location);
2573         }
2574       break;
2575
2576     default:
2577       break;
2578     }
2579
2580   error_at(this->location(), "expected operand");
2581   return Expression::make_error(this->location());
2582 }
2583
2584 // Handle a reference to a variable in an enclosing function.  We add
2585 // it to a list of such variables.  We return a reference to a field
2586 // in a struct which will be passed on the static chain when calling
2587 // the current function.
2588
2589 Expression*
2590 Parse::enclosing_var_reference(Named_object* in_function, Named_object* var,
2591                                Location location)
2592 {
2593   go_assert(var->is_variable() || var->is_result_variable());
2594
2595   this->mark_var_used(var);
2596
2597   Named_object* this_function = this->gogo_->current_function();
2598   Named_object* closure = this_function->func_value()->closure_var();
2599
2600   Enclosing_var ev(var, in_function, this->enclosing_vars_.size());
2601   std::pair<Enclosing_vars::iterator, bool> ins =
2602     this->enclosing_vars_.insert(ev);
2603   if (ins.second)
2604     {
2605       // This is a variable we have not seen before.  Add a new field
2606       // to the closure type.
2607       this_function->func_value()->add_closure_field(var, location);
2608     }
2609
2610   Expression* closure_ref = Expression::make_var_reference(closure,
2611                                                            location);
2612   closure_ref = Expression::make_unary(OPERATOR_MULT, closure_ref, location);
2613
2614   // The closure structure holds pointers to the variables, so we need
2615   // to introduce an indirection.
2616   Expression* e = Expression::make_field_reference(closure_ref,
2617                                                    ins.first->index(),
2618                                                    location);
2619   e = Expression::make_unary(OPERATOR_MULT, e, location);
2620   return e;
2621 }
2622
2623 // CompositeLit  = LiteralType LiteralValue .
2624 // LiteralType   = StructType | ArrayType | "[" "..." "]" ElementType |
2625 //                 SliceType | MapType | TypeName .
2626 // LiteralValue  = "{" [ ElementList [ "," ] ] "}" .
2627 // ElementList   = Element { "," Element } .
2628 // Element       = [ Key ":" ] Value .
2629 // Key           = FieldName | ElementIndex .
2630 // FieldName     = identifier .
2631 // ElementIndex  = Expression .
2632 // Value         = Expression | LiteralValue .
2633
2634 // We have already seen the type if there is one, and we are now
2635 // looking at the LiteralValue.  The case "[" "..."  "]" ElementType
2636 // will be seen here as an array type whose length is "nil".  The
2637 // DEPTH parameter is non-zero if this is an embedded composite
2638 // literal and the type was omitted.  It gives the number of steps up
2639 // to the type which was provided.  E.g., in [][]int{{1}} it will be
2640 // 1.  In [][][]int{{{1}}} it will be 2.
2641
2642 Expression*
2643 Parse::composite_lit(Type* type, int depth, Location location)
2644 {
2645   go_assert(this->peek_token()->is_op(OPERATOR_LCURLY));
2646   this->advance_token();
2647
2648   if (this->peek_token()->is_op(OPERATOR_RCURLY))
2649     {
2650       this->advance_token();
2651       return Expression::make_composite_literal(type, depth, false, NULL,
2652                                                 location);
2653     }
2654
2655   bool has_keys = false;
2656   Expression_list* vals = new Expression_list;
2657   while (true)
2658     {
2659       Expression* val;
2660       bool is_type_omitted = false;
2661
2662       const Token* token = this->peek_token();
2663
2664       if (token->is_identifier())
2665         {
2666           std::string identifier = token->identifier();
2667           bool is_exported = token->is_identifier_exported();
2668           Location location = token->location();
2669
2670           if (this->advance_token()->is_op(OPERATOR_COLON))
2671             {
2672               // This may be a field name.  We don't know for sure--it
2673               // could also be an expression for an array index.  We
2674               // don't want to parse it as an expression because may
2675               // trigger various errors, e.g., if this identifier
2676               // happens to be the name of a package.
2677               Gogo* gogo = this->gogo_;
2678               val = this->id_to_expression(gogo->pack_hidden_name(identifier,
2679                                                                   is_exported),
2680                                            location);
2681             }
2682           else
2683             {
2684               this->unget_token(Token::make_identifier_token(identifier,
2685                                                              is_exported,
2686                                                              location));
2687               val = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
2688             }
2689         }
2690       else if (!token->is_op(OPERATOR_LCURLY))
2691         val = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
2692       else
2693         {
2694           // This must be a composite literal inside another composite
2695           // literal, with the type omitted for the inner one.
2696           val = this->composite_lit(type, depth + 1, token->location());
2697           is_type_omitted = true;
2698         }
2699
2700       token = this->peek_token();
2701       if (!token->is_op(OPERATOR_COLON))
2702         {
2703           if (has_keys)
2704             vals->push_back(NULL);
2705         }
2706       else
2707         {
2708           if (is_type_omitted && !val->is_error_expression())
2709             {
2710               error_at(this->location(), "unexpected %<:%>");
2711               val = Expression::make_error(this->location());
2712             }
2713
2714           this->advance_token();
2715
2716           if (!has_keys && !vals->empty())
2717             {
2718               Expression_list* newvals = new Expression_list;
2719               for (Expression_list::const_iterator p = vals->begin();
2720                    p != vals->end();
2721                    ++p)
2722                 {
2723                   newvals->push_back(NULL);
2724                   newvals->push_back(*p);
2725                 }
2726               delete vals;
2727               vals = newvals;
2728             }
2729           has_keys = true;
2730
2731           if (val->unknown_expression() != NULL)
2732             val->unknown_expression()->set_is_composite_literal_key();
2733
2734           vals->push_back(val);
2735
2736           if (!token->is_op(OPERATOR_LCURLY))
2737             val = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
2738           else
2739             {
2740               // This must be a composite literal inside another
2741               // composite literal, with the type omitted for the
2742               // inner one.
2743               val = this->composite_lit(type, depth + 1, token->location());
2744             }
2745
2746           token = this->peek_token();
2747         }
2748
2749       vals->push_back(val);
2750
2751       if (token->is_op(OPERATOR_COMMA))
2752         {
2753           if (this->advance_token()->is_op(OPERATOR_RCURLY))
2754             {
2755               this->advance_token();
2756               break;
2757             }
2758         }
2759       else if (token->is_op(OPERATOR_RCURLY))
2760         {
2761           this->advance_token();
2762           break;
2763         }
2764       else
2765         {
2766           if (token->is_op(OPERATOR_SEMICOLON))
2767             error_at(this->location(),
2768                      "need trailing comma before newline in composite literal");
2769           else
2770             error_at(this->location(), "expected %<,%> or %<}%>");
2771
2772           this->gogo_->mark_locals_used();
2773           int depth = 0;
2774           while (!token->is_eof()
2775                  && (depth > 0 || !token->is_op(OPERATOR_RCURLY)))
2776             {
2777               if (token->is_op(OPERATOR_LCURLY))
2778                 ++depth;
2779               else if (token->is_op(OPERATOR_RCURLY))
2780                 --depth;
2781               token = this->advance_token();
2782             }
2783           if (token->is_op(OPERATOR_RCURLY))
2784             this->advance_token();
2785
2786           return Expression::make_error(location);
2787         }
2788     }
2789
2790   return Expression::make_composite_literal(type, depth, has_keys, vals,
2791                                             location);
2792 }
2793
2794 // FunctionLit = "func" Signature Block .
2795
2796 Expression*
2797 Parse::function_lit()
2798 {
2799   Location location = this->location();
2800   go_assert(this->peek_token()->is_keyword(KEYWORD_FUNC));
2801   this->advance_token();
2802
2803   Enclosing_vars hold_enclosing_vars;
2804   hold_enclosing_vars.swap(this->enclosing_vars_);
2805
2806   Function_type* type = this->signature(NULL, location);
2807   bool fntype_is_error = false;
2808   if (type == NULL)
2809     {
2810       type = Type::make_function_type(NULL, NULL, NULL, location);
2811       fntype_is_error = true;
2812     }
2813
2814   // For a function literal, the next token must be a '{'.  If we
2815   // don't see that, then we may have a type expression.
2816   if (!this->peek_token()->is_op(OPERATOR_LCURLY))
2817     return Expression::make_type(type, location);
2818
2819   bool hold_is_erroneous_function = this->is_erroneous_function_;
2820   if (fntype_is_error)
2821     this->is_erroneous_function_ = true;
2822
2823   Bc_stack* hold_break_stack = this->break_stack_;
2824   Bc_stack* hold_continue_stack = this->continue_stack_;
2825   this->break_stack_ = NULL;
2826   this->continue_stack_ = NULL;
2827
2828   Named_object* no = this->gogo_->start_function("", type, true, location);
2829
2830   Location end_loc = this->block();
2831
2832   this->gogo_->finish_function(end_loc);
2833
2834   if (this->break_stack_ != NULL)
2835     delete this->break_stack_;
2836   if (this->continue_stack_ != NULL)
2837     delete this->continue_stack_;
2838   this->break_stack_ = hold_break_stack;
2839   this->continue_stack_ = hold_continue_stack;
2840
2841   this->is_erroneous_function_ = hold_is_erroneous_function;
2842
2843   hold_enclosing_vars.swap(this->enclosing_vars_);
2844
2845   Expression* closure = this->create_closure(no, &hold_enclosing_vars,
2846                                              location);
2847
2848   return Expression::make_func_reference(no, closure, location);
2849 }
2850
2851 // Create a closure for the nested function FUNCTION.  This is based
2852 // on ENCLOSING_VARS, which is a list of all variables defined in
2853 // enclosing functions and referenced from FUNCTION.  A closure is the
2854 // address of a struct which contains the addresses of all the
2855 // referenced variables.  This returns NULL if no closure is required.
2856
2857 Expression*
2858 Parse::create_closure(Named_object* function, Enclosing_vars* enclosing_vars,
2859                       Location location)
2860 {
2861   if (enclosing_vars->empty())
2862     return NULL;
2863
2864   // Get the variables in order by their field index.
2865
2866   size_t enclosing_var_count = enclosing_vars->size();
2867   std::vector<Enclosing_var> ev(enclosing_var_count);
2868   for (Enclosing_vars::const_iterator p = enclosing_vars->begin();
2869        p != enclosing_vars->end();
2870        ++p)
2871     ev[p->index()] = *p;
2872
2873   // Build an initializer for a composite literal of the closure's
2874   // type.
2875
2876   Named_object* enclosing_function = this->gogo_->current_function();
2877   Expression_list* initializer = new Expression_list;
2878   for (size_t i = 0; i < enclosing_var_count; ++i)
2879     {
2880       go_assert(ev[i].index() == i);
2881       Named_object* var = ev[i].var();
2882       Expression* ref;
2883       if (ev[i].in_function() == enclosing_function)
2884         ref = Expression::make_var_reference(var, location);
2885       else
2886         ref = this->enclosing_var_reference(ev[i].in_function(), var,
2887                                             location);
2888       Expression* refaddr = Expression::make_unary(OPERATOR_AND, ref,
2889                                                    location);
2890       initializer->push_back(refaddr);
2891     }
2892
2893   Named_object* closure_var = function->func_value()->closure_var();
2894   Struct_type* st = closure_var->var_value()->type()->deref()->struct_type();
2895   Expression* cv = Expression::make_struct_composite_literal(st, initializer,
2896                                                              location);
2897   return Expression::make_heap_composite(cv, location);
2898 }
2899
2900 // PrimaryExpr = Operand { Selector | Index | Slice | TypeGuard | Call } .
2901
2902 // If MAY_BE_SINK is true, this expression may be "_".
2903
2904 // If MAY_BE_COMPOSITE_LIT is true, this expression may be a composite
2905 // literal.
2906
2907 // If IS_TYPE_SWITCH is not NULL, this will recognize a type switch
2908 // guard (var := expr.("type") using the literal keyword "type").
2909
2910 Expression*
2911 Parse::primary_expr(bool may_be_sink, bool may_be_composite_lit,
2912                     bool* is_type_switch)
2913 {
2914   Location start_loc = this->location();
2915   bool is_parenthesized = this->peek_token()->is_op(OPERATOR_LPAREN);
2916
2917   Expression* ret = this->operand(may_be_sink);
2918
2919   // An unknown name followed by a curly brace must be a composite
2920   // literal, and the unknown name must be a type.
2921   if (may_be_composite_lit
2922       && !is_parenthesized
2923       && ret->unknown_expression() != NULL
2924       && this->peek_token()->is_op(OPERATOR_LCURLY))
2925     {
2926       Named_object* no = ret->unknown_expression()->named_object();
2927       Type* type = Type::make_forward_declaration(no);
2928       ret = Expression::make_type(type, ret->location());
2929     }
2930
2931   // We handle composite literals and type casts here, as it is the
2932   // easiest way to handle types which are in parentheses, as in
2933   // "((uint))(1)".
2934   if (ret->is_type_expression())
2935     {
2936       if (this->peek_token()->is_op(OPERATOR_LCURLY))
2937         {
2938           if (!may_be_composite_lit)
2939             {
2940               Type* t = ret->type();
2941               if (t->named_type() != NULL
2942                   || t->forward_declaration_type() != NULL)
2943                 error_at(start_loc,
2944                          _("parentheses required around this composite literal"
2945                            "to avoid parsing ambiguity"));
2946             }
2947           else if (is_parenthesized)
2948             error_at(start_loc,
2949                      "cannot parenthesize type in composite literal");
2950           ret = this->composite_lit(ret->type(), 0, ret->location());
2951         }
2952       else if (this->peek_token()->is_op(OPERATOR_LPAREN))
2953         {
2954           Location loc = this->location();
2955           this->advance_token();
2956           Expression* expr = this->expression(PRECEDENCE_NORMAL, false, true,
2957                                               NULL);
2958           if (this->peek_token()->is_op(OPERATOR_ELLIPSIS))
2959             {
2960               error_at(this->location(),
2961                        "invalid use of %<...%> in type conversion");
2962               this->advance_token();
2963             }
2964           if (!this->peek_token()->is_op(OPERATOR_RPAREN))
2965             error_at(this->location(), "expected %<)%>");
2966           else
2967             this->advance_token();
2968           if (expr->is_error_expression())
2969             ret = expr;
2970           else
2971             {
2972               Type* t = ret->type();
2973               if (t->classification() == Type::TYPE_ARRAY
2974                   && t->array_type()->length() != NULL
2975                   && t->array_type()->length()->is_nil_expression())
2976                 {
2977                   error_at(ret->location(),
2978                            "invalid use of %<...%> in type conversion");
2979                   ret = Expression::make_error(loc);
2980                 }
2981               else
2982                 ret = Expression::make_cast(t, expr, loc);
2983             }
2984         }
2985     }
2986
2987   while (true)
2988     {
2989       const Token* token = this->peek_token();
2990       if (token->is_op(OPERATOR_LPAREN))
2991         ret = this->call(this->verify_not_sink(ret));
2992       else if (token->is_op(OPERATOR_DOT))
2993         {
2994           ret = this->selector(this->verify_not_sink(ret), is_type_switch);
2995           if (is_type_switch != NULL && *is_type_switch)
2996             break;
2997         }
2998       else if (token->is_op(OPERATOR_LSQUARE))
2999         ret = this->index(this->verify_not_sink(ret));
3000       else
3001         break;
3002     }
3003
3004   return ret;
3005 }
3006
3007 // Selector = "." identifier .
3008 // TypeGuard = "." "(" QualifiedIdent ")" .
3009
3010 // Note that Operand can expand to QualifiedIdent, which contains a
3011 // ".".  That is handled directly in operand when it sees a package
3012 // name.
3013
3014 // If IS_TYPE_SWITCH is not NULL, this will recognize a type switch
3015 // guard (var := expr.("type") using the literal keyword "type").
3016
3017 Expression*
3018 Parse::selector(Expression* left, bool* is_type_switch)
3019 {
3020   go_assert(this->peek_token()->is_op(OPERATOR_DOT));
3021   Location location = this->location();
3022
3023   const Token* token = this->advance_token();
3024   if (token->is_identifier())
3025     {
3026       // This could be a field in a struct, or a method in an
3027       // interface, or a method associated with a type.  We can't know
3028       // which until we have seen all the types.
3029       std::string name =
3030         this->gogo_->pack_hidden_name(token->identifier(),
3031                                       token->is_identifier_exported());
3032       if (token->identifier() == "_")
3033         {
3034           error_at(this->location(), "invalid use of %<_%>");
3035           name = this->gogo_->pack_hidden_name("blank", false);
3036         }
3037       this->advance_token();
3038       return Expression::make_selector(left, name, location);
3039     }
3040   else if (token->is_op(OPERATOR_LPAREN))
3041     {
3042       this->advance_token();
3043       Type* type = NULL;
3044       if (!this->peek_token()->is_keyword(KEYWORD_TYPE))
3045         type = this->type();
3046       else
3047         {
3048           if (is_type_switch != NULL)
3049             *is_type_switch = true;
3050           else
3051             {
3052               error_at(this->location(),
3053                        "use of %<.(type)%> outside type switch");
3054               type = Type::make_error_type();
3055             }
3056           this->advance_token();
3057         }
3058       if (!this->peek_token()->is_op(OPERATOR_RPAREN))
3059         error_at(this->location(), "missing %<)%>");
3060       else
3061         this->advance_token();
3062       if (is_type_switch != NULL && *is_type_switch)
3063         return left;
3064       return Expression::make_type_guard(left, type, location);
3065     }
3066   else
3067     {
3068       error_at(this->location(), "expected identifier or %<(%>");
3069       return left;
3070     }
3071 }
3072
3073 // Index          = "[" Expression "]" .
3074 // Slice          = "[" Expression ":" [ Expression ] "]" .
3075
3076 Expression*
3077 Parse::index(Expression* expr)
3078 {
3079   Location location = this->location();
3080   go_assert(this->peek_token()->is_op(OPERATOR_LSQUARE));
3081   this->advance_token();
3082
3083   Expression* start;
3084   if (!this->peek_token()->is_op(OPERATOR_COLON))
3085     start = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
3086   else
3087     {
3088       mpz_t zero;
3089       mpz_init_set_ui(zero, 0);
3090       start = Expression::make_integer(&zero, NULL, location);
3091       mpz_clear(zero);
3092     }
3093
3094   Expression* end = NULL;
3095   if (this->peek_token()->is_op(OPERATOR_COLON))
3096     {
3097       // We use nil to indicate a missing high expression.
3098       if (this->advance_token()->is_op(OPERATOR_RSQUARE))
3099         end = Expression::make_nil(this->location());
3100       else
3101         end = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
3102     }
3103   if (!this->peek_token()->is_op(OPERATOR_RSQUARE))
3104     error_at(this->location(), "missing %<]%>");
3105   else
3106     this->advance_token();
3107   return Expression::make_index(expr, start, end, location);
3108 }
3109
3110 // Call           = "(" [ ArgumentList [ "," ] ] ")" .
3111 // ArgumentList   = ExpressionList [ "..." ] .
3112
3113 Expression*
3114 Parse::call(Expression* func)
3115 {
3116   go_assert(this->peek_token()->is_op(OPERATOR_LPAREN));
3117   Expression_list* args = NULL;
3118   bool is_varargs = false;
3119   const Token* token = this->advance_token();
3120   if (!token->is_op(OPERATOR_RPAREN))
3121     {
3122       args = this->expression_list(NULL, false, true);
3123       token = this->peek_token();
3124       if (token->is_op(OPERATOR_ELLIPSIS))
3125         {
3126           is_varargs = true;
3127           token = this->advance_token();
3128         }
3129     }
3130   if (token->is_op(OPERATOR_COMMA))
3131     token = this->advance_token();
3132   if (!token->is_op(OPERATOR_RPAREN))
3133     error_at(this->location(), "missing %<)%>");
3134   else
3135     this->advance_token();
3136   if (func->is_error_expression())
3137     return func;
3138   return Expression::make_call(func, args, is_varargs, func->location());
3139 }
3140
3141 // Return an expression for a single unqualified identifier.
3142
3143 Expression*
3144 Parse::id_to_expression(const std::string& name, Location location)
3145 {
3146   Named_object* in_function;
3147   Named_object* named_object = this->gogo_->lookup(name, &in_function);
3148   if (named_object == NULL)
3149     named_object = this->gogo_->add_unknown_name(name, location);
3150
3151   if (in_function != NULL
3152       && in_function != this->gogo_->current_function()
3153       && (named_object->is_variable() || named_object->is_result_variable()))
3154     return this->enclosing_var_reference(in_function, named_object,
3155                                          location);
3156
3157   switch (named_object->classification())
3158     {
3159     case Named_object::NAMED_OBJECT_CONST:
3160       return Expression::make_const_reference(named_object, location);
3161     case Named_object::NAMED_OBJECT_VAR:
3162     case Named_object::NAMED_OBJECT_RESULT_VAR:
3163       this->mark_var_used(named_object);
3164       return Expression::make_var_reference(named_object, location);
3165     case Named_object::NAMED_OBJECT_SINK:
3166       return Expression::make_sink(location);
3167     case Named_object::NAMED_OBJECT_FUNC:
3168     case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
3169       return Expression::make_func_reference(named_object, NULL, location);
3170     case Named_object::NAMED_OBJECT_UNKNOWN:
3171       {
3172         Unknown_expression* ue =
3173           Expression::make_unknown_reference(named_object, location);
3174         if (this->is_erroneous_function_)
3175           ue->set_no_error_message();
3176         return ue;
3177       }
3178     case Named_object::NAMED_OBJECT_PACKAGE:
3179     case Named_object::NAMED_OBJECT_TYPE:
3180     case Named_object::NAMED_OBJECT_TYPE_DECLARATION:
3181       {
3182         // These cases can arise for a field name in a composite
3183         // literal.
3184         Unknown_expression* ue =
3185           Expression::make_unknown_reference(named_object, location);
3186         if (this->is_erroneous_function_)
3187           ue->set_no_error_message();
3188         return ue;
3189       }
3190     case Named_object::NAMED_OBJECT_ERRONEOUS:
3191       return Expression::make_error(location);
3192     default:
3193       error_at(this->location(), "unexpected type of identifier");
3194       return Expression::make_error(location);
3195     }
3196 }
3197
3198 // Expression = UnaryExpr { binary_op Expression } .
3199
3200 // PRECEDENCE is the precedence of the current operator.
3201
3202 // If MAY_BE_SINK is true, this expression may be "_".
3203
3204 // If MAY_BE_COMPOSITE_LIT is true, this expression may be a composite
3205 // literal.
3206
3207 // If IS_TYPE_SWITCH is not NULL, this will recognize a type switch
3208 // guard (var := expr.("type") using the literal keyword "type").
3209
3210 Expression*
3211 Parse::expression(Precedence precedence, bool may_be_sink,
3212                   bool may_be_composite_lit, bool* is_type_switch)
3213 {
3214   Expression* left = this->unary_expr(may_be_sink, may_be_composite_lit,
3215                                       is_type_switch);
3216
3217   while (true)
3218     {
3219       if (is_type_switch != NULL && *is_type_switch)
3220         return left;
3221
3222       const Token* token = this->peek_token();
3223       if (token->classification() != Token::TOKEN_OPERATOR)
3224         {
3225           // Not a binary_op.
3226           return left;
3227         }
3228
3229       Precedence right_precedence;
3230       switch (token->op())
3231         {
3232         case OPERATOR_OROR:
3233           right_precedence = PRECEDENCE_OROR;
3234           break;
3235         case OPERATOR_ANDAND:
3236           right_precedence = PRECEDENCE_ANDAND;
3237           break;
3238         case OPERATOR_EQEQ:
3239         case OPERATOR_NOTEQ:
3240         case OPERATOR_LT:
3241         case OPERATOR_LE:
3242         case OPERATOR_GT:
3243         case OPERATOR_GE:
3244           right_precedence = PRECEDENCE_RELOP;
3245           break;
3246         case OPERATOR_PLUS:
3247         case OPERATOR_MINUS:
3248         case OPERATOR_OR:
3249         case OPERATOR_XOR:
3250           right_precedence = PRECEDENCE_ADDOP;
3251           break;
3252         case OPERATOR_MULT:
3253         case OPERATOR_DIV:
3254         case OPERATOR_MOD:
3255         case OPERATOR_LSHIFT:
3256         case OPERATOR_RSHIFT:
3257         case OPERATOR_AND:
3258         case OPERATOR_BITCLEAR:
3259           right_precedence = PRECEDENCE_MULOP;
3260           break;
3261         default:
3262           right_precedence = PRECEDENCE_INVALID;
3263           break;
3264         }
3265
3266       if (right_precedence == PRECEDENCE_INVALID)
3267         {
3268           // Not a binary_op.
3269           return left;
3270         }
3271
3272       Operator op = token->op();
3273       Location binop_location = token->location();
3274
3275       if (precedence >= right_precedence)
3276         {
3277           // We've already seen A * B, and we see + C.  We want to
3278           // return so that A * B becomes a group.
3279           return left;
3280         }
3281
3282       this->advance_token();
3283
3284       left = this->verify_not_sink(left);
3285       Expression* right = this->expression(right_precedence, false,
3286                                            may_be_composite_lit,
3287                                            NULL);
3288       left = Expression::make_binary(op, left, right, binop_location);
3289     }
3290 }
3291
3292 bool
3293 Parse::expression_may_start_here()
3294 {
3295   const Token* token = this->peek_token();
3296   switch (token->classification())
3297     {
3298     case Token::TOKEN_INVALID:
3299     case Token::TOKEN_EOF:
3300       return false;
3301     case Token::TOKEN_KEYWORD:
3302       switch (token->keyword())
3303         {
3304         case KEYWORD_CHAN:
3305         case KEYWORD_FUNC:
3306         case KEYWORD_MAP:
3307         case KEYWORD_STRUCT:
3308         case KEYWORD_INTERFACE:
3309           return true;
3310         default:
3311           return false;
3312         }
3313     case Token::TOKEN_IDENTIFIER:
3314       return true;
3315     case Token::TOKEN_STRING:
3316       return true;
3317     case Token::TOKEN_OPERATOR:
3318       switch (token->op())
3319         {
3320         case OPERATOR_PLUS:
3321         case OPERATOR_MINUS:
3322         case OPERATOR_NOT:
3323         case OPERATOR_XOR:
3324         case OPERATOR_MULT:
3325         case OPERATOR_CHANOP:
3326         case OPERATOR_AND:
3327         case OPERATOR_LPAREN:
3328         case OPERATOR_LSQUARE:
3329           return true;
3330         default:
3331           return false;
3332         }
3333     case Token::TOKEN_CHARACTER:
3334     case Token::TOKEN_INTEGER:
3335     case Token::TOKEN_FLOAT:
3336     case Token::TOKEN_IMAGINARY:
3337       return true;
3338     default:
3339       go_unreachable();
3340     }
3341 }
3342
3343 // UnaryExpr = unary_op UnaryExpr | PrimaryExpr .
3344
3345 // If MAY_BE_SINK is true, this expression may be "_".
3346
3347 // If MAY_BE_COMPOSITE_LIT is true, this expression may be a composite
3348 // literal.
3349
3350 // If IS_TYPE_SWITCH is not NULL, this will recognize a type switch
3351 // guard (var := expr.("type") using the literal keyword "type").
3352
3353 Expression*
3354 Parse::unary_expr(bool may_be_sink, bool may_be_composite_lit,
3355                   bool* is_type_switch)
3356 {
3357   const Token* token = this->peek_token();
3358
3359   // There is a complex parse for <- chan.  The choices are
3360   // Convert x to type <- chan int:
3361   //   (<- chan int)(x)         
3362   // Receive from (x converted to type chan <- chan int):
3363   //   (<- chan <- chan int (x))
3364   // Convert x to type <- chan (<- chan int).
3365   //   (<- chan <- chan int)(x)
3366   if (token->is_op(OPERATOR_CHANOP))
3367     {
3368       Location location = token->location();
3369       if (this->advance_token()->is_keyword(KEYWORD_CHAN))
3370         {
3371           Expression* expr = this->primary_expr(false, may_be_composite_lit,
3372                                                 NULL);
3373           if (expr->is_error_expression())
3374             return expr;
3375           else if (!expr->is_type_expression())
3376             return Expression::make_receive(expr, location);
3377           else
3378             {
3379               if (expr->type()->is_error_type())
3380                 return expr;
3381
3382               // We picked up "chan TYPE", but it is not a type
3383               // conversion.
3384               Channel_type* ct = expr->type()->channel_type();
3385               if (ct == NULL)
3386                 {
3387                   // This is probably impossible.
3388                   error_at(location, "expected channel type");
3389                   return Expression::make_error(location);
3390                 }
3391               else if (ct->may_receive())
3392                 {
3393                   // <- chan TYPE.
3394                   Type* t = Type::make_channel_type(false, true,
3395                                                     ct->element_type());
3396                   return Expression::make_type(t, location);
3397                 }
3398               else
3399                 {
3400                   // <- chan <- TYPE.  Because we skipped the leading
3401                   // <-, we parsed this as chan <- TYPE.  With the
3402                   // leading <-, we parse it as <- chan (<- TYPE).
3403                   Type *t = this->reassociate_chan_direction(ct, location);
3404                   return Expression::make_type(t, location);
3405                 }
3406             }
3407         }
3408
3409       this->unget_token(Token::make_operator_token(OPERATOR_CHANOP, location));
3410       token = this->peek_token();
3411     }
3412
3413   if (token->is_op(OPERATOR_PLUS)
3414       || token->is_op(OPERATOR_MINUS)
3415       || token->is_op(OPERATOR_NOT)
3416       || token->is_op(OPERATOR_XOR)
3417       || token->is_op(OPERATOR_CHANOP)
3418       || token->is_op(OPERATOR_MULT)
3419       || token->is_op(OPERATOR_AND))
3420     {
3421       Location location = token->location();
3422       Operator op = token->op();
3423       this->advance_token();
3424
3425       Expression* expr = this->unary_expr(false, may_be_composite_lit, NULL);
3426       if (expr->is_error_expression())
3427         ;
3428       else if (op == OPERATOR_MULT && expr->is_type_expression())
3429         expr = Expression::make_type(Type::make_pointer_type(expr->type()),
3430                                      location);
3431       else if (op == OPERATOR_AND && expr->is_composite_literal())
3432         expr = Expression::make_heap_composite(expr, location);
3433       else if (op != OPERATOR_CHANOP)
3434         expr = Expression::make_unary(op, expr, location);
3435       else
3436         expr = Expression::make_receive(expr, location);
3437       return expr;
3438     }
3439   else
3440     return this->primary_expr(may_be_sink, may_be_composite_lit,
3441                               is_type_switch);
3442 }
3443
3444 // This is called for the obscure case of
3445 //   (<- chan <- chan int)(x)
3446 // In unary_expr we remove the leading <- and parse the remainder,
3447 // which gives us
3448 //   chan <- (chan int)
3449 // When we add the leading <- back in, we really want
3450 //   <- chan (<- chan int)
3451 // This means that we need to reassociate.
3452
3453 Type*
3454 Parse::reassociate_chan_direction(Channel_type *ct, Location location)
3455 {
3456   Channel_type* ele = ct->element_type()->channel_type();
3457   if (ele == NULL)
3458     {
3459       error_at(location, "parse error");
3460       return Type::make_error_type();
3461     }
3462   Type* sub = ele;
3463   if (ele->may_send())
3464     sub = Type::make_channel_type(false, true, ele->element_type());
3465   else
3466     sub = this->reassociate_chan_direction(ele, location);
3467   return Type::make_channel_type(false, true, sub);
3468 }
3469
3470 // Statement =
3471 //      Declaration | LabeledStmt | SimpleStmt |
3472 //      GoStmt | ReturnStmt | BreakStmt | ContinueStmt | GotoStmt |
3473 //      FallthroughStmt | Block | IfStmt | SwitchStmt | SelectStmt | ForStmt |
3474 //      DeferStmt .
3475
3476 // LABEL is the label of this statement if it has one.
3477
3478 void
3479 Parse::statement(Label* label)
3480 {
3481   const Token* token = this->peek_token();
3482   switch (token->classification())
3483     {
3484     case Token::TOKEN_KEYWORD:
3485       {
3486         switch (token->keyword())
3487           {
3488           case KEYWORD_CONST:
3489           case KEYWORD_TYPE:
3490           case KEYWORD_VAR:
3491             this->declaration();
3492             break;
3493           case KEYWORD_FUNC:
3494           case KEYWORD_MAP:
3495           case KEYWORD_STRUCT:
3496           case KEYWORD_INTERFACE:
3497             this->simple_stat(true, NULL, NULL, NULL);
3498             break;
3499           case KEYWORD_GO:
3500           case KEYWORD_DEFER:
3501             this->go_or_defer_stat();
3502             break;
3503           case KEYWORD_RETURN:
3504             this->return_stat();
3505             break;
3506           case KEYWORD_BREAK:
3507             this->break_stat();
3508             break;
3509           case KEYWORD_CONTINUE:
3510             this->continue_stat();
3511             break;
3512           case KEYWORD_GOTO:
3513             this->goto_stat();
3514             break;
3515           case KEYWORD_IF:
3516             this->if_stat();
3517             break;
3518           case KEYWORD_SWITCH:
3519             this->switch_stat(label);
3520             break;
3521           case KEYWORD_SELECT:
3522             this->select_stat(label);
3523             break;
3524           case KEYWORD_FOR:
3525             this->for_stat(label);
3526             break;
3527           default:
3528             error_at(this->location(), "expected statement");
3529             this->advance_token();
3530             break;
3531           }
3532       }
3533       break;
3534
3535     case Token::TOKEN_IDENTIFIER:
3536       {
3537         std::string identifier = token->identifier();
3538         bool is_exported = token->is_identifier_exported();
3539         Location location = token->location();
3540         if (this->advance_token()->is_op(OPERATOR_COLON))
3541           {
3542             this->advance_token();
3543             this->labeled_stmt(identifier, location);
3544           }
3545         else
3546           {
3547             this->unget_token(Token::make_identifier_token(identifier,
3548                                                            is_exported,
3549                                                            location));
3550             this->simple_stat(true, NULL, NULL, NULL);
3551           }
3552       }
3553       break;
3554
3555     case Token::TOKEN_OPERATOR:
3556       if (token->is_op(OPERATOR_LCURLY))
3557         {
3558           Location location = token->location();
3559           this->gogo_->start_block(location);
3560           Location end_loc = this->block();
3561           this->gogo_->add_block(this->gogo_->finish_block(end_loc),
3562                                  location);
3563         }
3564       else if (!token->is_op(OPERATOR_SEMICOLON))
3565         this->simple_stat(true, NULL, NULL, NULL);
3566       break;
3567
3568     case Token::TOKEN_STRING:
3569     case Token::TOKEN_CHARACTER:
3570     case Token::TOKEN_INTEGER:
3571     case Token::TOKEN_FLOAT:
3572     case Token::TOKEN_IMAGINARY:
3573       this->simple_stat(true, NULL, NULL, NULL);
3574       break;
3575
3576     default:
3577       error_at(this->location(), "expected statement");
3578       this->advance_token();
3579       break;
3580     }
3581 }
3582
3583 bool
3584 Parse::statement_may_start_here()
3585 {
3586   const Token* token = this->peek_token();
3587   switch (token->classification())
3588     {
3589     case Token::TOKEN_KEYWORD:
3590       {
3591         switch (token->keyword())
3592           {
3593           case KEYWORD_CONST:
3594           case KEYWORD_TYPE:
3595           case KEYWORD_VAR:
3596           case KEYWORD_FUNC:
3597           case KEYWORD_MAP:
3598           case KEYWORD_STRUCT:
3599           case KEYWORD_INTERFACE:
3600           case KEYWORD_GO:
3601           case KEYWORD_DEFER:
3602           case KEYWORD_RETURN:
3603           case KEYWORD_BREAK:
3604           case KEYWORD_CONTINUE:
3605           case KEYWORD_GOTO:
3606           case KEYWORD_IF:
3607           case KEYWORD_SWITCH:
3608           case KEYWORD_SELECT:
3609           case KEYWORD_FOR:
3610             return true;
3611
3612           default:
3613             return false;
3614           }
3615       }
3616       break;
3617
3618     case Token::TOKEN_IDENTIFIER:
3619       return true;
3620
3621     case Token::TOKEN_OPERATOR:
3622       if (token->is_op(OPERATOR_LCURLY)
3623           || token->is_op(OPERATOR_SEMICOLON))
3624         return true;
3625       else
3626         return this->expression_may_start_here();
3627
3628     case Token::TOKEN_STRING:
3629     case Token::TOKEN_CHARACTER:
3630     case Token::TOKEN_INTEGER:
3631     case Token::TOKEN_FLOAT:
3632     case Token::TOKEN_IMAGINARY:
3633       return true;
3634
3635     default:
3636       return false;
3637     }
3638 }
3639
3640 // LabeledStmt = Label ":" Statement .
3641 // Label       = identifier .
3642
3643 void
3644 Parse::labeled_stmt(const std::string& label_name, Location location)
3645 {
3646   Label* label = this->gogo_->add_label_definition(label_name, location);
3647
3648   if (this->peek_token()->is_op(OPERATOR_RCURLY))
3649     {
3650       // This is a label at the end of a block.  A program is
3651       // permitted to omit a semicolon here.
3652       return;
3653     }
3654
3655   if (!this->statement_may_start_here())
3656     {
3657       // Mark the label as used to avoid a useless error about an
3658       // unused label.
3659       label->set_is_used();
3660
3661       error_at(location, "missing statement after label");
3662       this->unget_token(Token::make_operator_token(OPERATOR_SEMICOLON,
3663                                                    location));
3664       return;
3665     }
3666
3667   this->statement(label);
3668 }
3669
3670 // SimpleStmt = EmptyStmt | ExpressionStmt | SendStmt | IncDecStmt |
3671 //      Assignment | ShortVarDecl .
3672
3673 // EmptyStmt was handled in Parse::statement.
3674
3675 // In order to make this work for if and switch statements, if
3676 // RETURN_EXP is not NULL, and we see an ExpressionStat, we return the
3677 // expression rather than adding an expression statement to the
3678 // current block.  If we see something other than an ExpressionStat,
3679 // we add the statement, set *RETURN_EXP to true if we saw a send
3680 // statement, and return NULL.  The handling of send statements is for
3681 // better error messages.
3682
3683 // If P_RANGE_CLAUSE is not NULL, then this will recognize a
3684 // RangeClause.
3685
3686 // If P_TYPE_SWITCH is not NULL, this will recognize a type switch
3687 // guard (var := expr.("type") using the literal keyword "type").
3688
3689 Expression*
3690 Parse::simple_stat(bool may_be_composite_lit, bool* return_exp,
3691                    Range_clause* p_range_clause, Type_switch* p_type_switch)
3692 {
3693   const Token* token = this->peek_token();
3694
3695   // An identifier follow by := is a SimpleVarDecl.
3696   if (token->is_identifier())
3697     {
3698       std::string identifier = token->identifier();
3699       bool is_exported = token->is_identifier_exported();
3700       Location location = token->location();
3701
3702       token = this->advance_token();
3703       if (token->is_op(OPERATOR_COLONEQ)
3704           || token->is_op(OPERATOR_COMMA))
3705         {
3706           identifier = this->gogo_->pack_hidden_name(identifier, is_exported);
3707           this->simple_var_decl_or_assignment(identifier, location,
3708                                               may_be_composite_lit,
3709                                               p_range_clause,
3710                                               (token->is_op(OPERATOR_COLONEQ)
3711                                                ? p_type_switch
3712                                                : NULL));
3713           return NULL;
3714         }
3715
3716       this->unget_token(Token::make_identifier_token(identifier, is_exported,
3717                                                      location));
3718     }
3719
3720   Expression* exp = this->expression(PRECEDENCE_NORMAL, true,
3721                                      may_be_composite_lit,
3722                                      (p_type_switch == NULL
3723                                       ? NULL
3724                                       : &p_type_switch->found));
3725   if (p_type_switch != NULL && p_type_switch->found)
3726     {
3727       p_type_switch->name.clear();
3728       p_type_switch->location = exp->location();
3729       p_type_switch->expr = this->verify_not_sink(exp);
3730       return NULL;
3731     }
3732   token = this->peek_token();
3733   if (token->is_op(OPERATOR_CHANOP))
3734     {
3735       this->send_stmt(this->verify_not_sink(exp));
3736       if (return_exp != NULL)
3737         *return_exp = true;
3738     }
3739   else if (token->is_op(OPERATOR_PLUSPLUS)
3740            || token->is_op(OPERATOR_MINUSMINUS))
3741     this->inc_dec_stat(this->verify_not_sink(exp));
3742   else if (token->is_op(OPERATOR_COMMA)
3743            || token->is_op(OPERATOR_EQ))
3744     this->assignment(exp, may_be_composite_lit, p_range_clause);
3745   else if (token->is_op(OPERATOR_PLUSEQ)
3746            || token->is_op(OPERATOR_MINUSEQ)
3747            || token->is_op(OPERATOR_OREQ)
3748            || token->is_op(OPERATOR_XOREQ)
3749            || token->is_op(OPERATOR_MULTEQ)
3750            || token->is_op(OPERATOR_DIVEQ)
3751            || token->is_op(OPERATOR_MODEQ)
3752            || token->is_op(OPERATOR_LSHIFTEQ)
3753            || token->is_op(OPERATOR_RSHIFTEQ)
3754            || token->is_op(OPERATOR_ANDEQ)
3755            || token->is_op(OPERATOR_BITCLEAREQ))
3756     this->assignment(this->verify_not_sink(exp), may_be_composite_lit,
3757                      p_range_clause);
3758   else if (return_exp != NULL)
3759     return this->verify_not_sink(exp);
3760   else
3761     {
3762       exp = this->verify_not_sink(exp);
3763
3764       if (token->is_op(OPERATOR_COLONEQ))
3765         {
3766           if (!exp->is_error_expression())
3767             error_at(token->location(), "non-name on left side of %<:=%>");
3768           this->gogo_->mark_locals_used();
3769           while (!token->is_op(OPERATOR_SEMICOLON)
3770                  && !token->is_eof())
3771             token = this->advance_token();
3772           return NULL;
3773         }
3774
3775       this->expression_stat(exp);
3776     }
3777
3778   return NULL;
3779 }
3780
3781 bool
3782 Parse::simple_stat_may_start_here()
3783 {
3784   return this->expression_may_start_here();
3785 }
3786
3787 // Parse { Statement ";" } which is used in a few places.  The list of
3788 // statements may end with a right curly brace, in which case the
3789 // semicolon may be omitted.
3790
3791 void
3792 Parse::statement_list()
3793 {
3794   while (this->statement_may_start_here())
3795     {
3796       this->statement(NULL);
3797       if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
3798         this->advance_token();
3799       else if (this->peek_token()->is_op(OPERATOR_RCURLY))
3800         break;
3801       else
3802         {
3803           if (!this->peek_token()->is_eof() || !saw_errors())
3804             error_at(this->location(), "expected %<;%> or %<}%> or newline");
3805           if (!this->skip_past_error(OPERATOR_RCURLY))
3806             return;
3807         }
3808     }
3809 }
3810
3811 bool
3812 Parse::statement_list_may_start_here()
3813 {
3814   return this->statement_may_start_here();
3815 }
3816
3817 // ExpressionStat = Expression .
3818
3819 void
3820 Parse::expression_stat(Expression* exp)
3821 {
3822   this->gogo_->add_statement(Statement::make_statement(exp, false));
3823 }
3824
3825 // SendStmt = Channel "&lt;-" Expression .
3826 // Channel  = Expression .
3827
3828 void
3829 Parse::send_stmt(Expression* channel)
3830 {
3831   go_assert(this->peek_token()->is_op(OPERATOR_CHANOP));
3832   Location loc = this->location();
3833   this->advance_token();
3834   Expression* val = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
3835   Statement* s = Statement::make_send_statement(channel, val, loc);
3836   this->gogo_->add_statement(s);
3837 }
3838
3839 // IncDecStat = Expression ( "++" | "--" ) .
3840
3841 void
3842 Parse::inc_dec_stat(Expression* exp)
3843 {
3844   const Token* token = this->peek_token();
3845
3846   // Lvalue maps require special handling.
3847   if (exp->index_expression() != NULL)
3848     exp->index_expression()->set_is_lvalue();
3849
3850   if (token->is_op(OPERATOR_PLUSPLUS))
3851     this->gogo_->add_statement(Statement::make_inc_statement(exp));
3852   else if (token->is_op(OPERATOR_MINUSMINUS))
3853     this->gogo_->add_statement(Statement::make_dec_statement(exp));
3854   else
3855     go_unreachable();
3856   this->advance_token();
3857 }
3858
3859 // Assignment = ExpressionList assign_op ExpressionList .
3860
3861 // EXP is an expression that we have already parsed.
3862
3863 // If MAY_BE_COMPOSITE_LIT is true, an expression on the right hand
3864 // side may be a composite literal.
3865
3866 // If RANGE_CLAUSE is not NULL, then this will recognize a
3867 // RangeClause.
3868
3869 void
3870 Parse::assignment(Expression* expr, bool may_be_composite_lit,
3871                   Range_clause* p_range_clause)
3872 {
3873   Expression_list* vars;
3874   if (!this->peek_token()->is_op(OPERATOR_COMMA))
3875     {
3876       vars = new Expression_list();
3877       vars->push_back(expr);
3878     }
3879   else
3880     {
3881       this->advance_token();
3882       vars = this->expression_list(expr, true, may_be_composite_lit);
3883     }
3884
3885   this->tuple_assignment(vars, may_be_composite_lit, p_range_clause);
3886 }
3887
3888 // An assignment statement.  LHS is the list of expressions which
3889 // appear on the left hand side.
3890
3891 // If MAY_BE_COMPOSITE_LIT is true, an expression on the right hand
3892 // side may be a composite literal.
3893
3894 // If RANGE_CLAUSE is not NULL, then this will recognize a
3895 // RangeClause.
3896
3897 void
3898 Parse::tuple_assignment(Expression_list* lhs, bool may_be_composite_lit,
3899                         Range_clause* p_range_clause)
3900 {
3901   const Token* token = this->peek_token();
3902   if (!token->is_op(OPERATOR_EQ)
3903       && !token->is_op(OPERATOR_PLUSEQ)
3904       && !token->is_op(OPERATOR_MINUSEQ)
3905       && !token->is_op(OPERATOR_OREQ)
3906       && !token->is_op(OPERATOR_XOREQ)
3907       && !token->is_op(OPERATOR_MULTEQ)
3908       && !token->is_op(OPERATOR_DIVEQ)
3909       && !token->is_op(OPERATOR_MODEQ)
3910       && !token->is_op(OPERATOR_LSHIFTEQ)
3911       && !token->is_op(OPERATOR_RSHIFTEQ)
3912       && !token->is_op(OPERATOR_ANDEQ)
3913       && !token->is_op(OPERATOR_BITCLEAREQ))
3914     {
3915       error_at(this->location(), "expected assignment operator");
3916       return;
3917     }
3918   Operator op = token->op();
3919   Location location = token->location();
3920
3921   token = this->advance_token();
3922
3923   if (p_range_clause != NULL && token->is_keyword(KEYWORD_RANGE))
3924     {
3925       if (op != OPERATOR_EQ)
3926         error_at(this->location(), "range clause requires %<=%>");
3927       this->range_clause_expr(lhs, p_range_clause);
3928       return;
3929     }
3930
3931   Expression_list* vals = this->expression_list(NULL, false,
3932                                                 may_be_composite_lit);
3933
3934   // We've parsed everything; check for errors.
3935   if (lhs == NULL || vals == NULL)
3936     return;
3937   for (Expression_list::const_iterator pe = lhs->begin();
3938        pe != lhs->end();
3939        ++pe)
3940     {
3941       if ((*pe)->is_error_expression())
3942         return;
3943       if (op != OPERATOR_EQ && (*pe)->is_sink_expression())
3944         error_at((*pe)->location(), "cannot use _ as value");
3945     }
3946   for (Expression_list::const_iterator pe = vals->begin();
3947        pe != vals->end();
3948        ++pe)
3949     {
3950       if ((*pe)->is_error_expression())
3951         return;
3952     }
3953
3954   // Map expressions act differently when they are lvalues.
3955   for (Expression_list::iterator plv = lhs->begin();
3956        plv != lhs->end();
3957        ++plv)
3958     if ((*plv)->index_expression() != NULL)
3959       (*plv)->index_expression()->set_is_lvalue();
3960
3961   Call_expression* call;
3962   Index_expression* map_index;
3963   Receive_expression* receive;
3964   Type_guard_expression* type_guard;
3965   if (lhs->size() == vals->size())
3966     {
3967       Statement* s;
3968       if (lhs->size() > 1)
3969         {
3970           if (op != OPERATOR_EQ)
3971             error_at(location, "multiple values only permitted with %<=%>");
3972           s = Statement::make_tuple_assignment(lhs, vals, location);
3973         }
3974       else
3975         {
3976           if (op == OPERATOR_EQ)
3977             s = Statement::make_assignment(lhs->front(), vals->front(),
3978                                            location);
3979           else
3980             s = Statement::make_assignment_operation(op, lhs->front(),
3981                                                      vals->front(), location);
3982           delet