1 //===--- ParseObjC.cpp - Objective C Parsing ------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the Objective-C portions of the Parser interface.
12 //===----------------------------------------------------------------------===//
14 #include "clang/Parse/ParseDiagnostic.h"
15 #include "clang/Parse/Parser.h"
16 #include "RAIIObjectsForParser.h"
17 #include "clang/Sema/DeclSpec.h"
18 #include "clang/Sema/PrettyDeclStackTrace.h"
19 #include "clang/Sema/Scope.h"
20 #include "llvm/ADT/SmallVector.h"
21 using namespace clang;
24 /// ParseObjCAtDirectives - Handle parts of the external-declaration production:
25 /// external-declaration: [C99 6.9]
26 /// [OBJC] objc-class-definition
27 /// [OBJC] objc-class-declaration
28 /// [OBJC] objc-alias-declaration
29 /// [OBJC] objc-protocol-definition
30 /// [OBJC] objc-method-definition
32 Decl *Parser::ParseObjCAtDirectives() {
33 SourceLocation AtLoc = ConsumeToken(); // the "@"
35 if (Tok.is(tok::code_completion)) {
36 Actions.CodeCompleteObjCAtDirective(getCurScope(), ObjCImpDecl, false);
37 ConsumeCodeCompletionToken();
40 switch (Tok.getObjCKeywordID()) {
42 return ParseObjCAtClassDeclaration(AtLoc);
43 case tok::objc_interface: {
44 ParsedAttributes attrs(AttrFactory);
45 return ParseObjCAtInterfaceDeclaration(AtLoc, attrs);
47 case tok::objc_protocol: {
48 ParsedAttributes attrs(AttrFactory);
49 return ParseObjCAtProtocolDeclaration(AtLoc, attrs);
51 case tok::objc_implementation:
52 return ParseObjCAtImplementationDeclaration(AtLoc);
54 return ParseObjCAtEndDeclaration(AtLoc);
55 case tok::objc_compatibility_alias:
56 return ParseObjCAtAliasDeclaration(AtLoc);
57 case tok::objc_synthesize:
58 return ParseObjCPropertySynthesize(AtLoc);
59 case tok::objc_dynamic:
60 return ParseObjCPropertyDynamic(AtLoc);
62 Diag(AtLoc, diag::err_unexpected_at);
69 /// objc-class-declaration:
70 /// '@' 'class' identifier-list ';'
72 Decl *Parser::ParseObjCAtClassDeclaration(SourceLocation atLoc) {
73 ConsumeToken(); // the identifier "class"
74 llvm::SmallVector<IdentifierInfo *, 8> ClassNames;
75 llvm::SmallVector<SourceLocation, 8> ClassLocs;
79 if (Tok.isNot(tok::identifier)) {
80 Diag(Tok, diag::err_expected_ident);
84 ClassNames.push_back(Tok.getIdentifierInfo());
85 ClassLocs.push_back(Tok.getLocation());
88 if (Tok.isNot(tok::comma))
95 if (ExpectAndConsume(tok::semi, diag::err_expected_semi_after, "@class"))
98 return Actions.ActOnForwardClassDeclaration(atLoc, ClassNames.data(),
105 /// objc-class-interface-attributes[opt] objc-class-interface
106 /// objc-category-interface
108 /// objc-class-interface:
109 /// '@' 'interface' identifier objc-superclass[opt]
110 /// objc-protocol-refs[opt]
111 /// objc-class-instance-variables[opt]
112 /// objc-interface-decl-list
115 /// objc-category-interface:
116 /// '@' 'interface' identifier '(' identifier[opt] ')'
117 /// objc-protocol-refs[opt]
118 /// objc-interface-decl-list
124 /// objc-class-interface-attributes:
125 /// __attribute__((visibility("default")))
126 /// __attribute__((visibility("hidden")))
127 /// __attribute__((deprecated))
128 /// __attribute__((unavailable))
129 /// __attribute__((objc_exception)) - used by NSException on 64-bit
131 Decl *Parser::ParseObjCAtInterfaceDeclaration(SourceLocation atLoc,
132 ParsedAttributes &attrs) {
133 assert(Tok.isObjCAtKeyword(tok::objc_interface) &&
134 "ParseObjCAtInterfaceDeclaration(): Expected @interface");
135 ConsumeToken(); // the "interface" identifier
137 // Code completion after '@interface'.
138 if (Tok.is(tok::code_completion)) {
139 Actions.CodeCompleteObjCInterfaceDecl(getCurScope());
140 ConsumeCodeCompletionToken();
143 if (Tok.isNot(tok::identifier)) {
144 Diag(Tok, diag::err_expected_ident); // missing class or category name.
148 // We have a class or category name - consume it.
149 IdentifierInfo *nameId = Tok.getIdentifierInfo();
150 SourceLocation nameLoc = ConsumeToken();
151 if (Tok.is(tok::l_paren) &&
152 !isKnownToBeTypeSpecifier(GetLookAheadToken(1))) { // we have a category.
153 // TODO(dgregor): Use the return value from the next line to provide better
156 SourceLocation categoryLoc, rparenLoc;
157 IdentifierInfo *categoryId = 0;
158 if (Tok.is(tok::code_completion)) {
159 Actions.CodeCompleteObjCInterfaceCategory(getCurScope(), nameId, nameLoc);
160 ConsumeCodeCompletionToken();
163 // For ObjC2, the category name is optional (not an error).
164 if (Tok.is(tok::identifier)) {
165 categoryId = Tok.getIdentifierInfo();
166 categoryLoc = ConsumeToken();
168 else if (!getLang().ObjC2) {
169 Diag(Tok, diag::err_expected_ident); // missing category name.
172 if (Tok.isNot(tok::r_paren)) {
173 Diag(Tok, diag::err_expected_rparen);
174 SkipUntil(tok::r_paren, false); // don't stop at ';'
177 rparenLoc = ConsumeParen();
178 // Next, we need to check for any protocol references.
179 SourceLocation LAngleLoc, EndProtoLoc;
180 llvm::SmallVector<Decl *, 8> ProtocolRefs;
181 llvm::SmallVector<SourceLocation, 8> ProtocolLocs;
182 if (Tok.is(tok::less) &&
183 ParseObjCProtocolReferences(ProtocolRefs, ProtocolLocs, true,
184 LAngleLoc, EndProtoLoc))
187 if (!attrs.empty()) // categories don't support attributes.
188 Diag(Tok, diag::err_objc_no_attributes_on_category);
191 Actions.ActOnStartCategoryInterface(atLoc,
193 categoryId, categoryLoc,
198 if (Tok.is(tok::l_brace))
199 ParseObjCClassInstanceVariables(CategoryType, tok::objc_private,
202 ParseObjCInterfaceDeclList(CategoryType, tok::objc_not_keyword);
205 // Parse a class interface.
206 IdentifierInfo *superClassId = 0;
207 SourceLocation superClassLoc;
209 if (Tok.is(tok::colon)) { // a super class is specified.
212 // Code completion of superclass names.
213 if (Tok.is(tok::code_completion)) {
214 Actions.CodeCompleteObjCSuperclass(getCurScope(), nameId, nameLoc);
215 ConsumeCodeCompletionToken();
218 if (Tok.isNot(tok::identifier)) {
219 Diag(Tok, diag::err_expected_ident); // missing super class name.
222 superClassId = Tok.getIdentifierInfo();
223 superClassLoc = ConsumeToken();
225 // Next, we need to check for any protocol references.
226 llvm::SmallVector<Decl *, 8> ProtocolRefs;
227 llvm::SmallVector<SourceLocation, 8> ProtocolLocs;
228 SourceLocation LAngleLoc, EndProtoLoc;
229 if (Tok.is(tok::less) &&
230 ParseObjCProtocolReferences(ProtocolRefs, ProtocolLocs, true,
231 LAngleLoc, EndProtoLoc))
235 Actions.ActOnStartClassInterface(atLoc, nameId, nameLoc,
236 superClassId, superClassLoc,
237 ProtocolRefs.data(), ProtocolRefs.size(),
239 EndProtoLoc, attrs.getList());
241 if (Tok.is(tok::l_brace))
242 ParseObjCClassInstanceVariables(ClsType, tok::objc_protected, atLoc);
244 ParseObjCInterfaceDeclList(ClsType, tok::objc_interface);
248 /// The Objective-C property callback. This should be defined where
249 /// it's used, but instead it's been lifted to here to support VS2005.
250 struct Parser::ObjCPropertyCallback : FieldCallback {
253 llvm::SmallVectorImpl<Decl *> &Props;
255 SourceLocation AtLoc;
256 tok::ObjCKeywordKind MethodImplKind;
258 ObjCPropertyCallback(Parser &P, Decl *IDecl,
259 llvm::SmallVectorImpl<Decl *> &Props,
260 ObjCDeclSpec &OCDS, SourceLocation AtLoc,
261 tok::ObjCKeywordKind MethodImplKind) :
262 P(P), IDecl(IDecl), Props(Props), OCDS(OCDS), AtLoc(AtLoc),
263 MethodImplKind(MethodImplKind) {
266 Decl *invoke(FieldDeclarator &FD) {
267 if (FD.D.getIdentifier() == 0) {
268 P.Diag(AtLoc, diag::err_objc_property_requires_field_name)
269 << FD.D.getSourceRange();
272 if (FD.BitfieldSize) {
273 P.Diag(AtLoc, diag::err_objc_property_bitfield)
274 << FD.D.getSourceRange();
278 // Install the property declarator into interfaceDecl.
279 IdentifierInfo *SelName =
280 OCDS.getGetterName() ? OCDS.getGetterName() : FD.D.getIdentifier();
283 P.PP.getSelectorTable().getNullarySelector(SelName);
284 IdentifierInfo *SetterName = OCDS.getSetterName();
287 SetterSel = P.PP.getSelectorTable().getSelector(1, &SetterName);
289 SetterSel = SelectorTable::constructSetterName(P.PP.getIdentifierTable(),
290 P.PP.getSelectorTable(),
291 FD.D.getIdentifier());
292 bool isOverridingProperty = false;
294 P.Actions.ActOnProperty(P.getCurScope(), AtLoc, FD, OCDS,
295 GetterSel, SetterSel, IDecl,
296 &isOverridingProperty,
298 if (!isOverridingProperty)
299 Props.push_back(Property);
305 /// objc-interface-decl-list:
307 /// objc-interface-decl-list objc-property-decl [OBJC2]
308 /// objc-interface-decl-list objc-method-requirement [OBJC2]
309 /// objc-interface-decl-list objc-method-proto ';'
310 /// objc-interface-decl-list declaration
311 /// objc-interface-decl-list ';'
313 /// objc-method-requirement: [OBJC2]
317 void Parser::ParseObjCInterfaceDeclList(Decl *interfaceDecl,
318 tok::ObjCKeywordKind contextKey) {
319 llvm::SmallVector<Decl *, 32> allMethods;
320 llvm::SmallVector<Decl *, 16> allProperties;
321 llvm::SmallVector<DeclGroupPtrTy, 8> allTUVariables;
322 tok::ObjCKeywordKind MethodImplKind = tok::objc_not_keyword;
327 // If this is a method prototype, parse it.
328 if (Tok.is(tok::minus) || Tok.is(tok::plus)) {
329 Decl *methodPrototype =
330 ParseObjCMethodPrototype(interfaceDecl, MethodImplKind, false);
331 allMethods.push_back(methodPrototype);
332 // Consume the ';' here, since ParseObjCMethodPrototype() is re-used for
333 // method definitions.
334 ExpectAndConsume(tok::semi, diag::err_expected_semi_after_method_proto,
338 if (Tok.is(tok::l_paren)) {
339 Diag(Tok, diag::err_expected_minus_or_plus);
340 ParseObjCMethodDecl(Tok.getLocation(),
343 MethodImplKind, false);
346 // Ignore excess semicolons.
347 if (Tok.is(tok::semi)) {
352 // If we got to the end of the file, exit the loop.
353 if (Tok.is(tok::eof))
356 // Code completion within an Objective-C interface.
357 if (Tok.is(tok::code_completion)) {
358 Actions.CodeCompleteOrdinaryName(getCurScope(),
359 ObjCImpDecl? Sema::PCC_ObjCImplementation
360 : Sema::PCC_ObjCInterface);
361 ConsumeCodeCompletionToken();
364 // If we don't have an @ directive, parse it as a function definition.
365 if (Tok.isNot(tok::at)) {
366 // The code below does not consume '}'s because it is afraid of eating the
367 // end of a namespace. Because of the way this code is structured, an
368 // erroneous r_brace would cause an infinite loop if not handled here.
369 if (Tok.is(tok::r_brace))
372 // FIXME: as the name implies, this rule allows function definitions.
373 // We could pass a flag or check for functions during semantic analysis.
374 ParsedAttributes attrs(AttrFactory);
375 allTUVariables.push_back(ParseDeclarationOrFunctionDefinition(attrs));
379 // Otherwise, we have an @ directive, eat the @.
380 SourceLocation AtLoc = ConsumeToken(); // the "@"
381 if (Tok.is(tok::code_completion)) {
382 Actions.CodeCompleteObjCAtDirective(getCurScope(), ObjCImpDecl, true);
383 ConsumeCodeCompletionToken();
387 tok::ObjCKeywordKind DirectiveKind = Tok.getObjCKeywordID();
389 if (DirectiveKind == tok::objc_end) { // @end -> terminate list
390 AtEnd.setBegin(AtLoc);
391 AtEnd.setEnd(Tok.getLocation());
393 } else if (DirectiveKind == tok::objc_not_keyword) {
394 Diag(Tok, diag::err_objc_unknown_at);
395 SkipUntil(tok::semi);
399 // Eat the identifier.
402 switch (DirectiveKind) {
404 // FIXME: If someone forgets an @end on a protocol, this loop will
405 // continue to eat up tons of stuff and spew lots of nonsense errors. It
406 // would probably be better to bail out if we saw an @class or @interface
407 // or something like that.
408 Diag(AtLoc, diag::err_objc_illegal_interface_qual);
409 // Skip until we see an '@' or '}' or ';'.
410 SkipUntil(tok::r_brace, tok::at);
413 case tok::objc_implementation:
414 case tok::objc_interface:
415 Diag(Tok, diag::err_objc_missing_end);
419 case tok::objc_required:
420 case tok::objc_optional:
421 // This is only valid on protocols.
422 // FIXME: Should this check for ObjC2 being enabled?
423 if (contextKey != tok::objc_protocol)
424 Diag(AtLoc, diag::err_objc_directive_only_in_protocol);
426 MethodImplKind = DirectiveKind;
429 case tok::objc_property:
430 if (!getLang().ObjC2)
431 Diag(AtLoc, diag::err_objc_properties_require_objc2);
434 // Parse property attribute list, if any.
435 if (Tok.is(tok::l_paren))
436 ParseObjCPropertyAttribute(OCDS, interfaceDecl);
438 ObjCPropertyCallback Callback(*this, interfaceDecl, allProperties,
439 OCDS, AtLoc, MethodImplKind);
441 // Parse all the comma separated declarators.
442 DeclSpec DS(AttrFactory);
443 ParseStructDeclaration(DS, Callback);
445 ExpectAndConsume(tok::semi, diag::err_expected_semi_decl_list);
450 // We break out of the big loop in two cases: when we see @end or when we see
451 // EOF. In the former case, eat the @end. In the later case, emit an error.
452 if (Tok.is(tok::code_completion)) {
453 Actions.CodeCompleteObjCAtDirective(getCurScope(), ObjCImpDecl, true);
454 ConsumeCodeCompletionToken();
455 } else if (Tok.isObjCAtKeyword(tok::objc_end))
456 ConsumeToken(); // the "end" identifier
458 Diag(Tok, diag::err_objc_missing_end);
460 // Insert collected methods declarations into the @interface object.
461 // This passes in an invalid SourceLocation for AtEndLoc when EOF is hit.
462 Actions.ActOnAtEnd(getCurScope(), AtEnd, interfaceDecl,
463 allMethods.data(), allMethods.size(),
464 allProperties.data(), allProperties.size(),
465 allTUVariables.data(), allTUVariables.size());
468 /// Parse property attribute declarations.
470 /// property-attr-decl: '(' property-attrlist ')'
471 /// property-attrlist:
472 /// property-attribute
473 /// property-attrlist ',' property-attribute
474 /// property-attribute:
475 /// getter '=' identifier
476 /// setter '=' identifier ':'
486 /// unsafe_unretained
488 void Parser::ParseObjCPropertyAttribute(ObjCDeclSpec &DS, Decl *ClassDecl) {
489 assert(Tok.getKind() == tok::l_paren);
490 SourceLocation LHSLoc = ConsumeParen(); // consume '('
493 if (Tok.is(tok::code_completion)) {
494 Actions.CodeCompleteObjCPropertyFlags(getCurScope(), DS);
495 ConsumeCodeCompletionToken();
497 const IdentifierInfo *II = Tok.getIdentifierInfo();
499 // If this is not an identifier at all, bail out early.
501 MatchRHSPunctuation(tok::r_paren, LHSLoc);
505 SourceLocation AttrName = ConsumeToken(); // consume last attribute name
507 if (II->isStr("readonly"))
508 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_readonly);
509 else if (II->isStr("assign"))
510 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_assign);
511 else if (II->isStr("unsafe_unretained"))
512 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_unsafe_unretained);
513 else if (II->isStr("readwrite"))
514 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_readwrite);
515 else if (II->isStr("retain"))
516 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_retain);
517 else if (II->isStr("strong"))
518 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_strong);
519 else if (II->isStr("copy"))
520 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_copy);
521 else if (II->isStr("nonatomic"))
522 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_nonatomic);
523 else if (II->isStr("atomic"))
524 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_atomic);
525 else if (II->isStr("weak"))
526 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_weak);
527 else if (II->isStr("getter") || II->isStr("setter")) {
528 bool IsSetter = II->getNameStart()[0] == 's';
530 // getter/setter require extra treatment.
531 unsigned DiagID = IsSetter ? diag::err_objc_expected_equal_for_setter :
532 diag::err_objc_expected_equal_for_getter;
534 if (ExpectAndConsume(tok::equal, DiagID, "", tok::r_paren))
537 if (Tok.is(tok::code_completion)) {
539 Actions.CodeCompleteObjCPropertySetter(getCurScope(), ClassDecl);
541 Actions.CodeCompleteObjCPropertyGetter(getCurScope(), ClassDecl);
542 ConsumeCodeCompletionToken();
546 SourceLocation SelLoc;
547 IdentifierInfo *SelIdent = ParseObjCSelectorPiece(SelLoc);
550 Diag(Tok, diag::err_objc_expected_selector_for_getter_setter)
552 SkipUntil(tok::r_paren);
557 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_setter);
558 DS.setSetterName(SelIdent);
560 if (ExpectAndConsume(tok::colon,
561 diag::err_expected_colon_after_setter_name, "",
565 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_getter);
566 DS.setGetterName(SelIdent);
569 Diag(AttrName, diag::err_objc_expected_property_attr) << II;
570 SkipUntil(tok::r_paren);
574 if (Tok.isNot(tok::comma))
580 MatchRHSPunctuation(tok::r_paren, LHSLoc);
583 /// objc-method-proto:
584 /// objc-instance-method objc-method-decl objc-method-attributes[opt]
585 /// objc-class-method objc-method-decl objc-method-attributes[opt]
587 /// objc-instance-method: '-'
588 /// objc-class-method: '+'
590 /// objc-method-attributes: [OBJC2]
591 /// __attribute__((deprecated))
593 Decl *Parser::ParseObjCMethodPrototype(Decl *IDecl,
594 tok::ObjCKeywordKind MethodImplKind,
595 bool MethodDefinition) {
596 assert((Tok.is(tok::minus) || Tok.is(tok::plus)) && "expected +/-");
598 tok::TokenKind methodType = Tok.getKind();
599 SourceLocation mLoc = ConsumeToken();
600 Decl *MDecl = ParseObjCMethodDecl(mLoc, methodType, IDecl,MethodImplKind,
602 // Since this rule is used for both method declarations and definitions,
603 // the caller is (optionally) responsible for consuming the ';'.
610 /// enum struct union if else while do for switch case default
611 /// break continue return goto asm sizeof typeof __alignof
612 /// unsigned long const short volatile signed restrict _Complex
613 /// in out inout bycopy byref oneway int char float double void _Bool
615 IdentifierInfo *Parser::ParseObjCSelectorPiece(SourceLocation &SelectorLoc) {
617 switch (Tok.getKind()) {
626 case tok::exclaimequal:
630 case tok::caretequal: {
631 std::string ThisTok(PP.getSpelling(Tok));
632 if (isalpha(ThisTok[0])) {
633 IdentifierInfo *II = &PP.getIdentifierTable().get(ThisTok.data());
634 Tok.setKind(tok::identifier);
635 SelectorLoc = ConsumeToken();
641 case tok::identifier:
651 case tok::kw_const_cast:
652 case tok::kw_continue:
653 case tok::kw_default:
657 case tok::kw_dynamic_cast:
660 case tok::kw_explicit:
672 case tok::kw_mutable:
673 case tok::kw_namespace:
675 case tok::kw_operator:
676 case tok::kw_private:
677 case tok::kw_protected:
679 case tok::kw_register:
680 case tok::kw_reinterpret_cast:
681 case tok::kw_restrict:
687 case tok::kw_static_cast:
690 case tok::kw_template:
695 case tok::kw_typedef:
697 case tok::kw_typename:
700 case tok::kw_unsigned:
702 case tok::kw_virtual:
704 case tok::kw_volatile:
705 case tok::kw_wchar_t:
708 case tok::kw__Complex:
709 case tok::kw___alignof:
710 IdentifierInfo *II = Tok.getIdentifierInfo();
711 SelectorLoc = ConsumeToken();
716 /// objc-for-collection-in: 'in'
718 bool Parser::isTokIdentifier_in() const {
719 // FIXME: May have to do additional look-ahead to only allow for
720 // valid tokens following an 'in'; such as an identifier, unary operators,
722 return (getLang().ObjC2 && Tok.is(tok::identifier) &&
723 Tok.getIdentifierInfo() == ObjCTypeQuals[objc_in]);
726 /// ParseObjCTypeQualifierList - This routine parses the objective-c's type
727 /// qualifier list and builds their bitmask representation in the input
730 /// objc-type-qualifiers:
731 /// objc-type-qualifier
732 /// objc-type-qualifiers objc-type-qualifier
734 void Parser::ParseObjCTypeQualifierList(ObjCDeclSpec &DS,
735 ObjCTypeNameContext Context) {
737 if (Tok.is(tok::code_completion)) {
738 Actions.CodeCompleteObjCPassingType(getCurScope(), DS,
739 Context == OTN_ParameterType);
740 ConsumeCodeCompletionToken();
743 if (Tok.isNot(tok::identifier))
746 const IdentifierInfo *II = Tok.getIdentifierInfo();
747 for (unsigned i = 0; i != objc_NumQuals; ++i) {
748 if (II != ObjCTypeQuals[i])
751 ObjCDeclSpec::ObjCDeclQualifier Qual;
753 default: assert(0 && "Unknown decl qualifier");
754 case objc_in: Qual = ObjCDeclSpec::DQ_In; break;
755 case objc_out: Qual = ObjCDeclSpec::DQ_Out; break;
756 case objc_inout: Qual = ObjCDeclSpec::DQ_Inout; break;
757 case objc_oneway: Qual = ObjCDeclSpec::DQ_Oneway; break;
758 case objc_bycopy: Qual = ObjCDeclSpec::DQ_Bycopy; break;
759 case objc_byref: Qual = ObjCDeclSpec::DQ_Byref; break;
761 DS.setObjCDeclQualifier(Qual);
767 // If this wasn't a recognized qualifier, bail out.
773 /// '(' objc-type-qualifiers[opt] type-name ')'
774 /// '(' objc-type-qualifiers[opt] ')'
776 ParsedType Parser::ParseObjCTypeName(ObjCDeclSpec &DS,
777 ObjCTypeNameContext Context) {
778 assert(Tok.is(tok::l_paren) && "expected (");
780 SourceLocation LParenLoc = ConsumeParen();
781 SourceLocation TypeStartLoc = Tok.getLocation();
783 // Parse type qualifiers, in, inout, etc.
784 ParseObjCTypeQualifierList(DS, Context);
787 if (isTypeSpecifierQualifier()) {
788 TypeResult TypeSpec =
789 ParseTypeName(0, Declarator::ObjCPrototypeContext, &DS);
790 if (!TypeSpec.isInvalid())
794 if (Tok.is(tok::r_paren))
796 else if (Tok.getLocation() == TypeStartLoc) {
797 // If we didn't eat any tokens, then this isn't a type.
798 Diag(Tok, diag::err_expected_type);
799 SkipUntil(tok::r_paren);
801 // Otherwise, we found *something*, but didn't get a ')' in the right
802 // place. Emit an error then return what we have as the type.
803 MatchRHSPunctuation(tok::r_paren, LParenLoc);
808 /// objc-method-decl:
810 /// objc-keyword-selector objc-parmlist[opt]
811 /// objc-type-name objc-selector
812 /// objc-type-name objc-keyword-selector objc-parmlist[opt]
814 /// objc-keyword-selector:
815 /// objc-keyword-decl
816 /// objc-keyword-selector objc-keyword-decl
818 /// objc-keyword-decl:
819 /// objc-selector ':' objc-type-name objc-keyword-attributes[opt] identifier
820 /// objc-selector ':' objc-keyword-attributes[opt] identifier
821 /// ':' objc-type-name objc-keyword-attributes[opt] identifier
822 /// ':' objc-keyword-attributes[opt] identifier
825 /// objc-parms objc-ellipsis[opt]
828 /// objc-parms , parameter-declaration
833 /// objc-keyword-attributes: [OBJC2]
834 /// __attribute__((unused))
836 Decl *Parser::ParseObjCMethodDecl(SourceLocation mLoc,
837 tok::TokenKind mType,
839 tok::ObjCKeywordKind MethodImplKind,
840 bool MethodDefinition) {
841 ParsingDeclRAIIObject PD(*this);
843 if (Tok.is(tok::code_completion)) {
844 Actions.CodeCompleteObjCMethodDecl(getCurScope(), mType == tok::minus,
845 /*ReturnType=*/ ParsedType(), IDecl);
846 ConsumeCodeCompletionToken();
849 // Parse the return type if present.
850 ParsedType ReturnType;
852 if (Tok.is(tok::l_paren))
853 ReturnType = ParseObjCTypeName(DSRet, OTN_ResultType);
855 // If attributes exist before the method, parse them.
856 ParsedAttributes methodAttrs(AttrFactory);
858 MaybeParseGNUAttributes(methodAttrs);
860 if (Tok.is(tok::code_completion)) {
861 Actions.CodeCompleteObjCMethodDecl(getCurScope(), mType == tok::minus,
863 ConsumeCodeCompletionToken();
866 // Now parse the selector.
867 SourceLocation selLoc;
868 IdentifierInfo *SelIdent = ParseObjCSelectorPiece(selLoc);
870 // An unnamed colon is valid.
871 if (!SelIdent && Tok.isNot(tok::colon)) { // missing selector name.
872 Diag(Tok, diag::err_expected_selector_for_method)
873 << SourceRange(mLoc, Tok.getLocation());
874 // Skip until we get a ; or {}.
875 SkipUntil(tok::r_brace);
879 llvm::SmallVector<DeclaratorChunk::ParamInfo, 8> CParamInfo;
880 if (Tok.isNot(tok::colon)) {
881 // If attributes exist after the method, parse them.
883 MaybeParseGNUAttributes(methodAttrs);
885 Selector Sel = PP.getSelectorTable().getNullarySelector(SelIdent);
887 = Actions.ActOnMethodDeclaration(getCurScope(), mLoc, Tok.getLocation(),
888 mType, IDecl, DSRet, ReturnType,
890 CParamInfo.data(), CParamInfo.size(),
891 methodAttrs.getList(), MethodImplKind,
892 false, MethodDefinition);
897 llvm::SmallVector<IdentifierInfo *, 12> KeyIdents;
898 llvm::SmallVector<Sema::ObjCArgInfo, 12> ArgInfos;
899 ParseScope PrototypeScope(this,
900 Scope::FunctionPrototypeScope|Scope::DeclScope);
902 AttributePool allParamAttrs(AttrFactory);
905 ParsedAttributes paramAttrs(AttrFactory);
906 Sema::ObjCArgInfo ArgInfo;
908 // Each iteration parses a single keyword argument.
909 if (Tok.isNot(tok::colon)) {
910 Diag(Tok, diag::err_expected_colon);
913 ConsumeToken(); // Eat the ':'.
915 ArgInfo.Type = ParsedType();
916 if (Tok.is(tok::l_paren)) // Parse the argument type if present.
917 ArgInfo.Type = ParseObjCTypeName(ArgInfo.DeclSpec, OTN_ParameterType);
919 // If attributes exist before the argument name, parse them.
920 ArgInfo.ArgAttrs = 0;
921 if (getLang().ObjC2) {
922 MaybeParseGNUAttributes(paramAttrs);
923 ArgInfo.ArgAttrs = paramAttrs.getList();
926 // Code completion for the next piece of the selector.
927 if (Tok.is(tok::code_completion)) {
928 ConsumeCodeCompletionToken();
929 KeyIdents.push_back(SelIdent);
930 Actions.CodeCompleteObjCMethodDeclSelector(getCurScope(),
932 /*AtParameterName=*/true,
936 KeyIdents.pop_back();
940 if (Tok.isNot(tok::identifier)) {
941 Diag(Tok, diag::err_expected_ident); // missing argument name.
945 ArgInfo.Name = Tok.getIdentifierInfo();
946 ArgInfo.NameLoc = Tok.getLocation();
947 ConsumeToken(); // Eat the identifier.
949 ArgInfos.push_back(ArgInfo);
950 KeyIdents.push_back(SelIdent);
952 // Make sure the attributes persist.
953 allParamAttrs.takeAllFrom(paramAttrs.getPool());
955 // Code completion for the next piece of the selector.
956 if (Tok.is(tok::code_completion)) {
957 ConsumeCodeCompletionToken();
958 Actions.CodeCompleteObjCMethodDeclSelector(getCurScope(),
960 /*AtParameterName=*/false,
967 // Check for another keyword selector.
969 SelIdent = ParseObjCSelectorPiece(Loc);
970 if (!SelIdent && Tok.isNot(tok::colon))
972 // We have a selector or a colon, continue parsing.
975 bool isVariadic = false;
977 // Parse the (optional) parameter list.
978 while (Tok.is(tok::comma)) {
980 if (Tok.is(tok::ellipsis)) {
985 DeclSpec DS(AttrFactory);
986 ParseDeclarationSpecifiers(DS);
987 // Parse the declarator.
988 Declarator ParmDecl(DS, Declarator::PrototypeContext);
989 ParseDeclarator(ParmDecl);
990 IdentifierInfo *ParmII = ParmDecl.getIdentifier();
991 Decl *Param = Actions.ActOnParamDeclarator(getCurScope(), ParmDecl);
992 CParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII,
993 ParmDecl.getIdentifierLoc(),
999 // FIXME: Add support for optional parameter list...
1000 // If attributes exist after the method, parse them.
1001 if (getLang().ObjC2)
1002 MaybeParseGNUAttributes(methodAttrs);
1004 if (KeyIdents.size() == 0) {
1005 // Leave prototype scope.
1006 PrototypeScope.Exit();
1010 Selector Sel = PP.getSelectorTable().getSelector(KeyIdents.size(),
1013 = Actions.ActOnMethodDeclaration(getCurScope(), mLoc, Tok.getLocation(),
1014 mType, IDecl, DSRet, ReturnType,
1015 selLoc, Sel, &ArgInfos[0],
1016 CParamInfo.data(), CParamInfo.size(),
1017 methodAttrs.getList(),
1018 MethodImplKind, isVariadic, MethodDefinition);
1019 // Leave prototype scope.
1020 PrototypeScope.Exit();
1022 PD.complete(Result);
1026 /// objc-protocol-refs:
1027 /// '<' identifier-list '>'
1030 ParseObjCProtocolReferences(llvm::SmallVectorImpl<Decl *> &Protocols,
1031 llvm::SmallVectorImpl<SourceLocation> &ProtocolLocs,
1032 bool WarnOnDeclarations,
1033 SourceLocation &LAngleLoc, SourceLocation &EndLoc) {
1034 assert(Tok.is(tok::less) && "expected <");
1036 LAngleLoc = ConsumeToken(); // the "<"
1038 llvm::SmallVector<IdentifierLocPair, 8> ProtocolIdents;
1041 if (Tok.is(tok::code_completion)) {
1042 Actions.CodeCompleteObjCProtocolReferences(ProtocolIdents.data(),
1043 ProtocolIdents.size());
1044 ConsumeCodeCompletionToken();
1047 if (Tok.isNot(tok::identifier)) {
1048 Diag(Tok, diag::err_expected_ident);
1049 SkipUntil(tok::greater);
1052 ProtocolIdents.push_back(std::make_pair(Tok.getIdentifierInfo(),
1053 Tok.getLocation()));
1054 ProtocolLocs.push_back(Tok.getLocation());
1057 if (Tok.isNot(tok::comma))
1063 if (Tok.isNot(tok::greater)) {
1064 Diag(Tok, diag::err_expected_greater);
1068 EndLoc = ConsumeAnyToken();
1070 // Convert the list of protocols identifiers into a list of protocol decls.
1071 Actions.FindProtocolDeclaration(WarnOnDeclarations,
1072 &ProtocolIdents[0], ProtocolIdents.size(),
1077 /// \brief Parse the Objective-C protocol qualifiers that follow a typename
1078 /// in a decl-specifier-seq, starting at the '<'.
1079 bool Parser::ParseObjCProtocolQualifiers(DeclSpec &DS) {
1080 assert(Tok.is(tok::less) && "Protocol qualifiers start with '<'");
1081 assert(getLang().ObjC1 && "Protocol qualifiers only exist in Objective-C");
1082 SourceLocation LAngleLoc, EndProtoLoc;
1083 llvm::SmallVector<Decl *, 8> ProtocolDecl;
1084 llvm::SmallVector<SourceLocation, 8> ProtocolLocs;
1085 bool Result = ParseObjCProtocolReferences(ProtocolDecl, ProtocolLocs, false,
1086 LAngleLoc, EndProtoLoc);
1087 DS.setProtocolQualifiers(ProtocolDecl.data(), ProtocolDecl.size(),
1088 ProtocolLocs.data(), LAngleLoc);
1089 if (EndProtoLoc.isValid())
1090 DS.SetRangeEnd(EndProtoLoc);
1095 /// objc-class-instance-variables:
1096 /// '{' objc-instance-variable-decl-list[opt] '}'
1098 /// objc-instance-variable-decl-list:
1099 /// objc-visibility-spec
1100 /// objc-instance-variable-decl ';'
1102 /// objc-instance-variable-decl-list objc-visibility-spec
1103 /// objc-instance-variable-decl-list objc-instance-variable-decl ';'
1104 /// objc-instance-variable-decl-list ';'
1106 /// objc-visibility-spec:
1110 /// @package [OBJC2]
1112 /// objc-instance-variable-decl:
1113 /// struct-declaration
1115 void Parser::ParseObjCClassInstanceVariables(Decl *interfaceDecl,
1116 tok::ObjCKeywordKind visibility,
1117 SourceLocation atLoc) {
1118 assert(Tok.is(tok::l_brace) && "expected {");
1119 llvm::SmallVector<Decl *, 32> AllIvarDecls;
1121 ParseScope ClassScope(this, Scope::DeclScope|Scope::ClassScope);
1123 SourceLocation LBraceLoc = ConsumeBrace(); // the "{"
1125 // While we still have something to read, read the instance variables.
1126 while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) {
1127 // Each iteration of this loop reads one objc-instance-variable-decl.
1129 // Check for extraneous top-level semicolon.
1130 if (Tok.is(tok::semi)) {
1131 Diag(Tok, diag::ext_extra_ivar_semi)
1132 << FixItHint::CreateRemoval(Tok.getLocation());
1137 // Set the default visibility to private.
1138 if (Tok.is(tok::at)) { // parse objc-visibility-spec
1139 ConsumeToken(); // eat the @ sign
1141 if (Tok.is(tok::code_completion)) {
1142 Actions.CodeCompleteObjCAtVisibility(getCurScope());
1143 ConsumeCodeCompletionToken();
1146 switch (Tok.getObjCKeywordID()) {
1147 case tok::objc_private:
1148 case tok::objc_public:
1149 case tok::objc_protected:
1150 case tok::objc_package:
1151 visibility = Tok.getObjCKeywordID();
1155 Diag(Tok, diag::err_objc_illegal_visibility_spec);
1160 if (Tok.is(tok::code_completion)) {
1161 Actions.CodeCompleteOrdinaryName(getCurScope(),
1162 Sema::PCC_ObjCInstanceVariableList);
1163 ConsumeCodeCompletionToken();
1166 struct ObjCIvarCallback : FieldCallback {
1169 tok::ObjCKeywordKind visibility;
1170 llvm::SmallVectorImpl<Decl *> &AllIvarDecls;
1172 ObjCIvarCallback(Parser &P, Decl *IDecl, tok::ObjCKeywordKind V,
1173 llvm::SmallVectorImpl<Decl *> &AllIvarDecls) :
1174 P(P), IDecl(IDecl), visibility(V), AllIvarDecls(AllIvarDecls) {
1177 Decl *invoke(FieldDeclarator &FD) {
1178 // Install the declarator into the interface decl.
1180 = P.Actions.ActOnIvar(P.getCurScope(),
1181 FD.D.getDeclSpec().getSourceRange().getBegin(),
1182 IDecl, FD.D, FD.BitfieldSize, visibility);
1184 AllIvarDecls.push_back(Field);
1187 } Callback(*this, interfaceDecl, visibility, AllIvarDecls);
1189 // Parse all the comma separated declarators.
1190 DeclSpec DS(AttrFactory);
1191 ParseStructDeclaration(DS, Callback);
1193 if (Tok.is(tok::semi)) {
1196 Diag(Tok, diag::err_expected_semi_decl_list);
1197 // Skip to end of block or statement
1198 SkipUntil(tok::r_brace, true, true);
1201 SourceLocation RBraceLoc = MatchRHSPunctuation(tok::r_brace, LBraceLoc);
1202 Actions.ActOnLastBitfield(RBraceLoc, interfaceDecl, AllIvarDecls);
1203 // Call ActOnFields() even if we don't have any decls. This is useful
1204 // for code rewriting tools that need to be aware of the empty list.
1205 Actions.ActOnFields(getCurScope(), atLoc, interfaceDecl,
1206 AllIvarDecls.data(), AllIvarDecls.size(),
1207 LBraceLoc, RBraceLoc, 0);
1211 /// objc-protocol-declaration:
1212 /// objc-protocol-definition
1213 /// objc-protocol-forward-reference
1215 /// objc-protocol-definition:
1216 /// @protocol identifier
1217 /// objc-protocol-refs[opt]
1218 /// objc-interface-decl-list
1221 /// objc-protocol-forward-reference:
1222 /// @protocol identifier-list ';'
1224 /// "@protocol identifier ;" should be resolved as "@protocol
1225 /// identifier-list ;": objc-interface-decl-list may not start with a
1226 /// semicolon in the first alternative if objc-protocol-refs are omitted.
1227 Decl *Parser::ParseObjCAtProtocolDeclaration(SourceLocation AtLoc,
1228 ParsedAttributes &attrs) {
1229 assert(Tok.isObjCAtKeyword(tok::objc_protocol) &&
1230 "ParseObjCAtProtocolDeclaration(): Expected @protocol");
1231 ConsumeToken(); // the "protocol" identifier
1233 if (Tok.is(tok::code_completion)) {
1234 Actions.CodeCompleteObjCProtocolDecl(getCurScope());
1235 ConsumeCodeCompletionToken();
1238 if (Tok.isNot(tok::identifier)) {
1239 Diag(Tok, diag::err_expected_ident); // missing protocol name.
1242 // Save the protocol name, then consume it.
1243 IdentifierInfo *protocolName = Tok.getIdentifierInfo();
1244 SourceLocation nameLoc = ConsumeToken();
1246 if (Tok.is(tok::semi)) { // forward declaration of one protocol.
1247 IdentifierLocPair ProtoInfo(protocolName, nameLoc);
1249 return Actions.ActOnForwardProtocolDeclaration(AtLoc, &ProtoInfo, 1,
1253 if (Tok.is(tok::comma)) { // list of forward declarations.
1254 llvm::SmallVector<IdentifierLocPair, 8> ProtocolRefs;
1255 ProtocolRefs.push_back(std::make_pair(protocolName, nameLoc));
1257 // Parse the list of forward declarations.
1259 ConsumeToken(); // the ','
1260 if (Tok.isNot(tok::identifier)) {
1261 Diag(Tok, diag::err_expected_ident);
1262 SkipUntil(tok::semi);
1265 ProtocolRefs.push_back(IdentifierLocPair(Tok.getIdentifierInfo(),
1266 Tok.getLocation()));
1267 ConsumeToken(); // the identifier
1269 if (Tok.isNot(tok::comma))
1273 if (ExpectAndConsume(tok::semi, diag::err_expected_semi_after, "@protocol"))
1276 return Actions.ActOnForwardProtocolDeclaration(AtLoc,
1278 ProtocolRefs.size(),
1282 // Last, and definitely not least, parse a protocol declaration.
1283 SourceLocation LAngleLoc, EndProtoLoc;
1285 llvm::SmallVector<Decl *, 8> ProtocolRefs;
1286 llvm::SmallVector<SourceLocation, 8> ProtocolLocs;
1287 if (Tok.is(tok::less) &&
1288 ParseObjCProtocolReferences(ProtocolRefs, ProtocolLocs, false,
1289 LAngleLoc, EndProtoLoc))
1293 Actions.ActOnStartProtocolInterface(AtLoc, protocolName, nameLoc,
1294 ProtocolRefs.data(),
1295 ProtocolRefs.size(),
1296 ProtocolLocs.data(),
1297 EndProtoLoc, attrs.getList());
1298 ParseObjCInterfaceDeclList(ProtoType, tok::objc_protocol);
1302 /// objc-implementation:
1303 /// objc-class-implementation-prologue
1304 /// objc-category-implementation-prologue
1306 /// objc-class-implementation-prologue:
1307 /// @implementation identifier objc-superclass[opt]
1308 /// objc-class-instance-variables[opt]
1310 /// objc-category-implementation-prologue:
1311 /// @implementation identifier ( identifier )
1312 Decl *Parser::ParseObjCAtImplementationDeclaration(
1313 SourceLocation atLoc) {
1314 assert(Tok.isObjCAtKeyword(tok::objc_implementation) &&
1315 "ParseObjCAtImplementationDeclaration(): Expected @implementation");
1316 ConsumeToken(); // the "implementation" identifier
1318 // Code completion after '@implementation'.
1319 if (Tok.is(tok::code_completion)) {
1320 Actions.CodeCompleteObjCImplementationDecl(getCurScope());
1321 ConsumeCodeCompletionToken();
1324 if (Tok.isNot(tok::identifier)) {
1325 Diag(Tok, diag::err_expected_ident); // missing class or category name.
1328 // We have a class or category name - consume it.
1329 IdentifierInfo *nameId = Tok.getIdentifierInfo();
1330 SourceLocation nameLoc = ConsumeToken(); // consume class or category name
1332 if (Tok.is(tok::l_paren)) {
1333 // we have a category implementation.
1335 SourceLocation categoryLoc, rparenLoc;
1336 IdentifierInfo *categoryId = 0;
1338 if (Tok.is(tok::code_completion)) {
1339 Actions.CodeCompleteObjCImplementationCategory(getCurScope(), nameId, nameLoc);
1340 ConsumeCodeCompletionToken();
1343 if (Tok.is(tok::identifier)) {
1344 categoryId = Tok.getIdentifierInfo();
1345 categoryLoc = ConsumeToken();
1347 Diag(Tok, diag::err_expected_ident); // missing category name.
1350 if (Tok.isNot(tok::r_paren)) {
1351 Diag(Tok, diag::err_expected_rparen);
1352 SkipUntil(tok::r_paren, false); // don't stop at ';'
1355 rparenLoc = ConsumeParen();
1356 Decl *ImplCatType = Actions.ActOnStartCategoryImplementation(
1357 atLoc, nameId, nameLoc, categoryId,
1359 ObjCImpDecl = ImplCatType;
1360 PendingObjCImpDecl.push_back(ObjCImpDecl);
1363 // We have a class implementation
1364 SourceLocation superClassLoc;
1365 IdentifierInfo *superClassId = 0;
1366 if (Tok.is(tok::colon)) {
1367 // We have a super class
1369 if (Tok.isNot(tok::identifier)) {
1370 Diag(Tok, diag::err_expected_ident); // missing super class name.
1373 superClassId = Tok.getIdentifierInfo();
1374 superClassLoc = ConsumeToken(); // Consume super class name
1376 Decl *ImplClsType = Actions.ActOnStartClassImplementation(
1377 atLoc, nameId, nameLoc,
1378 superClassId, superClassLoc);
1380 if (Tok.is(tok::l_brace)) // we have ivars
1381 ParseObjCClassInstanceVariables(ImplClsType/*FIXME*/,
1382 tok::objc_private, atLoc);
1383 ObjCImpDecl = ImplClsType;
1384 PendingObjCImpDecl.push_back(ObjCImpDecl);
1389 Decl *Parser::ParseObjCAtEndDeclaration(SourceRange atEnd) {
1390 assert(Tok.isObjCAtKeyword(tok::objc_end) &&
1391 "ParseObjCAtEndDeclaration(): Expected @end");
1392 Decl *Result = ObjCImpDecl;
1393 ConsumeToken(); // the "end" identifier
1395 Actions.ActOnAtEnd(getCurScope(), atEnd, ObjCImpDecl);
1397 PendingObjCImpDecl.pop_back();
1400 // missing @implementation
1401 Diag(atEnd.getBegin(), diag::err_expected_implementation);
1406 Parser::DeclGroupPtrTy Parser::FinishPendingObjCActions() {
1407 Actions.DiagnoseUseOfUnimplementedSelectors();
1408 if (PendingObjCImpDecl.empty())
1409 return Actions.ConvertDeclToDeclGroup(0);
1410 Decl *ImpDecl = PendingObjCImpDecl.pop_back_val();
1411 Actions.ActOnAtEnd(getCurScope(), SourceRange(), ImpDecl);
1412 return Actions.ConvertDeclToDeclGroup(ImpDecl);
1415 /// compatibility-alias-decl:
1416 /// @compatibility_alias alias-name class-name ';'
1418 Decl *Parser::ParseObjCAtAliasDeclaration(SourceLocation atLoc) {
1419 assert(Tok.isObjCAtKeyword(tok::objc_compatibility_alias) &&
1420 "ParseObjCAtAliasDeclaration(): Expected @compatibility_alias");
1421 ConsumeToken(); // consume compatibility_alias
1422 if (Tok.isNot(tok::identifier)) {
1423 Diag(Tok, diag::err_expected_ident);
1426 IdentifierInfo *aliasId = Tok.getIdentifierInfo();
1427 SourceLocation aliasLoc = ConsumeToken(); // consume alias-name
1428 if (Tok.isNot(tok::identifier)) {
1429 Diag(Tok, diag::err_expected_ident);
1432 IdentifierInfo *classId = Tok.getIdentifierInfo();
1433 SourceLocation classLoc = ConsumeToken(); // consume class-name;
1434 ExpectAndConsume(tok::semi, diag::err_expected_semi_after,
1435 "@compatibility_alias");
1436 return Actions.ActOnCompatiblityAlias(atLoc, aliasId, aliasLoc,
1440 /// property-synthesis:
1441 /// @synthesize property-ivar-list ';'
1443 /// property-ivar-list:
1445 /// property-ivar-list ',' property-ivar
1449 /// identifier '=' identifier
1451 Decl *Parser::ParseObjCPropertySynthesize(SourceLocation atLoc) {
1452 assert(Tok.isObjCAtKeyword(tok::objc_synthesize) &&
1453 "ParseObjCPropertyDynamic(): Expected '@synthesize'");
1454 ConsumeToken(); // consume synthesize
1457 if (Tok.is(tok::code_completion)) {
1458 Actions.CodeCompleteObjCPropertyDefinition(getCurScope(), ObjCImpDecl);
1459 ConsumeCodeCompletionToken();
1462 if (Tok.isNot(tok::identifier)) {
1463 Diag(Tok, diag::err_synthesized_property_name);
1464 SkipUntil(tok::semi);
1468 IdentifierInfo *propertyIvar = 0;
1469 IdentifierInfo *propertyId = Tok.getIdentifierInfo();
1470 SourceLocation propertyLoc = ConsumeToken(); // consume property name
1471 SourceLocation propertyIvarLoc;
1472 if (Tok.is(tok::equal)) {
1473 // property '=' ivar-name
1474 ConsumeToken(); // consume '='
1476 if (Tok.is(tok::code_completion)) {
1477 Actions.CodeCompleteObjCPropertySynthesizeIvar(getCurScope(), propertyId,
1479 ConsumeCodeCompletionToken();
1482 if (Tok.isNot(tok::identifier)) {
1483 Diag(Tok, diag::err_expected_ident);
1486 propertyIvar = Tok.getIdentifierInfo();
1487 propertyIvarLoc = ConsumeToken(); // consume ivar-name
1489 Actions.ActOnPropertyImplDecl(getCurScope(), atLoc, propertyLoc, true, ObjCImpDecl,
1490 propertyId, propertyIvar, propertyIvarLoc);
1491 if (Tok.isNot(tok::comma))
1493 ConsumeToken(); // consume ','
1495 ExpectAndConsume(tok::semi, diag::err_expected_semi_after, "@synthesize");
1499 /// property-dynamic:
1500 /// @dynamic property-list
1504 /// property-list ',' identifier
1506 Decl *Parser::ParseObjCPropertyDynamic(SourceLocation atLoc) {
1507 assert(Tok.isObjCAtKeyword(tok::objc_dynamic) &&
1508 "ParseObjCPropertyDynamic(): Expected '@dynamic'");
1509 ConsumeToken(); // consume dynamic
1511 if (Tok.is(tok::code_completion)) {
1512 Actions.CodeCompleteObjCPropertyDefinition(getCurScope(), ObjCImpDecl);
1513 ConsumeCodeCompletionToken();
1516 if (Tok.isNot(tok::identifier)) {
1517 Diag(Tok, diag::err_expected_ident);
1518 SkipUntil(tok::semi);
1522 IdentifierInfo *propertyId = Tok.getIdentifierInfo();
1523 SourceLocation propertyLoc = ConsumeToken(); // consume property name
1524 Actions.ActOnPropertyImplDecl(getCurScope(), atLoc, propertyLoc, false, ObjCImpDecl,
1525 propertyId, 0, SourceLocation());
1527 if (Tok.isNot(tok::comma))
1529 ConsumeToken(); // consume ','
1531 ExpectAndConsume(tok::semi, diag::err_expected_semi_after, "@dynamic");
1535 /// objc-throw-statement:
1536 /// throw expression[opt];
1538 StmtResult Parser::ParseObjCThrowStmt(SourceLocation atLoc) {
1540 ConsumeToken(); // consume throw
1541 if (Tok.isNot(tok::semi)) {
1542 Res = ParseExpression();
1543 if (Res.isInvalid()) {
1544 SkipUntil(tok::semi);
1549 ExpectAndConsume(tok::semi, diag::err_expected_semi_after, "@throw");
1550 return Actions.ActOnObjCAtThrowStmt(atLoc, Res.take(), getCurScope());
1553 /// objc-synchronized-statement:
1554 /// @synchronized '(' expression ')' compound-statement
1557 Parser::ParseObjCSynchronizedStmt(SourceLocation atLoc) {
1558 ConsumeToken(); // consume synchronized
1559 if (Tok.isNot(tok::l_paren)) {
1560 Diag(Tok, diag::err_expected_lparen_after) << "@synchronized";
1563 ConsumeParen(); // '('
1564 ExprResult Res(ParseExpression());
1565 if (Res.isInvalid()) {
1566 SkipUntil(tok::semi);
1569 if (Tok.isNot(tok::r_paren)) {
1570 Diag(Tok, diag::err_expected_lbrace);
1573 ConsumeParen(); // ')'
1574 if (Tok.isNot(tok::l_brace)) {
1575 Diag(Tok, diag::err_expected_lbrace);
1578 // Enter a scope to hold everything within the compound stmt. Compound
1579 // statements can always hold declarations.
1580 ParseScope BodyScope(this, Scope::DeclScope);
1582 StmtResult SynchBody(ParseCompoundStatementBody());
1585 if (SynchBody.isInvalid())
1586 SynchBody = Actions.ActOnNullStmt(Tok.getLocation());
1587 return Actions.ActOnObjCAtSynchronizedStmt(atLoc, Res.take(), SynchBody.take());
1590 /// objc-try-catch-statement:
1591 /// @try compound-statement objc-catch-list[opt]
1592 /// @try compound-statement objc-catch-list[opt] @finally compound-statement
1594 /// objc-catch-list:
1595 /// @catch ( parameter-declaration ) compound-statement
1596 /// objc-catch-list @catch ( catch-parameter-declaration ) compound-statement
1597 /// catch-parameter-declaration:
1598 /// parameter-declaration
1601 StmtResult Parser::ParseObjCTryStmt(SourceLocation atLoc) {
1602 bool catch_or_finally_seen = false;
1604 ConsumeToken(); // consume try
1605 if (Tok.isNot(tok::l_brace)) {
1606 Diag(Tok, diag::err_expected_lbrace);
1609 StmtVector CatchStmts(Actions);
1610 StmtResult FinallyStmt;
1611 ParseScope TryScope(this, Scope::DeclScope);
1612 StmtResult TryBody(ParseCompoundStatementBody());
1614 if (TryBody.isInvalid())
1615 TryBody = Actions.ActOnNullStmt(Tok.getLocation());
1617 while (Tok.is(tok::at)) {
1618 // At this point, we need to lookahead to determine if this @ is the start
1619 // of an @catch or @finally. We don't want to consume the @ token if this
1620 // is an @try or @encode or something else.
1621 Token AfterAt = GetLookAheadToken(1);
1622 if (!AfterAt.isObjCAtKeyword(tok::objc_catch) &&
1623 !AfterAt.isObjCAtKeyword(tok::objc_finally))
1626 SourceLocation AtCatchFinallyLoc = ConsumeToken();
1627 if (Tok.isObjCAtKeyword(tok::objc_catch)) {
1628 Decl *FirstPart = 0;
1629 ConsumeToken(); // consume catch
1630 if (Tok.is(tok::l_paren)) {
1632 ParseScope CatchScope(this, Scope::DeclScope|Scope::AtCatchScope);
1633 if (Tok.isNot(tok::ellipsis)) {
1634 DeclSpec DS(AttrFactory);
1635 ParseDeclarationSpecifiers(DS);
1636 Declarator ParmDecl(DS, Declarator::ObjCCatchContext);
1637 ParseDeclarator(ParmDecl);
1639 // Inform the actions module about the declarator, so it
1640 // gets added to the current scope.
1641 FirstPart = Actions.ActOnObjCExceptionDecl(getCurScope(), ParmDecl);
1643 ConsumeToken(); // consume '...'
1645 SourceLocation RParenLoc;
1647 if (Tok.is(tok::r_paren))
1648 RParenLoc = ConsumeParen();
1649 else // Skip over garbage, until we get to ')'. Eat the ')'.
1650 SkipUntil(tok::r_paren, true, false);
1652 StmtResult CatchBody(true);
1653 if (Tok.is(tok::l_brace))
1654 CatchBody = ParseCompoundStatementBody();
1656 Diag(Tok, diag::err_expected_lbrace);
1657 if (CatchBody.isInvalid())
1658 CatchBody = Actions.ActOnNullStmt(Tok.getLocation());
1660 StmtResult Catch = Actions.ActOnObjCAtCatchStmt(AtCatchFinallyLoc,
1664 if (!Catch.isInvalid())
1665 CatchStmts.push_back(Catch.release());
1668 Diag(AtCatchFinallyLoc, diag::err_expected_lparen_after)
1672 catch_or_finally_seen = true;
1674 assert(Tok.isObjCAtKeyword(tok::objc_finally) && "Lookahead confused?");
1675 ConsumeToken(); // consume finally
1676 ParseScope FinallyScope(this, Scope::DeclScope);
1678 StmtResult FinallyBody(true);
1679 if (Tok.is(tok::l_brace))
1680 FinallyBody = ParseCompoundStatementBody();
1682 Diag(Tok, diag::err_expected_lbrace);
1683 if (FinallyBody.isInvalid())
1684 FinallyBody = Actions.ActOnNullStmt(Tok.getLocation());
1685 FinallyStmt = Actions.ActOnObjCAtFinallyStmt(AtCatchFinallyLoc,
1686 FinallyBody.take());
1687 catch_or_finally_seen = true;
1691 if (!catch_or_finally_seen) {
1692 Diag(atLoc, diag::err_missing_catch_finally);
1696 return Actions.ActOnObjCAtTryStmt(atLoc, TryBody.take(),
1697 move_arg(CatchStmts),
1698 FinallyStmt.take());
1701 /// objc-autoreleasepool-statement:
1702 /// @autoreleasepool compound-statement
1705 Parser::ParseObjCAutoreleasePoolStmt(SourceLocation atLoc) {
1706 ConsumeToken(); // consume autoreleasepool
1707 if (Tok.isNot(tok::l_brace)) {
1708 Diag(Tok, diag::err_expected_lbrace);
1711 // Enter a scope to hold everything within the compound stmt. Compound
1712 // statements can always hold declarations.
1713 ParseScope BodyScope(this, Scope::DeclScope);
1715 StmtResult AutoreleasePoolBody(ParseCompoundStatementBody());
1718 if (AutoreleasePoolBody.isInvalid())
1719 AutoreleasePoolBody = Actions.ActOnNullStmt(Tok.getLocation());
1720 return Actions.ActOnObjCAutoreleasePoolStmt(atLoc,
1721 AutoreleasePoolBody.take());
1724 /// objc-method-def: objc-method-proto ';'[opt] '{' body '}'
1726 Decl *Parser::ParseObjCMethodDefinition() {
1727 Decl *MDecl = ParseObjCMethodPrototype(ObjCImpDecl);
1729 PrettyDeclStackTraceEntry CrashInfo(Actions, MDecl, Tok.getLocation(),
1730 "parsing Objective-C method");
1732 // parse optional ';'
1733 if (Tok.is(tok::semi)) {
1735 Diag(Tok, diag::warn_semicolon_before_method_body)
1736 << FixItHint::CreateRemoval(Tok.getLocation());
1741 // We should have an opening brace now.
1742 if (Tok.isNot(tok::l_brace)) {
1743 Diag(Tok, diag::err_expected_method_body);
1745 // Skip over garbage, until we get to '{'. Don't eat the '{'.
1746 SkipUntil(tok::l_brace, true, true);
1748 // If we didn't find the '{', bail out.
1749 if (Tok.isNot(tok::l_brace))
1752 SourceLocation BraceLoc = Tok.getLocation();
1754 // Enter a scope for the method body.
1755 ParseScope BodyScope(this,
1756 Scope::ObjCMethodScope|Scope::FnScope|Scope::DeclScope);
1758 // Tell the actions module that we have entered a method definition with the
1759 // specified Declarator for the method.
1760 Actions.ActOnStartOfObjCMethodDef(getCurScope(), MDecl);
1762 if (PP.isCodeCompletionEnabled()) {
1763 if (trySkippingFunctionBodyForCodeCompletion()) {
1765 return Actions.ActOnFinishFunctionBody(MDecl, 0);
1769 StmtResult FnBody(ParseCompoundStatementBody());
1771 // If the function body could not be parsed, make a bogus compoundstmt.
1772 if (FnBody.isInvalid())
1773 FnBody = Actions.ActOnCompoundStmt(BraceLoc, BraceLoc,
1774 MultiStmtArg(Actions), false);
1776 // Leave the function body scope.
1779 // TODO: Pass argument information.
1780 Actions.ActOnFinishFunctionBody(MDecl, FnBody.take());
1784 StmtResult Parser::ParseObjCAtStatement(SourceLocation AtLoc) {
1785 if (Tok.is(tok::code_completion)) {
1786 Actions.CodeCompleteObjCAtStatement(getCurScope());
1787 ConsumeCodeCompletionToken();
1791 if (Tok.isObjCAtKeyword(tok::objc_try))
1792 return ParseObjCTryStmt(AtLoc);
1794 if (Tok.isObjCAtKeyword(tok::objc_throw))
1795 return ParseObjCThrowStmt(AtLoc);
1797 if (Tok.isObjCAtKeyword(tok::objc_synchronized))
1798 return ParseObjCSynchronizedStmt(AtLoc);
1800 if (Tok.isObjCAtKeyword(tok::objc_autoreleasepool))
1801 return ParseObjCAutoreleasePoolStmt(AtLoc);
1803 ExprResult Res(ParseExpressionWithLeadingAt(AtLoc));
1804 if (Res.isInvalid()) {
1805 // If the expression is invalid, skip ahead to the next semicolon. Not
1806 // doing this opens us up to the possibility of infinite loops if
1807 // ParseExpression does not consume any tokens.
1808 SkipUntil(tok::semi);
1812 // Otherwise, eat the semicolon.
1813 ExpectAndConsumeSemi(diag::err_expected_semi_after_expr);
1814 return Actions.ActOnExprStmt(Actions.MakeFullExpr(Res.take()));
1817 ExprResult Parser::ParseObjCAtExpression(SourceLocation AtLoc) {
1818 switch (Tok.getKind()) {
1819 case tok::code_completion:
1820 Actions.CodeCompleteObjCAtExpression(getCurScope());
1821 ConsumeCodeCompletionToken();
1824 case tok::string_literal: // primary-expression: string-literal
1825 case tok::wide_string_literal:
1826 return ParsePostfixExpressionSuffix(ParseObjCStringLiteral(AtLoc));
1828 if (Tok.getIdentifierInfo() == 0)
1829 return ExprError(Diag(AtLoc, diag::err_unexpected_at));
1831 switch (Tok.getIdentifierInfo()->getObjCKeywordID()) {
1832 case tok::objc_encode:
1833 return ParsePostfixExpressionSuffix(ParseObjCEncodeExpression(AtLoc));
1834 case tok::objc_protocol:
1835 return ParsePostfixExpressionSuffix(ParseObjCProtocolExpression(AtLoc));
1836 case tok::objc_selector:
1837 return ParsePostfixExpressionSuffix(ParseObjCSelectorExpression(AtLoc));
1839 return ExprError(Diag(AtLoc, diag::err_unexpected_at));
1844 /// \brirg Parse the receiver of an Objective-C++ message send.
1846 /// This routine parses the receiver of a message send in
1847 /// Objective-C++ either as a type or as an expression. Note that this
1848 /// routine must not be called to parse a send to 'super', since it
1849 /// has no way to return such a result.
1851 /// \param IsExpr Whether the receiver was parsed as an expression.
1853 /// \param TypeOrExpr If the receiver was parsed as an expression (\c
1854 /// IsExpr is true), the parsed expression. If the receiver was parsed
1855 /// as a type (\c IsExpr is false), the parsed type.
1857 /// \returns True if an error occurred during parsing or semantic
1858 /// analysis, in which case the arguments do not have valid
1859 /// values. Otherwise, returns false for a successful parse.
1861 /// objc-receiver: [C++]
1862 /// 'super' [not parsed here]
1864 /// simple-type-specifier
1865 /// typename-specifier
1866 bool Parser::ParseObjCXXMessageReceiver(bool &IsExpr, void *&TypeOrExpr) {
1867 InMessageExpressionRAIIObject InMessage(*this, true);
1869 if (Tok.is(tok::identifier) || Tok.is(tok::coloncolon) ||
1870 Tok.is(tok::kw_typename) || Tok.is(tok::annot_cxxscope))
1871 TryAnnotateTypeOrScopeToken();
1873 if (!isCXXSimpleTypeSpecifier()) {
1876 ExprResult Receiver = ParseExpression();
1877 if (Receiver.isInvalid())
1881 TypeOrExpr = Receiver.take();
1886 // typename-specifier
1887 // simple-type-specifier
1888 // expression (that starts with one of the above)
1889 DeclSpec DS(AttrFactory);
1890 ParseCXXSimpleTypeSpecifier(DS);
1892 if (Tok.is(tok::l_paren)) {
1893 // If we see an opening parentheses at this point, we are
1894 // actually parsing an expression that starts with a
1895 // function-style cast, e.g.,
1897 // postfix-expression:
1898 // simple-type-specifier ( expression-list [opt] )
1899 // typename-specifier ( expression-list [opt] )
1901 // Parse the remainder of this case, then the (optional)
1902 // postfix-expression suffix, followed by the (optional)
1903 // right-hand side of the binary expression. We have an
1905 ExprResult Receiver = ParseCXXTypeConstructExpression(DS);
1906 if (!Receiver.isInvalid())
1907 Receiver = ParsePostfixExpressionSuffix(Receiver.take());
1908 if (!Receiver.isInvalid())
1909 Receiver = ParseRHSOfBinaryExpression(Receiver.take(), prec::Comma);
1910 if (Receiver.isInvalid())
1914 TypeOrExpr = Receiver.take();
1918 // We have a class message. Turn the simple-type-specifier or
1919 // typename-specifier we parsed into a type and parse the
1920 // remainder of the class message.
1921 Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
1922 TypeResult Type = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
1923 if (Type.isInvalid())
1927 TypeOrExpr = Type.get().getAsOpaquePtr();
1931 /// \brief Determine whether the parser is currently referring to a an
1932 /// Objective-C message send, using a simplified heuristic to avoid overhead.
1934 /// This routine will only return true for a subset of valid message-send
1936 bool Parser::isSimpleObjCMessageExpression() {
1937 assert(Tok.is(tok::l_square) && getLang().ObjC1 &&
1938 "Incorrect start for isSimpleObjCMessageExpression");
1939 return GetLookAheadToken(1).is(tok::identifier) &&
1940 GetLookAheadToken(2).is(tok::identifier);
1943 bool Parser::isStartOfObjCClassMessageMissingOpenBracket() {
1944 if (!getLang().ObjC1 || !NextToken().is(tok::identifier) ||
1945 InMessageExpression)
1951 if (Tok.is(tok::annot_typename))
1952 Type = getTypeAnnotation(Tok);
1953 else if (Tok.is(tok::identifier))
1954 Type = Actions.getTypeName(*Tok.getIdentifierInfo(), Tok.getLocation(),
1959 if (!Type.get().isNull() && Type.get()->isObjCObjectOrInterfaceType()) {
1960 const Token &AfterNext = GetLookAheadToken(2);
1961 if (AfterNext.is(tok::colon) || AfterNext.is(tok::r_square)) {
1962 if (Tok.is(tok::identifier))
1963 TryAnnotateTypeOrScopeToken();
1965 return Tok.is(tok::annot_typename);
1972 /// objc-message-expr:
1973 /// '[' objc-receiver objc-message-args ']'
1975 /// objc-receiver: [C]
1981 ExprResult Parser::ParseObjCMessageExpression() {
1982 assert(Tok.is(tok::l_square) && "'[' expected");
1983 SourceLocation LBracLoc = ConsumeBracket(); // consume '['
1985 if (Tok.is(tok::code_completion)) {
1986 Actions.CodeCompleteObjCMessageReceiver(getCurScope());
1987 ConsumeCodeCompletionToken();
1988 SkipUntil(tok::r_square);
1992 InMessageExpressionRAIIObject InMessage(*this, true);
1994 if (getLang().CPlusPlus) {
1995 // We completely separate the C and C++ cases because C++ requires
1996 // more complicated (read: slower) parsing.
1998 // Handle send to super.
1999 // FIXME: This doesn't benefit from the same typo-correction we
2000 // get in Objective-C.
2001 if (Tok.is(tok::identifier) && Tok.getIdentifierInfo() == Ident_super &&
2002 NextToken().isNot(tok::period) && getCurScope()->isInObjcMethodScope())
2003 return ParseObjCMessageExpressionBody(LBracLoc, ConsumeToken(),
2006 // Parse the receiver, which is either a type or an expression.
2008 void *TypeOrExpr = NULL;
2009 if (ParseObjCXXMessageReceiver(IsExpr, TypeOrExpr)) {
2010 SkipUntil(tok::r_square);
2015 return ParseObjCMessageExpressionBody(LBracLoc, SourceLocation(),
2017 static_cast<Expr*>(TypeOrExpr));
2019 return ParseObjCMessageExpressionBody(LBracLoc, SourceLocation(),
2020 ParsedType::getFromOpaquePtr(TypeOrExpr),
2024 if (Tok.is(tok::identifier)) {
2025 IdentifierInfo *Name = Tok.getIdentifierInfo();
2026 SourceLocation NameLoc = Tok.getLocation();
2027 ParsedType ReceiverType;
2028 switch (Actions.getObjCMessageKind(getCurScope(), Name, NameLoc,
2029 Name == Ident_super,
2030 NextToken().is(tok::period),
2032 case Sema::ObjCSuperMessage:
2033 return ParseObjCMessageExpressionBody(LBracLoc, ConsumeToken(),
2036 case Sema::ObjCClassMessage:
2037 if (!ReceiverType) {
2038 SkipUntil(tok::r_square);
2042 ConsumeToken(); // the type name
2044 return ParseObjCMessageExpressionBody(LBracLoc, SourceLocation(),
2047 case Sema::ObjCInstanceMessage:
2048 // Fall through to parse an expression.
2053 // Otherwise, an arbitrary expression can be the receiver of a send.
2054 ExprResult Res(ParseExpression());
2055 if (Res.isInvalid()) {
2056 SkipUntil(tok::r_square);
2060 return ParseObjCMessageExpressionBody(LBracLoc, SourceLocation(),
2061 ParsedType(), Res.take());
2064 /// \brief Parse the remainder of an Objective-C message following the
2065 /// '[' objc-receiver.
2067 /// This routine handles sends to super, class messages (sent to a
2068 /// class name), and instance messages (sent to an object), and the
2069 /// target is represented by \p SuperLoc, \p ReceiverType, or \p
2070 /// ReceiverExpr, respectively. Only one of these parameters may have
2073 /// \param LBracLoc The location of the opening '['.
2075 /// \param SuperLoc If this is a send to 'super', the location of the
2076 /// 'super' keyword that indicates a send to the superclass.
2078 /// \param ReceiverType If this is a class message, the type of the
2079 /// class we are sending a message to.
2081 /// \param ReceiverExpr If this is an instance message, the expression
2082 /// used to compute the receiver object.
2084 /// objc-message-args:
2086 /// objc-keywordarg-list
2088 /// objc-keywordarg-list:
2090 /// objc-keywordarg-list objc-keywordarg
2092 /// objc-keywordarg:
2093 /// selector-name[opt] ':' objc-keywordexpr
2095 /// objc-keywordexpr:
2096 /// nonempty-expr-list
2098 /// nonempty-expr-list:
2099 /// assignment-expression
2100 /// nonempty-expr-list , assignment-expression
2103 Parser::ParseObjCMessageExpressionBody(SourceLocation LBracLoc,
2104 SourceLocation SuperLoc,
2105 ParsedType ReceiverType,
2106 ExprArg ReceiverExpr) {
2107 InMessageExpressionRAIIObject InMessage(*this, true);
2109 if (Tok.is(tok::code_completion)) {
2110 if (SuperLoc.isValid())
2111 Actions.CodeCompleteObjCSuperMessage(getCurScope(), SuperLoc, 0, 0,
2113 else if (ReceiverType)
2114 Actions.CodeCompleteObjCClassMessage(getCurScope(), ReceiverType, 0, 0,
2117 Actions.CodeCompleteObjCInstanceMessage(getCurScope(), ReceiverExpr,
2119 ConsumeCodeCompletionToken();
2122 // Parse objc-selector
2124 IdentifierInfo *selIdent = ParseObjCSelectorPiece(Loc);
2126 SourceLocation SelectorLoc = Loc;
2128 llvm::SmallVector<IdentifierInfo *, 12> KeyIdents;
2129 ExprVector KeyExprs(Actions);
2131 if (Tok.is(tok::colon)) {
2133 // Each iteration parses a single keyword argument.
2134 KeyIdents.push_back(selIdent);
2136 if (Tok.isNot(tok::colon)) {
2137 Diag(Tok, diag::err_expected_colon);
2138 // We must manually skip to a ']', otherwise the expression skipper will
2139 // stop at the ']' when it skips to the ';'. We want it to skip beyond
2140 // the enclosing expression.
2141 SkipUntil(tok::r_square);
2145 ConsumeToken(); // Eat the ':'.
2146 /// Parse the expression after ':'
2148 if (Tok.is(tok::code_completion)) {
2149 if (SuperLoc.isValid())
2150 Actions.CodeCompleteObjCSuperMessage(getCurScope(), SuperLoc,
2153 /*AtArgumentEpression=*/true);
2154 else if (ReceiverType)
2155 Actions.CodeCompleteObjCClassMessage(getCurScope(), ReceiverType,
2158 /*AtArgumentEpression=*/true);
2160 Actions.CodeCompleteObjCInstanceMessage(getCurScope(), ReceiverExpr,
2163 /*AtArgumentEpression=*/true);
2165 ConsumeCodeCompletionToken();
2166 SkipUntil(tok::r_square);
2170 ExprResult Res(ParseAssignmentExpression());
2171 if (Res.isInvalid()) {
2172 // We must manually skip to a ']', otherwise the expression skipper will
2173 // stop at the ']' when it skips to the ';'. We want it to skip beyond
2174 // the enclosing expression.
2175 SkipUntil(tok::r_square);
2179 // We have a valid expression.
2180 KeyExprs.push_back(Res.release());
2182 // Code completion after each argument.
2183 if (Tok.is(tok::code_completion)) {
2184 if (SuperLoc.isValid())
2185 Actions.CodeCompleteObjCSuperMessage(getCurScope(), SuperLoc,
2188 /*AtArgumentEpression=*/false);
2189 else if (ReceiverType)
2190 Actions.CodeCompleteObjCClassMessage(getCurScope(), ReceiverType,
2193 /*AtArgumentEpression=*/false);
2195 Actions.CodeCompleteObjCInstanceMessage(getCurScope(), ReceiverExpr,
2198 /*AtArgumentEpression=*/false);
2199 ConsumeCodeCompletionToken();
2200 SkipUntil(tok::r_square);
2204 // Check for another keyword selector.
2205 selIdent = ParseObjCSelectorPiece(Loc);
2206 if (!selIdent && Tok.isNot(tok::colon))
2208 // We have a selector or a colon, continue parsing.
2210 // Parse the, optional, argument list, comma separated.
2211 while (Tok.is(tok::comma)) {
2212 ConsumeToken(); // Eat the ','.
2213 /// Parse the expression after ','
2214 ExprResult Res(ParseAssignmentExpression());
2215 if (Res.isInvalid()) {
2216 // We must manually skip to a ']', otherwise the expression skipper will
2217 // stop at the ']' when it skips to the ';'. We want it to skip beyond
2218 // the enclosing expression.
2219 SkipUntil(tok::r_square);
2223 // We have a valid expression.
2224 KeyExprs.push_back(Res.release());
2226 } else if (!selIdent) {
2227 Diag(Tok, diag::err_expected_ident); // missing selector name.
2229 // We must manually skip to a ']', otherwise the expression skipper will
2230 // stop at the ']' when it skips to the ';'. We want it to skip beyond
2231 // the enclosing expression.
2232 SkipUntil(tok::r_square);
2236 if (Tok.isNot(tok::r_square)) {
2237 if (Tok.is(tok::identifier))
2238 Diag(Tok, diag::err_expected_colon);
2240 Diag(Tok, diag::err_expected_rsquare);
2241 // We must manually skip to a ']', otherwise the expression skipper will
2242 // stop at the ']' when it skips to the ';'. We want it to skip beyond
2243 // the enclosing expression.
2244 SkipUntil(tok::r_square);
2248 SourceLocation RBracLoc = ConsumeBracket(); // consume ']'
2250 unsigned nKeys = KeyIdents.size();
2252 KeyIdents.push_back(selIdent);
2253 Selector Sel = PP.getSelectorTable().getSelector(nKeys, &KeyIdents[0]);
2255 if (SuperLoc.isValid())
2256 return Actions.ActOnSuperMessage(getCurScope(), SuperLoc, Sel,
2257 LBracLoc, SelectorLoc, RBracLoc,
2258 MultiExprArg(Actions,
2261 else if (ReceiverType)
2262 return Actions.ActOnClassMessage(getCurScope(), ReceiverType, Sel,
2263 LBracLoc, SelectorLoc, RBracLoc,
2264 MultiExprArg(Actions,
2267 return Actions.ActOnInstanceMessage(getCurScope(), ReceiverExpr, Sel,
2268 LBracLoc, SelectorLoc, RBracLoc,
2269 MultiExprArg(Actions,
2274 ExprResult Parser::ParseObjCStringLiteral(SourceLocation AtLoc) {
2275 ExprResult Res(ParseStringLiteralExpression());
2276 if (Res.isInvalid()) return move(Res);
2278 // @"foo" @"bar" is a valid concatenated string. Eat any subsequent string
2279 // expressions. At this point, we know that the only valid thing that starts
2280 // with '@' is an @"".
2281 llvm::SmallVector<SourceLocation, 4> AtLocs;
2282 ExprVector AtStrings(Actions);
2283 AtLocs.push_back(AtLoc);
2284 AtStrings.push_back(Res.release());
2286 while (Tok.is(tok::at)) {
2287 AtLocs.push_back(ConsumeToken()); // eat the @.
2289 // Invalid unless there is a string literal.
2290 if (!isTokenStringLiteral())
2291 return ExprError(Diag(Tok, diag::err_objc_concat_string));
2293 ExprResult Lit(ParseStringLiteralExpression());
2294 if (Lit.isInvalid())
2297 AtStrings.push_back(Lit.release());
2300 return Owned(Actions.ParseObjCStringLiteral(&AtLocs[0], AtStrings.take(),
2304 /// objc-encode-expression:
2305 /// @encode ( type-name )
2307 Parser::ParseObjCEncodeExpression(SourceLocation AtLoc) {
2308 assert(Tok.isObjCAtKeyword(tok::objc_encode) && "Not an @encode expression!");
2310 SourceLocation EncLoc = ConsumeToken();
2312 if (Tok.isNot(tok::l_paren))
2313 return ExprError(Diag(Tok, diag::err_expected_lparen_after) << "@encode");
2315 SourceLocation LParenLoc = ConsumeParen();
2317 TypeResult Ty = ParseTypeName();
2319 SourceLocation RParenLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc);
2324 return Owned(Actions.ParseObjCEncodeExpression(AtLoc, EncLoc, LParenLoc,
2325 Ty.get(), RParenLoc));
2328 /// objc-protocol-expression
2329 /// @protocol ( protocol-name )
2331 Parser::ParseObjCProtocolExpression(SourceLocation AtLoc) {
2332 SourceLocation ProtoLoc = ConsumeToken();
2334 if (Tok.isNot(tok::l_paren))
2335 return ExprError(Diag(Tok, diag::err_expected_lparen_after) << "@protocol");
2337 SourceLocation LParenLoc = ConsumeParen();
2339 if (Tok.isNot(tok::identifier))
2340 return ExprError(Diag(Tok, diag::err_expected_ident));
2342 IdentifierInfo *protocolId = Tok.getIdentifierInfo();
2345 SourceLocation RParenLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc);
2347 return Owned(Actions.ParseObjCProtocolExpression(protocolId, AtLoc, ProtoLoc,
2348 LParenLoc, RParenLoc));
2351 /// objc-selector-expression
2352 /// @selector '(' objc-keyword-selector ')'
2353 ExprResult Parser::ParseObjCSelectorExpression(SourceLocation AtLoc) {
2354 SourceLocation SelectorLoc = ConsumeToken();
2356 if (Tok.isNot(tok::l_paren))
2357 return ExprError(Diag(Tok, diag::err_expected_lparen_after) << "@selector");
2359 llvm::SmallVector<IdentifierInfo *, 12> KeyIdents;
2360 SourceLocation LParenLoc = ConsumeParen();
2361 SourceLocation sLoc;
2363 if (Tok.is(tok::code_completion)) {
2364 Actions.CodeCompleteObjCSelector(getCurScope(), KeyIdents.data(),
2366 ConsumeCodeCompletionToken();
2367 MatchRHSPunctuation(tok::r_paren, LParenLoc);
2371 IdentifierInfo *SelIdent = ParseObjCSelectorPiece(sLoc);
2372 if (!SelIdent && // missing selector name.
2373 Tok.isNot(tok::colon) && Tok.isNot(tok::coloncolon))
2374 return ExprError(Diag(Tok, diag::err_expected_ident));
2376 KeyIdents.push_back(SelIdent);
2377 unsigned nColons = 0;
2378 if (Tok.isNot(tok::r_paren)) {
2380 if (Tok.is(tok::coloncolon)) { // Handle :: in C++.
2382 KeyIdents.push_back(0);
2383 } else if (Tok.isNot(tok::colon))
2384 return ExprError(Diag(Tok, diag::err_expected_colon));
2387 ConsumeToken(); // Eat the ':' or '::'.
2388 if (Tok.is(tok::r_paren))
2391 if (Tok.is(tok::code_completion)) {
2392 Actions.CodeCompleteObjCSelector(getCurScope(), KeyIdents.data(),
2394 ConsumeCodeCompletionToken();
2395 MatchRHSPunctuation(tok::r_paren, LParenLoc);
2399 // Check for another keyword selector.
2401 SelIdent = ParseObjCSelectorPiece(Loc);
2402 KeyIdents.push_back(SelIdent);
2403 if (!SelIdent && Tok.isNot(tok::colon) && Tok.isNot(tok::coloncolon))
2407 SourceLocation RParenLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc);
2408 Selector Sel = PP.getSelectorTable().getSelector(nColons, &KeyIdents[0]);
2409 return Owned(Actions.ParseObjCSelectorExpression(Sel, AtLoc, SelectorLoc,
2410 LParenLoc, RParenLoc));