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