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