1 //===--- ParseObjC.cpp - Objective C Parsing ------------------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file implements the Objective-C portions of the Parser interface. 11 // 12 //===----------------------------------------------------------------------===// 13 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; 22 23 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 31 /// [OBJC] '@' 'end' 32 Decl *Parser::ParseObjCAtDirectives() { 33 SourceLocation AtLoc = ConsumeToken(); // the "@" 34 35 if (Tok.is(tok::code_completion)) { 36 Actions.CodeCompleteObjCAtDirective(getCurScope()); 37 ConsumeCodeCompletionToken(); 38 } 39 40 switch (Tok.getObjCKeywordID()) { 41 case tok::objc_class: 42 return ParseObjCAtClassDeclaration(AtLoc); 43 case tok::objc_interface: { 44 ParsedAttributes attrs(AttrFactory); 45 return ParseObjCAtInterfaceDeclaration(AtLoc, attrs); 46 } 47 case tok::objc_protocol: { 48 ParsedAttributes attrs(AttrFactory); 49 return ParseObjCAtProtocolDeclaration(AtLoc, attrs); 50 } 51 case tok::objc_implementation: 52 return ParseObjCAtImplementationDeclaration(AtLoc); 53 case tok::objc_end: 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); 61 default: 62 Diag(AtLoc, diag::err_unexpected_at); 63 SkipUntil(tok::semi); 64 return 0; 65 } 66 } 67 68 /// 69 /// objc-class-declaration: 70 /// '@' 'class' identifier-list ';' 71 /// 72 Decl *Parser::ParseObjCAtClassDeclaration(SourceLocation atLoc) { 73 ConsumeToken(); // the identifier "class" 74 SmallVector<IdentifierInfo *, 8> ClassNames; 75 SmallVector<SourceLocation, 8> ClassLocs; 76 77 78 while (1) { 79 if (Tok.isNot(tok::identifier)) { 80 Diag(Tok, diag::err_expected_ident); 81 SkipUntil(tok::semi); 82 return 0; 83 } 84 ClassNames.push_back(Tok.getIdentifierInfo()); 85 ClassLocs.push_back(Tok.getLocation()); 86 ConsumeToken(); 87 88 if (Tok.isNot(tok::comma)) 89 break; 90 91 ConsumeToken(); 92 } 93 94 // Consume the ';'. 95 if (ExpectAndConsume(tok::semi, diag::err_expected_semi_after, "@class")) 96 return 0; 97 98 return Actions.ActOnForwardClassDeclaration(atLoc, ClassNames.data(), 99 ClassLocs.data(), 100 ClassNames.size()); 101 } 102 103 /// 104 /// objc-interface: 105 /// objc-class-interface-attributes[opt] objc-class-interface 106 /// objc-category-interface 107 /// 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 113 /// @end 114 /// 115 /// objc-category-interface: 116 /// '@' 'interface' identifier '(' identifier[opt] ')' 117 /// objc-protocol-refs[opt] 118 /// objc-interface-decl-list 119 /// @end 120 /// 121 /// objc-superclass: 122 /// ':' identifier 123 /// 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 130 /// 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 136 137 // Code completion after '@interface'. 138 if (Tok.is(tok::code_completion)) { 139 Actions.CodeCompleteObjCInterfaceDecl(getCurScope()); 140 ConsumeCodeCompletionToken(); 141 } 142 143 if (Tok.isNot(tok::identifier)) { 144 Diag(Tok, diag::err_expected_ident); // missing class or category name. 145 return 0; 146 } 147 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 154 // recovery. 155 ConsumeParen(); 156 SourceLocation categoryLoc, rparenLoc; 157 IdentifierInfo *categoryId = 0; 158 if (Tok.is(tok::code_completion)) { 159 Actions.CodeCompleteObjCInterfaceCategory(getCurScope(), nameId, nameLoc); 160 ConsumeCodeCompletionToken(); 161 } 162 163 // For ObjC2, the category name is optional (not an error). 164 if (Tok.is(tok::identifier)) { 165 categoryId = Tok.getIdentifierInfo(); 166 categoryLoc = ConsumeToken(); 167 } 168 else if (!getLang().ObjC2) { 169 Diag(Tok, diag::err_expected_ident); // missing category name. 170 return 0; 171 } 172 if (Tok.isNot(tok::r_paren)) { 173 Diag(Tok, diag::err_expected_rparen); 174 SkipUntil(tok::r_paren, false); // don't stop at ';' 175 return 0; 176 } 177 rparenLoc = ConsumeParen(); 178 // Next, we need to check for any protocol references. 179 SourceLocation LAngleLoc, EndProtoLoc; 180 SmallVector<Decl *, 8> ProtocolRefs; 181 SmallVector<SourceLocation, 8> ProtocolLocs; 182 if (Tok.is(tok::less) && 183 ParseObjCProtocolReferences(ProtocolRefs, ProtocolLocs, true, 184 LAngleLoc, EndProtoLoc)) 185 return 0; 186 187 if (!attrs.empty()) // categories don't support attributes. 188 Diag(Tok, diag::err_objc_no_attributes_on_category); 189 190 Decl *CategoryType = 191 Actions.ActOnStartCategoryInterface(atLoc, 192 nameId, nameLoc, 193 categoryId, categoryLoc, 194 ProtocolRefs.data(), 195 ProtocolRefs.size(), 196 ProtocolLocs.data(), 197 EndProtoLoc); 198 199 if (Tok.is(tok::l_brace)) 200 ParseObjCClassInstanceVariables(CategoryType, tok::objc_private, atLoc); 201 202 ParseObjCInterfaceDeclList(tok::objc_not_keyword, CategoryType); 203 return CategoryType; 204 } 205 // Parse a class interface. 206 IdentifierInfo *superClassId = 0; 207 SourceLocation superClassLoc; 208 209 if (Tok.is(tok::colon)) { // a super class is specified. 210 ConsumeToken(); 211 212 // Code completion of superclass names. 213 if (Tok.is(tok::code_completion)) { 214 Actions.CodeCompleteObjCSuperclass(getCurScope(), nameId, nameLoc); 215 ConsumeCodeCompletionToken(); 216 } 217 218 if (Tok.isNot(tok::identifier)) { 219 Diag(Tok, diag::err_expected_ident); // missing super class name. 220 return 0; 221 } 222 superClassId = Tok.getIdentifierInfo(); 223 superClassLoc = ConsumeToken(); 224 } 225 // Next, we need to check for any protocol references. 226 SmallVector<Decl *, 8> ProtocolRefs; 227 SmallVector<SourceLocation, 8> ProtocolLocs; 228 SourceLocation LAngleLoc, EndProtoLoc; 229 if (Tok.is(tok::less) && 230 ParseObjCProtocolReferences(ProtocolRefs, ProtocolLocs, true, 231 LAngleLoc, EndProtoLoc)) 232 return 0; 233 234 Decl *ClsType = 235 Actions.ActOnStartClassInterface(atLoc, nameId, nameLoc, 236 superClassId, superClassLoc, 237 ProtocolRefs.data(), ProtocolRefs.size(), 238 ProtocolLocs.data(), 239 EndProtoLoc, attrs.getList()); 240 241 if (Tok.is(tok::l_brace)) 242 ParseObjCClassInstanceVariables(ClsType, tok::objc_protected, atLoc); 243 244 ParseObjCInterfaceDeclList(tok::objc_interface, ClsType); 245 return ClsType; 246 } 247 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 { 251 Parser &P; 252 SmallVectorImpl<Decl *> &Props; 253 ObjCDeclSpec &OCDS; 254 SourceLocation AtLoc; 255 tok::ObjCKeywordKind MethodImplKind; 256 257 ObjCPropertyCallback(Parser &P, 258 SmallVectorImpl<Decl *> &Props, 259 ObjCDeclSpec &OCDS, SourceLocation AtLoc, 260 tok::ObjCKeywordKind MethodImplKind) : 261 P(P), Props(Props), OCDS(OCDS), AtLoc(AtLoc), 262 MethodImplKind(MethodImplKind) { 263 } 264 265 Decl *invoke(FieldDeclarator &FD) { 266 if (FD.D.getIdentifier() == 0) { 267 P.Diag(AtLoc, diag::err_objc_property_requires_field_name) 268 << FD.D.getSourceRange(); 269 return 0; 270 } 271 if (FD.BitfieldSize) { 272 P.Diag(AtLoc, diag::err_objc_property_bitfield) 273 << FD.D.getSourceRange(); 274 return 0; 275 } 276 277 // Install the property declarator into interfaceDecl. 278 IdentifierInfo *SelName = 279 OCDS.getGetterName() ? OCDS.getGetterName() : FD.D.getIdentifier(); 280 281 Selector GetterSel = 282 P.PP.getSelectorTable().getNullarySelector(SelName); 283 IdentifierInfo *SetterName = OCDS.getSetterName(); 284 Selector SetterSel; 285 if (SetterName) 286 SetterSel = P.PP.getSelectorTable().getSelector(1, &SetterName); 287 else 288 SetterSel = SelectorTable::constructSetterName(P.PP.getIdentifierTable(), 289 P.PP.getSelectorTable(), 290 FD.D.getIdentifier()); 291 bool isOverridingProperty = false; 292 Decl *Property = 293 P.Actions.ActOnProperty(P.getCurScope(), AtLoc, FD, OCDS, 294 GetterSel, SetterSel, 295 &isOverridingProperty, 296 MethodImplKind); 297 if (!isOverridingProperty) 298 Props.push_back(Property); 299 300 return Property; 301 } 302 }; 303 304 /// objc-interface-decl-list: 305 /// empty 306 /// objc-interface-decl-list objc-property-decl [OBJC2] 307 /// objc-interface-decl-list objc-method-requirement [OBJC2] 308 /// objc-interface-decl-list objc-method-proto ';' 309 /// objc-interface-decl-list declaration 310 /// objc-interface-decl-list ';' 311 /// 312 /// objc-method-requirement: [OBJC2] 313 /// @required 314 /// @optional 315 /// 316 void Parser::ParseObjCInterfaceDeclList(tok::ObjCKeywordKind contextKey, 317 Decl *CDecl) { 318 SmallVector<Decl *, 32> allMethods; 319 SmallVector<Decl *, 16> allProperties; 320 SmallVector<DeclGroupPtrTy, 8> allTUVariables; 321 tok::ObjCKeywordKind MethodImplKind = tok::objc_not_keyword; 322 323 SourceRange AtEnd; 324 Actions.ActOnObjCContainerStartDefinition(CDecl); 325 326 while (1) { 327 // If this is a method prototype, parse it. 328 if (Tok.is(tok::minus) || Tok.is(tok::plus)) { 329 Decl *methodPrototype = 330 ParseObjCMethodPrototype(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, 335 "", tok::semi); 336 continue; 337 } 338 if (Tok.is(tok::l_paren)) { 339 Diag(Tok, diag::err_expected_minus_or_plus); 340 ParseObjCMethodDecl(Tok.getLocation(), 341 tok::minus, 342 MethodImplKind, false); 343 continue; 344 } 345 // Ignore excess semicolons. 346 if (Tok.is(tok::semi)) { 347 ConsumeToken(); 348 continue; 349 } 350 351 // If we got to the end of the file, exit the loop. 352 if (Tok.is(tok::eof)) 353 break; 354 355 // Code completion within an Objective-C interface. 356 if (Tok.is(tok::code_completion)) { 357 Actions.CodeCompleteOrdinaryName(getCurScope(), 358 ObjCImpDecl? Sema::PCC_ObjCImplementation 359 : Sema::PCC_ObjCInterface); 360 ConsumeCodeCompletionToken(); 361 } 362 363 // If we don't have an @ directive, parse it as a function definition. 364 if (Tok.isNot(tok::at)) { 365 // The code below does not consume '}'s because it is afraid of eating the 366 // end of a namespace. Because of the way this code is structured, an 367 // erroneous r_brace would cause an infinite loop if not handled here. 368 if (Tok.is(tok::r_brace)) 369 break; 370 ParsedAttributes attrs(AttrFactory); 371 allTUVariables.push_back(ParseDeclarationOrFunctionDefinition(attrs)); 372 continue; 373 } 374 375 // Otherwise, we have an @ directive, eat the @. 376 SourceLocation AtLoc = ConsumeToken(); // the "@" 377 if (Tok.is(tok::code_completion)) { 378 Actions.CodeCompleteObjCAtDirective(getCurScope()); 379 ConsumeCodeCompletionToken(); 380 break; 381 } 382 383 tok::ObjCKeywordKind DirectiveKind = Tok.getObjCKeywordID(); 384 385 if (DirectiveKind == tok::objc_end) { // @end -> terminate list 386 AtEnd.setBegin(AtLoc); 387 AtEnd.setEnd(Tok.getLocation()); 388 break; 389 } else if (DirectiveKind == tok::objc_not_keyword) { 390 Diag(Tok, diag::err_objc_unknown_at); 391 SkipUntil(tok::semi); 392 continue; 393 } 394 395 // Eat the identifier. 396 ConsumeToken(); 397 398 switch (DirectiveKind) { 399 default: 400 // FIXME: If someone forgets an @end on a protocol, this loop will 401 // continue to eat up tons of stuff and spew lots of nonsense errors. It 402 // would probably be better to bail out if we saw an @class or @interface 403 // or something like that. 404 Diag(AtLoc, diag::err_objc_illegal_interface_qual); 405 // Skip until we see an '@' or '}' or ';'. 406 SkipUntil(tok::r_brace, tok::at); 407 break; 408 409 case tok::objc_implementation: 410 case tok::objc_interface: 411 Diag(Tok, diag::err_objc_missing_end); 412 ConsumeToken(); 413 break; 414 415 case tok::objc_required: 416 case tok::objc_optional: 417 // This is only valid on protocols. 418 // FIXME: Should this check for ObjC2 being enabled? 419 if (contextKey != tok::objc_protocol) 420 Diag(AtLoc, diag::err_objc_directive_only_in_protocol); 421 else 422 MethodImplKind = DirectiveKind; 423 break; 424 425 case tok::objc_property: 426 if (!getLang().ObjC2) 427 Diag(AtLoc, diag::err_objc_properties_require_objc2); 428 429 ObjCDeclSpec OCDS; 430 // Parse property attribute list, if any. 431 if (Tok.is(tok::l_paren)) 432 ParseObjCPropertyAttribute(OCDS); 433 434 ObjCPropertyCallback Callback(*this, allProperties, 435 OCDS, AtLoc, MethodImplKind); 436 437 // Parse all the comma separated declarators. 438 DeclSpec DS(AttrFactory); 439 ParseStructDeclaration(DS, Callback); 440 441 ExpectAndConsume(tok::semi, diag::err_expected_semi_decl_list); 442 break; 443 } 444 } 445 446 // We break out of the big loop in two cases: when we see @end or when we see 447 // EOF. In the former case, eat the @end. In the later case, emit an error. 448 if (Tok.is(tok::code_completion)) { 449 Actions.CodeCompleteObjCAtDirective(getCurScope()); 450 ConsumeCodeCompletionToken(); 451 } else if (Tok.isObjCAtKeyword(tok::objc_end)) 452 ConsumeToken(); // the "end" identifier 453 else 454 Diag(Tok, diag::err_objc_missing_end); 455 456 // Insert collected methods declarations into the @interface object. 457 // This passes in an invalid SourceLocation for AtEndLoc when EOF is hit. 458 Actions.ActOnAtEnd(getCurScope(), AtEnd, 459 allMethods.data(), allMethods.size(), 460 allProperties.data(), allProperties.size(), 461 allTUVariables.data(), allTUVariables.size()); 462 Actions.ActOnObjCContainerFinishDefinition(CDecl); 463 } 464 465 /// Parse property attribute declarations. 466 /// 467 /// property-attr-decl: '(' property-attrlist ')' 468 /// property-attrlist: 469 /// property-attribute 470 /// property-attrlist ',' property-attribute 471 /// property-attribute: 472 /// getter '=' identifier 473 /// setter '=' identifier ':' 474 /// readonly 475 /// readwrite 476 /// assign 477 /// retain 478 /// copy 479 /// nonatomic 480 /// atomic 481 /// strong 482 /// weak 483 /// unsafe_unretained 484 /// 485 void Parser::ParseObjCPropertyAttribute(ObjCDeclSpec &DS) { 486 assert(Tok.getKind() == tok::l_paren); 487 SourceLocation LHSLoc = ConsumeParen(); // consume '(' 488 489 while (1) { 490 if (Tok.is(tok::code_completion)) { 491 Actions.CodeCompleteObjCPropertyFlags(getCurScope(), DS); 492 ConsumeCodeCompletionToken(); 493 } 494 const IdentifierInfo *II = Tok.getIdentifierInfo(); 495 496 // If this is not an identifier at all, bail out early. 497 if (II == 0) { 498 MatchRHSPunctuation(tok::r_paren, LHSLoc); 499 return; 500 } 501 502 SourceLocation AttrName = ConsumeToken(); // consume last attribute name 503 504 if (II->isStr("readonly")) 505 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_readonly); 506 else if (II->isStr("assign")) 507 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_assign); 508 else if (II->isStr("unsafe_unretained")) 509 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_unsafe_unretained); 510 else if (II->isStr("readwrite")) 511 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_readwrite); 512 else if (II->isStr("retain")) 513 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_retain); 514 else if (II->isStr("strong")) 515 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_strong); 516 else if (II->isStr("copy")) 517 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_copy); 518 else if (II->isStr("nonatomic")) 519 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_nonatomic); 520 else if (II->isStr("atomic")) 521 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_atomic); 522 else if (II->isStr("weak")) 523 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_weak); 524 else if (II->isStr("getter") || II->isStr("setter")) { 525 bool IsSetter = II->getNameStart()[0] == 's'; 526 527 // getter/setter require extra treatment. 528 unsigned DiagID = IsSetter ? diag::err_objc_expected_equal_for_setter : 529 diag::err_objc_expected_equal_for_getter; 530 531 if (ExpectAndConsume(tok::equal, DiagID, "", tok::r_paren)) 532 return; 533 534 if (Tok.is(tok::code_completion)) { 535 if (IsSetter) 536 Actions.CodeCompleteObjCPropertySetter(getCurScope()); 537 else 538 Actions.CodeCompleteObjCPropertyGetter(getCurScope()); 539 ConsumeCodeCompletionToken(); 540 } 541 542 543 SourceLocation SelLoc; 544 IdentifierInfo *SelIdent = ParseObjCSelectorPiece(SelLoc); 545 546 if (!SelIdent) { 547 Diag(Tok, diag::err_objc_expected_selector_for_getter_setter) 548 << IsSetter; 549 SkipUntil(tok::r_paren); 550 return; 551 } 552 553 if (IsSetter) { 554 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_setter); 555 DS.setSetterName(SelIdent); 556 557 if (ExpectAndConsume(tok::colon, 558 diag::err_expected_colon_after_setter_name, "", 559 tok::r_paren)) 560 return; 561 } else { 562 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_getter); 563 DS.setGetterName(SelIdent); 564 } 565 } else { 566 Diag(AttrName, diag::err_objc_expected_property_attr) << II; 567 SkipUntil(tok::r_paren); 568 return; 569 } 570 571 if (Tok.isNot(tok::comma)) 572 break; 573 574 ConsumeToken(); 575 } 576 577 MatchRHSPunctuation(tok::r_paren, LHSLoc); 578 } 579 580 /// objc-method-proto: 581 /// objc-instance-method objc-method-decl objc-method-attributes[opt] 582 /// objc-class-method objc-method-decl objc-method-attributes[opt] 583 /// 584 /// objc-instance-method: '-' 585 /// objc-class-method: '+' 586 /// 587 /// objc-method-attributes: [OBJC2] 588 /// __attribute__((deprecated)) 589 /// 590 Decl *Parser::ParseObjCMethodPrototype(tok::ObjCKeywordKind MethodImplKind, 591 bool MethodDefinition) { 592 assert((Tok.is(tok::minus) || Tok.is(tok::plus)) && "expected +/-"); 593 594 tok::TokenKind methodType = Tok.getKind(); 595 SourceLocation mLoc = ConsumeToken(); 596 Decl *MDecl = ParseObjCMethodDecl(mLoc, methodType, MethodImplKind, 597 MethodDefinition); 598 // Since this rule is used for both method declarations and definitions, 599 // the caller is (optionally) responsible for consuming the ';'. 600 return MDecl; 601 } 602 603 /// objc-selector: 604 /// identifier 605 /// one of 606 /// enum struct union if else while do for switch case default 607 /// break continue return goto asm sizeof typeof __alignof 608 /// unsigned long const short volatile signed restrict _Complex 609 /// in out inout bycopy byref oneway int char float double void _Bool 610 /// 611 IdentifierInfo *Parser::ParseObjCSelectorPiece(SourceLocation &SelectorLoc) { 612 613 switch (Tok.getKind()) { 614 default: 615 return 0; 616 case tok::ampamp: 617 case tok::ampequal: 618 case tok::amp: 619 case tok::pipe: 620 case tok::tilde: 621 case tok::exclaim: 622 case tok::exclaimequal: 623 case tok::pipepipe: 624 case tok::pipeequal: 625 case tok::caret: 626 case tok::caretequal: { 627 std::string ThisTok(PP.getSpelling(Tok)); 628 if (isalpha(ThisTok[0])) { 629 IdentifierInfo *II = &PP.getIdentifierTable().get(ThisTok.data()); 630 Tok.setKind(tok::identifier); 631 SelectorLoc = ConsumeToken(); 632 return II; 633 } 634 return 0; 635 } 636 637 case tok::identifier: 638 case tok::kw_asm: 639 case tok::kw_auto: 640 case tok::kw_bool: 641 case tok::kw_break: 642 case tok::kw_case: 643 case tok::kw_catch: 644 case tok::kw_char: 645 case tok::kw_class: 646 case tok::kw_const: 647 case tok::kw_const_cast: 648 case tok::kw_continue: 649 case tok::kw_default: 650 case tok::kw_delete: 651 case tok::kw_do: 652 case tok::kw_double: 653 case tok::kw_dynamic_cast: 654 case tok::kw_else: 655 case tok::kw_enum: 656 case tok::kw_explicit: 657 case tok::kw_export: 658 case tok::kw_extern: 659 case tok::kw_false: 660 case tok::kw_float: 661 case tok::kw_for: 662 case tok::kw_friend: 663 case tok::kw_goto: 664 case tok::kw_if: 665 case tok::kw_inline: 666 case tok::kw_int: 667 case tok::kw_long: 668 case tok::kw_mutable: 669 case tok::kw_namespace: 670 case tok::kw_new: 671 case tok::kw_operator: 672 case tok::kw_private: 673 case tok::kw_protected: 674 case tok::kw_public: 675 case tok::kw_register: 676 case tok::kw_reinterpret_cast: 677 case tok::kw_restrict: 678 case tok::kw_return: 679 case tok::kw_short: 680 case tok::kw_signed: 681 case tok::kw_sizeof: 682 case tok::kw_static: 683 case tok::kw_static_cast: 684 case tok::kw_struct: 685 case tok::kw_switch: 686 case tok::kw_template: 687 case tok::kw_this: 688 case tok::kw_throw: 689 case tok::kw_true: 690 case tok::kw_try: 691 case tok::kw_typedef: 692 case tok::kw_typeid: 693 case tok::kw_typename: 694 case tok::kw_typeof: 695 case tok::kw_union: 696 case tok::kw_unsigned: 697 case tok::kw_using: 698 case tok::kw_virtual: 699 case tok::kw_void: 700 case tok::kw_volatile: 701 case tok::kw_wchar_t: 702 case tok::kw_while: 703 case tok::kw__Bool: 704 case tok::kw__Complex: 705 case tok::kw___alignof: 706 IdentifierInfo *II = Tok.getIdentifierInfo(); 707 SelectorLoc = ConsumeToken(); 708 return II; 709 } 710 } 711 712 /// objc-for-collection-in: 'in' 713 /// 714 bool Parser::isTokIdentifier_in() const { 715 // FIXME: May have to do additional look-ahead to only allow for 716 // valid tokens following an 'in'; such as an identifier, unary operators, 717 // '[' etc. 718 return (getLang().ObjC2 && Tok.is(tok::identifier) && 719 Tok.getIdentifierInfo() == ObjCTypeQuals[objc_in]); 720 } 721 722 /// ParseObjCTypeQualifierList - This routine parses the objective-c's type 723 /// qualifier list and builds their bitmask representation in the input 724 /// argument. 725 /// 726 /// objc-type-qualifiers: 727 /// objc-type-qualifier 728 /// objc-type-qualifiers objc-type-qualifier 729 /// 730 void Parser::ParseObjCTypeQualifierList(ObjCDeclSpec &DS, 731 ObjCTypeNameContext Context) { 732 while (1) { 733 if (Tok.is(tok::code_completion)) { 734 Actions.CodeCompleteObjCPassingType(getCurScope(), DS, 735 Context == OTN_ParameterType); 736 ConsumeCodeCompletionToken(); 737 } 738 739 if (Tok.isNot(tok::identifier)) 740 return; 741 742 const IdentifierInfo *II = Tok.getIdentifierInfo(); 743 for (unsigned i = 0; i != objc_NumQuals; ++i) { 744 if (II != ObjCTypeQuals[i]) 745 continue; 746 747 ObjCDeclSpec::ObjCDeclQualifier Qual; 748 switch (i) { 749 default: assert(0 && "Unknown decl qualifier"); 750 case objc_in: Qual = ObjCDeclSpec::DQ_In; break; 751 case objc_out: Qual = ObjCDeclSpec::DQ_Out; break; 752 case objc_inout: Qual = ObjCDeclSpec::DQ_Inout; break; 753 case objc_oneway: Qual = ObjCDeclSpec::DQ_Oneway; break; 754 case objc_bycopy: Qual = ObjCDeclSpec::DQ_Bycopy; break; 755 case objc_byref: Qual = ObjCDeclSpec::DQ_Byref; break; 756 } 757 DS.setObjCDeclQualifier(Qual); 758 ConsumeToken(); 759 II = 0; 760 break; 761 } 762 763 // If this wasn't a recognized qualifier, bail out. 764 if (II) return; 765 } 766 } 767 768 /// objc-type-name: 769 /// '(' objc-type-qualifiers[opt] type-name ')' 770 /// '(' objc-type-qualifiers[opt] ')' 771 /// 772 ParsedType Parser::ParseObjCTypeName(ObjCDeclSpec &DS, 773 ObjCTypeNameContext Context) { 774 assert(Tok.is(tok::l_paren) && "expected ("); 775 776 SourceLocation LParenLoc = ConsumeParen(); 777 SourceLocation TypeStartLoc = Tok.getLocation(); 778 ObjCDeclContextSwitch ObjCDC(*this); 779 780 // Parse type qualifiers, in, inout, etc. 781 ParseObjCTypeQualifierList(DS, Context); 782 783 ParsedType Ty; 784 if (isTypeSpecifierQualifier()) { 785 TypeResult TypeSpec = 786 ParseTypeName(0, Declarator::ObjCPrototypeContext, &DS); 787 if (!TypeSpec.isInvalid()) 788 Ty = TypeSpec.get(); 789 } 790 791 if (Tok.is(tok::r_paren)) 792 ConsumeParen(); 793 else if (Tok.getLocation() == TypeStartLoc) { 794 // If we didn't eat any tokens, then this isn't a type. 795 Diag(Tok, diag::err_expected_type); 796 SkipUntil(tok::r_paren); 797 } else { 798 // Otherwise, we found *something*, but didn't get a ')' in the right 799 // place. Emit an error then return what we have as the type. 800 MatchRHSPunctuation(tok::r_paren, LParenLoc); 801 } 802 return Ty; 803 } 804 805 /// objc-method-decl: 806 /// objc-selector 807 /// objc-keyword-selector objc-parmlist[opt] 808 /// objc-type-name objc-selector 809 /// objc-type-name objc-keyword-selector objc-parmlist[opt] 810 /// 811 /// objc-keyword-selector: 812 /// objc-keyword-decl 813 /// objc-keyword-selector objc-keyword-decl 814 /// 815 /// objc-keyword-decl: 816 /// objc-selector ':' objc-type-name objc-keyword-attributes[opt] identifier 817 /// objc-selector ':' objc-keyword-attributes[opt] identifier 818 /// ':' objc-type-name objc-keyword-attributes[opt] identifier 819 /// ':' objc-keyword-attributes[opt] identifier 820 /// 821 /// objc-parmlist: 822 /// objc-parms objc-ellipsis[opt] 823 /// 824 /// objc-parms: 825 /// objc-parms , parameter-declaration 826 /// 827 /// objc-ellipsis: 828 /// , ... 829 /// 830 /// objc-keyword-attributes: [OBJC2] 831 /// __attribute__((unused)) 832 /// 833 Decl *Parser::ParseObjCMethodDecl(SourceLocation mLoc, 834 tok::TokenKind mType, 835 tok::ObjCKeywordKind MethodImplKind, 836 bool MethodDefinition) { 837 ParsingDeclRAIIObject PD(*this); 838 839 if (Tok.is(tok::code_completion)) { 840 Actions.CodeCompleteObjCMethodDecl(getCurScope(), mType == tok::minus, 841 /*ReturnType=*/ ParsedType()); 842 ConsumeCodeCompletionToken(); 843 } 844 845 // Parse the return type if present. 846 ParsedType ReturnType; 847 ObjCDeclSpec DSRet; 848 if (Tok.is(tok::l_paren)) 849 ReturnType = ParseObjCTypeName(DSRet, OTN_ResultType); 850 851 // If attributes exist before the method, parse them. 852 ParsedAttributes methodAttrs(AttrFactory); 853 if (getLang().ObjC2) 854 MaybeParseGNUAttributes(methodAttrs); 855 856 if (Tok.is(tok::code_completion)) { 857 Actions.CodeCompleteObjCMethodDecl(getCurScope(), mType == tok::minus, 858 ReturnType); 859 ConsumeCodeCompletionToken(); 860 } 861 862 // Now parse the selector. 863 SourceLocation selLoc; 864 IdentifierInfo *SelIdent = ParseObjCSelectorPiece(selLoc); 865 866 // An unnamed colon is valid. 867 if (!SelIdent && Tok.isNot(tok::colon)) { // missing selector name. 868 Diag(Tok, diag::err_expected_selector_for_method) 869 << SourceRange(mLoc, Tok.getLocation()); 870 // Skip until we get a ; or {}. 871 SkipUntil(tok::r_brace); 872 return 0; 873 } 874 875 SmallVector<DeclaratorChunk::ParamInfo, 8> CParamInfo; 876 if (Tok.isNot(tok::colon)) { 877 // If attributes exist after the method, parse them. 878 if (getLang().ObjC2) 879 MaybeParseGNUAttributes(methodAttrs); 880 881 Selector Sel = PP.getSelectorTable().getNullarySelector(SelIdent); 882 Decl *Result 883 = Actions.ActOnMethodDeclaration(getCurScope(), mLoc, Tok.getLocation(), 884 mType, DSRet, ReturnType, 885 selLoc, Sel, 0, 886 CParamInfo.data(), CParamInfo.size(), 887 methodAttrs.getList(), MethodImplKind, 888 false, MethodDefinition); 889 PD.complete(Result); 890 return Result; 891 } 892 893 SmallVector<IdentifierInfo *, 12> KeyIdents; 894 SmallVector<Sema::ObjCArgInfo, 12> ArgInfos; 895 ParseScope PrototypeScope(this, 896 Scope::FunctionPrototypeScope|Scope::DeclScope); 897 898 AttributePool allParamAttrs(AttrFactory); 899 900 while (1) { 901 ParsedAttributes paramAttrs(AttrFactory); 902 Sema::ObjCArgInfo ArgInfo; 903 904 // Each iteration parses a single keyword argument. 905 if (Tok.isNot(tok::colon)) { 906 Diag(Tok, diag::err_expected_colon); 907 break; 908 } 909 ConsumeToken(); // Eat the ':'. 910 911 ArgInfo.Type = ParsedType(); 912 if (Tok.is(tok::l_paren)) // Parse the argument type if present. 913 ArgInfo.Type = ParseObjCTypeName(ArgInfo.DeclSpec, OTN_ParameterType); 914 915 // If attributes exist before the argument name, parse them. 916 ArgInfo.ArgAttrs = 0; 917 if (getLang().ObjC2) { 918 MaybeParseGNUAttributes(paramAttrs); 919 ArgInfo.ArgAttrs = paramAttrs.getList(); 920 } 921 922 // Code completion for the next piece of the selector. 923 if (Tok.is(tok::code_completion)) { 924 ConsumeCodeCompletionToken(); 925 KeyIdents.push_back(SelIdent); 926 Actions.CodeCompleteObjCMethodDeclSelector(getCurScope(), 927 mType == tok::minus, 928 /*AtParameterName=*/true, 929 ReturnType, 930 KeyIdents.data(), 931 KeyIdents.size()); 932 KeyIdents.pop_back(); 933 break; 934 } 935 936 if (Tok.isNot(tok::identifier)) { 937 Diag(Tok, diag::err_expected_ident); // missing argument name. 938 break; 939 } 940 941 ArgInfo.Name = Tok.getIdentifierInfo(); 942 ArgInfo.NameLoc = Tok.getLocation(); 943 ConsumeToken(); // Eat the identifier. 944 945 ArgInfos.push_back(ArgInfo); 946 KeyIdents.push_back(SelIdent); 947 948 // Make sure the attributes persist. 949 allParamAttrs.takeAllFrom(paramAttrs.getPool()); 950 951 // Code completion for the next piece of the selector. 952 if (Tok.is(tok::code_completion)) { 953 ConsumeCodeCompletionToken(); 954 Actions.CodeCompleteObjCMethodDeclSelector(getCurScope(), 955 mType == tok::minus, 956 /*AtParameterName=*/false, 957 ReturnType, 958 KeyIdents.data(), 959 KeyIdents.size()); 960 break; 961 } 962 963 // Check for another keyword selector. 964 SourceLocation Loc; 965 SelIdent = ParseObjCSelectorPiece(Loc); 966 if (!SelIdent && Tok.isNot(tok::colon)) 967 break; 968 // We have a selector or a colon, continue parsing. 969 } 970 971 bool isVariadic = false; 972 973 // Parse the (optional) parameter list. 974 while (Tok.is(tok::comma)) { 975 ConsumeToken(); 976 if (Tok.is(tok::ellipsis)) { 977 isVariadic = true; 978 ConsumeToken(); 979 break; 980 } 981 DeclSpec DS(AttrFactory); 982 ParseDeclarationSpecifiers(DS); 983 // Parse the declarator. 984 Declarator ParmDecl(DS, Declarator::PrototypeContext); 985 ParseDeclarator(ParmDecl); 986 IdentifierInfo *ParmII = ParmDecl.getIdentifier(); 987 Decl *Param = Actions.ActOnParamDeclarator(getCurScope(), ParmDecl); 988 CParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII, 989 ParmDecl.getIdentifierLoc(), 990 Param, 991 0)); 992 993 } 994 995 // FIXME: Add support for optional parameter list... 996 // If attributes exist after the method, parse them. 997 if (getLang().ObjC2) 998 MaybeParseGNUAttributes(methodAttrs); 999 1000 if (KeyIdents.size() == 0) 1001 return 0; 1002 1003 Selector Sel = PP.getSelectorTable().getSelector(KeyIdents.size(), 1004 &KeyIdents[0]); 1005 Decl *Result 1006 = Actions.ActOnMethodDeclaration(getCurScope(), mLoc, Tok.getLocation(), 1007 mType, DSRet, ReturnType, 1008 selLoc, Sel, &ArgInfos[0], 1009 CParamInfo.data(), CParamInfo.size(), 1010 methodAttrs.getList(), 1011 MethodImplKind, isVariadic, MethodDefinition); 1012 1013 PD.complete(Result); 1014 return Result; 1015 } 1016 1017 /// objc-protocol-refs: 1018 /// '<' identifier-list '>' 1019 /// 1020 bool Parser:: 1021 ParseObjCProtocolReferences(SmallVectorImpl<Decl *> &Protocols, 1022 SmallVectorImpl<SourceLocation> &ProtocolLocs, 1023 bool WarnOnDeclarations, 1024 SourceLocation &LAngleLoc, SourceLocation &EndLoc) { 1025 assert(Tok.is(tok::less) && "expected <"); 1026 1027 LAngleLoc = ConsumeToken(); // the "<" 1028 1029 SmallVector<IdentifierLocPair, 8> ProtocolIdents; 1030 1031 while (1) { 1032 if (Tok.is(tok::code_completion)) { 1033 Actions.CodeCompleteObjCProtocolReferences(ProtocolIdents.data(), 1034 ProtocolIdents.size()); 1035 ConsumeCodeCompletionToken(); 1036 } 1037 1038 if (Tok.isNot(tok::identifier)) { 1039 Diag(Tok, diag::err_expected_ident); 1040 SkipUntil(tok::greater); 1041 return true; 1042 } 1043 ProtocolIdents.push_back(std::make_pair(Tok.getIdentifierInfo(), 1044 Tok.getLocation())); 1045 ProtocolLocs.push_back(Tok.getLocation()); 1046 ConsumeToken(); 1047 1048 if (Tok.isNot(tok::comma)) 1049 break; 1050 ConsumeToken(); 1051 } 1052 1053 // Consume the '>'. 1054 if (Tok.isNot(tok::greater)) { 1055 Diag(Tok, diag::err_expected_greater); 1056 return true; 1057 } 1058 1059 EndLoc = ConsumeAnyToken(); 1060 1061 // Convert the list of protocols identifiers into a list of protocol decls. 1062 Actions.FindProtocolDeclaration(WarnOnDeclarations, 1063 &ProtocolIdents[0], ProtocolIdents.size(), 1064 Protocols); 1065 return false; 1066 } 1067 1068 /// \brief Parse the Objective-C protocol qualifiers that follow a typename 1069 /// in a decl-specifier-seq, starting at the '<'. 1070 bool Parser::ParseObjCProtocolQualifiers(DeclSpec &DS) { 1071 assert(Tok.is(tok::less) && "Protocol qualifiers start with '<'"); 1072 assert(getLang().ObjC1 && "Protocol qualifiers only exist in Objective-C"); 1073 SourceLocation LAngleLoc, EndProtoLoc; 1074 SmallVector<Decl *, 8> ProtocolDecl; 1075 SmallVector<SourceLocation, 8> ProtocolLocs; 1076 bool Result = ParseObjCProtocolReferences(ProtocolDecl, ProtocolLocs, false, 1077 LAngleLoc, EndProtoLoc); 1078 DS.setProtocolQualifiers(ProtocolDecl.data(), ProtocolDecl.size(), 1079 ProtocolLocs.data(), LAngleLoc); 1080 if (EndProtoLoc.isValid()) 1081 DS.SetRangeEnd(EndProtoLoc); 1082 return Result; 1083 } 1084 1085 1086 /// objc-class-instance-variables: 1087 /// '{' objc-instance-variable-decl-list[opt] '}' 1088 /// 1089 /// objc-instance-variable-decl-list: 1090 /// objc-visibility-spec 1091 /// objc-instance-variable-decl ';' 1092 /// ';' 1093 /// objc-instance-variable-decl-list objc-visibility-spec 1094 /// objc-instance-variable-decl-list objc-instance-variable-decl ';' 1095 /// objc-instance-variable-decl-list ';' 1096 /// 1097 /// objc-visibility-spec: 1098 /// @private 1099 /// @protected 1100 /// @public 1101 /// @package [OBJC2] 1102 /// 1103 /// objc-instance-variable-decl: 1104 /// struct-declaration 1105 /// 1106 void Parser::ParseObjCClassInstanceVariables(Decl *interfaceDecl, 1107 tok::ObjCKeywordKind visibility, 1108 SourceLocation atLoc) { 1109 assert(Tok.is(tok::l_brace) && "expected {"); 1110 SmallVector<Decl *, 32> AllIvarDecls; 1111 1112 ParseScope ClassScope(this, Scope::DeclScope|Scope::ClassScope); 1113 1114 SourceLocation LBraceLoc = ConsumeBrace(); // the "{" 1115 1116 // While we still have something to read, read the instance variables. 1117 while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) { 1118 // Each iteration of this loop reads one objc-instance-variable-decl. 1119 1120 // Check for extraneous top-level semicolon. 1121 if (Tok.is(tok::semi)) { 1122 Diag(Tok, diag::ext_extra_ivar_semi) 1123 << FixItHint::CreateRemoval(Tok.getLocation()); 1124 ConsumeToken(); 1125 continue; 1126 } 1127 1128 // Set the default visibility to private. 1129 if (Tok.is(tok::at)) { // parse objc-visibility-spec 1130 ConsumeToken(); // eat the @ sign 1131 1132 if (Tok.is(tok::code_completion)) { 1133 Actions.CodeCompleteObjCAtVisibility(getCurScope()); 1134 ConsumeCodeCompletionToken(); 1135 } 1136 1137 switch (Tok.getObjCKeywordID()) { 1138 case tok::objc_private: 1139 case tok::objc_public: 1140 case tok::objc_protected: 1141 case tok::objc_package: 1142 visibility = Tok.getObjCKeywordID(); 1143 ConsumeToken(); 1144 continue; 1145 default: 1146 Diag(Tok, diag::err_objc_illegal_visibility_spec); 1147 continue; 1148 } 1149 } 1150 1151 if (Tok.is(tok::code_completion)) { 1152 Actions.CodeCompleteOrdinaryName(getCurScope(), 1153 Sema::PCC_ObjCInstanceVariableList); 1154 ConsumeCodeCompletionToken(); 1155 } 1156 1157 struct ObjCIvarCallback : FieldCallback { 1158 Parser &P; 1159 Decl *IDecl; 1160 tok::ObjCKeywordKind visibility; 1161 SmallVectorImpl<Decl *> &AllIvarDecls; 1162 1163 ObjCIvarCallback(Parser &P, Decl *IDecl, tok::ObjCKeywordKind V, 1164 SmallVectorImpl<Decl *> &AllIvarDecls) : 1165 P(P), IDecl(IDecl), visibility(V), AllIvarDecls(AllIvarDecls) { 1166 } 1167 1168 Decl *invoke(FieldDeclarator &FD) { 1169 P.Actions.ActOnObjCContainerStartDefinition(IDecl); 1170 // Install the declarator into the interface decl. 1171 Decl *Field 1172 = P.Actions.ActOnIvar(P.getCurScope(), 1173 FD.D.getDeclSpec().getSourceRange().getBegin(), 1174 FD.D, FD.BitfieldSize, visibility); 1175 P.Actions.ActOnObjCContainerFinishDefinition(IDecl); 1176 if (Field) 1177 AllIvarDecls.push_back(Field); 1178 return Field; 1179 } 1180 } Callback(*this, interfaceDecl, visibility, AllIvarDecls); 1181 1182 // Parse all the comma separated declarators. 1183 DeclSpec DS(AttrFactory); 1184 ParseStructDeclaration(DS, Callback); 1185 1186 if (Tok.is(tok::semi)) { 1187 ConsumeToken(); 1188 } else { 1189 Diag(Tok, diag::err_expected_semi_decl_list); 1190 // Skip to end of block or statement 1191 SkipUntil(tok::r_brace, true, true); 1192 } 1193 } 1194 SourceLocation RBraceLoc = MatchRHSPunctuation(tok::r_brace, LBraceLoc); 1195 Actions.ActOnObjCContainerStartDefinition(interfaceDecl); 1196 Actions.ActOnLastBitfield(RBraceLoc, AllIvarDecls); 1197 Actions.ActOnObjCContainerFinishDefinition(interfaceDecl); 1198 // Call ActOnFields() even if we don't have any decls. This is useful 1199 // for code rewriting tools that need to be aware of the empty list. 1200 Actions.ActOnFields(getCurScope(), atLoc, interfaceDecl, 1201 AllIvarDecls.data(), AllIvarDecls.size(), 1202 LBraceLoc, RBraceLoc, 0); 1203 return; 1204 } 1205 1206 /// objc-protocol-declaration: 1207 /// objc-protocol-definition 1208 /// objc-protocol-forward-reference 1209 /// 1210 /// objc-protocol-definition: 1211 /// @protocol identifier 1212 /// objc-protocol-refs[opt] 1213 /// objc-interface-decl-list 1214 /// @end 1215 /// 1216 /// objc-protocol-forward-reference: 1217 /// @protocol identifier-list ';' 1218 /// 1219 /// "@protocol identifier ;" should be resolved as "@protocol 1220 /// identifier-list ;": objc-interface-decl-list may not start with a 1221 /// semicolon in the first alternative if objc-protocol-refs are omitted. 1222 Decl *Parser::ParseObjCAtProtocolDeclaration(SourceLocation AtLoc, 1223 ParsedAttributes &attrs) { 1224 assert(Tok.isObjCAtKeyword(tok::objc_protocol) && 1225 "ParseObjCAtProtocolDeclaration(): Expected @protocol"); 1226 ConsumeToken(); // the "protocol" identifier 1227 1228 if (Tok.is(tok::code_completion)) { 1229 Actions.CodeCompleteObjCProtocolDecl(getCurScope()); 1230 ConsumeCodeCompletionToken(); 1231 } 1232 1233 if (Tok.isNot(tok::identifier)) { 1234 Diag(Tok, diag::err_expected_ident); // missing protocol name. 1235 return 0; 1236 } 1237 // Save the protocol name, then consume it. 1238 IdentifierInfo *protocolName = Tok.getIdentifierInfo(); 1239 SourceLocation nameLoc = ConsumeToken(); 1240 1241 if (Tok.is(tok::semi)) { // forward declaration of one protocol. 1242 IdentifierLocPair ProtoInfo(protocolName, nameLoc); 1243 ConsumeToken(); 1244 return Actions.ActOnForwardProtocolDeclaration(AtLoc, &ProtoInfo, 1, 1245 attrs.getList()); 1246 } 1247 1248 if (Tok.is(tok::comma)) { // list of forward declarations. 1249 SmallVector<IdentifierLocPair, 8> ProtocolRefs; 1250 ProtocolRefs.push_back(std::make_pair(protocolName, nameLoc)); 1251 1252 // Parse the list of forward declarations. 1253 while (1) { 1254 ConsumeToken(); // the ',' 1255 if (Tok.isNot(tok::identifier)) { 1256 Diag(Tok, diag::err_expected_ident); 1257 SkipUntil(tok::semi); 1258 return 0; 1259 } 1260 ProtocolRefs.push_back(IdentifierLocPair(Tok.getIdentifierInfo(), 1261 Tok.getLocation())); 1262 ConsumeToken(); // the identifier 1263 1264 if (Tok.isNot(tok::comma)) 1265 break; 1266 } 1267 // Consume the ';'. 1268 if (ExpectAndConsume(tok::semi, diag::err_expected_semi_after, "@protocol")) 1269 return 0; 1270 1271 return Actions.ActOnForwardProtocolDeclaration(AtLoc, 1272 &ProtocolRefs[0], 1273 ProtocolRefs.size(), 1274 attrs.getList()); 1275 } 1276 1277 // Last, and definitely not least, parse a protocol declaration. 1278 SourceLocation LAngleLoc, EndProtoLoc; 1279 1280 SmallVector<Decl *, 8> ProtocolRefs; 1281 SmallVector<SourceLocation, 8> ProtocolLocs; 1282 if (Tok.is(tok::less) && 1283 ParseObjCProtocolReferences(ProtocolRefs, ProtocolLocs, false, 1284 LAngleLoc, EndProtoLoc)) 1285 return 0; 1286 1287 Decl *ProtoType = 1288 Actions.ActOnStartProtocolInterface(AtLoc, protocolName, nameLoc, 1289 ProtocolRefs.data(), 1290 ProtocolRefs.size(), 1291 ProtocolLocs.data(), 1292 EndProtoLoc, attrs.getList()); 1293 1294 ParseObjCInterfaceDeclList(tok::objc_protocol, ProtoType); 1295 return ProtoType; 1296 } 1297 1298 /// objc-implementation: 1299 /// objc-class-implementation-prologue 1300 /// objc-category-implementation-prologue 1301 /// 1302 /// objc-class-implementation-prologue: 1303 /// @implementation identifier objc-superclass[opt] 1304 /// objc-class-instance-variables[opt] 1305 /// 1306 /// objc-category-implementation-prologue: 1307 /// @implementation identifier ( identifier ) 1308 Decl *Parser::ParseObjCAtImplementationDeclaration( 1309 SourceLocation atLoc) { 1310 assert(Tok.isObjCAtKeyword(tok::objc_implementation) && 1311 "ParseObjCAtImplementationDeclaration(): Expected @implementation"); 1312 ConsumeToken(); // the "implementation" identifier 1313 1314 // Code completion after '@implementation'. 1315 if (Tok.is(tok::code_completion)) { 1316 Actions.CodeCompleteObjCImplementationDecl(getCurScope()); 1317 ConsumeCodeCompletionToken(); 1318 } 1319 1320 if (Tok.isNot(tok::identifier)) { 1321 Diag(Tok, diag::err_expected_ident); // missing class or category name. 1322 return 0; 1323 } 1324 // We have a class or category name - consume it. 1325 IdentifierInfo *nameId = Tok.getIdentifierInfo(); 1326 SourceLocation nameLoc = ConsumeToken(); // consume class or category name 1327 1328 if (Tok.is(tok::l_paren)) { 1329 // we have a category implementation. 1330 ConsumeParen(); 1331 SourceLocation categoryLoc, rparenLoc; 1332 IdentifierInfo *categoryId = 0; 1333 1334 if (Tok.is(tok::code_completion)) { 1335 Actions.CodeCompleteObjCImplementationCategory(getCurScope(), nameId, nameLoc); 1336 ConsumeCodeCompletionToken(); 1337 } 1338 1339 if (Tok.is(tok::identifier)) { 1340 categoryId = Tok.getIdentifierInfo(); 1341 categoryLoc = ConsumeToken(); 1342 } else { 1343 Diag(Tok, diag::err_expected_ident); // missing category name. 1344 return 0; 1345 } 1346 if (Tok.isNot(tok::r_paren)) { 1347 Diag(Tok, diag::err_expected_rparen); 1348 SkipUntil(tok::r_paren, false); // don't stop at ';' 1349 return 0; 1350 } 1351 rparenLoc = ConsumeParen(); 1352 Decl *ImplCatType = Actions.ActOnStartCategoryImplementation( 1353 atLoc, nameId, nameLoc, categoryId, 1354 categoryLoc); 1355 1356 Actions.ActOnObjCContainerStartDefinition(ImplCatType); 1357 ObjCImpDecl = ImplCatType; 1358 PendingObjCImpDecl.push_back(ObjCImpDecl); 1359 return 0; 1360 } 1361 // We have a class implementation 1362 SourceLocation superClassLoc; 1363 IdentifierInfo *superClassId = 0; 1364 if (Tok.is(tok::colon)) { 1365 // We have a super class 1366 ConsumeToken(); 1367 if (Tok.isNot(tok::identifier)) { 1368 Diag(Tok, diag::err_expected_ident); // missing super class name. 1369 return 0; 1370 } 1371 superClassId = Tok.getIdentifierInfo(); 1372 superClassLoc = ConsumeToken(); // Consume super class name 1373 } 1374 Decl *ImplClsType = Actions.ActOnStartClassImplementation( 1375 atLoc, nameId, nameLoc, 1376 superClassId, superClassLoc); 1377 1378 if (Tok.is(tok::l_brace)) // we have ivars 1379 ParseObjCClassInstanceVariables(ImplClsType, tok::objc_private, atLoc); 1380 1381 Actions.ActOnObjCContainerStartDefinition(ImplClsType); 1382 ObjCImpDecl = ImplClsType; 1383 PendingObjCImpDecl.push_back(ObjCImpDecl); 1384 return 0; 1385 } 1386 1387 Decl *Parser::ParseObjCAtEndDeclaration(SourceRange atEnd) { 1388 assert(Tok.isObjCAtKeyword(tok::objc_end) && 1389 "ParseObjCAtEndDeclaration(): Expected @end"); 1390 Decl *Result = ObjCImpDecl; 1391 ConsumeToken(); // the "end" identifier 1392 if (ObjCImpDecl) { 1393 Actions.ActOnAtEnd(getCurScope(), atEnd); 1394 Actions.ActOnObjCContainerFinishDefinition(ObjCImpDecl); 1395 ObjCImpDecl = 0; 1396 PendingObjCImpDecl.pop_back(); 1397 } 1398 else { 1399 // missing @implementation 1400 Diag(atEnd.getBegin(), diag::err_expected_implementation); 1401 } 1402 return Result; 1403 } 1404 1405 Parser::DeclGroupPtrTy Parser::FinishPendingObjCActions() { 1406 Actions.DiagnoseUseOfUnimplementedSelectors(); 1407 if (PendingObjCImpDecl.empty()) 1408 return Actions.ConvertDeclToDeclGroup(0); 1409 Decl *ImpDecl = PendingObjCImpDecl.pop_back_val(); 1410 Actions.ActOnAtEnd(getCurScope(), SourceRange()); 1411 Actions.ActOnObjCContainerFinishDefinition(ImpDecl); 1412 return Actions.ConvertDeclToDeclGroup(ImpDecl); 1413 } 1414 1415 /// compatibility-alias-decl: 1416 /// @compatibility_alias alias-name class-name ';' 1417 /// 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); 1424 return 0; 1425 } 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); 1430 return 0; 1431 } 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, 1437 classId, classLoc); 1438 } 1439 1440 /// property-synthesis: 1441 /// @synthesize property-ivar-list ';' 1442 /// 1443 /// property-ivar-list: 1444 /// property-ivar 1445 /// property-ivar-list ',' property-ivar 1446 /// 1447 /// property-ivar: 1448 /// identifier 1449 /// identifier '=' identifier 1450 /// 1451 Decl *Parser::ParseObjCPropertySynthesize(SourceLocation atLoc) { 1452 assert(Tok.isObjCAtKeyword(tok::objc_synthesize) && 1453 "ParseObjCPropertyDynamic(): Expected '@synthesize'"); 1454 ConsumeToken(); // consume synthesize 1455 1456 while (true) { 1457 if (Tok.is(tok::code_completion)) { 1458 Actions.CodeCompleteObjCPropertyDefinition(getCurScope()); 1459 ConsumeCodeCompletionToken(); 1460 } 1461 1462 if (Tok.isNot(tok::identifier)) { 1463 Diag(Tok, diag::err_synthesized_property_name); 1464 SkipUntil(tok::semi); 1465 return 0; 1466 } 1467 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 '=' 1475 1476 if (Tok.is(tok::code_completion)) { 1477 Actions.CodeCompleteObjCPropertySynthesizeIvar(getCurScope(), propertyId); 1478 ConsumeCodeCompletionToken(); 1479 } 1480 1481 if (Tok.isNot(tok::identifier)) { 1482 Diag(Tok, diag::err_expected_ident); 1483 break; 1484 } 1485 propertyIvar = Tok.getIdentifierInfo(); 1486 propertyIvarLoc = ConsumeToken(); // consume ivar-name 1487 } 1488 Actions.ActOnPropertyImplDecl(getCurScope(), atLoc, propertyLoc, true, 1489 propertyId, propertyIvar, propertyIvarLoc); 1490 if (Tok.isNot(tok::comma)) 1491 break; 1492 ConsumeToken(); // consume ',' 1493 } 1494 ExpectAndConsume(tok::semi, diag::err_expected_semi_after, "@synthesize"); 1495 return 0; 1496 } 1497 1498 /// property-dynamic: 1499 /// @dynamic property-list 1500 /// 1501 /// property-list: 1502 /// identifier 1503 /// property-list ',' identifier 1504 /// 1505 Decl *Parser::ParseObjCPropertyDynamic(SourceLocation atLoc) { 1506 assert(Tok.isObjCAtKeyword(tok::objc_dynamic) && 1507 "ParseObjCPropertyDynamic(): Expected '@dynamic'"); 1508 ConsumeToken(); // consume dynamic 1509 while (true) { 1510 if (Tok.is(tok::code_completion)) { 1511 Actions.CodeCompleteObjCPropertyDefinition(getCurScope()); 1512 ConsumeCodeCompletionToken(); 1513 } 1514 1515 if (Tok.isNot(tok::identifier)) { 1516 Diag(Tok, diag::err_expected_ident); 1517 SkipUntil(tok::semi); 1518 return 0; 1519 } 1520 1521 IdentifierInfo *propertyId = Tok.getIdentifierInfo(); 1522 SourceLocation propertyLoc = ConsumeToken(); // consume property name 1523 Actions.ActOnPropertyImplDecl(getCurScope(), atLoc, propertyLoc, false, 1524 propertyId, 0, SourceLocation()); 1525 1526 if (Tok.isNot(tok::comma)) 1527 break; 1528 ConsumeToken(); // consume ',' 1529 } 1530 ExpectAndConsume(tok::semi, diag::err_expected_semi_after, "@dynamic"); 1531 return 0; 1532 } 1533 1534 /// objc-throw-statement: 1535 /// throw expression[opt]; 1536 /// 1537 StmtResult Parser::ParseObjCThrowStmt(SourceLocation atLoc) { 1538 ExprResult Res; 1539 ConsumeToken(); // consume throw 1540 if (Tok.isNot(tok::semi)) { 1541 Res = ParseExpression(); 1542 if (Res.isInvalid()) { 1543 SkipUntil(tok::semi); 1544 return StmtError(); 1545 } 1546 } 1547 // consume ';' 1548 ExpectAndConsume(tok::semi, diag::err_expected_semi_after, "@throw"); 1549 return Actions.ActOnObjCAtThrowStmt(atLoc, Res.take(), getCurScope()); 1550 } 1551 1552 /// objc-synchronized-statement: 1553 /// @synchronized '(' expression ')' compound-statement 1554 /// 1555 StmtResult 1556 Parser::ParseObjCSynchronizedStmt(SourceLocation atLoc) { 1557 ConsumeToken(); // consume synchronized 1558 if (Tok.isNot(tok::l_paren)) { 1559 Diag(Tok, diag::err_expected_lparen_after) << "@synchronized"; 1560 return StmtError(); 1561 } 1562 1563 // The operand is surrounded with parentheses. 1564 ConsumeParen(); // '(' 1565 ExprResult operand(ParseExpression()); 1566 1567 if (Tok.is(tok::r_paren)) { 1568 ConsumeParen(); // ')' 1569 } else { 1570 if (!operand.isInvalid()) 1571 Diag(Tok, diag::err_expected_rparen); 1572 1573 // Skip forward until we see a left brace, but don't consume it. 1574 SkipUntil(tok::l_brace, true, true); 1575 } 1576 1577 // Require a compound statement. 1578 if (Tok.isNot(tok::l_brace)) { 1579 if (!operand.isInvalid()) 1580 Diag(Tok, diag::err_expected_lbrace); 1581 return StmtError(); 1582 } 1583 1584 // Check the @synchronized operand now. 1585 if (!operand.isInvalid()) 1586 operand = Actions.ActOnObjCAtSynchronizedOperand(atLoc, operand.take()); 1587 1588 // Parse the compound statement within a new scope. 1589 ParseScope bodyScope(this, Scope::DeclScope); 1590 StmtResult body(ParseCompoundStatementBody()); 1591 bodyScope.Exit(); 1592 1593 // If there was a semantic or parse error earlier with the 1594 // operand, fail now. 1595 if (operand.isInvalid()) 1596 return StmtError(); 1597 1598 if (body.isInvalid()) 1599 body = Actions.ActOnNullStmt(Tok.getLocation()); 1600 1601 return Actions.ActOnObjCAtSynchronizedStmt(atLoc, operand.get(), body.get()); 1602 } 1603 1604 /// objc-try-catch-statement: 1605 /// @try compound-statement objc-catch-list[opt] 1606 /// @try compound-statement objc-catch-list[opt] @finally compound-statement 1607 /// 1608 /// objc-catch-list: 1609 /// @catch ( parameter-declaration ) compound-statement 1610 /// objc-catch-list @catch ( catch-parameter-declaration ) compound-statement 1611 /// catch-parameter-declaration: 1612 /// parameter-declaration 1613 /// '...' [OBJC2] 1614 /// 1615 StmtResult Parser::ParseObjCTryStmt(SourceLocation atLoc) { 1616 bool catch_or_finally_seen = false; 1617 1618 ConsumeToken(); // consume try 1619 if (Tok.isNot(tok::l_brace)) { 1620 Diag(Tok, diag::err_expected_lbrace); 1621 return StmtError(); 1622 } 1623 StmtVector CatchStmts(Actions); 1624 StmtResult FinallyStmt; 1625 ParseScope TryScope(this, Scope::DeclScope); 1626 StmtResult TryBody(ParseCompoundStatementBody()); 1627 TryScope.Exit(); 1628 if (TryBody.isInvalid()) 1629 TryBody = Actions.ActOnNullStmt(Tok.getLocation()); 1630 1631 while (Tok.is(tok::at)) { 1632 // At this point, we need to lookahead to determine if this @ is the start 1633 // of an @catch or @finally. We don't want to consume the @ token if this 1634 // is an @try or @encode or something else. 1635 Token AfterAt = GetLookAheadToken(1); 1636 if (!AfterAt.isObjCAtKeyword(tok::objc_catch) && 1637 !AfterAt.isObjCAtKeyword(tok::objc_finally)) 1638 break; 1639 1640 SourceLocation AtCatchFinallyLoc = ConsumeToken(); 1641 if (Tok.isObjCAtKeyword(tok::objc_catch)) { 1642 Decl *FirstPart = 0; 1643 ConsumeToken(); // consume catch 1644 if (Tok.is(tok::l_paren)) { 1645 ConsumeParen(); 1646 ParseScope CatchScope(this, Scope::DeclScope|Scope::AtCatchScope); 1647 if (Tok.isNot(tok::ellipsis)) { 1648 DeclSpec DS(AttrFactory); 1649 ParseDeclarationSpecifiers(DS); 1650 Declarator ParmDecl(DS, Declarator::ObjCCatchContext); 1651 ParseDeclarator(ParmDecl); 1652 1653 // Inform the actions module about the declarator, so it 1654 // gets added to the current scope. 1655 FirstPart = Actions.ActOnObjCExceptionDecl(getCurScope(), ParmDecl); 1656 } else 1657 ConsumeToken(); // consume '...' 1658 1659 SourceLocation RParenLoc; 1660 1661 if (Tok.is(tok::r_paren)) 1662 RParenLoc = ConsumeParen(); 1663 else // Skip over garbage, until we get to ')'. Eat the ')'. 1664 SkipUntil(tok::r_paren, true, false); 1665 1666 StmtResult CatchBody(true); 1667 if (Tok.is(tok::l_brace)) 1668 CatchBody = ParseCompoundStatementBody(); 1669 else 1670 Diag(Tok, diag::err_expected_lbrace); 1671 if (CatchBody.isInvalid()) 1672 CatchBody = Actions.ActOnNullStmt(Tok.getLocation()); 1673 1674 StmtResult Catch = Actions.ActOnObjCAtCatchStmt(AtCatchFinallyLoc, 1675 RParenLoc, 1676 FirstPart, 1677 CatchBody.take()); 1678 if (!Catch.isInvalid()) 1679 CatchStmts.push_back(Catch.release()); 1680 1681 } else { 1682 Diag(AtCatchFinallyLoc, diag::err_expected_lparen_after) 1683 << "@catch clause"; 1684 return StmtError(); 1685 } 1686 catch_or_finally_seen = true; 1687 } else { 1688 assert(Tok.isObjCAtKeyword(tok::objc_finally) && "Lookahead confused?"); 1689 ConsumeToken(); // consume finally 1690 ParseScope FinallyScope(this, Scope::DeclScope); 1691 1692 StmtResult FinallyBody(true); 1693 if (Tok.is(tok::l_brace)) 1694 FinallyBody = ParseCompoundStatementBody(); 1695 else 1696 Diag(Tok, diag::err_expected_lbrace); 1697 if (FinallyBody.isInvalid()) 1698 FinallyBody = Actions.ActOnNullStmt(Tok.getLocation()); 1699 FinallyStmt = Actions.ActOnObjCAtFinallyStmt(AtCatchFinallyLoc, 1700 FinallyBody.take()); 1701 catch_or_finally_seen = true; 1702 break; 1703 } 1704 } 1705 if (!catch_or_finally_seen) { 1706 Diag(atLoc, diag::err_missing_catch_finally); 1707 return StmtError(); 1708 } 1709 1710 return Actions.ActOnObjCAtTryStmt(atLoc, TryBody.take(), 1711 move_arg(CatchStmts), 1712 FinallyStmt.take()); 1713 } 1714 1715 /// objc-autoreleasepool-statement: 1716 /// @autoreleasepool compound-statement 1717 /// 1718 StmtResult 1719 Parser::ParseObjCAutoreleasePoolStmt(SourceLocation atLoc) { 1720 ConsumeToken(); // consume autoreleasepool 1721 if (Tok.isNot(tok::l_brace)) { 1722 Diag(Tok, diag::err_expected_lbrace); 1723 return StmtError(); 1724 } 1725 // Enter a scope to hold everything within the compound stmt. Compound 1726 // statements can always hold declarations. 1727 ParseScope BodyScope(this, Scope::DeclScope); 1728 1729 StmtResult AutoreleasePoolBody(ParseCompoundStatementBody()); 1730 1731 BodyScope.Exit(); 1732 if (AutoreleasePoolBody.isInvalid()) 1733 AutoreleasePoolBody = Actions.ActOnNullStmt(Tok.getLocation()); 1734 return Actions.ActOnObjCAutoreleasePoolStmt(atLoc, 1735 AutoreleasePoolBody.take()); 1736 } 1737 1738 /// objc-method-def: objc-method-proto ';'[opt] '{' body '}' 1739 /// 1740 Decl *Parser::ParseObjCMethodDefinition() { 1741 Decl *MDecl = ParseObjCMethodPrototype(); 1742 1743 PrettyDeclStackTraceEntry CrashInfo(Actions, MDecl, Tok.getLocation(), 1744 "parsing Objective-C method"); 1745 1746 // parse optional ';' 1747 if (Tok.is(tok::semi)) { 1748 if (ObjCImpDecl) { 1749 Diag(Tok, diag::warn_semicolon_before_method_body) 1750 << FixItHint::CreateRemoval(Tok.getLocation()); 1751 } 1752 ConsumeToken(); 1753 } 1754 1755 // We should have an opening brace now. 1756 if (Tok.isNot(tok::l_brace)) { 1757 Diag(Tok, diag::err_expected_method_body); 1758 1759 // Skip over garbage, until we get to '{'. Don't eat the '{'. 1760 SkipUntil(tok::l_brace, true, true); 1761 1762 // If we didn't find the '{', bail out. 1763 if (Tok.isNot(tok::l_brace)) 1764 return 0; 1765 } 1766 SourceLocation BraceLoc = Tok.getLocation(); 1767 1768 // Enter a scope for the method body. 1769 ParseScope BodyScope(this, 1770 Scope::ObjCMethodScope|Scope::FnScope|Scope::DeclScope); 1771 1772 // Tell the actions module that we have entered a method definition with the 1773 // specified Declarator for the method. 1774 Actions.ActOnStartOfObjCMethodDef(getCurScope(), MDecl); 1775 1776 if (PP.isCodeCompletionEnabled()) { 1777 if (trySkippingFunctionBodyForCodeCompletion()) { 1778 BodyScope.Exit(); 1779 return Actions.ActOnFinishFunctionBody(MDecl, 0); 1780 } 1781 } 1782 1783 StmtResult FnBody(ParseCompoundStatementBody()); 1784 1785 // If the function body could not be parsed, make a bogus compoundstmt. 1786 if (FnBody.isInvalid()) 1787 FnBody = Actions.ActOnCompoundStmt(BraceLoc, BraceLoc, 1788 MultiStmtArg(Actions), false); 1789 1790 // Leave the function body scope. 1791 BodyScope.Exit(); 1792 1793 // TODO: Pass argument information. 1794 Actions.ActOnFinishFunctionBody(MDecl, FnBody.take()); 1795 return MDecl; 1796 } 1797 1798 StmtResult Parser::ParseObjCAtStatement(SourceLocation AtLoc) { 1799 if (Tok.is(tok::code_completion)) { 1800 Actions.CodeCompleteObjCAtStatement(getCurScope()); 1801 ConsumeCodeCompletionToken(); 1802 return StmtError(); 1803 } 1804 1805 if (Tok.isObjCAtKeyword(tok::objc_try)) 1806 return ParseObjCTryStmt(AtLoc); 1807 1808 if (Tok.isObjCAtKeyword(tok::objc_throw)) 1809 return ParseObjCThrowStmt(AtLoc); 1810 1811 if (Tok.isObjCAtKeyword(tok::objc_synchronized)) 1812 return ParseObjCSynchronizedStmt(AtLoc); 1813 1814 if (Tok.isObjCAtKeyword(tok::objc_autoreleasepool)) 1815 return ParseObjCAutoreleasePoolStmt(AtLoc); 1816 1817 ExprResult Res(ParseExpressionWithLeadingAt(AtLoc)); 1818 if (Res.isInvalid()) { 1819 // If the expression is invalid, skip ahead to the next semicolon. Not 1820 // doing this opens us up to the possibility of infinite loops if 1821 // ParseExpression does not consume any tokens. 1822 SkipUntil(tok::semi); 1823 return StmtError(); 1824 } 1825 1826 // Otherwise, eat the semicolon. 1827 ExpectAndConsumeSemi(diag::err_expected_semi_after_expr); 1828 return Actions.ActOnExprStmt(Actions.MakeFullExpr(Res.take())); 1829 } 1830 1831 ExprResult Parser::ParseObjCAtExpression(SourceLocation AtLoc) { 1832 switch (Tok.getKind()) { 1833 case tok::code_completion: 1834 Actions.CodeCompleteObjCAtExpression(getCurScope()); 1835 ConsumeCodeCompletionToken(); 1836 return ExprError(); 1837 1838 case tok::string_literal: // primary-expression: string-literal 1839 case tok::wide_string_literal: 1840 return ParsePostfixExpressionSuffix(ParseObjCStringLiteral(AtLoc)); 1841 default: 1842 if (Tok.getIdentifierInfo() == 0) 1843 return ExprError(Diag(AtLoc, diag::err_unexpected_at)); 1844 1845 switch (Tok.getIdentifierInfo()->getObjCKeywordID()) { 1846 case tok::objc_encode: 1847 return ParsePostfixExpressionSuffix(ParseObjCEncodeExpression(AtLoc)); 1848 case tok::objc_protocol: 1849 return ParsePostfixExpressionSuffix(ParseObjCProtocolExpression(AtLoc)); 1850 case tok::objc_selector: 1851 return ParsePostfixExpressionSuffix(ParseObjCSelectorExpression(AtLoc)); 1852 default: 1853 return ExprError(Diag(AtLoc, diag::err_unexpected_at)); 1854 } 1855 } 1856 } 1857 1858 /// \brirg Parse the receiver of an Objective-C++ message send. 1859 /// 1860 /// This routine parses the receiver of a message send in 1861 /// Objective-C++ either as a type or as an expression. Note that this 1862 /// routine must not be called to parse a send to 'super', since it 1863 /// has no way to return such a result. 1864 /// 1865 /// \param IsExpr Whether the receiver was parsed as an expression. 1866 /// 1867 /// \param TypeOrExpr If the receiver was parsed as an expression (\c 1868 /// IsExpr is true), the parsed expression. If the receiver was parsed 1869 /// as a type (\c IsExpr is false), the parsed type. 1870 /// 1871 /// \returns True if an error occurred during parsing or semantic 1872 /// analysis, in which case the arguments do not have valid 1873 /// values. Otherwise, returns false for a successful parse. 1874 /// 1875 /// objc-receiver: [C++] 1876 /// 'super' [not parsed here] 1877 /// expression 1878 /// simple-type-specifier 1879 /// typename-specifier 1880 bool Parser::ParseObjCXXMessageReceiver(bool &IsExpr, void *&TypeOrExpr) { 1881 InMessageExpressionRAIIObject InMessage(*this, true); 1882 1883 if (Tok.is(tok::identifier) || Tok.is(tok::coloncolon) || 1884 Tok.is(tok::kw_typename) || Tok.is(tok::annot_cxxscope)) 1885 TryAnnotateTypeOrScopeToken(); 1886 1887 if (!isCXXSimpleTypeSpecifier()) { 1888 // objc-receiver: 1889 // expression 1890 ExprResult Receiver = ParseExpression(); 1891 if (Receiver.isInvalid()) 1892 return true; 1893 1894 IsExpr = true; 1895 TypeOrExpr = Receiver.take(); 1896 return false; 1897 } 1898 1899 // objc-receiver: 1900 // typename-specifier 1901 // simple-type-specifier 1902 // expression (that starts with one of the above) 1903 DeclSpec DS(AttrFactory); 1904 ParseCXXSimpleTypeSpecifier(DS); 1905 1906 if (Tok.is(tok::l_paren)) { 1907 // If we see an opening parentheses at this point, we are 1908 // actually parsing an expression that starts with a 1909 // function-style cast, e.g., 1910 // 1911 // postfix-expression: 1912 // simple-type-specifier ( expression-list [opt] ) 1913 // typename-specifier ( expression-list [opt] ) 1914 // 1915 // Parse the remainder of this case, then the (optional) 1916 // postfix-expression suffix, followed by the (optional) 1917 // right-hand side of the binary expression. We have an 1918 // instance method. 1919 ExprResult Receiver = ParseCXXTypeConstructExpression(DS); 1920 if (!Receiver.isInvalid()) 1921 Receiver = ParsePostfixExpressionSuffix(Receiver.take()); 1922 if (!Receiver.isInvalid()) 1923 Receiver = ParseRHSOfBinaryExpression(Receiver.take(), prec::Comma); 1924 if (Receiver.isInvalid()) 1925 return true; 1926 1927 IsExpr = true; 1928 TypeOrExpr = Receiver.take(); 1929 return false; 1930 } 1931 1932 // We have a class message. Turn the simple-type-specifier or 1933 // typename-specifier we parsed into a type and parse the 1934 // remainder of the class message. 1935 Declarator DeclaratorInfo(DS, Declarator::TypeNameContext); 1936 TypeResult Type = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo); 1937 if (Type.isInvalid()) 1938 return true; 1939 1940 IsExpr = false; 1941 TypeOrExpr = Type.get().getAsOpaquePtr(); 1942 return false; 1943 } 1944 1945 /// \brief Determine whether the parser is currently referring to a an 1946 /// Objective-C message send, using a simplified heuristic to avoid overhead. 1947 /// 1948 /// This routine will only return true for a subset of valid message-send 1949 /// expressions. 1950 bool Parser::isSimpleObjCMessageExpression() { 1951 assert(Tok.is(tok::l_square) && getLang().ObjC1 && 1952 "Incorrect start for isSimpleObjCMessageExpression"); 1953 return GetLookAheadToken(1).is(tok::identifier) && 1954 GetLookAheadToken(2).is(tok::identifier); 1955 } 1956 1957 bool Parser::isStartOfObjCClassMessageMissingOpenBracket() { 1958 if (!getLang().ObjC1 || !NextToken().is(tok::identifier) || 1959 InMessageExpression) 1960 return false; 1961 1962 1963 ParsedType Type; 1964 1965 if (Tok.is(tok::annot_typename)) 1966 Type = getTypeAnnotation(Tok); 1967 else if (Tok.is(tok::identifier)) 1968 Type = Actions.getTypeName(*Tok.getIdentifierInfo(), Tok.getLocation(), 1969 getCurScope()); 1970 else 1971 return false; 1972 1973 if (!Type.get().isNull() && Type.get()->isObjCObjectOrInterfaceType()) { 1974 const Token &AfterNext = GetLookAheadToken(2); 1975 if (AfterNext.is(tok::colon) || AfterNext.is(tok::r_square)) { 1976 if (Tok.is(tok::identifier)) 1977 TryAnnotateTypeOrScopeToken(); 1978 1979 return Tok.is(tok::annot_typename); 1980 } 1981 } 1982 1983 return false; 1984 } 1985 1986 /// objc-message-expr: 1987 /// '[' objc-receiver objc-message-args ']' 1988 /// 1989 /// objc-receiver: [C] 1990 /// 'super' 1991 /// expression 1992 /// class-name 1993 /// type-name 1994 /// 1995 ExprResult Parser::ParseObjCMessageExpression() { 1996 assert(Tok.is(tok::l_square) && "'[' expected"); 1997 SourceLocation LBracLoc = ConsumeBracket(); // consume '[' 1998 1999 if (Tok.is(tok::code_completion)) { 2000 Actions.CodeCompleteObjCMessageReceiver(getCurScope()); 2001 ConsumeCodeCompletionToken(); 2002 SkipUntil(tok::r_square); 2003 return ExprError(); 2004 } 2005 2006 InMessageExpressionRAIIObject InMessage(*this, true); 2007 2008 if (getLang().CPlusPlus) { 2009 // We completely separate the C and C++ cases because C++ requires 2010 // more complicated (read: slower) parsing. 2011 2012 // Handle send to super. 2013 // FIXME: This doesn't benefit from the same typo-correction we 2014 // get in Objective-C. 2015 if (Tok.is(tok::identifier) && Tok.getIdentifierInfo() == Ident_super && 2016 NextToken().isNot(tok::period) && getCurScope()->isInObjcMethodScope()) 2017 return ParseObjCMessageExpressionBody(LBracLoc, ConsumeToken(), 2018 ParsedType(), 0); 2019 2020 // Parse the receiver, which is either a type or an expression. 2021 bool IsExpr; 2022 void *TypeOrExpr = NULL; 2023 if (ParseObjCXXMessageReceiver(IsExpr, TypeOrExpr)) { 2024 SkipUntil(tok::r_square); 2025 return ExprError(); 2026 } 2027 2028 if (IsExpr) 2029 return ParseObjCMessageExpressionBody(LBracLoc, SourceLocation(), 2030 ParsedType(), 2031 static_cast<Expr*>(TypeOrExpr)); 2032 2033 return ParseObjCMessageExpressionBody(LBracLoc, SourceLocation(), 2034 ParsedType::getFromOpaquePtr(TypeOrExpr), 2035 0); 2036 } 2037 2038 if (Tok.is(tok::identifier)) { 2039 IdentifierInfo *Name = Tok.getIdentifierInfo(); 2040 SourceLocation NameLoc = Tok.getLocation(); 2041 ParsedType ReceiverType; 2042 switch (Actions.getObjCMessageKind(getCurScope(), Name, NameLoc, 2043 Name == Ident_super, 2044 NextToken().is(tok::period), 2045 ReceiverType)) { 2046 case Sema::ObjCSuperMessage: 2047 return ParseObjCMessageExpressionBody(LBracLoc, ConsumeToken(), 2048 ParsedType(), 0); 2049 2050 case Sema::ObjCClassMessage: 2051 if (!ReceiverType) { 2052 SkipUntil(tok::r_square); 2053 return ExprError(); 2054 } 2055 2056 ConsumeToken(); // the type name 2057 2058 return ParseObjCMessageExpressionBody(LBracLoc, SourceLocation(), 2059 ReceiverType, 0); 2060 2061 case Sema::ObjCInstanceMessage: 2062 // Fall through to parse an expression. 2063 break; 2064 } 2065 } 2066 2067 // Otherwise, an arbitrary expression can be the receiver of a send. 2068 ExprResult Res(ParseExpression()); 2069 if (Res.isInvalid()) { 2070 SkipUntil(tok::r_square); 2071 return move(Res); 2072 } 2073 2074 return ParseObjCMessageExpressionBody(LBracLoc, SourceLocation(), 2075 ParsedType(), Res.take()); 2076 } 2077 2078 /// \brief Parse the remainder of an Objective-C message following the 2079 /// '[' objc-receiver. 2080 /// 2081 /// This routine handles sends to super, class messages (sent to a 2082 /// class name), and instance messages (sent to an object), and the 2083 /// target is represented by \p SuperLoc, \p ReceiverType, or \p 2084 /// ReceiverExpr, respectively. Only one of these parameters may have 2085 /// a valid value. 2086 /// 2087 /// \param LBracLoc The location of the opening '['. 2088 /// 2089 /// \param SuperLoc If this is a send to 'super', the location of the 2090 /// 'super' keyword that indicates a send to the superclass. 2091 /// 2092 /// \param ReceiverType If this is a class message, the type of the 2093 /// class we are sending a message to. 2094 /// 2095 /// \param ReceiverExpr If this is an instance message, the expression 2096 /// used to compute the receiver object. 2097 /// 2098 /// objc-message-args: 2099 /// objc-selector 2100 /// objc-keywordarg-list 2101 /// 2102 /// objc-keywordarg-list: 2103 /// objc-keywordarg 2104 /// objc-keywordarg-list objc-keywordarg 2105 /// 2106 /// objc-keywordarg: 2107 /// selector-name[opt] ':' objc-keywordexpr 2108 /// 2109 /// objc-keywordexpr: 2110 /// nonempty-expr-list 2111 /// 2112 /// nonempty-expr-list: 2113 /// assignment-expression 2114 /// nonempty-expr-list , assignment-expression 2115 /// 2116 ExprResult 2117 Parser::ParseObjCMessageExpressionBody(SourceLocation LBracLoc, 2118 SourceLocation SuperLoc, 2119 ParsedType ReceiverType, 2120 ExprArg ReceiverExpr) { 2121 InMessageExpressionRAIIObject InMessage(*this, true); 2122 2123 if (Tok.is(tok::code_completion)) { 2124 if (SuperLoc.isValid()) 2125 Actions.CodeCompleteObjCSuperMessage(getCurScope(), SuperLoc, 0, 0, 2126 false); 2127 else if (ReceiverType) 2128 Actions.CodeCompleteObjCClassMessage(getCurScope(), ReceiverType, 0, 0, 2129 false); 2130 else 2131 Actions.CodeCompleteObjCInstanceMessage(getCurScope(), ReceiverExpr, 2132 0, 0, false); 2133 ConsumeCodeCompletionToken(); 2134 } 2135 2136 // Parse objc-selector 2137 SourceLocation Loc; 2138 IdentifierInfo *selIdent = ParseObjCSelectorPiece(Loc); 2139 2140 SourceLocation SelectorLoc = Loc; 2141 2142 SmallVector<IdentifierInfo *, 12> KeyIdents; 2143 ExprVector KeyExprs(Actions); 2144 2145 if (Tok.is(tok::colon)) { 2146 while (1) { 2147 // Each iteration parses a single keyword argument. 2148 KeyIdents.push_back(selIdent); 2149 2150 if (Tok.isNot(tok::colon)) { 2151 Diag(Tok, diag::err_expected_colon); 2152 // We must manually skip to a ']', otherwise the expression skipper will 2153 // stop at the ']' when it skips to the ';'. We want it to skip beyond 2154 // the enclosing expression. 2155 SkipUntil(tok::r_square); 2156 return ExprError(); 2157 } 2158 2159 ConsumeToken(); // Eat the ':'. 2160 /// Parse the expression after ':' 2161 2162 if (Tok.is(tok::code_completion)) { 2163 if (SuperLoc.isValid()) 2164 Actions.CodeCompleteObjCSuperMessage(getCurScope(), SuperLoc, 2165 KeyIdents.data(), 2166 KeyIdents.size(), 2167 /*AtArgumentEpression=*/true); 2168 else if (ReceiverType) 2169 Actions.CodeCompleteObjCClassMessage(getCurScope(), ReceiverType, 2170 KeyIdents.data(), 2171 KeyIdents.size(), 2172 /*AtArgumentEpression=*/true); 2173 else 2174 Actions.CodeCompleteObjCInstanceMessage(getCurScope(), ReceiverExpr, 2175 KeyIdents.data(), 2176 KeyIdents.size(), 2177 /*AtArgumentEpression=*/true); 2178 2179 ConsumeCodeCompletionToken(); 2180 SkipUntil(tok::r_square); 2181 return ExprError(); 2182 } 2183 2184 ExprResult Res(ParseAssignmentExpression()); 2185 if (Res.isInvalid()) { 2186 // We must manually skip to a ']', otherwise the expression skipper will 2187 // stop at the ']' when it skips to the ';'. We want it to skip beyond 2188 // the enclosing expression. 2189 SkipUntil(tok::r_square); 2190 return move(Res); 2191 } 2192 2193 // We have a valid expression. 2194 KeyExprs.push_back(Res.release()); 2195 2196 // Code completion after each argument. 2197 if (Tok.is(tok::code_completion)) { 2198 if (SuperLoc.isValid()) 2199 Actions.CodeCompleteObjCSuperMessage(getCurScope(), SuperLoc, 2200 KeyIdents.data(), 2201 KeyIdents.size(), 2202 /*AtArgumentEpression=*/false); 2203 else if (ReceiverType) 2204 Actions.CodeCompleteObjCClassMessage(getCurScope(), ReceiverType, 2205 KeyIdents.data(), 2206 KeyIdents.size(), 2207 /*AtArgumentEpression=*/false); 2208 else 2209 Actions.CodeCompleteObjCInstanceMessage(getCurScope(), ReceiverExpr, 2210 KeyIdents.data(), 2211 KeyIdents.size(), 2212 /*AtArgumentEpression=*/false); 2213 ConsumeCodeCompletionToken(); 2214 SkipUntil(tok::r_square); 2215 return ExprError(); 2216 } 2217 2218 // Check for another keyword selector. 2219 selIdent = ParseObjCSelectorPiece(Loc); 2220 if (!selIdent && Tok.isNot(tok::colon)) 2221 break; 2222 // We have a selector or a colon, continue parsing. 2223 } 2224 // Parse the, optional, argument list, comma separated. 2225 while (Tok.is(tok::comma)) { 2226 ConsumeToken(); // Eat the ','. 2227 /// Parse the expression after ',' 2228 ExprResult Res(ParseAssignmentExpression()); 2229 if (Res.isInvalid()) { 2230 // We must manually skip to a ']', otherwise the expression skipper will 2231 // stop at the ']' when it skips to the ';'. We want it to skip beyond 2232 // the enclosing expression. 2233 SkipUntil(tok::r_square); 2234 return move(Res); 2235 } 2236 2237 // We have a valid expression. 2238 KeyExprs.push_back(Res.release()); 2239 } 2240 } else if (!selIdent) { 2241 Diag(Tok, diag::err_expected_ident); // missing selector name. 2242 2243 // We must manually skip to a ']', otherwise the expression skipper will 2244 // stop at the ']' when it skips to the ';'. We want it to skip beyond 2245 // the enclosing expression. 2246 SkipUntil(tok::r_square); 2247 return ExprError(); 2248 } 2249 2250 if (Tok.isNot(tok::r_square)) { 2251 if (Tok.is(tok::identifier)) 2252 Diag(Tok, diag::err_expected_colon); 2253 else 2254 Diag(Tok, diag::err_expected_rsquare); 2255 // We must manually skip to a ']', otherwise the expression skipper will 2256 // stop at the ']' when it skips to the ';'. We want it to skip beyond 2257 // the enclosing expression. 2258 SkipUntil(tok::r_square); 2259 return ExprError(); 2260 } 2261 2262 SourceLocation RBracLoc = ConsumeBracket(); // consume ']' 2263 2264 unsigned nKeys = KeyIdents.size(); 2265 if (nKeys == 0) 2266 KeyIdents.push_back(selIdent); 2267 Selector Sel = PP.getSelectorTable().getSelector(nKeys, &KeyIdents[0]); 2268 2269 if (SuperLoc.isValid()) 2270 return Actions.ActOnSuperMessage(getCurScope(), SuperLoc, Sel, 2271 LBracLoc, SelectorLoc, RBracLoc, 2272 MultiExprArg(Actions, 2273 KeyExprs.take(), 2274 KeyExprs.size())); 2275 else if (ReceiverType) 2276 return Actions.ActOnClassMessage(getCurScope(), ReceiverType, Sel, 2277 LBracLoc, SelectorLoc, RBracLoc, 2278 MultiExprArg(Actions, 2279 KeyExprs.take(), 2280 KeyExprs.size())); 2281 return Actions.ActOnInstanceMessage(getCurScope(), ReceiverExpr, Sel, 2282 LBracLoc, SelectorLoc, RBracLoc, 2283 MultiExprArg(Actions, 2284 KeyExprs.take(), 2285 KeyExprs.size())); 2286 } 2287 2288 ExprResult Parser::ParseObjCStringLiteral(SourceLocation AtLoc) { 2289 ExprResult Res(ParseStringLiteralExpression()); 2290 if (Res.isInvalid()) return move(Res); 2291 2292 // @"foo" @"bar" is a valid concatenated string. Eat any subsequent string 2293 // expressions. At this point, we know that the only valid thing that starts 2294 // with '@' is an @"". 2295 SmallVector<SourceLocation, 4> AtLocs; 2296 ExprVector AtStrings(Actions); 2297 AtLocs.push_back(AtLoc); 2298 AtStrings.push_back(Res.release()); 2299 2300 while (Tok.is(tok::at)) { 2301 AtLocs.push_back(ConsumeToken()); // eat the @. 2302 2303 // Invalid unless there is a string literal. 2304 if (!isTokenStringLiteral()) 2305 return ExprError(Diag(Tok, diag::err_objc_concat_string)); 2306 2307 ExprResult Lit(ParseStringLiteralExpression()); 2308 if (Lit.isInvalid()) 2309 return move(Lit); 2310 2311 AtStrings.push_back(Lit.release()); 2312 } 2313 2314 return Owned(Actions.ParseObjCStringLiteral(&AtLocs[0], AtStrings.take(), 2315 AtStrings.size())); 2316 } 2317 2318 /// objc-encode-expression: 2319 /// @encode ( type-name ) 2320 ExprResult 2321 Parser::ParseObjCEncodeExpression(SourceLocation AtLoc) { 2322 assert(Tok.isObjCAtKeyword(tok::objc_encode) && "Not an @encode expression!"); 2323 2324 SourceLocation EncLoc = ConsumeToken(); 2325 2326 if (Tok.isNot(tok::l_paren)) 2327 return ExprError(Diag(Tok, diag::err_expected_lparen_after) << "@encode"); 2328 2329 SourceLocation LParenLoc = ConsumeParen(); 2330 2331 TypeResult Ty = ParseTypeName(); 2332 2333 SourceLocation RParenLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc); 2334 2335 if (Ty.isInvalid()) 2336 return ExprError(); 2337 2338 return Owned(Actions.ParseObjCEncodeExpression(AtLoc, EncLoc, LParenLoc, 2339 Ty.get(), RParenLoc)); 2340 } 2341 2342 /// objc-protocol-expression 2343 /// @protocol ( protocol-name ) 2344 ExprResult 2345 Parser::ParseObjCProtocolExpression(SourceLocation AtLoc) { 2346 SourceLocation ProtoLoc = ConsumeToken(); 2347 2348 if (Tok.isNot(tok::l_paren)) 2349 return ExprError(Diag(Tok, diag::err_expected_lparen_after) << "@protocol"); 2350 2351 SourceLocation LParenLoc = ConsumeParen(); 2352 2353 if (Tok.isNot(tok::identifier)) 2354 return ExprError(Diag(Tok, diag::err_expected_ident)); 2355 2356 IdentifierInfo *protocolId = Tok.getIdentifierInfo(); 2357 ConsumeToken(); 2358 2359 SourceLocation RParenLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc); 2360 2361 return Owned(Actions.ParseObjCProtocolExpression(protocolId, AtLoc, ProtoLoc, 2362 LParenLoc, RParenLoc)); 2363 } 2364 2365 /// objc-selector-expression 2366 /// @selector '(' objc-keyword-selector ')' 2367 ExprResult Parser::ParseObjCSelectorExpression(SourceLocation AtLoc) { 2368 SourceLocation SelectorLoc = ConsumeToken(); 2369 2370 if (Tok.isNot(tok::l_paren)) 2371 return ExprError(Diag(Tok, diag::err_expected_lparen_after) << "@selector"); 2372 2373 SmallVector<IdentifierInfo *, 12> KeyIdents; 2374 SourceLocation LParenLoc = ConsumeParen(); 2375 SourceLocation sLoc; 2376 2377 if (Tok.is(tok::code_completion)) { 2378 Actions.CodeCompleteObjCSelector(getCurScope(), KeyIdents.data(), 2379 KeyIdents.size()); 2380 ConsumeCodeCompletionToken(); 2381 MatchRHSPunctuation(tok::r_paren, LParenLoc); 2382 return ExprError(); 2383 } 2384 2385 IdentifierInfo *SelIdent = ParseObjCSelectorPiece(sLoc); 2386 if (!SelIdent && // missing selector name. 2387 Tok.isNot(tok::colon) && Tok.isNot(tok::coloncolon)) 2388 return ExprError(Diag(Tok, diag::err_expected_ident)); 2389 2390 KeyIdents.push_back(SelIdent); 2391 unsigned nColons = 0; 2392 if (Tok.isNot(tok::r_paren)) { 2393 while (1) { 2394 if (Tok.is(tok::coloncolon)) { // Handle :: in C++. 2395 ++nColons; 2396 KeyIdents.push_back(0); 2397 } else if (Tok.isNot(tok::colon)) 2398 return ExprError(Diag(Tok, diag::err_expected_colon)); 2399 2400 ++nColons; 2401 ConsumeToken(); // Eat the ':' or '::'. 2402 if (Tok.is(tok::r_paren)) 2403 break; 2404 2405 if (Tok.is(tok::code_completion)) { 2406 Actions.CodeCompleteObjCSelector(getCurScope(), KeyIdents.data(), 2407 KeyIdents.size()); 2408 ConsumeCodeCompletionToken(); 2409 MatchRHSPunctuation(tok::r_paren, LParenLoc); 2410 return ExprError(); 2411 } 2412 2413 // Check for another keyword selector. 2414 SourceLocation Loc; 2415 SelIdent = ParseObjCSelectorPiece(Loc); 2416 KeyIdents.push_back(SelIdent); 2417 if (!SelIdent && Tok.isNot(tok::colon) && Tok.isNot(tok::coloncolon)) 2418 break; 2419 } 2420 } 2421 SourceLocation RParenLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc); 2422 Selector Sel = PP.getSelectorTable().getSelector(nColons, &KeyIdents[0]); 2423 return Owned(Actions.ParseObjCSelectorExpression(Sel, AtLoc, SelectorLoc, 2424 LParenLoc, RParenLoc)); 2425 } 2426