1 // parse.cc -- Go frontend parser.
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.
12 #include "statements.h"
13 #include "expressions.h"
16 // Struct Parse::Enclosing_var_comparison.
18 // Return true if v1 should be considered to be less than v2.
21 Parse::Enclosing_var_comparison::operator()(const Enclosing_var& v1,
22 const Enclosing_var& v2)
24 if (v1.var() == v2.var())
27 const std::string& n1(v1.var()->name());
28 const std::string& n2(v2.var()->name());
29 int i = n1.compare(n2);
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.
43 Parse::Parse(Lex* lex, Gogo* gogo)
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),
51 continue_stack_(NULL),
58 // Return the current token.
63 if (this->unget_token_valid_)
64 return &this->unget_token_;
65 if (this->token_.is_invalid())
66 this->token_ = this->lex_->next_token();
70 // Advance to the next token and return it.
73 Parse::advance_token()
75 if (this->unget_token_valid_)
77 this->unget_token_valid_ = false;
78 if (!this->token_.is_invalid())
81 this->token_ = this->lex_->next_token();
85 // Push a token back on the input stream.
88 Parse::unget_token(const Token& token)
90 go_assert(!this->unget_token_valid_);
91 this->unget_token_ = token;
92 this->unget_token_valid_ = true;
95 // The location of the current token.
100 return this->peek_token()->location();
103 // IdentifierList = identifier { "," identifier } .
106 Parse::identifier_list(Typed_identifier_list* til)
108 const Token* token = this->peek_token();
111 if (!token->is_identifier())
113 error_at(this->location(), "expected identifier");
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))
123 token = this->advance_token();
127 // ExpressionList = Expression { "," Expression } .
129 // If MAY_BE_COMPOSITE_LIT is true, an expression may be a composite
132 // If MAY_BE_SINK is true, the expressions in the list may be "_".
135 Parse::expression_list(Expression* first, bool may_be_sink,
136 bool may_be_composite_lit)
138 Expression_list* ret = new Expression_list();
140 ret->push_back(first);
143 ret->push_back(this->expression(PRECEDENCE_NORMAL, may_be_sink,
144 may_be_composite_lit, NULL));
146 const Token* token = this->peek_token();
147 if (!token->is_op(OPERATOR_COMMA))
150 // Most expression lists permit a trailing comma.
151 Location location = token->location();
152 this->advance_token();
153 if (!this->expression_may_start_here())
155 this->unget_token(Token::make_operator_token(OPERATOR_COMMA,
162 // QualifiedIdent = [ PackageName "." ] identifier .
163 // PackageName = identifier .
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
171 Parse::qualified_ident(std::string* pname, Named_object** ppackage)
173 const Token* token = this->peek_token();
174 if (!token->is_identifier())
176 error_at(this->location(), "expected identifier");
180 std::string name = token->identifier();
181 bool is_exported = token->is_identifier_exported();
182 name = this->gogo_->pack_hidden_name(name, is_exported);
184 token = this->advance_token();
185 if (!token->is_op(OPERATOR_DOT))
192 Named_object* package = this->gogo_->lookup(name, NULL);
193 if (package == NULL || !package->is_package())
195 error_at(this->location(), "expected package");
196 // We expect . IDENTIFIER; skip both.
197 if (this->advance_token()->is_identifier())
198 this->advance_token();
202 package->package_value()->set_used();
204 token = this->advance_token();
205 if (!token->is_identifier())
207 error_at(this->location(), "expected identifier");
211 name = token->identifier();
215 error_at(this->location(), "invalid use of %<_%>");
219 if (package->name() == this->gogo_->package_name())
220 name = this->gogo_->pack_hidden_name(name,
221 token->is_identifier_exported());
226 this->advance_token();
231 // Type = TypeName | TypeLit | "(" Type ")" .
233 // ArrayType | StructType | PointerType | FunctionType | InterfaceType |
234 // SliceType | MapType | ChannelType .
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))
251 Location location = token->location();
252 this->advance_token();
253 Type* type = this->signature(NULL, location);
255 return Type::make_error_type();
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))
266 this->advance_token();
267 Type* ret = this->type();
268 if (this->peek_token()->is_op(OPERATOR_RPAREN))
269 this->advance_token();
272 if (!ret->is_error_type())
273 error_at(this->location(), "expected %<)%>");
279 error_at(token->location(), "expected type");
280 return Type::make_error_type();
285 Parse::type_may_start_here()
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));
300 // TypeName = QualifiedIdent .
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.
306 Parse::type_name(bool issue_error)
308 Location location = this->location();
311 Named_object* package;
312 if (!this->qualified_ident(&name, &package))
313 return Type::make_error_type();
315 Named_object* named_object;
317 named_object = this->gogo_->lookup(name, NULL);
320 named_object = package->package_value()->lookup(name);
321 if (named_object == NULL
323 && package->name() != this->gogo_->package_name())
325 // Check whether the name is there but hidden.
326 std::string s = ('.' + package->package_value()->unique_prefix()
327 + '.' + package->package_value()->name()
329 named_object = package->package_value()->lookup(s);
330 if (named_object != NULL)
332 const std::string& packname(package->package_value()->name());
333 error_at(location, "invalid reference to hidden type %<%s.%s%>",
334 Gogo::message_name(packname).c_str(),
335 Gogo::message_name(name).c_str());
342 if (named_object == NULL)
345 named_object = this->gogo_->add_unknown_name(name, location);
348 const std::string& packname(package->package_value()->name());
349 error_at(location, "reference to undefined identifier %<%s.%s%>",
350 Gogo::message_name(packname).c_str(),
351 Gogo::message_name(name).c_str());
356 else if (named_object->is_type())
358 if (!named_object->type_value()->is_visible())
361 else if (named_object->is_unknown() || named_object->is_type_declaration())
369 error_at(location, "expected type");
370 return Type::make_error_type();
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);
381 // ArrayType = "[" [ ArrayLength ] "]" ElementType .
382 // ArrayLength = Expression .
383 // ElementType = CompleteType .
386 Parse::array_type(bool may_use_ellipsis)
388 go_assert(this->peek_token()->is_op(OPERATOR_LSQUARE));
389 const Token* token = this->advance_token();
391 Expression* length = NULL;
392 if (token->is_op(OPERATOR_RSQUARE))
393 this->advance_token();
396 if (!token->is_op(OPERATOR_ELLIPSIS))
397 length = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
398 else if (may_use_ellipsis)
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();
409 error_at(this->location(),
410 "use of %<[...]%> outside of array literal");
411 length = Expression::make_error(this->location());
412 this->advance_token();
414 if (!this->peek_token()->is_op(OPERATOR_RSQUARE))
416 error_at(this->location(), "expected %<]%>");
417 return Type::make_error_type();
419 this->advance_token();
422 Type* element_type = this->type();
424 return Type::make_array_type(element_type, length);
427 // MapType = "map" "[" KeyType "]" ValueType .
428 // KeyType = CompleteType .
429 // ValueType = CompleteType .
434 Location location = this->location();
435 go_assert(this->peek_token()->is_keyword(KEYWORD_MAP));
436 if (!this->advance_token()->is_op(OPERATOR_LSQUARE))
438 error_at(this->location(), "expected %<[%>");
439 return Type::make_error_type();
441 this->advance_token();
443 Type* key_type = this->type();
445 if (!this->peek_token()->is_op(OPERATOR_RSQUARE))
447 error_at(this->location(), "expected %<]%>");
448 return Type::make_error_type();
450 this->advance_token();
452 Type* value_type = this->type();
454 if (key_type->is_error_type() || value_type->is_error_type())
455 return Type::make_error_type();
457 return Type::make_map_type(key_type, value_type, location);
460 // StructType = "struct" "{" { FieldDecl ";" } "}" .
465 go_assert(this->peek_token()->is_keyword(KEYWORD_STRUCT));
466 Location location = this->location();
467 if (!this->advance_token()->is_op(OPERATOR_LCURLY))
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 %<{%>");
475 error_at(this->location(), "expected %<{%>");
476 return Type::make_error_type();
479 this->advance_token();
481 Struct_field_list* sfl = new Struct_field_list;
482 while (!this->peek_token()->is_op(OPERATOR_RCURLY))
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))
489 error_at(this->location(), "expected %<;%> or %<}%> or newline");
490 if (!this->skip_past_error(OPERATOR_RCURLY))
491 return Type::make_error_type();
494 this->advance_token();
496 for (Struct_field_list::const_iterator pi = sfl->begin();
500 if (pi->type()->is_error_type())
502 for (Struct_field_list::const_iterator pj = pi + 1;
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());
513 return Type::make_struct_type(sfl, location);
516 // FieldDecl = (IdentifierList CompleteType | TypeName) [ Tag ] .
517 // Tag = string_lit .
520 Parse::field_decl(Struct_field_list* sfl)
522 const Token* token = this->peek_token();
523 Location location = token->location();
525 bool is_anonymous_pointer;
526 if (token->is_op(OPERATOR_MULT))
529 is_anonymous_pointer = true;
531 else if (token->is_identifier())
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,
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)
552 token = this->advance_token();
558 if (is_anonymous_pointer)
560 this->advance_token();
561 if (!this->peek_token()->is_identifier())
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)
568 token = this->advance_token();
572 Type* type = this->type_name(true);
575 if (this->peek_token()->is_string())
577 tag = this->peek_token()->string_value();
578 this->advance_token();
581 if (!type->is_error_type())
583 if (is_anonymous_pointer)
584 type = Type::make_pointer_type(type);
585 sfl->push_back(Struct_field(Typed_identifier("", type, location)));
587 sfl->back().set_tag(tag);
592 Typed_identifier_list til;
595 token = this->peek_token();
596 if (!token->is_identifier())
598 error_at(this->location(), "expected identifier");
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))
607 this->advance_token();
610 Type* type = this->type();
613 if (this->peek_token()->is_string())
615 tag = this->peek_token()->string_value();
616 this->advance_token();
619 for (Typed_identifier_list::iterator p = til.begin();
624 sfl->push_back(Struct_field(*p));
626 sfl->back().set_tag(tag);
631 // PointerType = "*" Type .
634 Parse::pointer_type()
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())
641 return Type::make_pointer_type(type);
644 // ChannelType = Channel | SendChannel | RecvChannel .
645 // Channel = "chan" ElementType .
646 // SendChannel = "chan" "<-" ElementType .
647 // RecvChannel = "<-" "chan" ElementType .
650 Parse::channel_type()
652 const Token* token = this->peek_token();
655 if (token->is_op(OPERATOR_CHANOP))
657 if (!this->advance_token()->is_keyword(KEYWORD_CHAN))
659 error_at(this->location(), "expected %<chan%>");
660 return Type::make_error_type();
663 this->advance_token();
667 go_assert(token->is_keyword(KEYWORD_CHAN));
668 if (this->advance_token()->is_op(OPERATOR_CHANOP))
671 this->advance_token();
675 // Better error messages for the common error of omitting the
676 // channel element type.
677 if (!this->type_may_start_here())
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");
687 error_at(this->location(), "expected channel element type");
688 return Type::make_error_type();
691 Type* element_type = this->type();
692 return Type::make_channel_type(send, receive, element_type);
695 // Give an error for a duplicate parameter or receiver name.
698 Parse::check_signature_names(const Typed_identifier_list* params,
701 for (Typed_identifier_list::const_iterator p = params->begin();
705 if (p->name().empty() || Gogo::is_sink_name(p->name()))
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);
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());
721 // Signature = Parameters [ Result ] .
723 // RECEIVER is the receiver if there is one, or NULL. LOCATION is the
724 // location of the start of the type.
726 // This returns NULL on a parse error.
729 Parse::signature(Typed_identifier* receiver, Location location)
731 bool is_varargs = false;
732 Typed_identifier_list* params;
733 bool params_ok = this->parameters(¶ms, &is_varargs);
735 Typed_identifier_list* results = NULL;
736 if (this->peek_token()->is_op(OPERATOR_LPAREN)
737 || this->type_may_start_here())
739 if (!this->result(&results))
748 this->check_signature_names(params, &names);
750 this->check_signature_names(results, &names);
752 Function_type* ret = Type::make_function_type(receiver, params, results,
755 ret->set_is_varargs();
759 // Parameters = "(" [ ParameterList [ "," ] ] ")" .
761 // This returns false on a parse error.
764 Parse::parameters(Typed_identifier_list** pparams, bool* is_varargs)
768 if (!this->peek_token()->is_op(OPERATOR_LPAREN))
770 error_at(this->location(), "expected %<(%>");
774 Typed_identifier_list* params = NULL;
775 bool saw_error = false;
777 const Token* token = this->advance_token();
778 if (!token->is_op(OPERATOR_RPAREN))
780 params = this->parameter_list(is_varargs);
783 token = this->peek_token();
786 // The optional trailing comma is picked up in parameter_list.
788 if (!token->is_op(OPERATOR_RPAREN))
789 error_at(this->location(), "expected %<)%>");
791 this->advance_token();
800 // ParameterList = ParameterDecl { "," ParameterDecl } .
802 // This sets *IS_VARARGS if the list ends with an ellipsis.
803 // IS_VARARGS will be NULL if varargs are not permitted.
805 // We pick up an optional trailing comma.
807 // This returns NULL if some error is seen.
809 Typed_identifier_list*
810 Parse::parameter_list(bool* is_varargs)
812 Location location = this->location();
813 Typed_identifier_list* ret = new Typed_identifier_list();
815 bool saw_error = false;
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.
822 bool parameters_have_names;
823 const Token* token = this->peek_token();
824 if (!token->is_identifier())
826 // This must be a type which starts with something like '*'.
827 parameters_have_names = false;
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))
837 if (token->is_op(OPERATOR_DOT))
839 // This is a qualified identifier, which must turn out
841 parameters_have_names = false;
843 else if (token->is_op(OPERATOR_RPAREN))
845 // A single identifier followed by a parenthesis must be
847 parameters_have_names = false;
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;
857 this->unget_token(Token::make_identifier_token(name, is_exported,
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
867 std::string id_name = this->gogo_->pack_hidden_name(name,
869 ret->push_back(Typed_identifier(id_name, NULL, location));
870 bool just_saw_comma = true;
871 while (this->advance_token()->is_identifier())
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))
880 just_saw_comma = false;
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;
893 else if (this->peek_token()->is_op(OPERATOR_RPAREN))
895 // We saw ID1 "," ID2 ")". ID1 and ID2 must be types,
896 // and the parameters don't have names.
897 parameters_have_names = false;
899 else if (this->peek_token()->is_op(OPERATOR_DOT))
901 // We saw ID1 "," ID2 ".". ID2 must be a package name,
902 // ID1 must be a type, and the parameters don't have
904 parameters_have_names = false;
905 this->unget_token(Token::make_identifier_token(name, is_exported,
908 just_saw_comma = true;
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;
918 if (parameters_have_names)
920 go_assert(!just_saw_comma);
921 // We have just seen ID1, ID2 xxx.
923 if (!this->peek_token()->is_op(OPERATOR_ELLIPSIS))
927 error_at(this->location(), "%<...%> only permits one name");
929 this->advance_token();
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;
941 Typed_identifier_list* tret = new Typed_identifier_list();
942 for (Typed_identifier_list::const_iterator p = ret->begin();
946 Named_object* no = this->gogo_->lookup(p->name(), NULL);
949 no = this->gogo_->add_unknown_name(p->name(),
953 type = no->type_value();
954 else if (no->is_unknown() || no->is_type_declaration())
955 type = Type::make_forward_declaration(no);
958 error_at(p->location(), "expected %<%s%> to be a type",
959 Gogo::message_name(p->name()).c_str());
961 type = Type::make_error_type();
963 tret->push_back(Typed_identifier("", type, p->location()));
968 || this->peek_token()->is_op(OPERATOR_RPAREN))
969 return saw_error ? NULL : ret;
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))
978 if (is_varargs != NULL && *is_varargs)
980 error_at(this->location(), "%<...%> must be last parameter");
983 if (this->advance_token()->is_op(OPERATOR_RPAREN))
985 this->parameter_decl(parameters_have_names, ret, is_varargs, &mix_error);
989 error_at(location, "invalid named/anonymous mix");
1000 // ParameterDecl = [ IdentifierList ] [ "..." ] Type .
1003 Parse::parameter_decl(bool parameters_have_names,
1004 Typed_identifier_list* til,
1008 if (!parameters_have_names)
1011 Location location = this->location();
1012 if (!this->peek_token()->is_identifier())
1014 if (!this->peek_token()->is_op(OPERATOR_ELLIPSIS))
1015 type = this->type();
1018 if (is_varargs == NULL)
1019 error_at(this->location(), "invalid use of %<...%>");
1022 this->advance_token();
1023 if (is_varargs == NULL
1024 && this->peek_token()->is_op(OPERATOR_RPAREN))
1025 type = Type::make_error_type();
1028 Type* element_type = this->type();
1029 type = Type::make_array_type(element_type, NULL);
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)))
1041 while (!this->peek_token()->is_op(OPERATOR_COMMA)
1042 && !this->peek_token()->is_op(OPERATOR_RPAREN))
1043 this->advance_token();
1046 if (!type->is_error_type())
1047 til->push_back(Typed_identifier("", type, location));
1051 size_t orig_count = til->size();
1052 if (this->peek_token()->is_identifier())
1053 this->identifier_list(til);
1056 size_t new_count = til->size();
1059 if (!this->peek_token()->is_op(OPERATOR_ELLIPSIS))
1060 type = this->type();
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");
1069 this->advance_token();
1070 Type* element_type = this->type();
1071 type = Type::make_array_type(element_type, NULL);
1073 for (size_t i = orig_count; i < new_count; ++i)
1074 til->set_type(i, type);
1078 // Result = Parameters | Type .
1080 // This returns false on a parse error.
1083 Parse::result(Typed_identifier_list** presults)
1085 if (this->peek_token()->is_op(OPERATOR_LPAREN))
1086 return this->parameters(presults, NULL);
1089 Location location = this->location();
1090 Type* type = this->type();
1091 if (type->is_error_type())
1096 Typed_identifier_list* til = new Typed_identifier_list();
1097 til->push_back(Typed_identifier("", type, location));
1103 // Block = "{" [ StatementList ] "}" .
1105 // Returns the location of the closing brace.
1110 if (!this->peek_token()->is_op(OPERATOR_LCURLY))
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 %<{%>");
1118 error_at(this->location(), "expected %<{%>");
1119 return Linemap::unknown_location();
1123 const Token* token = this->advance_token();
1125 if (!token->is_op(OPERATOR_RCURLY))
1127 this->statement_list();
1128 token = this->peek_token();
1129 if (!token->is_op(OPERATOR_RCURLY))
1131 if (!token->is_eof() || !saw_errors())
1132 error_at(this->location(), "expected %<}%>");
1134 this->gogo_->mark_locals_used();
1136 // Skip ahead to the end of the block, in hopes of avoiding
1137 // lots of meaningless errors.
1138 Location ret = token->location();
1140 while (!token->is_eof())
1142 if (token->is_op(OPERATOR_LCURLY))
1144 else if (token->is_op(OPERATOR_RCURLY))
1149 this->advance_token();
1153 token = this->advance_token();
1154 ret = token->location();
1160 Location ret = token->location();
1161 this->advance_token();
1165 // InterfaceType = "interface" "{" [ MethodSpecList ] "}" .
1166 // MethodSpecList = MethodSpec { ";" MethodSpec } [ ";" ] .
1169 Parse::interface_type()
1171 go_assert(this->peek_token()->is_keyword(KEYWORD_INTERFACE));
1172 Location location = this->location();
1174 if (!this->advance_token()->is_op(OPERATOR_LCURLY))
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 %<{%>");
1182 error_at(this->location(), "expected %<{%>");
1183 return Type::make_error_type();
1186 this->advance_token();
1188 Typed_identifier_list* methods = new Typed_identifier_list();
1189 if (!this->peek_token()->is_op(OPERATOR_RCURLY))
1191 this->method_spec(methods);
1192 while (this->peek_token()->is_op(OPERATOR_SEMICOLON))
1194 if (this->advance_token()->is_op(OPERATOR_RCURLY))
1196 this->method_spec(methods);
1198 if (!this->peek_token()->is_op(OPERATOR_RCURLY))
1200 error_at(this->location(), "expected %<}%>");
1201 while (!this->advance_token()->is_op(OPERATOR_RCURLY))
1203 if (this->peek_token()->is_eof())
1204 return Type::make_error_type();
1208 this->advance_token();
1210 if (methods->empty())
1216 Interface_type* ret = Type::make_interface_type(methods, location);
1217 this->gogo_->record_interface_type(ret);
1221 // MethodSpec = MethodName Signature | InterfaceTypeName .
1222 // MethodName = identifier .
1223 // InterfaceTypeName = TypeName .
1226 Parse::method_spec(Typed_identifier_list* methods)
1228 const Token* token = this->peek_token();
1229 if (!token->is_identifier())
1231 error_at(this->location(), "expected identifier");
1235 std::string name = token->identifier();
1236 bool is_exported = token->is_identifier_exported();
1237 Location location = token->location();
1239 if (this->advance_token()->is_op(OPERATOR_LPAREN))
1241 // This is a MethodName.
1242 name = this->gogo_->pack_hidden_name(name, is_exported);
1243 Type* type = this->signature(NULL, location);
1246 methods->push_back(Typed_identifier(name, type, location));
1250 this->unget_token(Token::make_identifier_token(name, is_exported,
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)))
1257 if (this->peek_token()->is_op(OPERATOR_COMMA))
1258 error_at(this->location(),
1259 "name list not allowed in interface type");
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();
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));
1277 // Declaration = ConstDecl | TypeDecl | VarDecl | FunctionDecl | MethodDecl .
1280 Parse::declaration()
1282 const Token* token = this->peek_token();
1283 if (token->is_keyword(KEYWORD_CONST))
1285 else if (token->is_keyword(KEYWORD_TYPE))
1287 else if (token->is_keyword(KEYWORD_VAR))
1289 else if (token->is_keyword(KEYWORD_FUNC))
1290 this->function_decl();
1293 error_at(this->location(), "expected declaration");
1294 this->advance_token();
1299 Parse::declaration_may_start_here()
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));
1308 // Decl<P> = P | "(" [ List<P> ] ")" .
1311 Parse::decl(void (Parse::*pfn)(void*), void* varg)
1313 if (this->peek_token()->is_eof())
1316 error_at(this->location(), "unexpected end of file");
1320 if (!this->peek_token()->is_op(OPERATOR_LPAREN))
1324 if (!this->advance_token()->is_op(OPERATOR_RPAREN))
1326 this->list(pfn, varg, true);
1327 if (!this->peek_token()->is_op(OPERATOR_RPAREN))
1329 error_at(this->location(), "missing %<)%>");
1330 while (!this->advance_token()->is_op(OPERATOR_RPAREN))
1332 if (this->peek_token()->is_eof())
1337 this->advance_token();
1341 // List<P> = P { ";" P } [ ";" ] .
1343 // In order to pick up the trailing semicolon we need to know what
1344 // might follow. This is either a '}' or a ')'.
1347 Parse::list(void (Parse::*pfn)(void*), void* varg, bool follow_is_paren)
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))
1354 if (this->peek_token()->is_op(OPERATOR_COMMA))
1355 error_at(this->location(), "unexpected comma");
1356 if (this->advance_token()->is_op(follow))
1362 // ConstDecl = "const" ( ConstSpec | "(" { ConstSpec ";" } ")" ) .
1367 go_assert(this->peek_token()->is_keyword(KEYWORD_CONST));
1368 this->advance_token();
1371 Type* last_type = NULL;
1372 Expression_list* last_expr_list = NULL;
1374 if (!this->peek_token()->is_op(OPERATOR_LPAREN))
1375 this->const_spec(&last_type, &last_expr_list);
1378 this->advance_token();
1379 while (!this->peek_token()->is_op(OPERATOR_RPAREN))
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))
1386 error_at(this->location(), "expected %<;%> or %<)%> or newline");
1387 if (!this->skip_past_error(OPERATOR_RPAREN))
1391 this->advance_token();
1394 if (last_expr_list != NULL)
1395 delete last_expr_list;
1398 // ConstSpec = IdentifierList [ [ CompleteType ] "=" ExpressionList ] .
1401 Parse::const_spec(Type** last_type, Expression_list** last_expr_list)
1403 Typed_identifier_list til;
1404 this->identifier_list(&til);
1407 if (this->type_may_start_here())
1409 type = this->type();
1411 *last_expr_list = NULL;
1414 Expression_list *expr_list;
1415 if (!this->peek_token()->is_op(OPERATOR_EQ))
1417 if (*last_expr_list == NULL)
1419 error_at(this->location(), "expected %<=%>");
1423 expr_list = new Expression_list;
1424 for (Expression_list::const_iterator p = (*last_expr_list)->begin();
1425 p != (*last_expr_list)->end();
1427 expr_list->push_back((*p)->copy());
1431 this->advance_token();
1432 expr_list = this->expression_list(NULL, false, true);
1434 if (*last_expr_list != NULL)
1435 delete *last_expr_list;
1436 *last_expr_list = expr_list;
1439 Expression_list::const_iterator pe = expr_list->begin();
1440 for (Typed_identifier_list::iterator pi = til.begin();
1444 if (pe == expr_list->end())
1446 error_at(this->location(), "not enough initializers");
1452 if (!Gogo::is_sink_name(pi->name()))
1453 this->gogo_->add_constant(*pi, *pe, this->iota_value());
1455 if (pe != expr_list->end())
1456 error_at(this->location(), "too many initializers");
1458 this->increment_iota();
1463 // TypeDecl = "type" Decl<TypeSpec> .
1468 go_assert(this->peek_token()->is_keyword(KEYWORD_TYPE));
1469 this->advance_token();
1470 this->decl(&Parse::type_spec, NULL);
1473 // TypeSpec = identifier Type .
1476 Parse::type_spec(void*)
1478 const Token* token = this->peek_token();
1479 if (!token->is_identifier())
1481 error_at(this->location(), "expected identifier");
1484 std::string name = token->identifier();
1485 bool is_exported = token->is_identifier_exported();
1486 Location location = token->location();
1487 token = this->advance_token();
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;
1495 name = this->gogo_->pack_hidden_name(name, is_exported);
1496 named_type = this->gogo_->declare_type(name, location);
1500 if (!this->peek_token()->is_op(OPERATOR_SEMICOLON))
1501 type = this->type();
1504 error_at(this->location(),
1505 "unexpected semicolon or newline in type declaration");
1506 type = Type::make_error_type();
1507 this->advance_token();
1510 if (type->is_error_type())
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();
1520 if (named_type->is_type_declaration())
1522 Type* ftype = type->forwarded();
1523 if (ftype->forward_declaration_type() != NULL
1524 && (ftype->forward_declaration_type()->named_object()
1527 error_at(location, "invalid recursive type");
1528 type = Type::make_error_type();
1531 this->gogo_->define_type(named_type,
1532 Type::make_named_type(named_type, type,
1534 go_assert(named_type->package() == NULL);
1538 // This will probably give a redefinition error.
1539 this->gogo_->add_type(name, type, location);
1544 // VarDecl = "var" Decl<VarSpec> .
1549 go_assert(this->peek_token()->is_keyword(KEYWORD_VAR));
1550 this->advance_token();
1551 this->decl(&Parse::var_spec, NULL);
1554 // VarSpec = IdentifierList
1555 // ( CompleteType [ "=" ExpressionList ] | "=" ExpressionList ) .
1558 Parse::var_spec(void*)
1560 // Get the variable names.
1561 Typed_identifier_list til;
1562 this->identifier_list(&til);
1564 Location location = this->location();
1567 Expression_list* init = NULL;
1568 if (!this->peek_token()->is_op(OPERATOR_EQ))
1570 type = this->type();
1571 if (type->is_error_type())
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();
1579 if (this->peek_token()->is_op(OPERATOR_EQ))
1581 this->advance_token();
1582 init = this->expression_list(NULL, false, true);
1587 this->advance_token();
1588 init = this->expression_list(NULL, false, true);
1591 this->init_vars(&til, type, init, false, location);
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.
1602 Parse::init_vars(const Typed_identifier_list* til, Type* type,
1603 Expression_list* init, bool is_coloneq,
1606 // Check for an initialization which can yield multiple values.
1607 if (init != NULL && init->size() == 1 && til->size() > 1)
1609 if (this->init_vars_from_call(til, type, *init->begin(), is_coloneq,
1612 if (this->init_vars_from_map(til, type, *init->begin(), is_coloneq,
1615 if (this->init_vars_from_receive(til, type, *init->begin(), is_coloneq,
1618 if (this->init_vars_from_type_guard(til, type, *init->begin(),
1619 is_coloneq, location))
1623 if (init != NULL && init->size() != til->size())
1625 if (init->empty() || !init->front()->is_error_expression())
1626 error_at(location, "wrong number of initializations");
1629 type = Type::make_error_type();
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.
1636 Expression_list::const_iterator pexpr;
1638 pexpr = init->begin();
1639 bool any_new = false;
1640 for (Typed_identifier_list::const_iterator p = til->begin();
1645 go_assert(pexpr != init->end());
1646 this->init_var(*p, type, init == NULL ? NULL : *pexpr, is_coloneq,
1652 go_assert(pexpr == init->end());
1653 if (is_coloneq && !any_new)
1654 error_at(location, "variables redeclared but no variable is new");
1657 // See if we need to initialize a list of variables from a function
1658 // call. This returns true if we have set up the variables and the
1662 Parse::init_vars_from_call(const Typed_identifier_list* vars, Type* type,
1663 Expression* expr, bool is_coloneq,
1666 Call_expression* call = expr->call_expression();
1670 // This is a function call. We can't check here whether it returns
1671 // the right number of values, but it might. Declare the variables,
1672 // and then assign the results of the call to them.
1674 Named_object* first_var = NULL;
1675 unsigned int index = 0;
1676 bool any_new = false;
1677 for (Typed_identifier_list::const_iterator pv = vars->begin();
1681 Expression* init = Expression::make_call_result(call, index);
1682 Named_object* no = this->init_var(*pv, type, init, is_coloneq, false,
1685 if (this->gogo_->in_global_scope() && no->is_variable())
1687 if (first_var == NULL)
1691 // The subsequent vars have an implicit dependency on
1692 // the first one, so that everything gets initialized in
1693 // the right order and so that we detect cycles
1695 this->gogo_->record_var_depends_on(no->var_value(), first_var);
1700 if (is_coloneq && !any_new)
1701 error_at(location, "variables redeclared but no variable is new");
1706 // See if we need to initialize a pair of values from a map index
1707 // expression. This returns true if we have set up the variables and
1708 // the initialization.
1711 Parse::init_vars_from_map(const Typed_identifier_list* vars, Type* type,
1712 Expression* expr, bool is_coloneq,
1715 Index_expression* index = expr->index_expression();
1718 if (vars->size() != 2)
1721 // This is an index which is being assigned to two variables. It
1722 // must be a map index. Declare the variables, and then assign the
1723 // results of the map index.
1724 bool any_new = false;
1725 Typed_identifier_list::const_iterator p = vars->begin();
1726 Expression* init = type == NULL ? index : NULL;
1727 Named_object* val_no = this->init_var(*p, type, init, is_coloneq,
1728 type == NULL, &any_new);
1729 if (type == NULL && any_new && val_no->is_variable())
1730 val_no->var_value()->set_type_from_init_tuple();
1731 Expression* val_var = Expression::make_var_reference(val_no, location);
1734 Type* var_type = type;
1735 if (var_type == NULL)
1736 var_type = Type::lookup_bool_type();
1737 Named_object* no = this->init_var(*p, var_type, NULL, is_coloneq, false,
1739 Expression* present_var = Expression::make_var_reference(no, location);
1741 if (is_coloneq && !any_new)
1742 error_at(location, "variables redeclared but no variable is new");
1744 Statement* s = Statement::make_tuple_map_assignment(val_var, present_var,
1747 if (!this->gogo_->in_global_scope())
1748 this->gogo_->add_statement(s);
1749 else if (!val_no->is_sink())
1751 if (val_no->is_variable())
1752 val_no->var_value()->add_preinit_statement(this->gogo_, s);
1754 else if (!no->is_sink())
1756 if (no->is_variable())
1757 no->var_value()->add_preinit_statement(this->gogo_, s);
1761 // Execute the map index expression just so that we can fail if
1763 Named_object* dummy = this->create_dummy_global(Type::lookup_bool_type(),
1765 dummy->var_value()->add_preinit_statement(this->gogo_, s);
1771 // See if we need to initialize a pair of values from a receive
1772 // expression. This returns true if we have set up the variables and
1773 // the initialization.
1776 Parse::init_vars_from_receive(const Typed_identifier_list* vars, Type* type,
1777 Expression* expr, bool is_coloneq,
1780 Receive_expression* receive = expr->receive_expression();
1781 if (receive == NULL)
1783 if (vars->size() != 2)
1786 // This is a receive expression which is being assigned to two
1787 // variables. Declare the variables, and then assign the results of
1789 bool any_new = false;
1790 Typed_identifier_list::const_iterator p = vars->begin();
1791 Expression* init = type == NULL ? receive : NULL;
1792 Named_object* val_no = this->init_var(*p, type, init, is_coloneq,
1793 type == NULL, &any_new);
1794 if (type == NULL && any_new && val_no->is_variable())
1795 val_no->var_value()->set_type_from_init_tuple();
1796 Expression* val_var = Expression::make_var_reference(val_no, location);
1799 Type* var_type = type;
1800 if (var_type == NULL)
1801 var_type = Type::lookup_bool_type();
1802 Named_object* no = this->init_var(*p, var_type, NULL, is_coloneq, false,
1804 Expression* received_var = Expression::make_var_reference(no, location);
1806 if (is_coloneq && !any_new)
1807 error_at(location, "variables redeclared but no variable is new");
1809 Statement* s = Statement::make_tuple_receive_assignment(val_var,
1814 if (!this->gogo_->in_global_scope())
1815 this->gogo_->add_statement(s);
1816 else if (!val_no->is_sink())
1818 if (val_no->is_variable())
1819 val_no->var_value()->add_preinit_statement(this->gogo_, s);
1821 else if (!no->is_sink())
1823 if (no->is_variable())
1824 no->var_value()->add_preinit_statement(this->gogo_, s);
1828 Named_object* dummy = this->create_dummy_global(Type::lookup_bool_type(),
1830 dummy->var_value()->add_preinit_statement(this->gogo_, s);
1836 // See if we need to initialize a pair of values from a type guard
1837 // expression. This returns true if we have set up the variables and
1838 // the initialization.
1841 Parse::init_vars_from_type_guard(const Typed_identifier_list* vars,
1842 Type* type, Expression* expr,
1843 bool is_coloneq, Location location)
1845 Type_guard_expression* type_guard = expr->type_guard_expression();
1846 if (type_guard == NULL)
1848 if (vars->size() != 2)
1851 // This is a type guard expression which is being assigned to two
1852 // variables. Declare the variables, and then assign the results of
1854 bool any_new = false;
1855 Typed_identifier_list::const_iterator p = vars->begin();
1856 Type* var_type = type;
1857 if (var_type == NULL)
1858 var_type = type_guard->type();
1859 Named_object* val_no = this->init_var(*p, var_type, NULL, is_coloneq, false,
1861 Expression* val_var = Expression::make_var_reference(val_no, location);
1865 if (var_type == NULL)
1866 var_type = Type::lookup_bool_type();
1867 Named_object* no = this->init_var(*p, var_type, NULL, is_coloneq, false,
1869 Expression* ok_var = Expression::make_var_reference(no, location);
1871 Expression* texpr = type_guard->expr();
1872 Type* t = type_guard->type();
1873 Statement* s = Statement::make_tuple_type_guard_assignment(val_var, ok_var,
1877 if (is_coloneq && !any_new)
1878 error_at(location, "variables redeclared but no variable is new");
1880 if (!this->gogo_->in_global_scope())
1881 this->gogo_->add_statement(s);
1882 else if (!val_no->is_sink())
1884 if (val_no->is_variable())
1885 val_no->var_value()->add_preinit_statement(this->gogo_, s);
1887 else if (!no->is_sink())
1889 if (no->is_variable())
1890 no->var_value()->add_preinit_statement(this->gogo_, s);
1894 Named_object* dummy = this->create_dummy_global(type, NULL, location);
1895 dummy->var_value()->add_preinit_statement(this->gogo_, s);
1901 // Create a single variable. If IS_COLONEQ is true, we permit
1902 // redeclarations in the same block, and we set *IS_NEW when we find a
1903 // new variable which is not a redeclaration.
1906 Parse::init_var(const Typed_identifier& tid, Type* type, Expression* init,
1907 bool is_coloneq, bool type_from_init, bool* is_new)
1909 Location location = tid.location();
1911 if (Gogo::is_sink_name(tid.name()))
1913 if (!type_from_init && init != NULL)
1915 if (this->gogo_->in_global_scope())
1916 return this->create_dummy_global(type, init, location);
1917 else if (type == NULL)
1918 this->gogo_->add_statement(Statement::make_statement(init, true));
1921 // With both a type and an initializer, create a dummy
1922 // variable so that we will check whether the
1923 // initializer can be assigned to the type.
1924 Variable* var = new Variable(type, init, false, false, false,
1929 snprintf(buf, sizeof buf, "sink$%d", count);
1931 return this->gogo_->add_variable(buf, var);
1935 this->gogo_->add_type_to_verify(type);
1936 return this->gogo_->add_sink();
1941 Named_object* no = this->gogo_->lookup_in_block(tid.name());
1943 && (no->is_variable() || no->is_result_variable()))
1945 // INIT may be NULL even when IS_COLONEQ is true for cases
1946 // like v, ok := x.(int).
1947 if (!type_from_init && init != NULL)
1949 Expression *v = Expression::make_var_reference(no, location);
1950 Statement *s = Statement::make_assignment(v, init, location);
1951 this->gogo_->add_statement(s);
1957 Variable* var = new Variable(type, init, this->gogo_->in_global_scope(),
1958 false, false, location);
1959 Named_object* no = this->gogo_->add_variable(tid.name(), var);
1960 if (!no->is_variable())
1962 // The name is already defined, so we just gave an error.
1963 return this->gogo_->add_sink();
1968 // Create a dummy global variable to force an initializer to be run in
1969 // the right place. This is used when a sink variable is initialized
1973 Parse::create_dummy_global(Type* type, Expression* init,
1976 if (type == NULL && init == NULL)
1977 type = Type::lookup_bool_type();
1978 Variable* var = new Variable(type, init, true, false, false, location);
1981 snprintf(buf, sizeof buf, "_.%d", count);
1983 return this->gogo_->add_variable(buf, var);
1986 // SimpleVarDecl = identifier ":=" Expression .
1988 // We've already seen the identifier.
1990 // FIXME: We also have to implement
1991 // IdentifierList ":=" ExpressionList
1992 // In order to support both "a, b := 1, 0" and "a, b = 1, 0" we accept
1993 // tuple assignments here as well.
1995 // If MAY_BE_COMPOSITE_LIT is true, the expression on the right hand
1996 // side may be a composite literal.
1998 // If P_RANGE_CLAUSE is not NULL, then this will recognize a
2001 // If P_TYPE_SWITCH is not NULL, this will recognize a type switch
2002 // guard (var := expr.("type") using the literal keyword "type").
2005 Parse::simple_var_decl_or_assignment(const std::string& name,
2007 bool may_be_composite_lit,
2008 Range_clause* p_range_clause,
2009 Type_switch* p_type_switch)
2011 Typed_identifier_list til;
2012 til.push_back(Typed_identifier(name, NULL, location));
2014 // We've seen one identifier. If we see a comma now, this could be
2016 if (this->peek_token()->is_op(OPERATOR_COMMA))
2018 go_assert(p_type_switch == NULL);
2021 const Token* token = this->advance_token();
2022 if (!token->is_identifier())
2025 std::string id = token->identifier();
2026 bool is_id_exported = token->is_identifier_exported();
2027 Location id_location = token->location();
2029 token = this->advance_token();
2030 if (!token->is_op(OPERATOR_COMMA))
2032 if (token->is_op(OPERATOR_COLONEQ))
2034 id = this->gogo_->pack_hidden_name(id, is_id_exported);
2035 til.push_back(Typed_identifier(id, NULL, location));
2038 this->unget_token(Token::make_identifier_token(id,
2044 id = this->gogo_->pack_hidden_name(id, is_id_exported);
2045 til.push_back(Typed_identifier(id, NULL, location));
2048 // We have a comma separated list of identifiers in TIL. If the
2049 // next token is COLONEQ, then this is a simple var decl, and we
2050 // have the complete list of identifiers. If the next token is
2051 // not COLONEQ, then the only valid parse is a tuple assignment.
2052 // The list of identifiers we have so far is really a list of
2053 // expressions. There are more expressions following.
2055 if (!this->peek_token()->is_op(OPERATOR_COLONEQ))
2057 Expression_list* exprs = new Expression_list;
2058 for (Typed_identifier_list::const_iterator p = til.begin();
2061 exprs->push_back(this->id_to_expression(p->name(),
2064 Expression_list* more_exprs =
2065 this->expression_list(NULL, true, may_be_composite_lit);
2066 for (Expression_list::const_iterator p = more_exprs->begin();
2067 p != more_exprs->end();
2069 exprs->push_back(*p);
2072 this->tuple_assignment(exprs, may_be_composite_lit, p_range_clause);
2077 go_assert(this->peek_token()->is_op(OPERATOR_COLONEQ));
2078 const Token* token = this->advance_token();
2080 if (p_range_clause != NULL && token->is_keyword(KEYWORD_RANGE))
2082 this->range_clause_decl(&til, p_range_clause);
2086 Expression_list* init;
2087 if (p_type_switch == NULL)
2088 init = this->expression_list(NULL, false, may_be_composite_lit);
2091 bool is_type_switch = false;
2092 Expression* expr = this->expression(PRECEDENCE_NORMAL, false,
2093 may_be_composite_lit,
2097 p_type_switch->found = true;
2098 p_type_switch->name = name;
2099 p_type_switch->location = location;
2100 p_type_switch->expr = expr;
2104 if (!this->peek_token()->is_op(OPERATOR_COMMA))
2106 init = new Expression_list();
2107 init->push_back(expr);
2111 this->advance_token();
2112 init = this->expression_list(expr, false, may_be_composite_lit);
2116 this->init_vars(&til, NULL, init, true, location);
2119 // FunctionDecl = "func" identifier Signature [ Block ] .
2120 // MethodDecl = "func" Receiver identifier Signature [ Block ] .
2122 // Deprecated gcc extension:
2123 // FunctionDecl = "func" identifier Signature
2124 // __asm__ "(" string_lit ")" .
2125 // This extension means a function whose real name is the identifier
2126 // inside the asm. This extension will be removed at some future
2127 // date. It has been replaced with //extern comments.
2130 Parse::function_decl()
2132 go_assert(this->peek_token()->is_keyword(KEYWORD_FUNC));
2133 Location location = this->location();
2134 std::string extern_name = this->lex_->extern_name();
2135 const Token* token = this->advance_token();
2137 Typed_identifier* rec = NULL;
2138 if (token->is_op(OPERATOR_LPAREN))
2140 rec = this->receiver();
2141 token = this->peek_token();
2144 if (!token->is_identifier())
2146 error_at(this->location(), "expected function name");
2151 this->gogo_->pack_hidden_name(token->identifier(),
2152 token->is_identifier_exported());
2154 this->advance_token();
2156 Function_type* fntype = this->signature(rec, this->location());
2158 Named_object* named_object = NULL;
2160 if (this->peek_token()->is_keyword(KEYWORD_ASM))
2162 if (!this->advance_token()->is_op(OPERATOR_LPAREN))
2164 error_at(this->location(), "expected %<(%>");
2167 token = this->advance_token();
2168 if (!token->is_string())
2170 error_at(this->location(), "expected string");
2173 std::string asm_name = token->string_value();
2174 if (!this->advance_token()->is_op(OPERATOR_RPAREN))
2176 error_at(this->location(), "expected %<)%>");
2179 this->advance_token();
2180 if (!Gogo::is_sink_name(name))
2182 named_object = this->gogo_->declare_function(name, fntype, location);
2183 if (named_object->is_function_declaration())
2184 named_object->func_declaration_value()->set_asm_name(asm_name);
2188 // Check for the easy error of a newline before the opening brace.
2189 if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
2191 Location semi_loc = this->location();
2192 if (this->advance_token()->is_op(OPERATOR_LCURLY))
2193 error_at(this->location(),
2194 "unexpected semicolon or newline before %<{%>");
2196 this->unget_token(Token::make_operator_token(OPERATOR_SEMICOLON,
2200 if (!this->peek_token()->is_op(OPERATOR_LCURLY))
2202 if (named_object == NULL && !Gogo::is_sink_name(name))
2205 this->gogo_->add_erroneous_name(name);
2208 named_object = this->gogo_->declare_function(name, fntype,
2210 if (!extern_name.empty()
2211 && named_object->is_function_declaration())
2213 Function_declaration* fd =
2214 named_object->func_declaration_value();
2215 fd->set_asm_name(extern_name);
2222 bool hold_is_erroneous_function = this->is_erroneous_function_;
2225 fntype = Type::make_function_type(NULL, NULL, NULL, location);
2226 this->is_erroneous_function_ = true;
2227 if (!Gogo::is_sink_name(name))
2228 this->gogo_->add_erroneous_name(name);
2229 name = this->gogo_->pack_hidden_name("_", false);
2231 this->gogo_->start_function(name, fntype, true, location);
2232 Location end_loc = this->block();
2233 this->gogo_->finish_function(end_loc);
2234 this->is_erroneous_function_ = hold_is_erroneous_function;
2238 // Receiver = "(" [ identifier ] [ "*" ] BaseTypeName ")" .
2239 // BaseTypeName = identifier .
2244 go_assert(this->peek_token()->is_op(OPERATOR_LPAREN));
2247 const Token* token = this->advance_token();
2248 Location location = token->location();
2249 if (!token->is_op(OPERATOR_MULT))
2251 if (!token->is_identifier())
2253 error_at(this->location(), "method has no receiver");
2254 this->gogo_->mark_locals_used();
2255 while (!token->is_eof() && !token->is_op(OPERATOR_RPAREN))
2256 token = this->advance_token();
2257 if (!token->is_eof())
2258 this->advance_token();
2261 name = token->identifier();
2262 bool is_exported = token->is_identifier_exported();
2263 token = this->advance_token();
2264 if (!token->is_op(OPERATOR_DOT) && !token->is_op(OPERATOR_RPAREN))
2266 // An identifier followed by something other than a dot or a
2267 // right parenthesis must be a receiver name followed by a
2269 name = this->gogo_->pack_hidden_name(name, is_exported);
2273 // This must be a type name.
2274 this->unget_token(Token::make_identifier_token(name, is_exported,
2276 token = this->peek_token();
2281 // Here the receiver name is in NAME (it is empty if the receiver is
2282 // unnamed) and TOKEN is the first token in the type.
2284 bool is_pointer = false;
2285 if (token->is_op(OPERATOR_MULT))
2288 token = this->advance_token();
2291 if (!token->is_identifier())
2293 error_at(this->location(), "expected receiver name or type");
2294 this->gogo_->mark_locals_used();
2295 int c = token->is_op(OPERATOR_LPAREN) ? 1 : 0;
2296 while (!token->is_eof())
2298 token = this->advance_token();
2299 if (token->is_op(OPERATOR_LPAREN))
2301 else if (token->is_op(OPERATOR_RPAREN))
2308 if (!token->is_eof())
2309 this->advance_token();
2313 Type* type = this->type_name(true);
2315 if (is_pointer && !type->is_error_type())
2316 type = Type::make_pointer_type(type);
2318 if (this->peek_token()->is_op(OPERATOR_RPAREN))
2319 this->advance_token();
2322 if (this->peek_token()->is_op(OPERATOR_COMMA))
2323 error_at(this->location(), "method has multiple receivers");
2325 error_at(this->location(), "expected %<)%>");
2326 this->gogo_->mark_locals_used();
2327 while (!token->is_eof() && !token->is_op(OPERATOR_RPAREN))
2328 token = this->advance_token();
2329 if (!token->is_eof())
2330 this->advance_token();
2334 return new Typed_identifier(name, type, location);
2337 // Operand = Literal | QualifiedIdent | MethodExpr | "(" Expression ")" .
2338 // Literal = BasicLit | CompositeLit | FunctionLit .
2339 // BasicLit = int_lit | float_lit | imaginary_lit | char_lit | string_lit .
2341 // If MAY_BE_SINK is true, this operand may be "_".
2344 Parse::operand(bool may_be_sink)
2346 const Token* token = this->peek_token();
2348 switch (token->classification())
2350 case Token::TOKEN_IDENTIFIER:
2352 Location location = token->location();
2353 std::string id = token->identifier();
2354 bool is_exported = token->is_identifier_exported();
2355 std::string packed = this->gogo_->pack_hidden_name(id, is_exported);
2357 Named_object* in_function;
2358 Named_object* named_object = this->gogo_->lookup(packed, &in_function);
2360 Package* package = NULL;
2361 if (named_object != NULL && named_object->is_package())
2363 if (!this->advance_token()->is_op(OPERATOR_DOT)
2364 || !this->advance_token()->is_identifier())
2366 error_at(location, "unexpected reference to package");
2367 return Expression::make_error(location);
2369 package = named_object->package_value();
2370 package->set_used();
2371 id = this->peek_token()->identifier();
2372 is_exported = this->peek_token()->is_identifier_exported();
2373 packed = this->gogo_->pack_hidden_name(id, is_exported);
2374 named_object = package->lookup(packed);
2375 location = this->location();
2376 go_assert(in_function == NULL);
2379 this->advance_token();
2381 if (named_object != NULL
2382 && named_object->is_type()
2383 && !named_object->type_value()->is_visible())
2385 go_assert(package != NULL);
2386 error_at(location, "invalid reference to hidden type %<%s.%s%>",
2387 Gogo::message_name(package->name()).c_str(),
2388 Gogo::message_name(id).c_str());
2389 return Expression::make_error(location);
2393 if (named_object == NULL)
2395 if (package != NULL)
2397 std::string n1 = Gogo::message_name(package->name());
2398 std::string n2 = Gogo::message_name(id);
2401 ("invalid reference to unexported identifier "
2403 n1.c_str(), n2.c_str());
2406 "reference to undefined identifier %<%s.%s%>",
2407 n1.c_str(), n2.c_str());
2408 return Expression::make_error(location);
2411 named_object = this->gogo_->add_unknown_name(packed, location);
2414 if (in_function != NULL
2415 && in_function != this->gogo_->current_function()
2416 && (named_object->is_variable()
2417 || named_object->is_result_variable()))
2418 return this->enclosing_var_reference(in_function, named_object,
2421 switch (named_object->classification())
2423 case Named_object::NAMED_OBJECT_CONST:
2424 return Expression::make_const_reference(named_object, location);
2425 case Named_object::NAMED_OBJECT_TYPE:
2426 return Expression::make_type(named_object->type_value(), location);
2427 case Named_object::NAMED_OBJECT_TYPE_DECLARATION:
2429 Type* t = Type::make_forward_declaration(named_object);
2430 return Expression::make_type(t, location);
2432 case Named_object::NAMED_OBJECT_VAR:
2433 case Named_object::NAMED_OBJECT_RESULT_VAR:
2434 this->mark_var_used(named_object);
2435 return Expression::make_var_reference(named_object, location);
2436 case Named_object::NAMED_OBJECT_SINK:
2438 return Expression::make_sink(location);
2441 error_at(location, "cannot use _ as value");
2442 return Expression::make_error(location);
2444 case Named_object::NAMED_OBJECT_FUNC:
2445 case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
2446 return Expression::make_func_reference(named_object, NULL,
2448 case Named_object::NAMED_OBJECT_UNKNOWN:
2450 Unknown_expression* ue =
2451 Expression::make_unknown_reference(named_object, location);
2452 if (this->is_erroneous_function_)
2453 ue->set_no_error_message();
2456 case Named_object::NAMED_OBJECT_ERRONEOUS:
2457 return Expression::make_error(location);
2464 case Token::TOKEN_STRING:
2465 ret = Expression::make_string(token->string_value(), token->location());
2466 this->advance_token();
2469 case Token::TOKEN_CHARACTER:
2470 ret = Expression::make_character(token->character_value(), NULL,
2472 this->advance_token();
2475 case Token::TOKEN_INTEGER:
2476 ret = Expression::make_integer(token->integer_value(), NULL,
2478 this->advance_token();
2481 case Token::TOKEN_FLOAT:
2482 ret = Expression::make_float(token->float_value(), NULL,
2484 this->advance_token();
2487 case Token::TOKEN_IMAGINARY:
2490 mpfr_init_set_ui(zero, 0, GMP_RNDN);
2491 ret = Expression::make_complex(&zero, token->imaginary_value(),
2492 NULL, token->location());
2494 this->advance_token();
2498 case Token::TOKEN_KEYWORD:
2499 switch (token->keyword())
2502 return this->function_lit();
2504 case KEYWORD_INTERFACE:
2506 case KEYWORD_STRUCT:
2508 Location location = token->location();
2509 return Expression::make_type(this->type(), location);
2516 case Token::TOKEN_OPERATOR:
2517 if (token->is_op(OPERATOR_LPAREN))
2519 this->advance_token();
2520 ret = this->expression(PRECEDENCE_NORMAL, may_be_sink, true, NULL);
2521 if (!this->peek_token()->is_op(OPERATOR_RPAREN))
2522 error_at(this->location(), "missing %<)%>");
2524 this->advance_token();
2527 else if (token->is_op(OPERATOR_LSQUARE))
2529 // Here we call array_type directly, as this is the only
2530 // case where an ellipsis is permitted for an array type.
2531 Location location = token->location();
2532 return Expression::make_type(this->array_type(true), location);
2540 error_at(this->location(), "expected operand");
2541 return Expression::make_error(this->location());
2544 // Handle a reference to a variable in an enclosing function. We add
2545 // it to a list of such variables. We return a reference to a field
2546 // in a struct which will be passed on the static chain when calling
2547 // the current function.
2550 Parse::enclosing_var_reference(Named_object* in_function, Named_object* var,
2553 go_assert(var->is_variable() || var->is_result_variable());
2555 this->mark_var_used(var);
2557 Named_object* this_function = this->gogo_->current_function();
2558 Named_object* closure = this_function->func_value()->closure_var();
2560 Enclosing_var ev(var, in_function, this->enclosing_vars_.size());
2561 std::pair<Enclosing_vars::iterator, bool> ins =
2562 this->enclosing_vars_.insert(ev);
2565 // This is a variable we have not seen before. Add a new field
2566 // to the closure type.
2567 this_function->func_value()->add_closure_field(var, location);
2570 Expression* closure_ref = Expression::make_var_reference(closure,
2572 closure_ref = Expression::make_unary(OPERATOR_MULT, closure_ref, location);
2574 // The closure structure holds pointers to the variables, so we need
2575 // to introduce an indirection.
2576 Expression* e = Expression::make_field_reference(closure_ref,
2579 e = Expression::make_unary(OPERATOR_MULT, e, location);
2583 // CompositeLit = LiteralType LiteralValue .
2584 // LiteralType = StructType | ArrayType | "[" "..." "]" ElementType |
2585 // SliceType | MapType | TypeName .
2586 // LiteralValue = "{" [ ElementList [ "," ] ] "}" .
2587 // ElementList = Element { "," Element } .
2588 // Element = [ Key ":" ] Value .
2589 // Key = FieldName | ElementIndex .
2590 // FieldName = identifier .
2591 // ElementIndex = Expression .
2592 // Value = Expression | LiteralValue .
2594 // We have already seen the type if there is one, and we are now
2595 // looking at the LiteralValue. The case "[" "..." "]" ElementType
2596 // will be seen here as an array type whose length is "nil". The
2597 // DEPTH parameter is non-zero if this is an embedded composite
2598 // literal and the type was omitted. It gives the number of steps up
2599 // to the type which was provided. E.g., in [][]int{{1}} it will be
2600 // 1. In [][][]int{{{1}}} it will be 2.
2603 Parse::composite_lit(Type* type, int depth, Location location)
2605 go_assert(this->peek_token()->is_op(OPERATOR_LCURLY));
2606 this->advance_token();
2608 if (this->peek_token()->is_op(OPERATOR_RCURLY))
2610 this->advance_token();
2611 return Expression::make_composite_literal(type, depth, false, NULL,
2615 bool has_keys = false;
2616 Expression_list* vals = new Expression_list;
2620 bool is_type_omitted = false;
2622 const Token* token = this->peek_token();
2624 if (token->is_identifier())
2626 std::string identifier = token->identifier();
2627 bool is_exported = token->is_identifier_exported();
2628 Location location = token->location();
2630 if (this->advance_token()->is_op(OPERATOR_COLON))
2632 // This may be a field name. We don't know for sure--it
2633 // could also be an expression for an array index. We
2634 // don't want to parse it as an expression because may
2635 // trigger various errors, e.g., if this identifier
2636 // happens to be the name of a package.
2637 Gogo* gogo = this->gogo_;
2638 val = this->id_to_expression(gogo->pack_hidden_name(identifier,
2644 this->unget_token(Token::make_identifier_token(identifier,
2647 val = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
2650 else if (!token->is_op(OPERATOR_LCURLY))
2651 val = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
2654 // This must be a composite literal inside another composite
2655 // literal, with the type omitted for the inner one.
2656 val = this->composite_lit(type, depth + 1, token->location());
2657 is_type_omitted = true;
2660 token = this->peek_token();
2661 if (!token->is_op(OPERATOR_COLON))
2664 vals->push_back(NULL);
2668 if (is_type_omitted && !val->is_error_expression())
2670 error_at(this->location(), "unexpected %<:%>");
2671 val = Expression::make_error(this->location());
2674 this->advance_token();
2676 if (!has_keys && !vals->empty())
2678 Expression_list* newvals = new Expression_list;
2679 for (Expression_list::const_iterator p = vals->begin();
2683 newvals->push_back(NULL);
2684 newvals->push_back(*p);
2691 if (val->unknown_expression() != NULL)
2692 val->unknown_expression()->set_is_composite_literal_key();
2694 vals->push_back(val);
2696 if (!token->is_op(OPERATOR_LCURLY))
2697 val = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
2700 // This must be a composite literal inside another
2701 // composite literal, with the type omitted for the
2703 val = this->composite_lit(type, depth + 1, token->location());
2706 token = this->peek_token();
2709 vals->push_back(val);
2711 if (token->is_op(OPERATOR_COMMA))
2713 if (this->advance_token()->is_op(OPERATOR_RCURLY))
2715 this->advance_token();
2719 else if (token->is_op(OPERATOR_RCURLY))
2721 this->advance_token();
2726 error_at(this->location(), "expected %<,%> or %<}%>");
2728 this->gogo_->mark_locals_used();
2730 while (!token->is_eof()
2731 && (depth > 0 || !token->is_op(OPERATOR_RCURLY)))
2733 if (token->is_op(OPERATOR_LCURLY))
2735 else if (token->is_op(OPERATOR_RCURLY))
2737 token = this->advance_token();
2739 if (token->is_op(OPERATOR_RCURLY))
2740 this->advance_token();
2742 return Expression::make_error(location);
2746 return Expression::make_composite_literal(type, depth, has_keys, vals,
2750 // FunctionLit = "func" Signature Block .
2753 Parse::function_lit()
2755 Location location = this->location();
2756 go_assert(this->peek_token()->is_keyword(KEYWORD_FUNC));
2757 this->advance_token();
2759 Enclosing_vars hold_enclosing_vars;
2760 hold_enclosing_vars.swap(this->enclosing_vars_);
2762 Function_type* type = this->signature(NULL, location);
2763 bool fntype_is_error = false;
2766 type = Type::make_function_type(NULL, NULL, NULL, location);
2767 fntype_is_error = true;
2770 // For a function literal, the next token must be a '{'. If we
2771 // don't see that, then we may have a type expression.
2772 if (!this->peek_token()->is_op(OPERATOR_LCURLY))
2773 return Expression::make_type(type, location);
2775 bool hold_is_erroneous_function = this->is_erroneous_function_;
2776 if (fntype_is_error)
2777 this->is_erroneous_function_ = true;
2779 Bc_stack* hold_break_stack = this->break_stack_;
2780 Bc_stack* hold_continue_stack = this->continue_stack_;
2781 this->break_stack_ = NULL;
2782 this->continue_stack_ = NULL;
2784 Named_object* no = this->gogo_->start_function("", type, true, location);
2786 Location end_loc = this->block();
2788 this->gogo_->finish_function(end_loc);
2790 if (this->break_stack_ != NULL)
2791 delete this->break_stack_;
2792 if (this->continue_stack_ != NULL)
2793 delete this->continue_stack_;
2794 this->break_stack_ = hold_break_stack;
2795 this->continue_stack_ = hold_continue_stack;
2797 this->is_erroneous_function_ = hold_is_erroneous_function;
2799 hold_enclosing_vars.swap(this->enclosing_vars_);
2801 Expression* closure = this->create_closure(no, &hold_enclosing_vars,
2804 return Expression::make_func_reference(no, closure, location);
2807 // Create a closure for the nested function FUNCTION. This is based
2808 // on ENCLOSING_VARS, which is a list of all variables defined in
2809 // enclosing functions and referenced from FUNCTION. A closure is the
2810 // address of a struct which contains the addresses of all the
2811 // referenced variables. This returns NULL if no closure is required.
2814 Parse::create_closure(Named_object* function, Enclosing_vars* enclosing_vars,
2817 if (enclosing_vars->empty())
2820 // Get the variables in order by their field index.
2822 size_t enclosing_var_count = enclosing_vars->size();
2823 std::vector<Enclosing_var> ev(enclosing_var_count);
2824 for (Enclosing_vars::const_iterator p = enclosing_vars->begin();
2825 p != enclosing_vars->end();
2827 ev[p->index()] = *p;
2829 // Build an initializer for a composite literal of the closure's
2832 Named_object* enclosing_function = this->gogo_->current_function();
2833 Expression_list* initializer = new Expression_list;
2834 for (size_t i = 0; i < enclosing_var_count; ++i)
2836 go_assert(ev[i].index() == i);
2837 Named_object* var = ev[i].var();
2839 if (ev[i].in_function() == enclosing_function)
2840 ref = Expression::make_var_reference(var, location);
2842 ref = this->enclosing_var_reference(ev[i].in_function(), var,
2844 Expression* refaddr = Expression::make_unary(OPERATOR_AND, ref,
2846 initializer->push_back(refaddr);
2849 Named_object* closure_var = function->func_value()->closure_var();
2850 Struct_type* st = closure_var->var_value()->type()->deref()->struct_type();
2851 Expression* cv = Expression::make_struct_composite_literal(st, initializer,
2853 return Expression::make_heap_composite(cv, location);
2856 // PrimaryExpr = Operand { Selector | Index | Slice | TypeGuard | Call } .
2858 // If MAY_BE_SINK is true, this expression may be "_".
2860 // If MAY_BE_COMPOSITE_LIT is true, this expression may be a composite
2863 // If IS_TYPE_SWITCH is not NULL, this will recognize a type switch
2864 // guard (var := expr.("type") using the literal keyword "type").
2867 Parse::primary_expr(bool may_be_sink, bool may_be_composite_lit,
2868 bool* is_type_switch)
2870 Location start_loc = this->location();
2871 bool is_parenthesized = this->peek_token()->is_op(OPERATOR_LPAREN);
2873 Expression* ret = this->operand(may_be_sink);
2875 // An unknown name followed by a curly brace must be a composite
2876 // literal, and the unknown name must be a type.
2877 if (may_be_composite_lit
2878 && !is_parenthesized
2879 && ret->unknown_expression() != NULL
2880 && this->peek_token()->is_op(OPERATOR_LCURLY))
2882 Named_object* no = ret->unknown_expression()->named_object();
2883 Type* type = Type::make_forward_declaration(no);
2884 ret = Expression::make_type(type, ret->location());
2887 // We handle composite literals and type casts here, as it is the
2888 // easiest way to handle types which are in parentheses, as in
2890 if (ret->is_type_expression())
2892 if (this->peek_token()->is_op(OPERATOR_LCURLY))
2894 if (!may_be_composite_lit)
2896 Type* t = ret->type();
2897 if (t->named_type() != NULL
2898 || t->forward_declaration_type() != NULL)
2900 _("parentheses required around this composite literal"
2901 "to avoid parsing ambiguity"));
2903 else if (is_parenthesized)
2905 "cannot parenthesize type in composite literal");
2906 ret = this->composite_lit(ret->type(), 0, ret->location());
2908 else if (this->peek_token()->is_op(OPERATOR_LPAREN))
2910 Location loc = this->location();
2911 this->advance_token();
2912 Expression* expr = this->expression(PRECEDENCE_NORMAL, false, true,
2914 if (this->peek_token()->is_op(OPERATOR_ELLIPSIS))
2916 error_at(this->location(),
2917 "invalid use of %<...%> in type conversion");
2918 this->advance_token();
2920 if (!this->peek_token()->is_op(OPERATOR_RPAREN))
2921 error_at(this->location(), "expected %<)%>");
2923 this->advance_token();
2924 if (expr->is_error_expression())
2928 Type* t = ret->type();
2929 if (t->classification() == Type::TYPE_ARRAY
2930 && t->array_type()->length() != NULL
2931 && t->array_type()->length()->is_nil_expression())
2933 error_at(ret->location(),
2934 "invalid use of %<...%> in type conversion");
2935 ret = Expression::make_error(loc);
2938 ret = Expression::make_cast(t, expr, loc);
2945 const Token* token = this->peek_token();
2946 if (token->is_op(OPERATOR_LPAREN))
2947 ret = this->call(this->verify_not_sink(ret));
2948 else if (token->is_op(OPERATOR_DOT))
2950 ret = this->selector(this->verify_not_sink(ret), is_type_switch);
2951 if (is_type_switch != NULL && *is_type_switch)
2954 else if (token->is_op(OPERATOR_LSQUARE))
2955 ret = this->index(this->verify_not_sink(ret));
2963 // Selector = "." identifier .
2964 // TypeGuard = "." "(" QualifiedIdent ")" .
2966 // Note that Operand can expand to QualifiedIdent, which contains a
2967 // ".". That is handled directly in operand when it sees a package
2970 // If IS_TYPE_SWITCH is not NULL, this will recognize a type switch
2971 // guard (var := expr.("type") using the literal keyword "type").
2974 Parse::selector(Expression* left, bool* is_type_switch)
2976 go_assert(this->peek_token()->is_op(OPERATOR_DOT));
2977 Location location = this->location();
2979 const Token* token = this->advance_token();
2980 if (token->is_identifier())
2982 // This could be a field in a struct, or a method in an
2983 // interface, or a method associated with a type. We can't know
2984 // which until we have seen all the types.
2986 this->gogo_->pack_hidden_name(token->identifier(),
2987 token->is_identifier_exported());
2988 if (token->identifier() == "_")
2990 error_at(this->location(), "invalid use of %<_%>");
2991 name = this->gogo_->pack_hidden_name("blank", false);
2993 this->advance_token();
2994 return Expression::make_selector(left, name, location);
2996 else if (token->is_op(OPERATOR_LPAREN))
2998 this->advance_token();
3000 if (!this->peek_token()->is_keyword(KEYWORD_TYPE))
3001 type = this->type();
3004 if (is_type_switch != NULL)
3005 *is_type_switch = true;
3008 error_at(this->location(),
3009 "use of %<.(type)%> outside type switch");
3010 type = Type::make_error_type();
3012 this->advance_token();
3014 if (!this->peek_token()->is_op(OPERATOR_RPAREN))
3015 error_at(this->location(), "missing %<)%>");
3017 this->advance_token();
3018 if (is_type_switch != NULL && *is_type_switch)
3020 return Expression::make_type_guard(left, type, location);
3024 error_at(this->location(), "expected identifier or %<(%>");
3029 // Index = "[" Expression "]" .
3030 // Slice = "[" Expression ":" [ Expression ] "]" .
3033 Parse::index(Expression* expr)
3035 Location location = this->location();
3036 go_assert(this->peek_token()->is_op(OPERATOR_LSQUARE));
3037 this->advance_token();
3040 if (!this->peek_token()->is_op(OPERATOR_COLON))
3041 start = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
3045 mpz_init_set_ui(zero, 0);
3046 start = Expression::make_integer(&zero, NULL, location);
3050 Expression* end = NULL;
3051 if (this->peek_token()->is_op(OPERATOR_COLON))
3053 // We use nil to indicate a missing high expression.
3054 if (this->advance_token()->is_op(OPERATOR_RSQUARE))
3055 end = Expression::make_nil(this->location());
3057 end = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
3059 if (!this->peek_token()->is_op(OPERATOR_RSQUARE))
3060 error_at(this->location(), "missing %<]%>");
3062 this->advance_token();
3063 return Expression::make_index(expr, start, end, location);
3066 // Call = "(" [ ArgumentList [ "," ] ] ")" .
3067 // ArgumentList = ExpressionList [ "..." ] .
3070 Parse::call(Expression* func)
3072 go_assert(this->peek_token()->is_op(OPERATOR_LPAREN));
3073 Expression_list* args = NULL;
3074 bool is_varargs = false;
3075 const Token* token = this->advance_token();
3076 if (!token->is_op(OPERATOR_RPAREN))
3078 args = this->expression_list(NULL, false, true);
3079 token = this->peek_token();
3080 if (token->is_op(OPERATOR_ELLIPSIS))
3083 token = this->advance_token();
3086 if (token->is_op(OPERATOR_COMMA))
3087 token = this->advance_token();
3088 if (!token->is_op(OPERATOR_RPAREN))
3089 error_at(this->location(), "missing %<)%>");
3091 this->advance_token();
3092 if (func->is_error_expression())
3094 return Expression::make_call(func, args, is_varargs, func->location());
3097 // Return an expression for a single unqualified identifier.
3100 Parse::id_to_expression(const std::string& name, Location location)
3102 Named_object* in_function;
3103 Named_object* named_object = this->gogo_->lookup(name, &in_function);
3104 if (named_object == NULL)
3105 named_object = this->gogo_->add_unknown_name(name, location);
3107 if (in_function != NULL
3108 && in_function != this->gogo_->current_function()
3109 && (named_object->is_variable() || named_object->is_result_variable()))
3110 return this->enclosing_var_reference(in_function, named_object,
3113 switch (named_object->classification())
3115 case Named_object::NAMED_OBJECT_CONST:
3116 return Expression::make_const_reference(named_object, location);
3117 case Named_object::NAMED_OBJECT_VAR:
3118 case Named_object::NAMED_OBJECT_RESULT_VAR:
3119 this->mark_var_used(named_object);
3120 return Expression::make_var_reference(named_object, location);
3121 case Named_object::NAMED_OBJECT_SINK:
3122 return Expression::make_sink(location);
3123 case Named_object::NAMED_OBJECT_FUNC:
3124 case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
3125 return Expression::make_func_reference(named_object, NULL, location);
3126 case Named_object::NAMED_OBJECT_UNKNOWN:
3128 Unknown_expression* ue =
3129 Expression::make_unknown_reference(named_object, location);
3130 if (this->is_erroneous_function_)
3131 ue->set_no_error_message();
3134 case Named_object::NAMED_OBJECT_PACKAGE:
3135 case Named_object::NAMED_OBJECT_TYPE:
3136 case Named_object::NAMED_OBJECT_TYPE_DECLARATION:
3138 // These cases can arise for a field name in a composite
3140 Unknown_expression* ue =
3141 Expression::make_unknown_reference(named_object, location);
3142 if (this->is_erroneous_function_)
3143 ue->set_no_error_message();
3146 case Named_object::NAMED_OBJECT_ERRONEOUS:
3147 return Expression::make_error(location);
3149 error_at(this->location(), "unexpected type of identifier");
3150 return Expression::make_error(location);
3154 // Expression = UnaryExpr { binary_op Expression } .
3156 // PRECEDENCE is the precedence of the current operator.
3158 // If MAY_BE_SINK is true, this expression may be "_".
3160 // If MAY_BE_COMPOSITE_LIT is true, this expression may be a composite
3163 // If IS_TYPE_SWITCH is not NULL, this will recognize a type switch
3164 // guard (var := expr.("type") using the literal keyword "type").
3167 Parse::expression(Precedence precedence, bool may_be_sink,
3168 bool may_be_composite_lit, bool* is_type_switch)
3170 Expression* left = this->unary_expr(may_be_sink, may_be_composite_lit,
3175 if (is_type_switch != NULL && *is_type_switch)
3178 const Token* token = this->peek_token();
3179 if (token->classification() != Token::TOKEN_OPERATOR)
3185 Precedence right_precedence;
3186 switch (token->op())
3189 right_precedence = PRECEDENCE_OROR;
3191 case OPERATOR_ANDAND:
3192 right_precedence = PRECEDENCE_ANDAND;
3195 case OPERATOR_NOTEQ:
3200 right_precedence = PRECEDENCE_RELOP;
3203 case OPERATOR_MINUS:
3206 right_precedence = PRECEDENCE_ADDOP;
3211 case OPERATOR_LSHIFT:
3212 case OPERATOR_RSHIFT:
3214 case OPERATOR_BITCLEAR:
3215 right_precedence = PRECEDENCE_MULOP;
3218 right_precedence = PRECEDENCE_INVALID;
3222 if (right_precedence == PRECEDENCE_INVALID)
3228 Operator op = token->op();
3229 Location binop_location = token->location();
3231 if (precedence >= right_precedence)
3233 // We've already seen A * B, and we see + C. We want to
3234 // return so that A * B becomes a group.
3238 this->advance_token();
3240 left = this->verify_not_sink(left);
3241 Expression* right = this->expression(right_precedence, false,
3242 may_be_composite_lit,
3244 left = Expression::make_binary(op, left, right, binop_location);
3249 Parse::expression_may_start_here()
3251 const Token* token = this->peek_token();
3252 switch (token->classification())
3254 case Token::TOKEN_INVALID:
3255 case Token::TOKEN_EOF:
3257 case Token::TOKEN_KEYWORD:
3258 switch (token->keyword())
3263 case KEYWORD_STRUCT:
3264 case KEYWORD_INTERFACE:
3269 case Token::TOKEN_IDENTIFIER:
3271 case Token::TOKEN_STRING:
3273 case Token::TOKEN_OPERATOR:
3274 switch (token->op())
3277 case OPERATOR_MINUS:
3281 case OPERATOR_CHANOP:
3283 case OPERATOR_LPAREN:
3284 case OPERATOR_LSQUARE:
3289 case Token::TOKEN_CHARACTER:
3290 case Token::TOKEN_INTEGER:
3291 case Token::TOKEN_FLOAT:
3292 case Token::TOKEN_IMAGINARY:
3299 // UnaryExpr = unary_op UnaryExpr | PrimaryExpr .
3301 // If MAY_BE_SINK is true, this expression may be "_".
3303 // If MAY_BE_COMPOSITE_LIT is true, this expression may be a composite
3306 // If IS_TYPE_SWITCH is not NULL, this will recognize a type switch
3307 // guard (var := expr.("type") using the literal keyword "type").
3310 Parse::unary_expr(bool may_be_sink, bool may_be_composite_lit,
3311 bool* is_type_switch)
3313 const Token* token = this->peek_token();
3314 if (token->is_op(OPERATOR_PLUS)
3315 || token->is_op(OPERATOR_MINUS)
3316 || token->is_op(OPERATOR_NOT)
3317 || token->is_op(OPERATOR_XOR)
3318 || token->is_op(OPERATOR_CHANOP)
3319 || token->is_op(OPERATOR_MULT)
3320 || token->is_op(OPERATOR_AND))
3322 Location location = token->location();
3323 Operator op = token->op();
3324 this->advance_token();
3326 if (op == OPERATOR_CHANOP
3327 && this->peek_token()->is_keyword(KEYWORD_CHAN))
3329 // This is "<- chan" which must be the start of a type.
3330 this->unget_token(Token::make_operator_token(op, location));
3331 return Expression::make_type(this->type(), location);
3334 Expression* expr = this->unary_expr(false, may_be_composite_lit, NULL);
3335 if (expr->is_error_expression())
3337 else if (op == OPERATOR_MULT && expr->is_type_expression())
3338 expr = Expression::make_type(Type::make_pointer_type(expr->type()),
3340 else if (op == OPERATOR_AND && expr->is_composite_literal())
3341 expr = Expression::make_heap_composite(expr, location);
3342 else if (op != OPERATOR_CHANOP)
3343 expr = Expression::make_unary(op, expr, location);
3345 expr = Expression::make_receive(expr, location);
3349 return this->primary_expr(may_be_sink, may_be_composite_lit,
3354 // Declaration | LabeledStmt | SimpleStmt |
3355 // GoStmt | ReturnStmt | BreakStmt | ContinueStmt | GotoStmt |
3356 // FallthroughStmt | Block | IfStmt | SwitchStmt | SelectStmt | ForStmt |
3359 // LABEL is the label of this statement if it has one.
3362 Parse::statement(Label* label)
3364 const Token* token = this->peek_token();
3365 switch (token->classification())
3367 case Token::TOKEN_KEYWORD:
3369 switch (token->keyword())
3374 this->declaration();
3378 case KEYWORD_STRUCT:
3379 case KEYWORD_INTERFACE:
3380 this->simple_stat(true, NULL, NULL, NULL);
3384 this->go_or_defer_stat();
3386 case KEYWORD_RETURN:
3387 this->return_stat();
3392 case KEYWORD_CONTINUE:
3393 this->continue_stat();
3401 case KEYWORD_SWITCH:
3402 this->switch_stat(label);
3404 case KEYWORD_SELECT:
3405 this->select_stat(label);