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/Parser.h" 15 #include "RAIIObjectsForParser.h" 16 #include "clang/Basic/CharInfo.h" 17 #include "clang/Parse/ParseDiagnostic.h" 18 #include "clang/Sema/DeclSpec.h" 19 #include "clang/Sema/PrettyDeclStackTrace.h" 20 #include "clang/Sema/Scope.h" 21 #include "llvm/ADT/SmallVector.h" 22 #include "llvm/ADT/StringExtras.h" 23 using namespace clang; 24 25 26 /// ParseObjCAtDirectives - Handle parts of the external-declaration production: 27 /// external-declaration: [C99 6.9] 28 /// [OBJC] objc-class-definition 29 /// [OBJC] objc-class-declaration 30 /// [OBJC] objc-alias-declaration 31 /// [OBJC] objc-protocol-definition 32 /// [OBJC] objc-method-definition 33 /// [OBJC] '@' 'end' 34 Parser::DeclGroupPtrTy Parser::ParseObjCAtDirectives() { 35 SourceLocation AtLoc = ConsumeToken(); // the "@" 36 37 if (Tok.is(tok::code_completion)) { 38 Actions.CodeCompleteObjCAtDirective(getCurScope()); 39 cutOffParsing(); 40 return DeclGroupPtrTy(); 41 } 42 43 Decl *SingleDecl = 0; 44 switch (Tok.getObjCKeywordID()) { 45 case tok::objc_class: 46 return ParseObjCAtClassDeclaration(AtLoc); 47 case tok::objc_interface: { 48 ParsedAttributes attrs(AttrFactory); 49 SingleDecl = ParseObjCAtInterfaceDeclaration(AtLoc, attrs); 50 break; 51 } 52 case tok::objc_protocol: { 53 ParsedAttributes attrs(AttrFactory); 54 return ParseObjCAtProtocolDeclaration(AtLoc, attrs); 55 } 56 case tok::objc_implementation: 57 return ParseObjCAtImplementationDeclaration(AtLoc); 58 case tok::objc_end: 59 return ParseObjCAtEndDeclaration(AtLoc); 60 case tok::objc_compatibility_alias: 61 SingleDecl = ParseObjCAtAliasDeclaration(AtLoc); 62 break; 63 case tok::objc_synthesize: 64 SingleDecl = ParseObjCPropertySynthesize(AtLoc); 65 break; 66 case tok::objc_dynamic: 67 SingleDecl = ParseObjCPropertyDynamic(AtLoc); 68 break; 69 case tok::objc_import: 70 if (getLangOpts().Modules) 71 return ParseModuleImport(AtLoc); 72 73 // Fall through 74 75 default: 76 Diag(AtLoc, diag::err_unexpected_at); 77 SkipUntil(tok::semi); 78 SingleDecl = 0; 79 break; 80 } 81 return Actions.ConvertDeclToDeclGroup(SingleDecl); 82 } 83 84 /// 85 /// objc-class-declaration: 86 /// '@' 'class' identifier-list ';' 87 /// 88 Parser::DeclGroupPtrTy 89 Parser::ParseObjCAtClassDeclaration(SourceLocation atLoc) { 90 ConsumeToken(); // the identifier "class" 91 SmallVector<IdentifierInfo *, 8> ClassNames; 92 SmallVector<SourceLocation, 8> ClassLocs; 93 94 95 while (1) { 96 if (Tok.isNot(tok::identifier)) { 97 Diag(Tok, diag::err_expected_ident); 98 SkipUntil(tok::semi); 99 return Actions.ConvertDeclToDeclGroup(0); 100 } 101 ClassNames.push_back(Tok.getIdentifierInfo()); 102 ClassLocs.push_back(Tok.getLocation()); 103 ConsumeToken(); 104 105 if (Tok.isNot(tok::comma)) 106 break; 107 108 ConsumeToken(); 109 } 110 111 // Consume the ';'. 112 if (ExpectAndConsume(tok::semi, diag::err_expected_semi_after, "@class")) 113 return Actions.ConvertDeclToDeclGroup(0); 114 115 return Actions.ActOnForwardClassDeclaration(atLoc, ClassNames.data(), 116 ClassLocs.data(), 117 ClassNames.size()); 118 } 119 120 void Parser::CheckNestedObjCContexts(SourceLocation AtLoc) 121 { 122 Sema::ObjCContainerKind ock = Actions.getObjCContainerKind(); 123 if (ock == Sema::OCK_None) 124 return; 125 126 Decl *Decl = Actions.getObjCDeclContext(); 127 if (CurParsedObjCImpl) { 128 CurParsedObjCImpl->finish(AtLoc); 129 } else { 130 Actions.ActOnAtEnd(getCurScope(), AtLoc); 131 } 132 Diag(AtLoc, diag::err_objc_missing_end) 133 << FixItHint::CreateInsertion(AtLoc, "@end\n"); 134 if (Decl) 135 Diag(Decl->getLocStart(), diag::note_objc_container_start) 136 << (int) ock; 137 } 138 139 /// 140 /// objc-interface: 141 /// objc-class-interface-attributes[opt] objc-class-interface 142 /// objc-category-interface 143 /// 144 /// objc-class-interface: 145 /// '@' 'interface' identifier objc-superclass[opt] 146 /// objc-protocol-refs[opt] 147 /// objc-class-instance-variables[opt] 148 /// objc-interface-decl-list 149 /// @end 150 /// 151 /// objc-category-interface: 152 /// '@' 'interface' identifier '(' identifier[opt] ')' 153 /// objc-protocol-refs[opt] 154 /// objc-interface-decl-list 155 /// @end 156 /// 157 /// objc-superclass: 158 /// ':' identifier 159 /// 160 /// objc-class-interface-attributes: 161 /// __attribute__((visibility("default"))) 162 /// __attribute__((visibility("hidden"))) 163 /// __attribute__((deprecated)) 164 /// __attribute__((unavailable)) 165 /// __attribute__((objc_exception)) - used by NSException on 64-bit 166 /// __attribute__((objc_root_class)) 167 /// 168 Decl *Parser::ParseObjCAtInterfaceDeclaration(SourceLocation AtLoc, 169 ParsedAttributes &attrs) { 170 assert(Tok.isObjCAtKeyword(tok::objc_interface) && 171 "ParseObjCAtInterfaceDeclaration(): Expected @interface"); 172 CheckNestedObjCContexts(AtLoc); 173 ConsumeToken(); // the "interface" identifier 174 175 // Code completion after '@interface'. 176 if (Tok.is(tok::code_completion)) { 177 Actions.CodeCompleteObjCInterfaceDecl(getCurScope()); 178 cutOffParsing(); 179 return 0; 180 } 181 182 if (Tok.isNot(tok::identifier)) { 183 Diag(Tok, diag::err_expected_ident); // missing class or category name. 184 return 0; 185 } 186 187 // We have a class or category name - consume it. 188 IdentifierInfo *nameId = Tok.getIdentifierInfo(); 189 SourceLocation nameLoc = ConsumeToken(); 190 if (Tok.is(tok::l_paren) && 191 !isKnownToBeTypeSpecifier(GetLookAheadToken(1))) { // we have a category. 192 193 BalancedDelimiterTracker T(*this, tok::l_paren); 194 T.consumeOpen(); 195 196 SourceLocation categoryLoc; 197 IdentifierInfo *categoryId = 0; 198 if (Tok.is(tok::code_completion)) { 199 Actions.CodeCompleteObjCInterfaceCategory(getCurScope(), nameId, nameLoc); 200 cutOffParsing(); 201 return 0; 202 } 203 204 // For ObjC2, the category name is optional (not an error). 205 if (Tok.is(tok::identifier)) { 206 categoryId = Tok.getIdentifierInfo(); 207 categoryLoc = ConsumeToken(); 208 } 209 else if (!getLangOpts().ObjC2) { 210 Diag(Tok, diag::err_expected_ident); // missing category name. 211 return 0; 212 } 213 214 T.consumeClose(); 215 if (T.getCloseLocation().isInvalid()) 216 return 0; 217 218 if (!attrs.empty()) { // categories don't support attributes. 219 Diag(nameLoc, diag::err_objc_no_attributes_on_category); 220 attrs.clear(); 221 } 222 223 // Next, we need to check for any protocol references. 224 SourceLocation LAngleLoc, EndProtoLoc; 225 SmallVector<Decl *, 8> ProtocolRefs; 226 SmallVector<SourceLocation, 8> ProtocolLocs; 227 if (Tok.is(tok::less) && 228 ParseObjCProtocolReferences(ProtocolRefs, ProtocolLocs, true, 229 LAngleLoc, EndProtoLoc)) 230 return 0; 231 232 Decl *CategoryType = 233 Actions.ActOnStartCategoryInterface(AtLoc, 234 nameId, nameLoc, 235 categoryId, categoryLoc, 236 ProtocolRefs.data(), 237 ProtocolRefs.size(), 238 ProtocolLocs.data(), 239 EndProtoLoc); 240 241 if (Tok.is(tok::l_brace)) 242 ParseObjCClassInstanceVariables(CategoryType, tok::objc_private, AtLoc); 243 244 ParseObjCInterfaceDeclList(tok::objc_not_keyword, CategoryType); 245 return CategoryType; 246 } 247 // Parse a class interface. 248 IdentifierInfo *superClassId = 0; 249 SourceLocation superClassLoc; 250 251 if (Tok.is(tok::colon)) { // a super class is specified. 252 ConsumeToken(); 253 254 // Code completion of superclass names. 255 if (Tok.is(tok::code_completion)) { 256 Actions.CodeCompleteObjCSuperclass(getCurScope(), nameId, nameLoc); 257 cutOffParsing(); 258 return 0; 259 } 260 261 if (Tok.isNot(tok::identifier)) { 262 Diag(Tok, diag::err_expected_ident); // missing super class name. 263 return 0; 264 } 265 superClassId = Tok.getIdentifierInfo(); 266 superClassLoc = ConsumeToken(); 267 } 268 // Next, we need to check for any protocol references. 269 SmallVector<Decl *, 8> ProtocolRefs; 270 SmallVector<SourceLocation, 8> ProtocolLocs; 271 SourceLocation LAngleLoc, EndProtoLoc; 272 if (Tok.is(tok::less) && 273 ParseObjCProtocolReferences(ProtocolRefs, ProtocolLocs, true, 274 LAngleLoc, EndProtoLoc)) 275 return 0; 276 277 Decl *ClsType = 278 Actions.ActOnStartClassInterface(AtLoc, nameId, nameLoc, 279 superClassId, superClassLoc, 280 ProtocolRefs.data(), ProtocolRefs.size(), 281 ProtocolLocs.data(), 282 EndProtoLoc, attrs.getList()); 283 284 if (Tok.is(tok::l_brace)) 285 ParseObjCClassInstanceVariables(ClsType, tok::objc_protected, AtLoc); 286 287 ParseObjCInterfaceDeclList(tok::objc_interface, ClsType); 288 return ClsType; 289 } 290 291 /// The Objective-C property callback. This should be defined where 292 /// it's used, but instead it's been lifted to here to support VS2005. 293 struct Parser::ObjCPropertyCallback : FieldCallback { 294 private: 295 virtual void anchor(); 296 public: 297 Parser &P; 298 SmallVectorImpl<Decl *> &Props; 299 ObjCDeclSpec &OCDS; 300 SourceLocation AtLoc; 301 SourceLocation LParenLoc; 302 tok::ObjCKeywordKind MethodImplKind; 303 304 ObjCPropertyCallback(Parser &P, 305 SmallVectorImpl<Decl *> &Props, 306 ObjCDeclSpec &OCDS, SourceLocation AtLoc, 307 SourceLocation LParenLoc, 308 tok::ObjCKeywordKind MethodImplKind) : 309 P(P), Props(Props), OCDS(OCDS), AtLoc(AtLoc), LParenLoc(LParenLoc), 310 MethodImplKind(MethodImplKind) { 311 } 312 313 void invoke(ParsingFieldDeclarator &FD) { 314 if (FD.D.getIdentifier() == 0) { 315 P.Diag(AtLoc, diag::err_objc_property_requires_field_name) 316 << FD.D.getSourceRange(); 317 return; 318 } 319 if (FD.BitfieldSize) { 320 P.Diag(AtLoc, diag::err_objc_property_bitfield) 321 << FD.D.getSourceRange(); 322 return; 323 } 324 325 // Install the property declarator into interfaceDecl. 326 IdentifierInfo *SelName = 327 OCDS.getGetterName() ? OCDS.getGetterName() : FD.D.getIdentifier(); 328 329 Selector GetterSel = 330 P.PP.getSelectorTable().getNullarySelector(SelName); 331 IdentifierInfo *SetterName = OCDS.getSetterName(); 332 Selector SetterSel; 333 if (SetterName) 334 SetterSel = P.PP.getSelectorTable().getSelector(1, &SetterName); 335 else 336 SetterSel = SelectorTable::constructSetterName(P.PP.getIdentifierTable(), 337 P.PP.getSelectorTable(), 338 FD.D.getIdentifier()); 339 bool isOverridingProperty = false; 340 Decl *Property = 341 P.Actions.ActOnProperty(P.getCurScope(), AtLoc, LParenLoc, 342 FD, OCDS, 343 GetterSel, SetterSel, 344 &isOverridingProperty, 345 MethodImplKind); 346 if (!isOverridingProperty) 347 Props.push_back(Property); 348 349 FD.complete(Property); 350 } 351 }; 352 353 void Parser::ObjCPropertyCallback::anchor() { 354 } 355 356 /// objc-interface-decl-list: 357 /// empty 358 /// objc-interface-decl-list objc-property-decl [OBJC2] 359 /// objc-interface-decl-list objc-method-requirement [OBJC2] 360 /// objc-interface-decl-list objc-method-proto ';' 361 /// objc-interface-decl-list declaration 362 /// objc-interface-decl-list ';' 363 /// 364 /// objc-method-requirement: [OBJC2] 365 /// @required 366 /// @optional 367 /// 368 void Parser::ParseObjCInterfaceDeclList(tok::ObjCKeywordKind contextKey, 369 Decl *CDecl) { 370 SmallVector<Decl *, 32> allMethods; 371 SmallVector<Decl *, 16> allProperties; 372 SmallVector<DeclGroupPtrTy, 8> allTUVariables; 373 tok::ObjCKeywordKind MethodImplKind = tok::objc_not_keyword; 374 375 SourceRange AtEnd; 376 377 while (1) { 378 // If this is a method prototype, parse it. 379 if (Tok.is(tok::minus) || Tok.is(tok::plus)) { 380 if (Decl *methodPrototype = 381 ParseObjCMethodPrototype(MethodImplKind, false)) 382 allMethods.push_back(methodPrototype); 383 // Consume the ';' here, since ParseObjCMethodPrototype() is re-used for 384 // method definitions. 385 if (ExpectAndConsumeSemi(diag::err_expected_semi_after_method_proto)) { 386 // We didn't find a semi and we error'ed out. Skip until a ';' or '@'. 387 SkipUntil(tok::at, /*StopAtSemi=*/true, /*DontConsume=*/true); 388 if (Tok.is(tok::semi)) 389 ConsumeToken(); 390 } 391 continue; 392 } 393 if (Tok.is(tok::l_paren)) { 394 Diag(Tok, diag::err_expected_minus_or_plus); 395 ParseObjCMethodDecl(Tok.getLocation(), 396 tok::minus, 397 MethodImplKind, false); 398 continue; 399 } 400 // Ignore excess semicolons. 401 if (Tok.is(tok::semi)) { 402 ConsumeToken(); 403 continue; 404 } 405 406 // If we got to the end of the file, exit the loop. 407 if (Tok.is(tok::eof)) 408 break; 409 410 // Code completion within an Objective-C interface. 411 if (Tok.is(tok::code_completion)) { 412 Actions.CodeCompleteOrdinaryName(getCurScope(), 413 CurParsedObjCImpl? Sema::PCC_ObjCImplementation 414 : Sema::PCC_ObjCInterface); 415 return cutOffParsing(); 416 } 417 418 // If we don't have an @ directive, parse it as a function definition. 419 if (Tok.isNot(tok::at)) { 420 // The code below does not consume '}'s because it is afraid of eating the 421 // end of a namespace. Because of the way this code is structured, an 422 // erroneous r_brace would cause an infinite loop if not handled here. 423 if (Tok.is(tok::r_brace)) 424 break; 425 ParsedAttributesWithRange attrs(AttrFactory); 426 allTUVariables.push_back(ParseDeclarationOrFunctionDefinition(attrs)); 427 continue; 428 } 429 430 // Otherwise, we have an @ directive, eat the @. 431 SourceLocation AtLoc = ConsumeToken(); // the "@" 432 if (Tok.is(tok::code_completion)) { 433 Actions.CodeCompleteObjCAtDirective(getCurScope()); 434 return cutOffParsing(); 435 } 436 437 tok::ObjCKeywordKind DirectiveKind = Tok.getObjCKeywordID(); 438 439 if (DirectiveKind == tok::objc_end) { // @end -> terminate list 440 AtEnd.setBegin(AtLoc); 441 AtEnd.setEnd(Tok.getLocation()); 442 break; 443 } else if (DirectiveKind == tok::objc_not_keyword) { 444 Diag(Tok, diag::err_objc_unknown_at); 445 SkipUntil(tok::semi); 446 continue; 447 } 448 449 // Eat the identifier. 450 ConsumeToken(); 451 452 switch (DirectiveKind) { 453 default: 454 // FIXME: If someone forgets an @end on a protocol, this loop will 455 // continue to eat up tons of stuff and spew lots of nonsense errors. It 456 // would probably be better to bail out if we saw an @class or @interface 457 // or something like that. 458 Diag(AtLoc, diag::err_objc_illegal_interface_qual); 459 // Skip until we see an '@' or '}' or ';'. 460 SkipUntil(tok::r_brace, tok::at); 461 break; 462 463 case tok::objc_implementation: 464 case tok::objc_interface: 465 Diag(AtLoc, diag::err_objc_missing_end) 466 << FixItHint::CreateInsertion(AtLoc, "@end\n"); 467 Diag(CDecl->getLocStart(), diag::note_objc_container_start) 468 << (int) Actions.getObjCContainerKind(); 469 ConsumeToken(); 470 break; 471 472 case tok::objc_required: 473 case tok::objc_optional: 474 // This is only valid on protocols. 475 // FIXME: Should this check for ObjC2 being enabled? 476 if (contextKey != tok::objc_protocol) 477 Diag(AtLoc, diag::err_objc_directive_only_in_protocol); 478 else 479 MethodImplKind = DirectiveKind; 480 break; 481 482 case tok::objc_property: 483 if (!getLangOpts().ObjC2) 484 Diag(AtLoc, diag::err_objc_properties_require_objc2); 485 486 ObjCDeclSpec OCDS; 487 SourceLocation LParenLoc; 488 // Parse property attribute list, if any. 489 if (Tok.is(tok::l_paren)) { 490 LParenLoc = Tok.getLocation(); 491 ParseObjCPropertyAttribute(OCDS); 492 } 493 494 ObjCPropertyCallback Callback(*this, allProperties, 495 OCDS, AtLoc, LParenLoc, MethodImplKind); 496 497 // Parse all the comma separated declarators. 498 ParsingDeclSpec DS(*this); 499 ParseStructDeclaration(DS, Callback); 500 501 ExpectAndConsume(tok::semi, diag::err_expected_semi_decl_list); 502 break; 503 } 504 } 505 506 // We break out of the big loop in two cases: when we see @end or when we see 507 // EOF. In the former case, eat the @end. In the later case, emit an error. 508 if (Tok.is(tok::code_completion)) { 509 Actions.CodeCompleteObjCAtDirective(getCurScope()); 510 return cutOffParsing(); 511 } else if (Tok.isObjCAtKeyword(tok::objc_end)) { 512 ConsumeToken(); // the "end" identifier 513 } else { 514 Diag(Tok, diag::err_objc_missing_end) 515 << FixItHint::CreateInsertion(Tok.getLocation(), "\n@end\n"); 516 Diag(CDecl->getLocStart(), diag::note_objc_container_start) 517 << (int) Actions.getObjCContainerKind(); 518 AtEnd.setBegin(Tok.getLocation()); 519 AtEnd.setEnd(Tok.getLocation()); 520 } 521 522 // Insert collected methods declarations into the @interface object. 523 // This passes in an invalid SourceLocation for AtEndLoc when EOF is hit. 524 Actions.ActOnAtEnd(getCurScope(), AtEnd, 525 allMethods.data(), allMethods.size(), 526 allProperties.data(), allProperties.size(), 527 allTUVariables.data(), allTUVariables.size()); 528 } 529 530 /// Parse property attribute declarations. 531 /// 532 /// property-attr-decl: '(' property-attrlist ')' 533 /// property-attrlist: 534 /// property-attribute 535 /// property-attrlist ',' property-attribute 536 /// property-attribute: 537 /// getter '=' identifier 538 /// setter '=' identifier ':' 539 /// readonly 540 /// readwrite 541 /// assign 542 /// retain 543 /// copy 544 /// nonatomic 545 /// atomic 546 /// strong 547 /// weak 548 /// unsafe_unretained 549 /// 550 void Parser::ParseObjCPropertyAttribute(ObjCDeclSpec &DS) { 551 assert(Tok.getKind() == tok::l_paren); 552 BalancedDelimiterTracker T(*this, tok::l_paren); 553 T.consumeOpen(); 554 555 while (1) { 556 if (Tok.is(tok::code_completion)) { 557 Actions.CodeCompleteObjCPropertyFlags(getCurScope(), DS); 558 return cutOffParsing(); 559 } 560 const IdentifierInfo *II = Tok.getIdentifierInfo(); 561 562 // If this is not an identifier at all, bail out early. 563 if (II == 0) { 564 T.consumeClose(); 565 return; 566 } 567 568 SourceLocation AttrName = ConsumeToken(); // consume last attribute name 569 570 if (II->isStr("readonly")) 571 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_readonly); 572 else if (II->isStr("assign")) 573 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_assign); 574 else if (II->isStr("unsafe_unretained")) 575 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_unsafe_unretained); 576 else if (II->isStr("readwrite")) 577 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_readwrite); 578 else if (II->isStr("retain")) 579 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_retain); 580 else if (II->isStr("strong")) 581 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_strong); 582 else if (II->isStr("copy")) 583 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_copy); 584 else if (II->isStr("nonatomic")) 585 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_nonatomic); 586 else if (II->isStr("atomic")) 587 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_atomic); 588 else if (II->isStr("weak")) 589 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_weak); 590 else if (II->isStr("getter") || II->isStr("setter")) { 591 bool IsSetter = II->getNameStart()[0] == 's'; 592 593 // getter/setter require extra treatment. 594 unsigned DiagID = IsSetter ? diag::err_objc_expected_equal_for_setter : 595 diag::err_objc_expected_equal_for_getter; 596 597 if (ExpectAndConsume(tok::equal, DiagID, "", tok::r_paren)) 598 return; 599 600 if (Tok.is(tok::code_completion)) { 601 if (IsSetter) 602 Actions.CodeCompleteObjCPropertySetter(getCurScope()); 603 else 604 Actions.CodeCompleteObjCPropertyGetter(getCurScope()); 605 return cutOffParsing(); 606 } 607 608 609 SourceLocation SelLoc; 610 IdentifierInfo *SelIdent = ParseObjCSelectorPiece(SelLoc); 611 612 if (!SelIdent) { 613 Diag(Tok, diag::err_objc_expected_selector_for_getter_setter) 614 << IsSetter; 615 SkipUntil(tok::r_paren); 616 return; 617 } 618 619 if (IsSetter) { 620 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_setter); 621 DS.setSetterName(SelIdent); 622 623 if (ExpectAndConsume(tok::colon, 624 diag::err_expected_colon_after_setter_name, "", 625 tok::r_paren)) 626 return; 627 } else { 628 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_getter); 629 DS.setGetterName(SelIdent); 630 } 631 } else { 632 Diag(AttrName, diag::err_objc_expected_property_attr) << II; 633 SkipUntil(tok::r_paren); 634 return; 635 } 636 637 if (Tok.isNot(tok::comma)) 638 break; 639 640 ConsumeToken(); 641 } 642 643 T.consumeClose(); 644 } 645 646 /// objc-method-proto: 647 /// objc-instance-method objc-method-decl objc-method-attributes[opt] 648 /// objc-class-method objc-method-decl objc-method-attributes[opt] 649 /// 650 /// objc-instance-method: '-' 651 /// objc-class-method: '+' 652 /// 653 /// objc-method-attributes: [OBJC2] 654 /// __attribute__((deprecated)) 655 /// 656 Decl *Parser::ParseObjCMethodPrototype(tok::ObjCKeywordKind MethodImplKind, 657 bool MethodDefinition) { 658 assert((Tok.is(tok::minus) || Tok.is(tok::plus)) && "expected +/-"); 659 660 tok::TokenKind methodType = Tok.getKind(); 661 SourceLocation mLoc = ConsumeToken(); 662 Decl *MDecl = ParseObjCMethodDecl(mLoc, methodType, MethodImplKind, 663 MethodDefinition); 664 // Since this rule is used for both method declarations and definitions, 665 // the caller is (optionally) responsible for consuming the ';'. 666 return MDecl; 667 } 668 669 /// objc-selector: 670 /// identifier 671 /// one of 672 /// enum struct union if else while do for switch case default 673 /// break continue return goto asm sizeof typeof __alignof 674 /// unsigned long const short volatile signed restrict _Complex 675 /// in out inout bycopy byref oneway int char float double void _Bool 676 /// 677 IdentifierInfo *Parser::ParseObjCSelectorPiece(SourceLocation &SelectorLoc) { 678 679 switch (Tok.getKind()) { 680 default: 681 return 0; 682 case tok::ampamp: 683 case tok::ampequal: 684 case tok::amp: 685 case tok::pipe: 686 case tok::tilde: 687 case tok::exclaim: 688 case tok::exclaimequal: 689 case tok::pipepipe: 690 case tok::pipeequal: 691 case tok::caret: 692 case tok::caretequal: { 693 std::string ThisTok(PP.getSpelling(Tok)); 694 if (isLetter(ThisTok[0])) { 695 IdentifierInfo *II = &PP.getIdentifierTable().get(ThisTok.data()); 696 Tok.setKind(tok::identifier); 697 SelectorLoc = ConsumeToken(); 698 return II; 699 } 700 return 0; 701 } 702 703 case tok::identifier: 704 case tok::kw_asm: 705 case tok::kw_auto: 706 case tok::kw_bool: 707 case tok::kw_break: 708 case tok::kw_case: 709 case tok::kw_catch: 710 case tok::kw_char: 711 case tok::kw_class: 712 case tok::kw_const: 713 case tok::kw_const_cast: 714 case tok::kw_continue: 715 case tok::kw_default: 716 case tok::kw_delete: 717 case tok::kw_do: 718 case tok::kw_double: 719 case tok::kw_dynamic_cast: 720 case tok::kw_else: 721 case tok::kw_enum: 722 case tok::kw_explicit: 723 case tok::kw_export: 724 case tok::kw_extern: 725 case tok::kw_false: 726 case tok::kw_float: 727 case tok::kw_for: 728 case tok::kw_friend: 729 case tok::kw_goto: 730 case tok::kw_if: 731 case tok::kw_inline: 732 case tok::kw_int: 733 case tok::kw_long: 734 case tok::kw_mutable: 735 case tok::kw_namespace: 736 case tok::kw_new: 737 case tok::kw_operator: 738 case tok::kw_private: 739 case tok::kw_protected: 740 case tok::kw_public: 741 case tok::kw_register: 742 case tok::kw_reinterpret_cast: 743 case tok::kw_restrict: 744 case tok::kw_return: 745 case tok::kw_short: 746 case tok::kw_signed: 747 case tok::kw_sizeof: 748 case tok::kw_static: 749 case tok::kw_static_cast: 750 case tok::kw_struct: 751 case tok::kw_switch: 752 case tok::kw_template: 753 case tok::kw_this: 754 case tok::kw_throw: 755 case tok::kw_true: 756 case tok::kw_try: 757 case tok::kw_typedef: 758 case tok::kw_typeid: 759 case tok::kw_typename: 760 case tok::kw_typeof: 761 case tok::kw_union: 762 case tok::kw_unsigned: 763 case tok::kw_using: 764 case tok::kw_virtual: 765 case tok::kw_void: 766 case tok::kw_volatile: 767 case tok::kw_wchar_t: 768 case tok::kw_while: 769 case tok::kw__Bool: 770 case tok::kw__Complex: 771 case tok::kw___alignof: 772 IdentifierInfo *II = Tok.getIdentifierInfo(); 773 SelectorLoc = ConsumeToken(); 774 return II; 775 } 776 } 777 778 /// objc-for-collection-in: 'in' 779 /// 780 bool Parser::isTokIdentifier_in() const { 781 // FIXME: May have to do additional look-ahead to only allow for 782 // valid tokens following an 'in'; such as an identifier, unary operators, 783 // '[' etc. 784 return (getLangOpts().ObjC2 && Tok.is(tok::identifier) && 785 Tok.getIdentifierInfo() == ObjCTypeQuals[objc_in]); 786 } 787 788 /// ParseObjCTypeQualifierList - This routine parses the objective-c's type 789 /// qualifier list and builds their bitmask representation in the input 790 /// argument. 791 /// 792 /// objc-type-qualifiers: 793 /// objc-type-qualifier 794 /// objc-type-qualifiers objc-type-qualifier 795 /// 796 void Parser::ParseObjCTypeQualifierList(ObjCDeclSpec &DS, 797 Declarator::TheContext Context) { 798 assert(Context == Declarator::ObjCParameterContext || 799 Context == Declarator::ObjCResultContext); 800 801 while (1) { 802 if (Tok.is(tok::code_completion)) { 803 Actions.CodeCompleteObjCPassingType(getCurScope(), DS, 804 Context == Declarator::ObjCParameterContext); 805 return cutOffParsing(); 806 } 807 808 if (Tok.isNot(tok::identifier)) 809 return; 810 811 const IdentifierInfo *II = Tok.getIdentifierInfo(); 812 for (unsigned i = 0; i != objc_NumQuals; ++i) { 813 if (II != ObjCTypeQuals[i]) 814 continue; 815 816 ObjCDeclSpec::ObjCDeclQualifier Qual; 817 switch (i) { 818 default: llvm_unreachable("Unknown decl qualifier"); 819 case objc_in: Qual = ObjCDeclSpec::DQ_In; break; 820 case objc_out: Qual = ObjCDeclSpec::DQ_Out; break; 821 case objc_inout: Qual = ObjCDeclSpec::DQ_Inout; break; 822 case objc_oneway: Qual = ObjCDeclSpec::DQ_Oneway; break; 823 case objc_bycopy: Qual = ObjCDeclSpec::DQ_Bycopy; break; 824 case objc_byref: Qual = ObjCDeclSpec::DQ_Byref; break; 825 } 826 DS.setObjCDeclQualifier(Qual); 827 ConsumeToken(); 828 II = 0; 829 break; 830 } 831 832 // If this wasn't a recognized qualifier, bail out. 833 if (II) return; 834 } 835 } 836 837 /// Take all the decl attributes out of the given list and add 838 /// them to the given attribute set. 839 static void takeDeclAttributes(ParsedAttributes &attrs, 840 AttributeList *list) { 841 while (list) { 842 AttributeList *cur = list; 843 list = cur->getNext(); 844 845 if (!cur->isUsedAsTypeAttr()) { 846 // Clear out the next pointer. We're really completely 847 // destroying the internal invariants of the declarator here, 848 // but it doesn't matter because we're done with it. 849 cur->setNext(0); 850 attrs.add(cur); 851 } 852 } 853 } 854 855 /// takeDeclAttributes - Take all the decl attributes from the given 856 /// declarator and add them to the given list. 857 static void takeDeclAttributes(ParsedAttributes &attrs, 858 Declarator &D) { 859 // First, take ownership of all attributes. 860 attrs.getPool().takeAllFrom(D.getAttributePool()); 861 attrs.getPool().takeAllFrom(D.getDeclSpec().getAttributePool()); 862 863 // Now actually move the attributes over. 864 takeDeclAttributes(attrs, D.getDeclSpec().getAttributes().getList()); 865 takeDeclAttributes(attrs, D.getAttributes()); 866 for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) 867 takeDeclAttributes(attrs, 868 const_cast<AttributeList*>(D.getTypeObject(i).getAttrs())); 869 } 870 871 /// objc-type-name: 872 /// '(' objc-type-qualifiers[opt] type-name ')' 873 /// '(' objc-type-qualifiers[opt] ')' 874 /// 875 ParsedType Parser::ParseObjCTypeName(ObjCDeclSpec &DS, 876 Declarator::TheContext context, 877 ParsedAttributes *paramAttrs) { 878 assert(context == Declarator::ObjCParameterContext || 879 context == Declarator::ObjCResultContext); 880 assert((paramAttrs != 0) == (context == Declarator::ObjCParameterContext)); 881 882 assert(Tok.is(tok::l_paren) && "expected ("); 883 884 BalancedDelimiterTracker T(*this, tok::l_paren); 885 T.consumeOpen(); 886 887 SourceLocation TypeStartLoc = Tok.getLocation(); 888 ObjCDeclContextSwitch ObjCDC(*this); 889 890 // Parse type qualifiers, in, inout, etc. 891 ParseObjCTypeQualifierList(DS, context); 892 893 ParsedType Ty; 894 if (isTypeSpecifierQualifier()) { 895 // Parse an abstract declarator. 896 DeclSpec declSpec(AttrFactory); 897 declSpec.setObjCQualifiers(&DS); 898 ParseSpecifierQualifierList(declSpec); 899 declSpec.SetRangeEnd(Tok.getLocation()); 900 Declarator declarator(declSpec, context); 901 ParseDeclarator(declarator); 902 903 // If that's not invalid, extract a type. 904 if (!declarator.isInvalidType()) { 905 TypeResult type = Actions.ActOnTypeName(getCurScope(), declarator); 906 if (!type.isInvalid()) 907 Ty = type.get(); 908 909 // If we're parsing a parameter, steal all the decl attributes 910 // and add them to the decl spec. 911 if (context == Declarator::ObjCParameterContext) 912 takeDeclAttributes(*paramAttrs, declarator); 913 } 914 } else if (context == Declarator::ObjCResultContext && 915 Tok.is(tok::identifier)) { 916 if (!Ident_instancetype) 917 Ident_instancetype = PP.getIdentifierInfo("instancetype"); 918 919 if (Tok.getIdentifierInfo() == Ident_instancetype) { 920 Ty = Actions.ActOnObjCInstanceType(Tok.getLocation()); 921 ConsumeToken(); 922 } 923 } 924 925 if (Tok.is(tok::r_paren)) 926 T.consumeClose(); 927 else if (Tok.getLocation() == TypeStartLoc) { 928 // If we didn't eat any tokens, then this isn't a type. 929 Diag(Tok, diag::err_expected_type); 930 SkipUntil(tok::r_paren); 931 } else { 932 // Otherwise, we found *something*, but didn't get a ')' in the right 933 // place. Emit an error then return what we have as the type. 934 T.consumeClose(); 935 } 936 return Ty; 937 } 938 939 /// objc-method-decl: 940 /// objc-selector 941 /// objc-keyword-selector objc-parmlist[opt] 942 /// objc-type-name objc-selector 943 /// objc-type-name objc-keyword-selector objc-parmlist[opt] 944 /// 945 /// objc-keyword-selector: 946 /// objc-keyword-decl 947 /// objc-keyword-selector objc-keyword-decl 948 /// 949 /// objc-keyword-decl: 950 /// objc-selector ':' objc-type-name objc-keyword-attributes[opt] identifier 951 /// objc-selector ':' objc-keyword-attributes[opt] identifier 952 /// ':' objc-type-name objc-keyword-attributes[opt] identifier 953 /// ':' objc-keyword-attributes[opt] identifier 954 /// 955 /// objc-parmlist: 956 /// objc-parms objc-ellipsis[opt] 957 /// 958 /// objc-parms: 959 /// objc-parms , parameter-declaration 960 /// 961 /// objc-ellipsis: 962 /// , ... 963 /// 964 /// objc-keyword-attributes: [OBJC2] 965 /// __attribute__((unused)) 966 /// 967 Decl *Parser::ParseObjCMethodDecl(SourceLocation mLoc, 968 tok::TokenKind mType, 969 tok::ObjCKeywordKind MethodImplKind, 970 bool MethodDefinition) { 971 ParsingDeclRAIIObject PD(*this, ParsingDeclRAIIObject::NoParent); 972 973 if (Tok.is(tok::code_completion)) { 974 Actions.CodeCompleteObjCMethodDecl(getCurScope(), mType == tok::minus, 975 /*ReturnType=*/ ParsedType()); 976 cutOffParsing(); 977 return 0; 978 } 979 980 // Parse the return type if present. 981 ParsedType ReturnType; 982 ObjCDeclSpec DSRet; 983 if (Tok.is(tok::l_paren)) 984 ReturnType = ParseObjCTypeName(DSRet, Declarator::ObjCResultContext, 0); 985 986 // If attributes exist before the method, parse them. 987 ParsedAttributes methodAttrs(AttrFactory); 988 if (getLangOpts().ObjC2) 989 MaybeParseGNUAttributes(methodAttrs); 990 991 if (Tok.is(tok::code_completion)) { 992 Actions.CodeCompleteObjCMethodDecl(getCurScope(), mType == tok::minus, 993 ReturnType); 994 cutOffParsing(); 995 return 0; 996 } 997 998 // Now parse the selector. 999 SourceLocation selLoc; 1000 IdentifierInfo *SelIdent = ParseObjCSelectorPiece(selLoc); 1001 1002 // An unnamed colon is valid. 1003 if (!SelIdent && Tok.isNot(tok::colon)) { // missing selector name. 1004 Diag(Tok, diag::err_expected_selector_for_method) 1005 << SourceRange(mLoc, Tok.getLocation()); 1006 // Skip until we get a ; or @. 1007 SkipUntil(tok::at, true /*StopAtSemi*/, true /*don't consume*/); 1008 return 0; 1009 } 1010 1011 SmallVector<DeclaratorChunk::ParamInfo, 8> CParamInfo; 1012 if (Tok.isNot(tok::colon)) { 1013 // If attributes exist after the method, parse them. 1014 if (getLangOpts().ObjC2) 1015 MaybeParseGNUAttributes(methodAttrs); 1016 1017 Selector Sel = PP.getSelectorTable().getNullarySelector(SelIdent); 1018 Decl *Result 1019 = Actions.ActOnMethodDeclaration(getCurScope(), mLoc, Tok.getLocation(), 1020 mType, DSRet, ReturnType, 1021 selLoc, Sel, 0, 1022 CParamInfo.data(), CParamInfo.size(), 1023 methodAttrs.getList(), MethodImplKind, 1024 false, MethodDefinition); 1025 PD.complete(Result); 1026 return Result; 1027 } 1028 1029 SmallVector<IdentifierInfo *, 12> KeyIdents; 1030 SmallVector<SourceLocation, 12> KeyLocs; 1031 SmallVector<Sema::ObjCArgInfo, 12> ArgInfos; 1032 ParseScope PrototypeScope(this, Scope::FunctionPrototypeScope | 1033 Scope::FunctionDeclarationScope | Scope::DeclScope); 1034 1035 AttributePool allParamAttrs(AttrFactory); 1036 while (1) { 1037 ParsedAttributes paramAttrs(AttrFactory); 1038 Sema::ObjCArgInfo ArgInfo; 1039 1040 // Each iteration parses a single keyword argument. 1041 if (Tok.isNot(tok::colon)) { 1042 Diag(Tok, diag::err_expected_colon); 1043 break; 1044 } 1045 ConsumeToken(); // Eat the ':'. 1046 1047 ArgInfo.Type = ParsedType(); 1048 if (Tok.is(tok::l_paren)) // Parse the argument type if present. 1049 ArgInfo.Type = ParseObjCTypeName(ArgInfo.DeclSpec, 1050 Declarator::ObjCParameterContext, 1051 ¶mAttrs); 1052 1053 // If attributes exist before the argument name, parse them. 1054 // Regardless, collect all the attributes we've parsed so far. 1055 ArgInfo.ArgAttrs = 0; 1056 if (getLangOpts().ObjC2) { 1057 MaybeParseGNUAttributes(paramAttrs); 1058 ArgInfo.ArgAttrs = paramAttrs.getList(); 1059 } 1060 1061 // Code completion for the next piece of the selector. 1062 if (Tok.is(tok::code_completion)) { 1063 KeyIdents.push_back(SelIdent); 1064 Actions.CodeCompleteObjCMethodDeclSelector(getCurScope(), 1065 mType == tok::minus, 1066 /*AtParameterName=*/true, 1067 ReturnType, 1068 KeyIdents.data(), 1069 KeyIdents.size()); 1070 cutOffParsing(); 1071 return 0; 1072 } 1073 1074 if (Tok.isNot(tok::identifier)) { 1075 Diag(Tok, diag::err_expected_ident); // missing argument name. 1076 break; 1077 } 1078 1079 ArgInfo.Name = Tok.getIdentifierInfo(); 1080 ArgInfo.NameLoc = Tok.getLocation(); 1081 ConsumeToken(); // Eat the identifier. 1082 1083 ArgInfos.push_back(ArgInfo); 1084 KeyIdents.push_back(SelIdent); 1085 KeyLocs.push_back(selLoc); 1086 1087 // Make sure the attributes persist. 1088 allParamAttrs.takeAllFrom(paramAttrs.getPool()); 1089 1090 // Code completion for the next piece of the selector. 1091 if (Tok.is(tok::code_completion)) { 1092 Actions.CodeCompleteObjCMethodDeclSelector(getCurScope(), 1093 mType == tok::minus, 1094 /*AtParameterName=*/false, 1095 ReturnType, 1096 KeyIdents.data(), 1097 KeyIdents.size()); 1098 cutOffParsing(); 1099 return 0; 1100 } 1101 1102 // Check for another keyword selector. 1103 SelIdent = ParseObjCSelectorPiece(selLoc); 1104 if (!SelIdent && Tok.isNot(tok::colon)) 1105 break; 1106 if (!SelIdent) { 1107 SourceLocation ColonLoc = Tok.getLocation(); 1108 if (PP.getLocForEndOfToken(ArgInfo.NameLoc) == ColonLoc) { 1109 Diag(ArgInfo.NameLoc, diag::warn_missing_selector_name) << ArgInfo.Name; 1110 Diag(ArgInfo.NameLoc, diag::note_missing_selector_name) << ArgInfo.Name; 1111 Diag(ColonLoc, diag::note_force_empty_selector_name) << ArgInfo.Name; 1112 } 1113 } 1114 // We have a selector or a colon, continue parsing. 1115 } 1116 1117 bool isVariadic = false; 1118 bool cStyleParamWarned = false; 1119 // Parse the (optional) parameter list. 1120 while (Tok.is(tok::comma)) { 1121 ConsumeToken(); 1122 if (Tok.is(tok::ellipsis)) { 1123 isVariadic = true; 1124 ConsumeToken(); 1125 break; 1126 } 1127 if (!cStyleParamWarned) { 1128 Diag(Tok, diag::warn_cstyle_param); 1129 cStyleParamWarned = true; 1130 } 1131 DeclSpec DS(AttrFactory); 1132 ParseDeclarationSpecifiers(DS); 1133 // Parse the declarator. 1134 Declarator ParmDecl(DS, Declarator::PrototypeContext); 1135 ParseDeclarator(ParmDecl); 1136 IdentifierInfo *ParmII = ParmDecl.getIdentifier(); 1137 Decl *Param = Actions.ActOnParamDeclarator(getCurScope(), ParmDecl); 1138 CParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII, 1139 ParmDecl.getIdentifierLoc(), 1140 Param, 1141 0)); 1142 } 1143 1144 // FIXME: Add support for optional parameter list... 1145 // If attributes exist after the method, parse them. 1146 if (getLangOpts().ObjC2) 1147 MaybeParseGNUAttributes(methodAttrs); 1148 1149 if (KeyIdents.size() == 0) 1150 return 0; 1151 1152 Selector Sel = PP.getSelectorTable().getSelector(KeyIdents.size(), 1153 &KeyIdents[0]); 1154 Decl *Result 1155 = Actions.ActOnMethodDeclaration(getCurScope(), mLoc, Tok.getLocation(), 1156 mType, DSRet, ReturnType, 1157 KeyLocs, Sel, &ArgInfos[0], 1158 CParamInfo.data(), CParamInfo.size(), 1159 methodAttrs.getList(), 1160 MethodImplKind, isVariadic, MethodDefinition); 1161 1162 PD.complete(Result); 1163 return Result; 1164 } 1165 1166 /// objc-protocol-refs: 1167 /// '<' identifier-list '>' 1168 /// 1169 bool Parser:: 1170 ParseObjCProtocolReferences(SmallVectorImpl<Decl *> &Protocols, 1171 SmallVectorImpl<SourceLocation> &ProtocolLocs, 1172 bool WarnOnDeclarations, 1173 SourceLocation &LAngleLoc, SourceLocation &EndLoc) { 1174 assert(Tok.is(tok::less) && "expected <"); 1175 1176 LAngleLoc = ConsumeToken(); // the "<" 1177 1178 SmallVector<IdentifierLocPair, 8> ProtocolIdents; 1179 1180 while (1) { 1181 if (Tok.is(tok::code_completion)) { 1182 Actions.CodeCompleteObjCProtocolReferences(ProtocolIdents.data(), 1183 ProtocolIdents.size()); 1184 cutOffParsing(); 1185 return true; 1186 } 1187 1188 if (Tok.isNot(tok::identifier)) { 1189 Diag(Tok, diag::err_expected_ident); 1190 SkipUntil(tok::greater); 1191 return true; 1192 } 1193 ProtocolIdents.push_back(std::make_pair(Tok.getIdentifierInfo(), 1194 Tok.getLocation())); 1195 ProtocolLocs.push_back(Tok.getLocation()); 1196 ConsumeToken(); 1197 1198 if (Tok.isNot(tok::comma)) 1199 break; 1200 ConsumeToken(); 1201 } 1202 1203 // Consume the '>'. 1204 if (ParseGreaterThanInTemplateList(EndLoc, /*ConsumeLastToken=*/true)) 1205 return true; 1206 1207 // Convert the list of protocols identifiers into a list of protocol decls. 1208 Actions.FindProtocolDeclaration(WarnOnDeclarations, 1209 &ProtocolIdents[0], ProtocolIdents.size(), 1210 Protocols); 1211 return false; 1212 } 1213 1214 /// \brief Parse the Objective-C protocol qualifiers that follow a typename 1215 /// in a decl-specifier-seq, starting at the '<'. 1216 bool Parser::ParseObjCProtocolQualifiers(DeclSpec &DS) { 1217 assert(Tok.is(tok::less) && "Protocol qualifiers start with '<'"); 1218 assert(getLangOpts().ObjC1 && "Protocol qualifiers only exist in Objective-C"); 1219 SourceLocation LAngleLoc, EndProtoLoc; 1220 SmallVector<Decl *, 8> ProtocolDecl; 1221 SmallVector<SourceLocation, 8> ProtocolLocs; 1222 bool Result = ParseObjCProtocolReferences(ProtocolDecl, ProtocolLocs, false, 1223 LAngleLoc, EndProtoLoc); 1224 DS.setProtocolQualifiers(ProtocolDecl.data(), ProtocolDecl.size(), 1225 ProtocolLocs.data(), LAngleLoc); 1226 if (EndProtoLoc.isValid()) 1227 DS.SetRangeEnd(EndProtoLoc); 1228 return Result; 1229 } 1230 1231 1232 /// objc-class-instance-variables: 1233 /// '{' objc-instance-variable-decl-list[opt] '}' 1234 /// 1235 /// objc-instance-variable-decl-list: 1236 /// objc-visibility-spec 1237 /// objc-instance-variable-decl ';' 1238 /// ';' 1239 /// objc-instance-variable-decl-list objc-visibility-spec 1240 /// objc-instance-variable-decl-list objc-instance-variable-decl ';' 1241 /// objc-instance-variable-decl-list ';' 1242 /// 1243 /// objc-visibility-spec: 1244 /// @private 1245 /// @protected 1246 /// @public 1247 /// @package [OBJC2] 1248 /// 1249 /// objc-instance-variable-decl: 1250 /// struct-declaration 1251 /// 1252 void Parser::ParseObjCClassInstanceVariables(Decl *interfaceDecl, 1253 tok::ObjCKeywordKind visibility, 1254 SourceLocation atLoc) { 1255 assert(Tok.is(tok::l_brace) && "expected {"); 1256 SmallVector<Decl *, 32> AllIvarDecls; 1257 1258 ParseScope ClassScope(this, Scope::DeclScope|Scope::ClassScope); 1259 ObjCDeclContextSwitch ObjCDC(*this); 1260 1261 BalancedDelimiterTracker T(*this, tok::l_brace); 1262 T.consumeOpen(); 1263 1264 // While we still have something to read, read the instance variables. 1265 while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) { 1266 // Each iteration of this loop reads one objc-instance-variable-decl. 1267 1268 // Check for extraneous top-level semicolon. 1269 if (Tok.is(tok::semi)) { 1270 ConsumeExtraSemi(InstanceVariableList); 1271 continue; 1272 } 1273 1274 // Set the default visibility to private. 1275 if (Tok.is(tok::at)) { // parse objc-visibility-spec 1276 ConsumeToken(); // eat the @ sign 1277 1278 if (Tok.is(tok::code_completion)) { 1279 Actions.CodeCompleteObjCAtVisibility(getCurScope()); 1280 return cutOffParsing(); 1281 } 1282 1283 switch (Tok.getObjCKeywordID()) { 1284 case tok::objc_private: 1285 case tok::objc_public: 1286 case tok::objc_protected: 1287 case tok::objc_package: 1288 visibility = Tok.getObjCKeywordID(); 1289 ConsumeToken(); 1290 continue; 1291 default: 1292 Diag(Tok, diag::err_objc_illegal_visibility_spec); 1293 continue; 1294 } 1295 } 1296 1297 if (Tok.is(tok::code_completion)) { 1298 Actions.CodeCompleteOrdinaryName(getCurScope(), 1299 Sema::PCC_ObjCInstanceVariableList); 1300 return cutOffParsing(); 1301 } 1302 1303 struct ObjCIvarCallback : FieldCallback { 1304 Parser &P; 1305 Decl *IDecl; 1306 tok::ObjCKeywordKind visibility; 1307 SmallVectorImpl<Decl *> &AllIvarDecls; 1308 1309 ObjCIvarCallback(Parser &P, Decl *IDecl, tok::ObjCKeywordKind V, 1310 SmallVectorImpl<Decl *> &AllIvarDecls) : 1311 P(P), IDecl(IDecl), visibility(V), AllIvarDecls(AllIvarDecls) { 1312 } 1313 1314 void invoke(ParsingFieldDeclarator &FD) { 1315 P.Actions.ActOnObjCContainerStartDefinition(IDecl); 1316 // Install the declarator into the interface decl. 1317 Decl *Field 1318 = P.Actions.ActOnIvar(P.getCurScope(), 1319 FD.D.getDeclSpec().getSourceRange().getBegin(), 1320 FD.D, FD.BitfieldSize, visibility); 1321 P.Actions.ActOnObjCContainerFinishDefinition(); 1322 if (Field) 1323 AllIvarDecls.push_back(Field); 1324 FD.complete(Field); 1325 } 1326 } Callback(*this, interfaceDecl, visibility, AllIvarDecls); 1327 1328 // Parse all the comma separated declarators. 1329 ParsingDeclSpec DS(*this); 1330 ParseStructDeclaration(DS, Callback); 1331 1332 if (Tok.is(tok::semi)) { 1333 ConsumeToken(); 1334 } else { 1335 Diag(Tok, diag::err_expected_semi_decl_list); 1336 // Skip to end of block or statement 1337 SkipUntil(tok::r_brace, true, true); 1338 } 1339 } 1340 T.consumeClose(); 1341 1342 Actions.ActOnObjCContainerStartDefinition(interfaceDecl); 1343 Actions.ActOnLastBitfield(T.getCloseLocation(), AllIvarDecls); 1344 Actions.ActOnObjCContainerFinishDefinition(); 1345 // Call ActOnFields() even if we don't have any decls. This is useful 1346 // for code rewriting tools that need to be aware of the empty list. 1347 Actions.ActOnFields(getCurScope(), atLoc, interfaceDecl, 1348 AllIvarDecls, 1349 T.getOpenLocation(), T.getCloseLocation(), 0); 1350 return; 1351 } 1352 1353 /// objc-protocol-declaration: 1354 /// objc-protocol-definition 1355 /// objc-protocol-forward-reference 1356 /// 1357 /// objc-protocol-definition: 1358 /// \@protocol identifier 1359 /// objc-protocol-refs[opt] 1360 /// objc-interface-decl-list 1361 /// \@end 1362 /// 1363 /// objc-protocol-forward-reference: 1364 /// \@protocol identifier-list ';' 1365 /// 1366 /// "\@protocol identifier ;" should be resolved as "\@protocol 1367 /// identifier-list ;": objc-interface-decl-list may not start with a 1368 /// semicolon in the first alternative if objc-protocol-refs are omitted. 1369 Parser::DeclGroupPtrTy 1370 Parser::ParseObjCAtProtocolDeclaration(SourceLocation AtLoc, 1371 ParsedAttributes &attrs) { 1372 assert(Tok.isObjCAtKeyword(tok::objc_protocol) && 1373 "ParseObjCAtProtocolDeclaration(): Expected @protocol"); 1374 ConsumeToken(); // the "protocol" identifier 1375 1376 if (Tok.is(tok::code_completion)) { 1377 Actions.CodeCompleteObjCProtocolDecl(getCurScope()); 1378 cutOffParsing(); 1379 return DeclGroupPtrTy(); 1380 } 1381 1382 if (Tok.isNot(tok::identifier)) { 1383 Diag(Tok, diag::err_expected_ident); // missing protocol name. 1384 return DeclGroupPtrTy(); 1385 } 1386 // Save the protocol name, then consume it. 1387 IdentifierInfo *protocolName = Tok.getIdentifierInfo(); 1388 SourceLocation nameLoc = ConsumeToken(); 1389 1390 if (Tok.is(tok::semi)) { // forward declaration of one protocol. 1391 IdentifierLocPair ProtoInfo(protocolName, nameLoc); 1392 ConsumeToken(); 1393 return Actions.ActOnForwardProtocolDeclaration(AtLoc, &ProtoInfo, 1, 1394 attrs.getList()); 1395 } 1396 1397 CheckNestedObjCContexts(AtLoc); 1398 1399 if (Tok.is(tok::comma)) { // list of forward declarations. 1400 SmallVector<IdentifierLocPair, 8> ProtocolRefs; 1401 ProtocolRefs.push_back(std::make_pair(protocolName, nameLoc)); 1402 1403 // Parse the list of forward declarations. 1404 while (1) { 1405 ConsumeToken(); // the ',' 1406 if (Tok.isNot(tok::identifier)) { 1407 Diag(Tok, diag::err_expected_ident); 1408 SkipUntil(tok::semi); 1409 return DeclGroupPtrTy(); 1410 } 1411 ProtocolRefs.push_back(IdentifierLocPair(Tok.getIdentifierInfo(), 1412 Tok.getLocation())); 1413 ConsumeToken(); // the identifier 1414 1415 if (Tok.isNot(tok::comma)) 1416 break; 1417 } 1418 // Consume the ';'. 1419 if (ExpectAndConsume(tok::semi, diag::err_expected_semi_after, "@protocol")) 1420 return DeclGroupPtrTy(); 1421 1422 return Actions.ActOnForwardProtocolDeclaration(AtLoc, 1423 &ProtocolRefs[0], 1424 ProtocolRefs.size(), 1425 attrs.getList()); 1426 } 1427 1428 // Last, and definitely not least, parse a protocol declaration. 1429 SourceLocation LAngleLoc, EndProtoLoc; 1430 1431 SmallVector<Decl *, 8> ProtocolRefs; 1432 SmallVector<SourceLocation, 8> ProtocolLocs; 1433 if (Tok.is(tok::less) && 1434 ParseObjCProtocolReferences(ProtocolRefs, ProtocolLocs, false, 1435 LAngleLoc, EndProtoLoc)) 1436 return DeclGroupPtrTy(); 1437 1438 Decl *ProtoType = 1439 Actions.ActOnStartProtocolInterface(AtLoc, protocolName, nameLoc, 1440 ProtocolRefs.data(), 1441 ProtocolRefs.size(), 1442 ProtocolLocs.data(), 1443 EndProtoLoc, attrs.getList()); 1444 1445 ParseObjCInterfaceDeclList(tok::objc_protocol, ProtoType); 1446 return Actions.ConvertDeclToDeclGroup(ProtoType); 1447 } 1448 1449 /// objc-implementation: 1450 /// objc-class-implementation-prologue 1451 /// objc-category-implementation-prologue 1452 /// 1453 /// objc-class-implementation-prologue: 1454 /// @implementation identifier objc-superclass[opt] 1455 /// objc-class-instance-variables[opt] 1456 /// 1457 /// objc-category-implementation-prologue: 1458 /// @implementation identifier ( identifier ) 1459 Parser::DeclGroupPtrTy 1460 Parser::ParseObjCAtImplementationDeclaration(SourceLocation AtLoc) { 1461 assert(Tok.isObjCAtKeyword(tok::objc_implementation) && 1462 "ParseObjCAtImplementationDeclaration(): Expected @implementation"); 1463 CheckNestedObjCContexts(AtLoc); 1464 ConsumeToken(); // the "implementation" identifier 1465 1466 // Code completion after '@implementation'. 1467 if (Tok.is(tok::code_completion)) { 1468 Actions.CodeCompleteObjCImplementationDecl(getCurScope()); 1469 cutOffParsing(); 1470 return DeclGroupPtrTy(); 1471 } 1472 1473 if (Tok.isNot(tok::identifier)) { 1474 Diag(Tok, diag::err_expected_ident); // missing class or category name. 1475 return DeclGroupPtrTy(); 1476 } 1477 // We have a class or category name - consume it. 1478 IdentifierInfo *nameId = Tok.getIdentifierInfo(); 1479 SourceLocation nameLoc = ConsumeToken(); // consume class or category name 1480 Decl *ObjCImpDecl = 0; 1481 1482 if (Tok.is(tok::l_paren)) { 1483 // we have a category implementation. 1484 ConsumeParen(); 1485 SourceLocation categoryLoc, rparenLoc; 1486 IdentifierInfo *categoryId = 0; 1487 1488 if (Tok.is(tok::code_completion)) { 1489 Actions.CodeCompleteObjCImplementationCategory(getCurScope(), nameId, nameLoc); 1490 cutOffParsing(); 1491 return DeclGroupPtrTy(); 1492 } 1493 1494 if (Tok.is(tok::identifier)) { 1495 categoryId = Tok.getIdentifierInfo(); 1496 categoryLoc = ConsumeToken(); 1497 } else { 1498 Diag(Tok, diag::err_expected_ident); // missing category name. 1499 return DeclGroupPtrTy(); 1500 } 1501 if (Tok.isNot(tok::r_paren)) { 1502 Diag(Tok, diag::err_expected_rparen); 1503 SkipUntil(tok::r_paren, false); // don't stop at ';' 1504 return DeclGroupPtrTy(); 1505 } 1506 rparenLoc = ConsumeParen(); 1507 ObjCImpDecl = Actions.ActOnStartCategoryImplementation( 1508 AtLoc, nameId, nameLoc, categoryId, 1509 categoryLoc); 1510 1511 } else { 1512 // We have a class implementation 1513 SourceLocation superClassLoc; 1514 IdentifierInfo *superClassId = 0; 1515 if (Tok.is(tok::colon)) { 1516 // We have a super class 1517 ConsumeToken(); 1518 if (Tok.isNot(tok::identifier)) { 1519 Diag(Tok, diag::err_expected_ident); // missing super class name. 1520 return DeclGroupPtrTy(); 1521 } 1522 superClassId = Tok.getIdentifierInfo(); 1523 superClassLoc = ConsumeToken(); // Consume super class name 1524 } 1525 ObjCImpDecl = Actions.ActOnStartClassImplementation( 1526 AtLoc, nameId, nameLoc, 1527 superClassId, superClassLoc); 1528 1529 if (Tok.is(tok::l_brace)) // we have ivars 1530 ParseObjCClassInstanceVariables(ObjCImpDecl, tok::objc_private, AtLoc); 1531 } 1532 assert(ObjCImpDecl); 1533 1534 SmallVector<Decl *, 8> DeclsInGroup; 1535 1536 { 1537 ObjCImplParsingDataRAII ObjCImplParsing(*this, ObjCImpDecl); 1538 while (!ObjCImplParsing.isFinished() && Tok.isNot(tok::eof)) { 1539 ParsedAttributesWithRange attrs(AttrFactory); 1540 MaybeParseCXX11Attributes(attrs); 1541 MaybeParseMicrosoftAttributes(attrs); 1542 if (DeclGroupPtrTy DGP = ParseExternalDeclaration(attrs)) { 1543 DeclGroupRef DG = DGP.get(); 1544 DeclsInGroup.append(DG.begin(), DG.end()); 1545 } 1546 } 1547 } 1548 1549 return Actions.ActOnFinishObjCImplementation(ObjCImpDecl, DeclsInGroup); 1550 } 1551 1552 Parser::DeclGroupPtrTy 1553 Parser::ParseObjCAtEndDeclaration(SourceRange atEnd) { 1554 assert(Tok.isObjCAtKeyword(tok::objc_end) && 1555 "ParseObjCAtEndDeclaration(): Expected @end"); 1556 ConsumeToken(); // the "end" identifier 1557 if (CurParsedObjCImpl) 1558 CurParsedObjCImpl->finish(atEnd); 1559 else 1560 // missing @implementation 1561 Diag(atEnd.getBegin(), diag::err_expected_objc_container); 1562 return DeclGroupPtrTy(); 1563 } 1564 1565 Parser::ObjCImplParsingDataRAII::~ObjCImplParsingDataRAII() { 1566 if (!Finished) { 1567 finish(P.Tok.getLocation()); 1568 if (P.Tok.is(tok::eof)) { 1569 P.Diag(P.Tok, diag::err_objc_missing_end) 1570 << FixItHint::CreateInsertion(P.Tok.getLocation(), "\n@end\n"); 1571 P.Diag(Dcl->getLocStart(), diag::note_objc_container_start) 1572 << Sema::OCK_Implementation; 1573 } 1574 } 1575 P.CurParsedObjCImpl = 0; 1576 assert(LateParsedObjCMethods.empty()); 1577 } 1578 1579 void Parser::ObjCImplParsingDataRAII::finish(SourceRange AtEnd) { 1580 assert(!Finished); 1581 P.Actions.DefaultSynthesizeProperties(P.getCurScope(), Dcl); 1582 for (size_t i = 0; i < LateParsedObjCMethods.size(); ++i) 1583 P.ParseLexedObjCMethodDefs(*LateParsedObjCMethods[i], 1584 true/*Methods*/); 1585 1586 P.Actions.ActOnAtEnd(P.getCurScope(), AtEnd); 1587 1588 if (HasCFunction) 1589 for (size_t i = 0; i < LateParsedObjCMethods.size(); ++i) 1590 P.ParseLexedObjCMethodDefs(*LateParsedObjCMethods[i], 1591 false/*c-functions*/); 1592 1593 /// \brief Clear and free the cached objc methods. 1594 for (LateParsedObjCMethodContainer::iterator 1595 I = LateParsedObjCMethods.begin(), 1596 E = LateParsedObjCMethods.end(); I != E; ++I) 1597 delete *I; 1598 LateParsedObjCMethods.clear(); 1599 1600 Finished = true; 1601 } 1602 1603 /// compatibility-alias-decl: 1604 /// @compatibility_alias alias-name class-name ';' 1605 /// 1606 Decl *Parser::ParseObjCAtAliasDeclaration(SourceLocation atLoc) { 1607 assert(Tok.isObjCAtKeyword(tok::objc_compatibility_alias) && 1608 "ParseObjCAtAliasDeclaration(): Expected @compatibility_alias"); 1609 ConsumeToken(); // consume compatibility_alias 1610 if (Tok.isNot(tok::identifier)) { 1611 Diag(Tok, diag::err_expected_ident); 1612 return 0; 1613 } 1614 IdentifierInfo *aliasId = Tok.getIdentifierInfo(); 1615 SourceLocation aliasLoc = ConsumeToken(); // consume alias-name 1616 if (Tok.isNot(tok::identifier)) { 1617 Diag(Tok, diag::err_expected_ident); 1618 return 0; 1619 } 1620 IdentifierInfo *classId = Tok.getIdentifierInfo(); 1621 SourceLocation classLoc = ConsumeToken(); // consume class-name; 1622 ExpectAndConsume(tok::semi, diag::err_expected_semi_after, 1623 "@compatibility_alias"); 1624 return Actions.ActOnCompatibilityAlias(atLoc, aliasId, aliasLoc, 1625 classId, classLoc); 1626 } 1627 1628 /// property-synthesis: 1629 /// @synthesize property-ivar-list ';' 1630 /// 1631 /// property-ivar-list: 1632 /// property-ivar 1633 /// property-ivar-list ',' property-ivar 1634 /// 1635 /// property-ivar: 1636 /// identifier 1637 /// identifier '=' identifier 1638 /// 1639 Decl *Parser::ParseObjCPropertySynthesize(SourceLocation atLoc) { 1640 assert(Tok.isObjCAtKeyword(tok::objc_synthesize) && 1641 "ParseObjCPropertyDynamic(): Expected '@synthesize'"); 1642 ConsumeToken(); // consume synthesize 1643 1644 while (true) { 1645 if (Tok.is(tok::code_completion)) { 1646 Actions.CodeCompleteObjCPropertyDefinition(getCurScope()); 1647 cutOffParsing(); 1648 return 0; 1649 } 1650 1651 if (Tok.isNot(tok::identifier)) { 1652 Diag(Tok, diag::err_synthesized_property_name); 1653 SkipUntil(tok::semi); 1654 return 0; 1655 } 1656 1657 IdentifierInfo *propertyIvar = 0; 1658 IdentifierInfo *propertyId = Tok.getIdentifierInfo(); 1659 SourceLocation propertyLoc = ConsumeToken(); // consume property name 1660 SourceLocation propertyIvarLoc; 1661 if (Tok.is(tok::equal)) { 1662 // property '=' ivar-name 1663 ConsumeToken(); // consume '=' 1664 1665 if (Tok.is(tok::code_completion)) { 1666 Actions.CodeCompleteObjCPropertySynthesizeIvar(getCurScope(), propertyId); 1667 cutOffParsing(); 1668 return 0; 1669 } 1670 1671 if (Tok.isNot(tok::identifier)) { 1672 Diag(Tok, diag::err_expected_ident); 1673 break; 1674 } 1675 propertyIvar = Tok.getIdentifierInfo(); 1676 propertyIvarLoc = ConsumeToken(); // consume ivar-name 1677 } 1678 Actions.ActOnPropertyImplDecl(getCurScope(), atLoc, propertyLoc, true, 1679 propertyId, propertyIvar, propertyIvarLoc); 1680 if (Tok.isNot(tok::comma)) 1681 break; 1682 ConsumeToken(); // consume ',' 1683 } 1684 ExpectAndConsume(tok::semi, diag::err_expected_semi_after, "@synthesize"); 1685 return 0; 1686 } 1687 1688 /// property-dynamic: 1689 /// @dynamic property-list 1690 /// 1691 /// property-list: 1692 /// identifier 1693 /// property-list ',' identifier 1694 /// 1695 Decl *Parser::ParseObjCPropertyDynamic(SourceLocation atLoc) { 1696 assert(Tok.isObjCAtKeyword(tok::objc_dynamic) && 1697 "ParseObjCPropertyDynamic(): Expected '@dynamic'"); 1698 ConsumeToken(); // consume dynamic 1699 while (true) { 1700 if (Tok.is(tok::code_completion)) { 1701 Actions.CodeCompleteObjCPropertyDefinition(getCurScope()); 1702 cutOffParsing(); 1703 return 0; 1704 } 1705 1706 if (Tok.isNot(tok::identifier)) { 1707 Diag(Tok, diag::err_expected_ident); 1708 SkipUntil(tok::semi); 1709 return 0; 1710 } 1711 1712 IdentifierInfo *propertyId = Tok.getIdentifierInfo(); 1713 SourceLocation propertyLoc = ConsumeToken(); // consume property name 1714 Actions.ActOnPropertyImplDecl(getCurScope(), atLoc, propertyLoc, false, 1715 propertyId, 0, SourceLocation()); 1716 1717 if (Tok.isNot(tok::comma)) 1718 break; 1719 ConsumeToken(); // consume ',' 1720 } 1721 ExpectAndConsume(tok::semi, diag::err_expected_semi_after, "@dynamic"); 1722 return 0; 1723 } 1724 1725 /// objc-throw-statement: 1726 /// throw expression[opt]; 1727 /// 1728 StmtResult Parser::ParseObjCThrowStmt(SourceLocation atLoc) { 1729 ExprResult Res; 1730 ConsumeToken(); // consume throw 1731 if (Tok.isNot(tok::semi)) { 1732 Res = ParseExpression(); 1733 if (Res.isInvalid()) { 1734 SkipUntil(tok::semi); 1735 return StmtError(); 1736 } 1737 } 1738 // consume ';' 1739 ExpectAndConsume(tok::semi, diag::err_expected_semi_after, "@throw"); 1740 return Actions.ActOnObjCAtThrowStmt(atLoc, Res.take(), getCurScope()); 1741 } 1742 1743 /// objc-synchronized-statement: 1744 /// @synchronized '(' expression ')' compound-statement 1745 /// 1746 StmtResult 1747 Parser::ParseObjCSynchronizedStmt(SourceLocation atLoc) { 1748 ConsumeToken(); // consume synchronized 1749 if (Tok.isNot(tok::l_paren)) { 1750 Diag(Tok, diag::err_expected_lparen_after) << "@synchronized"; 1751 return StmtError(); 1752 } 1753 1754 // The operand is surrounded with parentheses. 1755 ConsumeParen(); // '(' 1756 ExprResult operand(ParseExpression()); 1757 1758 if (Tok.is(tok::r_paren)) { 1759 ConsumeParen(); // ')' 1760 } else { 1761 if (!operand.isInvalid()) 1762 Diag(Tok, diag::err_expected_rparen); 1763 1764 // Skip forward until we see a left brace, but don't consume it. 1765 SkipUntil(tok::l_brace, true, true); 1766 } 1767 1768 // Require a compound statement. 1769 if (Tok.isNot(tok::l_brace)) { 1770 if (!operand.isInvalid()) 1771 Diag(Tok, diag::err_expected_lbrace); 1772 return StmtError(); 1773 } 1774 1775 // Check the @synchronized operand now. 1776 if (!operand.isInvalid()) 1777 operand = Actions.ActOnObjCAtSynchronizedOperand(atLoc, operand.take()); 1778 1779 // Parse the compound statement within a new scope. 1780 ParseScope bodyScope(this, Scope::DeclScope); 1781 StmtResult body(ParseCompoundStatementBody()); 1782 bodyScope.Exit(); 1783 1784 // If there was a semantic or parse error earlier with the 1785 // operand, fail now. 1786 if (operand.isInvalid()) 1787 return StmtError(); 1788 1789 if (body.isInvalid()) 1790 body = Actions.ActOnNullStmt(Tok.getLocation()); 1791 1792 return Actions.ActOnObjCAtSynchronizedStmt(atLoc, operand.get(), body.get()); 1793 } 1794 1795 /// objc-try-catch-statement: 1796 /// @try compound-statement objc-catch-list[opt] 1797 /// @try compound-statement objc-catch-list[opt] @finally compound-statement 1798 /// 1799 /// objc-catch-list: 1800 /// @catch ( parameter-declaration ) compound-statement 1801 /// objc-catch-list @catch ( catch-parameter-declaration ) compound-statement 1802 /// catch-parameter-declaration: 1803 /// parameter-declaration 1804 /// '...' [OBJC2] 1805 /// 1806 StmtResult Parser::ParseObjCTryStmt(SourceLocation atLoc) { 1807 bool catch_or_finally_seen = false; 1808 1809 ConsumeToken(); // consume try 1810 if (Tok.isNot(tok::l_brace)) { 1811 Diag(Tok, diag::err_expected_lbrace); 1812 return StmtError(); 1813 } 1814 StmtVector CatchStmts; 1815 StmtResult FinallyStmt; 1816 ParseScope TryScope(this, Scope::DeclScope); 1817 StmtResult TryBody(ParseCompoundStatementBody()); 1818 TryScope.Exit(); 1819 if (TryBody.isInvalid()) 1820 TryBody = Actions.ActOnNullStmt(Tok.getLocation()); 1821 1822 while (Tok.is(tok::at)) { 1823 // At this point, we need to lookahead to determine if this @ is the start 1824 // of an @catch or @finally. We don't want to consume the @ token if this 1825 // is an @try or @encode or something else. 1826 Token AfterAt = GetLookAheadToken(1); 1827 if (!AfterAt.isObjCAtKeyword(tok::objc_catch) && 1828 !AfterAt.isObjCAtKeyword(tok::objc_finally)) 1829 break; 1830 1831 SourceLocation AtCatchFinallyLoc = ConsumeToken(); 1832 if (Tok.isObjCAtKeyword(tok::objc_catch)) { 1833 Decl *FirstPart = 0; 1834 ConsumeToken(); // consume catch 1835 if (Tok.is(tok::l_paren)) { 1836 ConsumeParen(); 1837 ParseScope CatchScope(this, Scope::DeclScope|Scope::AtCatchScope); 1838 if (Tok.isNot(tok::ellipsis)) { 1839 DeclSpec DS(AttrFactory); 1840 ParseDeclarationSpecifiers(DS); 1841 Declarator ParmDecl(DS, Declarator::ObjCCatchContext); 1842 ParseDeclarator(ParmDecl); 1843 1844 // Inform the actions module about the declarator, so it 1845 // gets added to the current scope. 1846 FirstPart = Actions.ActOnObjCExceptionDecl(getCurScope(), ParmDecl); 1847 } else 1848 ConsumeToken(); // consume '...' 1849 1850 SourceLocation RParenLoc; 1851 1852 if (Tok.is(tok::r_paren)) 1853 RParenLoc = ConsumeParen(); 1854 else // Skip over garbage, until we get to ')'. Eat the ')'. 1855 SkipUntil(tok::r_paren, true, false); 1856 1857 StmtResult CatchBody(true); 1858 if (Tok.is(tok::l_brace)) 1859 CatchBody = ParseCompoundStatementBody(); 1860 else 1861 Diag(Tok, diag::err_expected_lbrace); 1862 if (CatchBody.isInvalid()) 1863 CatchBody = Actions.ActOnNullStmt(Tok.getLocation()); 1864 1865 StmtResult Catch = Actions.ActOnObjCAtCatchStmt(AtCatchFinallyLoc, 1866 RParenLoc, 1867 FirstPart, 1868 CatchBody.take()); 1869 if (!Catch.isInvalid()) 1870 CatchStmts.push_back(Catch.release()); 1871 1872 } else { 1873 Diag(AtCatchFinallyLoc, diag::err_expected_lparen_after) 1874 << "@catch clause"; 1875 return StmtError(); 1876 } 1877 catch_or_finally_seen = true; 1878 } else { 1879 assert(Tok.isObjCAtKeyword(tok::objc_finally) && "Lookahead confused?"); 1880 ConsumeToken(); // consume finally 1881 ParseScope FinallyScope(this, Scope::DeclScope); 1882 1883 StmtResult FinallyBody(true); 1884 if (Tok.is(tok::l_brace)) 1885 FinallyBody = ParseCompoundStatementBody(); 1886 else 1887 Diag(Tok, diag::err_expected_lbrace); 1888 if (FinallyBody.isInvalid()) 1889 FinallyBody = Actions.ActOnNullStmt(Tok.getLocation()); 1890 FinallyStmt = Actions.ActOnObjCAtFinallyStmt(AtCatchFinallyLoc, 1891 FinallyBody.take()); 1892 catch_or_finally_seen = true; 1893 break; 1894 } 1895 } 1896 if (!catch_or_finally_seen) { 1897 Diag(atLoc, diag::err_missing_catch_finally); 1898 return StmtError(); 1899 } 1900 1901 return Actions.ActOnObjCAtTryStmt(atLoc, TryBody.take(), 1902 CatchStmts, 1903 FinallyStmt.take()); 1904 } 1905 1906 /// objc-autoreleasepool-statement: 1907 /// @autoreleasepool compound-statement 1908 /// 1909 StmtResult 1910 Parser::ParseObjCAutoreleasePoolStmt(SourceLocation atLoc) { 1911 ConsumeToken(); // consume autoreleasepool 1912 if (Tok.isNot(tok::l_brace)) { 1913 Diag(Tok, diag::err_expected_lbrace); 1914 return StmtError(); 1915 } 1916 // Enter a scope to hold everything within the compound stmt. Compound 1917 // statements can always hold declarations. 1918 ParseScope BodyScope(this, Scope::DeclScope); 1919 1920 StmtResult AutoreleasePoolBody(ParseCompoundStatementBody()); 1921 1922 BodyScope.Exit(); 1923 if (AutoreleasePoolBody.isInvalid()) 1924 AutoreleasePoolBody = Actions.ActOnNullStmt(Tok.getLocation()); 1925 return Actions.ActOnObjCAutoreleasePoolStmt(atLoc, 1926 AutoreleasePoolBody.take()); 1927 } 1928 1929 /// StashAwayMethodOrFunctionBodyTokens - Consume the tokens and store them 1930 /// for later parsing. 1931 void Parser::StashAwayMethodOrFunctionBodyTokens(Decl *MDecl) { 1932 LexedMethod* LM = new LexedMethod(this, MDecl); 1933 CurParsedObjCImpl->LateParsedObjCMethods.push_back(LM); 1934 CachedTokens &Toks = LM->Toks; 1935 // Begin by storing the '{' or 'try' or ':' token. 1936 Toks.push_back(Tok); 1937 if (Tok.is(tok::kw_try)) { 1938 ConsumeToken(); 1939 if (Tok.is(tok::colon)) { 1940 Toks.push_back(Tok); 1941 ConsumeToken(); 1942 while (Tok.isNot(tok::l_brace)) { 1943 ConsumeAndStoreUntil(tok::l_paren, Toks, /*StopAtSemi=*/false); 1944 ConsumeAndStoreUntil(tok::r_paren, Toks, /*StopAtSemi=*/false); 1945 } 1946 } 1947 Toks.push_back(Tok); // also store '{' 1948 } 1949 else if (Tok.is(tok::colon)) { 1950 ConsumeToken(); 1951 while (Tok.isNot(tok::l_brace)) { 1952 ConsumeAndStoreUntil(tok::l_paren, Toks, /*StopAtSemi=*/false); 1953 ConsumeAndStoreUntil(tok::r_paren, Toks, /*StopAtSemi=*/false); 1954 } 1955 Toks.push_back(Tok); // also store '{' 1956 } 1957 ConsumeBrace(); 1958 // Consume everything up to (and including) the matching right brace. 1959 ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/false); 1960 while (Tok.is(tok::kw_catch)) { 1961 ConsumeAndStoreUntil(tok::l_brace, Toks, /*StopAtSemi=*/false); 1962 ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/false); 1963 } 1964 } 1965 1966 /// objc-method-def: objc-method-proto ';'[opt] '{' body '}' 1967 /// 1968 Decl *Parser::ParseObjCMethodDefinition() { 1969 Decl *MDecl = ParseObjCMethodPrototype(); 1970 1971 PrettyDeclStackTraceEntry CrashInfo(Actions, MDecl, Tok.getLocation(), 1972 "parsing Objective-C method"); 1973 1974 // parse optional ';' 1975 if (Tok.is(tok::semi)) { 1976 if (CurParsedObjCImpl) { 1977 Diag(Tok, diag::warn_semicolon_before_method_body) 1978 << FixItHint::CreateRemoval(Tok.getLocation()); 1979 } 1980 ConsumeToken(); 1981 } 1982 1983 // We should have an opening brace now. 1984 if (Tok.isNot(tok::l_brace)) { 1985 Diag(Tok, diag::err_expected_method_body); 1986 1987 // Skip over garbage, until we get to '{'. Don't eat the '{'. 1988 SkipUntil(tok::l_brace, true, true); 1989 1990 // If we didn't find the '{', bail out. 1991 if (Tok.isNot(tok::l_brace)) 1992 return 0; 1993 } 1994 1995 if (!MDecl) { 1996 ConsumeBrace(); 1997 SkipUntil(tok::r_brace, /*StopAtSemi=*/false); 1998 return 0; 1999 } 2000 2001 // Allow the rest of sema to find private method decl implementations. 2002 Actions.AddAnyMethodToGlobalPool(MDecl); 2003 assert (CurParsedObjCImpl 2004 && "ParseObjCMethodDefinition - Method out of @implementation"); 2005 // Consume the tokens and store them for later parsing. 2006 StashAwayMethodOrFunctionBodyTokens(MDecl); 2007 return MDecl; 2008 } 2009 2010 StmtResult Parser::ParseObjCAtStatement(SourceLocation AtLoc) { 2011 if (Tok.is(tok::code_completion)) { 2012 Actions.CodeCompleteObjCAtStatement(getCurScope()); 2013 cutOffParsing(); 2014 return StmtError(); 2015 } 2016 2017 if (Tok.isObjCAtKeyword(tok::objc_try)) 2018 return ParseObjCTryStmt(AtLoc); 2019 2020 if (Tok.isObjCAtKeyword(tok::objc_throw)) 2021 return ParseObjCThrowStmt(AtLoc); 2022 2023 if (Tok.isObjCAtKeyword(tok::objc_synchronized)) 2024 return ParseObjCSynchronizedStmt(AtLoc); 2025 2026 if (Tok.isObjCAtKeyword(tok::objc_autoreleasepool)) 2027 return ParseObjCAutoreleasePoolStmt(AtLoc); 2028 2029 ExprResult Res(ParseExpressionWithLeadingAt(AtLoc)); 2030 if (Res.isInvalid()) { 2031 // If the expression is invalid, skip ahead to the next semicolon. Not 2032 // doing this opens us up to the possibility of infinite loops if 2033 // ParseExpression does not consume any tokens. 2034 SkipUntil(tok::semi); 2035 return StmtError(); 2036 } 2037 2038 // Otherwise, eat the semicolon. 2039 ExpectAndConsumeSemi(diag::err_expected_semi_after_expr); 2040 return Actions.ActOnExprStmt(Res); 2041 } 2042 2043 ExprResult Parser::ParseObjCAtExpression(SourceLocation AtLoc) { 2044 switch (Tok.getKind()) { 2045 case tok::code_completion: 2046 Actions.CodeCompleteObjCAtExpression(getCurScope()); 2047 cutOffParsing(); 2048 return ExprError(); 2049 2050 case tok::minus: 2051 case tok::plus: { 2052 tok::TokenKind Kind = Tok.getKind(); 2053 SourceLocation OpLoc = ConsumeToken(); 2054 2055 if (!Tok.is(tok::numeric_constant)) { 2056 const char *Symbol = 0; 2057 switch (Kind) { 2058 case tok::minus: Symbol = "-"; break; 2059 case tok::plus: Symbol = "+"; break; 2060 default: llvm_unreachable("missing unary operator case"); 2061 } 2062 Diag(Tok, diag::err_nsnumber_nonliteral_unary) 2063 << Symbol; 2064 return ExprError(); 2065 } 2066 2067 ExprResult Lit(Actions.ActOnNumericConstant(Tok)); 2068 if (Lit.isInvalid()) { 2069 return Lit; 2070 } 2071 ConsumeToken(); // Consume the literal token. 2072 2073 Lit = Actions.ActOnUnaryOp(getCurScope(), OpLoc, Kind, Lit.take()); 2074 if (Lit.isInvalid()) 2075 return Lit; 2076 2077 return ParsePostfixExpressionSuffix( 2078 Actions.BuildObjCNumericLiteral(AtLoc, Lit.take())); 2079 } 2080 2081 case tok::string_literal: // primary-expression: string-literal 2082 case tok::wide_string_literal: 2083 return ParsePostfixExpressionSuffix(ParseObjCStringLiteral(AtLoc)); 2084 2085 case tok::char_constant: 2086 return ParsePostfixExpressionSuffix(ParseObjCCharacterLiteral(AtLoc)); 2087 2088 case tok::numeric_constant: 2089 return ParsePostfixExpressionSuffix(ParseObjCNumericLiteral(AtLoc)); 2090 2091 case tok::kw_true: // Objective-C++, etc. 2092 case tok::kw___objc_yes: // c/c++/objc/objc++ __objc_yes 2093 return ParsePostfixExpressionSuffix(ParseObjCBooleanLiteral(AtLoc, true)); 2094 case tok::kw_false: // Objective-C++, etc. 2095 case tok::kw___objc_no: // c/c++/objc/objc++ __objc_no 2096 return ParsePostfixExpressionSuffix(ParseObjCBooleanLiteral(AtLoc, false)); 2097 2098 case tok::l_square: 2099 // Objective-C array literal 2100 return ParsePostfixExpressionSuffix(ParseObjCArrayLiteral(AtLoc)); 2101 2102 case tok::l_brace: 2103 // Objective-C dictionary literal 2104 return ParsePostfixExpressionSuffix(ParseObjCDictionaryLiteral(AtLoc)); 2105 2106 case tok::l_paren: 2107 // Objective-C boxed expression 2108 return ParsePostfixExpressionSuffix(ParseObjCBoxedExpr(AtLoc)); 2109 2110 default: 2111 if (Tok.getIdentifierInfo() == 0) 2112 return ExprError(Diag(AtLoc, diag::err_unexpected_at)); 2113 2114 switch (Tok.getIdentifierInfo()->getObjCKeywordID()) { 2115 case tok::objc_encode: 2116 return ParsePostfixExpressionSuffix(ParseObjCEncodeExpression(AtLoc)); 2117 case tok::objc_protocol: 2118 return ParsePostfixExpressionSuffix(ParseObjCProtocolExpression(AtLoc)); 2119 case tok::objc_selector: 2120 return ParsePostfixExpressionSuffix(ParseObjCSelectorExpression(AtLoc)); 2121 default: { 2122 const char *str = 0; 2123 if (GetLookAheadToken(1).is(tok::l_brace)) { 2124 char ch = Tok.getIdentifierInfo()->getNameStart()[0]; 2125 str = 2126 ch == 't' ? "try" 2127 : (ch == 'f' ? "finally" 2128 : (ch == 'a' ? "autoreleasepool" : 0)); 2129 } 2130 if (str) { 2131 SourceLocation kwLoc = Tok.getLocation(); 2132 return ExprError(Diag(AtLoc, diag::err_unexpected_at) << 2133 FixItHint::CreateReplacement(kwLoc, str)); 2134 } 2135 else 2136 return ExprError(Diag(AtLoc, diag::err_unexpected_at)); 2137 } 2138 } 2139 } 2140 } 2141 2142 /// \brief Parse the receiver of an Objective-C++ message send. 2143 /// 2144 /// This routine parses the receiver of a message send in 2145 /// Objective-C++ either as a type or as an expression. Note that this 2146 /// routine must not be called to parse a send to 'super', since it 2147 /// has no way to return such a result. 2148 /// 2149 /// \param IsExpr Whether the receiver was parsed as an expression. 2150 /// 2151 /// \param TypeOrExpr If the receiver was parsed as an expression (\c 2152 /// IsExpr is true), the parsed expression. If the receiver was parsed 2153 /// as a type (\c IsExpr is false), the parsed type. 2154 /// 2155 /// \returns True if an error occurred during parsing or semantic 2156 /// analysis, in which case the arguments do not have valid 2157 /// values. Otherwise, returns false for a successful parse. 2158 /// 2159 /// objc-receiver: [C++] 2160 /// 'super' [not parsed here] 2161 /// expression 2162 /// simple-type-specifier 2163 /// typename-specifier 2164 bool Parser::ParseObjCXXMessageReceiver(bool &IsExpr, void *&TypeOrExpr) { 2165 InMessageExpressionRAIIObject InMessage(*this, true); 2166 2167 if (Tok.is(tok::identifier) || Tok.is(tok::coloncolon) || 2168 Tok.is(tok::kw_typename) || Tok.is(tok::annot_cxxscope)) 2169 TryAnnotateTypeOrScopeToken(); 2170 2171 if (!Actions.isSimpleTypeSpecifier(Tok.getKind())) { 2172 // objc-receiver: 2173 // expression 2174 ExprResult Receiver = ParseExpression(); 2175 if (Receiver.isInvalid()) 2176 return true; 2177 2178 IsExpr = true; 2179 TypeOrExpr = Receiver.take(); 2180 return false; 2181 } 2182 2183 // objc-receiver: 2184 // typename-specifier 2185 // simple-type-specifier 2186 // expression (that starts with one of the above) 2187 DeclSpec DS(AttrFactory); 2188 ParseCXXSimpleTypeSpecifier(DS); 2189 2190 if (Tok.is(tok::l_paren)) { 2191 // If we see an opening parentheses at this point, we are 2192 // actually parsing an expression that starts with a 2193 // function-style cast, e.g., 2194 // 2195 // postfix-expression: 2196 // simple-type-specifier ( expression-list [opt] ) 2197 // typename-specifier ( expression-list [opt] ) 2198 // 2199 // Parse the remainder of this case, then the (optional) 2200 // postfix-expression suffix, followed by the (optional) 2201 // right-hand side of the binary expression. We have an 2202 // instance method. 2203 ExprResult Receiver = ParseCXXTypeConstructExpression(DS); 2204 if (!Receiver.isInvalid()) 2205 Receiver = ParsePostfixExpressionSuffix(Receiver.take()); 2206 if (!Receiver.isInvalid()) 2207 Receiver = ParseRHSOfBinaryExpression(Receiver.take(), prec::Comma); 2208 if (Receiver.isInvalid()) 2209 return true; 2210 2211 IsExpr = true; 2212 TypeOrExpr = Receiver.take(); 2213 return false; 2214 } 2215 2216 // We have a class message. Turn the simple-type-specifier or 2217 // typename-specifier we parsed into a type and parse the 2218 // remainder of the class message. 2219 Declarator DeclaratorInfo(DS, Declarator::TypeNameContext); 2220 TypeResult Type = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo); 2221 if (Type.isInvalid()) 2222 return true; 2223 2224 IsExpr = false; 2225 TypeOrExpr = Type.get().getAsOpaquePtr(); 2226 return false; 2227 } 2228 2229 /// \brief Determine whether the parser is currently referring to a an 2230 /// Objective-C message send, using a simplified heuristic to avoid overhead. 2231 /// 2232 /// This routine will only return true for a subset of valid message-send 2233 /// expressions. 2234 bool Parser::isSimpleObjCMessageExpression() { 2235 assert(Tok.is(tok::l_square) && getLangOpts().ObjC1 && 2236 "Incorrect start for isSimpleObjCMessageExpression"); 2237 return GetLookAheadToken(1).is(tok::identifier) && 2238 GetLookAheadToken(2).is(tok::identifier); 2239 } 2240 2241 bool Parser::isStartOfObjCClassMessageMissingOpenBracket() { 2242 if (!getLangOpts().ObjC1 || !NextToken().is(tok::identifier) || 2243 InMessageExpression) 2244 return false; 2245 2246 2247 ParsedType Type; 2248 2249 if (Tok.is(tok::annot_typename)) 2250 Type = getTypeAnnotation(Tok); 2251 else if (Tok.is(tok::identifier)) 2252 Type = Actions.getTypeName(*Tok.getIdentifierInfo(), Tok.getLocation(), 2253 getCurScope()); 2254 else 2255 return false; 2256 2257 if (!Type.get().isNull() && Type.get()->isObjCObjectOrInterfaceType()) { 2258 const Token &AfterNext = GetLookAheadToken(2); 2259 if (AfterNext.is(tok::colon) || AfterNext.is(tok::r_square)) { 2260 if (Tok.is(tok::identifier)) 2261 TryAnnotateTypeOrScopeToken(); 2262 2263 return Tok.is(tok::annot_typename); 2264 } 2265 } 2266 2267 return false; 2268 } 2269 2270 /// objc-message-expr: 2271 /// '[' objc-receiver objc-message-args ']' 2272 /// 2273 /// objc-receiver: [C] 2274 /// 'super' 2275 /// expression 2276 /// class-name 2277 /// type-name 2278 /// 2279 ExprResult Parser::ParseObjCMessageExpression() { 2280 assert(Tok.is(tok::l_square) && "'[' expected"); 2281 SourceLocation LBracLoc = ConsumeBracket(); // consume '[' 2282 2283 if (Tok.is(tok::code_completion)) { 2284 Actions.CodeCompleteObjCMessageReceiver(getCurScope()); 2285 cutOffParsing(); 2286 return ExprError(); 2287 } 2288 2289 InMessageExpressionRAIIObject InMessage(*this, true); 2290 2291 if (getLangOpts().CPlusPlus) { 2292 // We completely separate the C and C++ cases because C++ requires 2293 // more complicated (read: slower) parsing. 2294 2295 // Handle send to super. 2296 // FIXME: This doesn't benefit from the same typo-correction we 2297 // get in Objective-C. 2298 if (Tok.is(tok::identifier) && Tok.getIdentifierInfo() == Ident_super && 2299 NextToken().isNot(tok::period) && getCurScope()->isInObjcMethodScope()) 2300 return ParseObjCMessageExpressionBody(LBracLoc, ConsumeToken(), 2301 ParsedType(), 0); 2302 2303 // Parse the receiver, which is either a type or an expression. 2304 bool IsExpr; 2305 void *TypeOrExpr = NULL; 2306 if (ParseObjCXXMessageReceiver(IsExpr, TypeOrExpr)) { 2307 SkipUntil(tok::r_square); 2308 return ExprError(); 2309 } 2310 2311 if (IsExpr) 2312 return ParseObjCMessageExpressionBody(LBracLoc, SourceLocation(), 2313 ParsedType(), 2314 static_cast<Expr*>(TypeOrExpr)); 2315 2316 return ParseObjCMessageExpressionBody(LBracLoc, SourceLocation(), 2317 ParsedType::getFromOpaquePtr(TypeOrExpr), 2318 0); 2319 } 2320 2321 if (Tok.is(tok::identifier)) { 2322 IdentifierInfo *Name = Tok.getIdentifierInfo(); 2323 SourceLocation NameLoc = Tok.getLocation(); 2324 ParsedType ReceiverType; 2325 switch (Actions.getObjCMessageKind(getCurScope(), Name, NameLoc, 2326 Name == Ident_super, 2327 NextToken().is(tok::period), 2328 ReceiverType)) { 2329 case Sema::ObjCSuperMessage: 2330 return ParseObjCMessageExpressionBody(LBracLoc, ConsumeToken(), 2331 ParsedType(), 0); 2332 2333 case Sema::ObjCClassMessage: 2334 if (!ReceiverType) { 2335 SkipUntil(tok::r_square); 2336 return ExprError(); 2337 } 2338 2339 ConsumeToken(); // the type name 2340 2341 return ParseObjCMessageExpressionBody(LBracLoc, SourceLocation(), 2342 ReceiverType, 0); 2343 2344 case Sema::ObjCInstanceMessage: 2345 // Fall through to parse an expression. 2346 break; 2347 } 2348 } 2349 2350 // Otherwise, an arbitrary expression can be the receiver of a send. 2351 ExprResult Res(ParseExpression()); 2352 if (Res.isInvalid()) { 2353 SkipUntil(tok::r_square); 2354 return Res; 2355 } 2356 2357 return ParseObjCMessageExpressionBody(LBracLoc, SourceLocation(), 2358 ParsedType(), Res.take()); 2359 } 2360 2361 /// \brief Parse the remainder of an Objective-C message following the 2362 /// '[' objc-receiver. 2363 /// 2364 /// This routine handles sends to super, class messages (sent to a 2365 /// class name), and instance messages (sent to an object), and the 2366 /// target is represented by \p SuperLoc, \p ReceiverType, or \p 2367 /// ReceiverExpr, respectively. Only one of these parameters may have 2368 /// a valid value. 2369 /// 2370 /// \param LBracLoc The location of the opening '['. 2371 /// 2372 /// \param SuperLoc If this is a send to 'super', the location of the 2373 /// 'super' keyword that indicates a send to the superclass. 2374 /// 2375 /// \param ReceiverType If this is a class message, the type of the 2376 /// class we are sending a message to. 2377 /// 2378 /// \param ReceiverExpr If this is an instance message, the expression 2379 /// used to compute the receiver object. 2380 /// 2381 /// objc-message-args: 2382 /// objc-selector 2383 /// objc-keywordarg-list 2384 /// 2385 /// objc-keywordarg-list: 2386 /// objc-keywordarg 2387 /// objc-keywordarg-list objc-keywordarg 2388 /// 2389 /// objc-keywordarg: 2390 /// selector-name[opt] ':' objc-keywordexpr 2391 /// 2392 /// objc-keywordexpr: 2393 /// nonempty-expr-list 2394 /// 2395 /// nonempty-expr-list: 2396 /// assignment-expression 2397 /// nonempty-expr-list , assignment-expression 2398 /// 2399 ExprResult 2400 Parser::ParseObjCMessageExpressionBody(SourceLocation LBracLoc, 2401 SourceLocation SuperLoc, 2402 ParsedType ReceiverType, 2403 ExprArg ReceiverExpr) { 2404 InMessageExpressionRAIIObject InMessage(*this, true); 2405 2406 if (Tok.is(tok::code_completion)) { 2407 if (SuperLoc.isValid()) 2408 Actions.CodeCompleteObjCSuperMessage(getCurScope(), SuperLoc, 0, 0, 2409 false); 2410 else if (ReceiverType) 2411 Actions.CodeCompleteObjCClassMessage(getCurScope(), ReceiverType, 0, 0, 2412 false); 2413 else 2414 Actions.CodeCompleteObjCInstanceMessage(getCurScope(), ReceiverExpr, 2415 0, 0, false); 2416 cutOffParsing(); 2417 return ExprError(); 2418 } 2419 2420 // Parse objc-selector 2421 SourceLocation Loc; 2422 IdentifierInfo *selIdent = ParseObjCSelectorPiece(Loc); 2423 2424 SmallVector<IdentifierInfo *, 12> KeyIdents; 2425 SmallVector<SourceLocation, 12> KeyLocs; 2426 ExprVector KeyExprs; 2427 2428 if (Tok.is(tok::colon)) { 2429 while (1) { 2430 // Each iteration parses a single keyword argument. 2431 KeyIdents.push_back(selIdent); 2432 KeyLocs.push_back(Loc); 2433 2434 if (Tok.isNot(tok::colon)) { 2435 Diag(Tok, diag::err_expected_colon); 2436 // We must manually skip to a ']', otherwise the expression skipper will 2437 // stop at the ']' when it skips to the ';'. We want it to skip beyond 2438 // the enclosing expression. 2439 SkipUntil(tok::r_square); 2440 return ExprError(); 2441 } 2442 2443 ConsumeToken(); // Eat the ':'. 2444 /// Parse the expression after ':' 2445 2446 if (Tok.is(tok::code_completion)) { 2447 if (SuperLoc.isValid()) 2448 Actions.CodeCompleteObjCSuperMessage(getCurScope(), SuperLoc, 2449 KeyIdents.data(), 2450 KeyIdents.size(), 2451 /*AtArgumentEpression=*/true); 2452 else if (ReceiverType) 2453 Actions.CodeCompleteObjCClassMessage(getCurScope(), ReceiverType, 2454 KeyIdents.data(), 2455 KeyIdents.size(), 2456 /*AtArgumentEpression=*/true); 2457 else 2458 Actions.CodeCompleteObjCInstanceMessage(getCurScope(), ReceiverExpr, 2459 KeyIdents.data(), 2460 KeyIdents.size(), 2461 /*AtArgumentEpression=*/true); 2462 2463 cutOffParsing(); 2464 return ExprError(); 2465 } 2466 2467 ExprResult Res(ParseAssignmentExpression()); 2468 if (Res.isInvalid()) { 2469 // We must manually skip to a ']', otherwise the expression skipper will 2470 // stop at the ']' when it skips to the ';'. We want it to skip beyond 2471 // the enclosing expression. 2472 SkipUntil(tok::r_square); 2473 return Res; 2474 } 2475 2476 // We have a valid expression. 2477 KeyExprs.push_back(Res.release()); 2478 2479 // Code completion after each argument. 2480 if (Tok.is(tok::code_completion)) { 2481 if (SuperLoc.isValid()) 2482 Actions.CodeCompleteObjCSuperMessage(getCurScope(), SuperLoc, 2483 KeyIdents.data(), 2484 KeyIdents.size(), 2485 /*AtArgumentEpression=*/false); 2486 else if (ReceiverType) 2487 Actions.CodeCompleteObjCClassMessage(getCurScope(), ReceiverType, 2488 KeyIdents.data(), 2489 KeyIdents.size(), 2490 /*AtArgumentEpression=*/false); 2491 else 2492 Actions.CodeCompleteObjCInstanceMessage(getCurScope(), ReceiverExpr, 2493 KeyIdents.data(), 2494 KeyIdents.size(), 2495 /*AtArgumentEpression=*/false); 2496 cutOffParsing(); 2497 return ExprError(); 2498 } 2499 2500 // Check for another keyword selector. 2501 selIdent = ParseObjCSelectorPiece(Loc); 2502 if (!selIdent && Tok.isNot(tok::colon)) 2503 break; 2504 // We have a selector or a colon, continue parsing. 2505 } 2506 // Parse the, optional, argument list, comma separated. 2507 while (Tok.is(tok::comma)) { 2508 SourceLocation commaLoc = ConsumeToken(); // Eat the ','. 2509 /// Parse the expression after ',' 2510 ExprResult Res(ParseAssignmentExpression()); 2511 if (Res.isInvalid()) { 2512 if (Tok.is(tok::colon)) { 2513 Diag(commaLoc, diag::note_extra_comma_message_arg) << 2514 FixItHint::CreateRemoval(commaLoc); 2515 } 2516 // We must manually skip to a ']', otherwise the expression skipper will 2517 // stop at the ']' when it skips to the ';'. We want it to skip beyond 2518 // the enclosing expression. 2519 SkipUntil(tok::r_square); 2520 return Res; 2521 } 2522 2523 // We have a valid expression. 2524 KeyExprs.push_back(Res.release()); 2525 } 2526 } else if (!selIdent) { 2527 Diag(Tok, diag::err_expected_ident); // missing selector name. 2528 2529 // We must manually skip to a ']', otherwise the expression skipper will 2530 // stop at the ']' when it skips to the ';'. We want it to skip beyond 2531 // the enclosing expression. 2532 SkipUntil(tok::r_square); 2533 return ExprError(); 2534 } 2535 2536 if (Tok.isNot(tok::r_square)) { 2537 if (Tok.is(tok::identifier)) 2538 Diag(Tok, diag::err_expected_colon); 2539 else 2540 Diag(Tok, diag::err_expected_rsquare); 2541 // We must manually skip to a ']', otherwise the expression skipper will 2542 // stop at the ']' when it skips to the ';'. We want it to skip beyond 2543 // the enclosing expression. 2544 SkipUntil(tok::r_square); 2545 return ExprError(); 2546 } 2547 2548 SourceLocation RBracLoc = ConsumeBracket(); // consume ']' 2549 2550 unsigned nKeys = KeyIdents.size(); 2551 if (nKeys == 0) { 2552 KeyIdents.push_back(selIdent); 2553 KeyLocs.push_back(Loc); 2554 } 2555 Selector Sel = PP.getSelectorTable().getSelector(nKeys, &KeyIdents[0]); 2556 2557 if (SuperLoc.isValid()) 2558 return Actions.ActOnSuperMessage(getCurScope(), SuperLoc, Sel, 2559 LBracLoc, KeyLocs, RBracLoc, KeyExprs); 2560 else if (ReceiverType) 2561 return Actions.ActOnClassMessage(getCurScope(), ReceiverType, Sel, 2562 LBracLoc, KeyLocs, RBracLoc, KeyExprs); 2563 return Actions.ActOnInstanceMessage(getCurScope(), ReceiverExpr, Sel, 2564 LBracLoc, KeyLocs, RBracLoc, KeyExprs); 2565 } 2566 2567 ExprResult Parser::ParseObjCStringLiteral(SourceLocation AtLoc) { 2568 ExprResult Res(ParseStringLiteralExpression()); 2569 if (Res.isInvalid()) return Res; 2570 2571 // @"foo" @"bar" is a valid concatenated string. Eat any subsequent string 2572 // expressions. At this point, we know that the only valid thing that starts 2573 // with '@' is an @"". 2574 SmallVector<SourceLocation, 4> AtLocs; 2575 ExprVector AtStrings; 2576 AtLocs.push_back(AtLoc); 2577 AtStrings.push_back(Res.release()); 2578 2579 while (Tok.is(tok::at)) { 2580 AtLocs.push_back(ConsumeToken()); // eat the @. 2581 2582 // Invalid unless there is a string literal. 2583 if (!isTokenStringLiteral()) 2584 return ExprError(Diag(Tok, diag::err_objc_concat_string)); 2585 2586 ExprResult Lit(ParseStringLiteralExpression()); 2587 if (Lit.isInvalid()) 2588 return Lit; 2589 2590 AtStrings.push_back(Lit.release()); 2591 } 2592 2593 return Actions.ParseObjCStringLiteral(&AtLocs[0], AtStrings.data(), 2594 AtStrings.size()); 2595 } 2596 2597 /// ParseObjCBooleanLiteral - 2598 /// objc-scalar-literal : '@' boolean-keyword 2599 /// ; 2600 /// boolean-keyword: 'true' | 'false' | '__objc_yes' | '__objc_no' 2601 /// ; 2602 ExprResult Parser::ParseObjCBooleanLiteral(SourceLocation AtLoc, 2603 bool ArgValue) { 2604 SourceLocation EndLoc = ConsumeToken(); // consume the keyword. 2605 return Actions.ActOnObjCBoolLiteral(AtLoc, EndLoc, ArgValue); 2606 } 2607 2608 /// ParseObjCCharacterLiteral - 2609 /// objc-scalar-literal : '@' character-literal 2610 /// ; 2611 ExprResult Parser::ParseObjCCharacterLiteral(SourceLocation AtLoc) { 2612 ExprResult Lit(Actions.ActOnCharacterConstant(Tok)); 2613 if (Lit.isInvalid()) { 2614 return Lit; 2615 } 2616 ConsumeToken(); // Consume the literal token. 2617 return Actions.BuildObjCNumericLiteral(AtLoc, Lit.take()); 2618 } 2619 2620 /// ParseObjCNumericLiteral - 2621 /// objc-scalar-literal : '@' scalar-literal 2622 /// ; 2623 /// scalar-literal : | numeric-constant /* any numeric constant. */ 2624 /// ; 2625 ExprResult Parser::ParseObjCNumericLiteral(SourceLocation AtLoc) { 2626 ExprResult Lit(Actions.ActOnNumericConstant(Tok)); 2627 if (Lit.isInvalid()) { 2628 return Lit; 2629 } 2630 ConsumeToken(); // Consume the literal token. 2631 return Actions.BuildObjCNumericLiteral(AtLoc, Lit.take()); 2632 } 2633 2634 /// ParseObjCBoxedExpr - 2635 /// objc-box-expression: 2636 /// @( assignment-expression ) 2637 ExprResult 2638 Parser::ParseObjCBoxedExpr(SourceLocation AtLoc) { 2639 if (Tok.isNot(tok::l_paren)) 2640 return ExprError(Diag(Tok, diag::err_expected_lparen_after) << "@"); 2641 2642 BalancedDelimiterTracker T(*this, tok::l_paren); 2643 T.consumeOpen(); 2644 ExprResult ValueExpr(ParseAssignmentExpression()); 2645 if (T.consumeClose()) 2646 return ExprError(); 2647 2648 if (ValueExpr.isInvalid()) 2649 return ExprError(); 2650 2651 // Wrap the sub-expression in a parenthesized expression, to distinguish 2652 // a boxed expression from a literal. 2653 SourceLocation LPLoc = T.getOpenLocation(), RPLoc = T.getCloseLocation(); 2654 ValueExpr = Actions.ActOnParenExpr(LPLoc, RPLoc, ValueExpr.take()); 2655 return Actions.BuildObjCBoxedExpr(SourceRange(AtLoc, RPLoc), 2656 ValueExpr.take()); 2657 } 2658 2659 ExprResult Parser::ParseObjCArrayLiteral(SourceLocation AtLoc) { 2660 ExprVector ElementExprs; // array elements. 2661 ConsumeBracket(); // consume the l_square. 2662 2663 while (Tok.isNot(tok::r_square)) { 2664 // Parse list of array element expressions (all must be id types). 2665 ExprResult Res(ParseAssignmentExpression()); 2666 if (Res.isInvalid()) { 2667 // We must manually skip to a ']', otherwise the expression skipper will 2668 // stop at the ']' when it skips to the ';'. We want it to skip beyond 2669 // the enclosing expression. 2670 SkipUntil(tok::r_square); 2671 return Res; 2672 } 2673 2674 // Parse the ellipsis that indicates a pack expansion. 2675 if (Tok.is(tok::ellipsis)) 2676 Res = Actions.ActOnPackExpansion(Res.get(), ConsumeToken()); 2677 if (Res.isInvalid()) 2678 return true; 2679 2680 ElementExprs.push_back(Res.release()); 2681 2682 if (Tok.is(tok::comma)) 2683 ConsumeToken(); // Eat the ','. 2684 else if (Tok.isNot(tok::r_square)) 2685 return ExprError(Diag(Tok, diag::err_expected_rsquare_or_comma)); 2686 } 2687 SourceLocation EndLoc = ConsumeBracket(); // location of ']' 2688 MultiExprArg Args(ElementExprs); 2689 return Actions.BuildObjCArrayLiteral(SourceRange(AtLoc, EndLoc), Args); 2690 } 2691 2692 ExprResult Parser::ParseObjCDictionaryLiteral(SourceLocation AtLoc) { 2693 SmallVector<ObjCDictionaryElement, 4> Elements; // dictionary elements. 2694 ConsumeBrace(); // consume the l_square. 2695 while (Tok.isNot(tok::r_brace)) { 2696 // Parse the comma separated key : value expressions. 2697 ExprResult KeyExpr; 2698 { 2699 ColonProtectionRAIIObject X(*this); 2700 KeyExpr = ParseAssignmentExpression(); 2701 if (KeyExpr.isInvalid()) { 2702 // We must manually skip to a '}', otherwise the expression skipper will 2703 // stop at the '}' when it skips to the ';'. We want it to skip beyond 2704 // the enclosing expression. 2705 SkipUntil(tok::r_brace); 2706 return KeyExpr; 2707 } 2708 } 2709 2710 if (Tok.is(tok::colon)) { 2711 ConsumeToken(); 2712 } else { 2713 return ExprError(Diag(Tok, diag::err_expected_colon)); 2714 } 2715 2716 ExprResult ValueExpr(ParseAssignmentExpression()); 2717 if (ValueExpr.isInvalid()) { 2718 // We must manually skip to a '}', otherwise the expression skipper will 2719 // stop at the '}' when it skips to the ';'. We want it to skip beyond 2720 // the enclosing expression. 2721 SkipUntil(tok::r_brace); 2722 return ValueExpr; 2723 } 2724 2725 // Parse the ellipsis that designates this as a pack expansion. 2726 SourceLocation EllipsisLoc; 2727 if (Tok.is(tok::ellipsis) && getLangOpts().CPlusPlus) 2728 EllipsisLoc = ConsumeToken(); 2729 2730 // We have a valid expression. Collect it in a vector so we can 2731 // build the argument list. 2732 ObjCDictionaryElement Element = { 2733 KeyExpr.get(), ValueExpr.get(), EllipsisLoc, None 2734 }; 2735 Elements.push_back(Element); 2736 2737 if (Tok.is(tok::comma)) 2738 ConsumeToken(); // Eat the ','. 2739 else if (Tok.isNot(tok::r_brace)) 2740 return ExprError(Diag(Tok, diag::err_expected_rbrace_or_comma)); 2741 } 2742 SourceLocation EndLoc = ConsumeBrace(); 2743 2744 // Create the ObjCDictionaryLiteral. 2745 return Actions.BuildObjCDictionaryLiteral(SourceRange(AtLoc, EndLoc), 2746 Elements.data(), Elements.size()); 2747 } 2748 2749 /// objc-encode-expression: 2750 /// \@encode ( type-name ) 2751 ExprResult 2752 Parser::ParseObjCEncodeExpression(SourceLocation AtLoc) { 2753 assert(Tok.isObjCAtKeyword(tok::objc_encode) && "Not an @encode expression!"); 2754 2755 SourceLocation EncLoc = ConsumeToken(); 2756 2757 if (Tok.isNot(tok::l_paren)) 2758 return ExprError(Diag(Tok, diag::err_expected_lparen_after) << "@encode"); 2759 2760 BalancedDelimiterTracker T(*this, tok::l_paren); 2761 T.consumeOpen(); 2762 2763 TypeResult Ty = ParseTypeName(); 2764 2765 T.consumeClose(); 2766 2767 if (Ty.isInvalid()) 2768 return ExprError(); 2769 2770 return Actions.ParseObjCEncodeExpression(AtLoc, EncLoc, T.getOpenLocation(), 2771 Ty.get(), T.getCloseLocation()); 2772 } 2773 2774 /// objc-protocol-expression 2775 /// \@protocol ( protocol-name ) 2776 ExprResult 2777 Parser::ParseObjCProtocolExpression(SourceLocation AtLoc) { 2778 SourceLocation ProtoLoc = ConsumeToken(); 2779 2780 if (Tok.isNot(tok::l_paren)) 2781 return ExprError(Diag(Tok, diag::err_expected_lparen_after) << "@protocol"); 2782 2783 BalancedDelimiterTracker T(*this, tok::l_paren); 2784 T.consumeOpen(); 2785 2786 if (Tok.isNot(tok::identifier)) 2787 return ExprError(Diag(Tok, diag::err_expected_ident)); 2788 2789 IdentifierInfo *protocolId = Tok.getIdentifierInfo(); 2790 SourceLocation ProtoIdLoc = ConsumeToken(); 2791 2792 T.consumeClose(); 2793 2794 return Actions.ParseObjCProtocolExpression(protocolId, AtLoc, ProtoLoc, 2795 T.getOpenLocation(), ProtoIdLoc, 2796 T.getCloseLocation()); 2797 } 2798 2799 /// objc-selector-expression 2800 /// @selector '(' objc-keyword-selector ')' 2801 ExprResult Parser::ParseObjCSelectorExpression(SourceLocation AtLoc) { 2802 SourceLocation SelectorLoc = ConsumeToken(); 2803 2804 if (Tok.isNot(tok::l_paren)) 2805 return ExprError(Diag(Tok, diag::err_expected_lparen_after) << "@selector"); 2806 2807 SmallVector<IdentifierInfo *, 12> KeyIdents; 2808 SourceLocation sLoc; 2809 2810 BalancedDelimiterTracker T(*this, tok::l_paren); 2811 T.consumeOpen(); 2812 2813 if (Tok.is(tok::code_completion)) { 2814 Actions.CodeCompleteObjCSelector(getCurScope(), KeyIdents.data(), 2815 KeyIdents.size()); 2816 cutOffParsing(); 2817 return ExprError(); 2818 } 2819 2820 IdentifierInfo *SelIdent = ParseObjCSelectorPiece(sLoc); 2821 if (!SelIdent && // missing selector name. 2822 Tok.isNot(tok::colon) && Tok.isNot(tok::coloncolon)) 2823 return ExprError(Diag(Tok, diag::err_expected_ident)); 2824 2825 KeyIdents.push_back(SelIdent); 2826 unsigned nColons = 0; 2827 if (Tok.isNot(tok::r_paren)) { 2828 while (1) { 2829 if (Tok.is(tok::coloncolon)) { // Handle :: in C++. 2830 ++nColons; 2831 KeyIdents.push_back(0); 2832 } else if (Tok.isNot(tok::colon)) 2833 return ExprError(Diag(Tok, diag::err_expected_colon)); 2834 2835 ++nColons; 2836 ConsumeToken(); // Eat the ':' or '::'. 2837 if (Tok.is(tok::r_paren)) 2838 break; 2839 2840 if (Tok.is(tok::code_completion)) { 2841 Actions.CodeCompleteObjCSelector(getCurScope(), KeyIdents.data(), 2842 KeyIdents.size()); 2843 cutOffParsing(); 2844 return ExprError(); 2845 } 2846 2847 // Check for another keyword selector. 2848 SourceLocation Loc; 2849 SelIdent = ParseObjCSelectorPiece(Loc); 2850 KeyIdents.push_back(SelIdent); 2851 if (!SelIdent && Tok.isNot(tok::colon) && Tok.isNot(tok::coloncolon)) 2852 break; 2853 } 2854 } 2855 T.consumeClose(); 2856 Selector Sel = PP.getSelectorTable().getSelector(nColons, &KeyIdents[0]); 2857 return Actions.ParseObjCSelectorExpression(Sel, AtLoc, SelectorLoc, 2858 T.getOpenLocation(), 2859 T.getCloseLocation()); 2860 } 2861 2862 void Parser::ParseLexedObjCMethodDefs(LexedMethod &LM, bool parseMethod) { 2863 // MCDecl might be null due to error in method or c-function prototype, etc. 2864 Decl *MCDecl = LM.D; 2865 bool skip = MCDecl && 2866 ((parseMethod && !Actions.isObjCMethodDecl(MCDecl)) || 2867 (!parseMethod && Actions.isObjCMethodDecl(MCDecl))); 2868 if (skip) 2869 return; 2870 2871 // Save the current token position. 2872 SourceLocation OrigLoc = Tok.getLocation(); 2873 2874 assert(!LM.Toks.empty() && "ParseLexedObjCMethodDef - Empty body!"); 2875 // Append the current token at the end of the new token stream so that it 2876 // doesn't get lost. 2877 LM.Toks.push_back(Tok); 2878 PP.EnterTokenStream(LM.Toks.data(), LM.Toks.size(), true, false); 2879 2880 // Consume the previously pushed token. 2881 ConsumeAnyToken(); 2882 2883 assert((Tok.is(tok::l_brace) || Tok.is(tok::kw_try) || 2884 Tok.is(tok::colon)) && 2885 "Inline objective-c method not starting with '{' or 'try' or ':'"); 2886 // Enter a scope for the method or c-fucntion body. 2887 ParseScope BodyScope(this, 2888 parseMethod 2889 ? Scope::ObjCMethodScope|Scope::FnScope|Scope::DeclScope 2890 : Scope::FnScope|Scope::DeclScope); 2891 2892 // Tell the actions module that we have entered a method or c-function definition 2893 // with the specified Declarator for the method/function. 2894 if (parseMethod) 2895 Actions.ActOnStartOfObjCMethodDef(getCurScope(), MCDecl); 2896 else 2897 Actions.ActOnStartOfFunctionDef(getCurScope(), MCDecl); 2898 if (Tok.is(tok::kw_try)) 2899 MCDecl = ParseFunctionTryBlock(MCDecl, BodyScope); 2900 else { 2901 if (Tok.is(tok::colon)) 2902 ParseConstructorInitializer(MCDecl); 2903 MCDecl = ParseFunctionStatementBody(MCDecl, BodyScope); 2904 } 2905 2906 if (Tok.getLocation() != OrigLoc) { 2907 // Due to parsing error, we either went over the cached tokens or 2908 // there are still cached tokens left. If it's the latter case skip the 2909 // leftover tokens. 2910 // Since this is an uncommon situation that should be avoided, use the 2911 // expensive isBeforeInTranslationUnit call. 2912 if (PP.getSourceManager().isBeforeInTranslationUnit(Tok.getLocation(), 2913 OrigLoc)) 2914 while (Tok.getLocation() != OrigLoc && Tok.isNot(tok::eof)) 2915 ConsumeAnyToken(); 2916 } 2917 2918 return; 2919 } 2920