1 //===--- ParseObjC.cpp - Objective C Parsing ------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file implements the Objective-C portions of the Parser interface. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "clang/AST/ASTContext.h" 14 #include "clang/AST/PrettyDeclStackTrace.h" 15 #include "clang/Basic/CharInfo.h" 16 #include "clang/Basic/TargetInfo.h" 17 #include "clang/Parse/ParseDiagnostic.h" 18 #include "clang/Parse/Parser.h" 19 #include "clang/Parse/RAIIObjectsForParser.h" 20 #include "clang/Sema/DeclSpec.h" 21 #include "clang/Sema/Scope.h" 22 #include "llvm/ADT/SmallVector.h" 23 #include "llvm/ADT/StringExtras.h" 24 25 using namespace clang; 26 27 /// Skips attributes after an Objective-C @ directive. Emits a diagnostic. 28 void Parser::MaybeSkipAttributes(tok::ObjCKeywordKind Kind) { 29 ParsedAttributes attrs(AttrFactory); 30 if (Tok.is(tok::kw___attribute)) { 31 if (Kind == tok::objc_interface || Kind == tok::objc_protocol) 32 Diag(Tok, diag::err_objc_postfix_attribute_hint) 33 << (Kind == tok::objc_protocol); 34 else 35 Diag(Tok, diag::err_objc_postfix_attribute); 36 ParseGNUAttributes(attrs); 37 } 38 } 39 40 /// ParseObjCAtDirectives - Handle parts of the external-declaration production: 41 /// external-declaration: [C99 6.9] 42 /// [OBJC] objc-class-definition 43 /// [OBJC] objc-class-declaration 44 /// [OBJC] objc-alias-declaration 45 /// [OBJC] objc-protocol-definition 46 /// [OBJC] objc-method-definition 47 /// [OBJC] '@' 'end' 48 Parser::DeclGroupPtrTy 49 Parser::ParseObjCAtDirectives(ParsedAttributesWithRange &Attrs) { 50 SourceLocation AtLoc = ConsumeToken(); // the "@" 51 52 if (Tok.is(tok::code_completion)) { 53 Actions.CodeCompleteObjCAtDirective(getCurScope()); 54 cutOffParsing(); 55 return nullptr; 56 } 57 58 Decl *SingleDecl = nullptr; 59 switch (Tok.getObjCKeywordID()) { 60 case tok::objc_class: 61 return ParseObjCAtClassDeclaration(AtLoc); 62 case tok::objc_interface: 63 SingleDecl = ParseObjCAtInterfaceDeclaration(AtLoc, Attrs); 64 break; 65 case tok::objc_protocol: 66 return ParseObjCAtProtocolDeclaration(AtLoc, Attrs); 67 case tok::objc_implementation: 68 return ParseObjCAtImplementationDeclaration(AtLoc, Attrs); 69 case tok::objc_end: 70 return ParseObjCAtEndDeclaration(AtLoc); 71 case tok::objc_compatibility_alias: 72 SingleDecl = ParseObjCAtAliasDeclaration(AtLoc); 73 break; 74 case tok::objc_synthesize: 75 SingleDecl = ParseObjCPropertySynthesize(AtLoc); 76 break; 77 case tok::objc_dynamic: 78 SingleDecl = ParseObjCPropertyDynamic(AtLoc); 79 break; 80 case tok::objc_import: 81 if (getLangOpts().Modules || getLangOpts().DebuggerSupport) { 82 SingleDecl = ParseModuleImport(AtLoc); 83 break; 84 } 85 Diag(AtLoc, diag::err_atimport); 86 SkipUntil(tok::semi); 87 return Actions.ConvertDeclToDeclGroup(nullptr); 88 default: 89 Diag(AtLoc, diag::err_unexpected_at); 90 SkipUntil(tok::semi); 91 SingleDecl = nullptr; 92 break; 93 } 94 return Actions.ConvertDeclToDeclGroup(SingleDecl); 95 } 96 97 /// Class to handle popping type parameters when leaving the scope. 98 class Parser::ObjCTypeParamListScope { 99 Sema &Actions; 100 Scope *S; 101 ObjCTypeParamList *Params; 102 103 public: 104 ObjCTypeParamListScope(Sema &Actions, Scope *S) 105 : Actions(Actions), S(S), Params(nullptr) {} 106 107 ~ObjCTypeParamListScope() { 108 leave(); 109 } 110 111 void enter(ObjCTypeParamList *P) { 112 assert(!Params); 113 Params = P; 114 } 115 116 void leave() { 117 if (Params) 118 Actions.popObjCTypeParamList(S, Params); 119 Params = nullptr; 120 } 121 }; 122 123 /// 124 /// objc-class-declaration: 125 /// '@' 'class' objc-class-forward-decl (',' objc-class-forward-decl)* ';' 126 /// 127 /// objc-class-forward-decl: 128 /// identifier objc-type-parameter-list[opt] 129 /// 130 Parser::DeclGroupPtrTy 131 Parser::ParseObjCAtClassDeclaration(SourceLocation atLoc) { 132 ConsumeToken(); // the identifier "class" 133 SmallVector<IdentifierInfo *, 8> ClassNames; 134 SmallVector<SourceLocation, 8> ClassLocs; 135 SmallVector<ObjCTypeParamList *, 8> ClassTypeParams; 136 137 while (1) { 138 MaybeSkipAttributes(tok::objc_class); 139 if (expectIdentifier()) { 140 SkipUntil(tok::semi); 141 return Actions.ConvertDeclToDeclGroup(nullptr); 142 } 143 ClassNames.push_back(Tok.getIdentifierInfo()); 144 ClassLocs.push_back(Tok.getLocation()); 145 ConsumeToken(); 146 147 // Parse the optional objc-type-parameter-list. 148 ObjCTypeParamList *TypeParams = nullptr; 149 if (Tok.is(tok::less)) 150 TypeParams = parseObjCTypeParamList(); 151 ClassTypeParams.push_back(TypeParams); 152 if (!TryConsumeToken(tok::comma)) 153 break; 154 } 155 156 // Consume the ';'. 157 if (ExpectAndConsume(tok::semi, diag::err_expected_after, "@class")) 158 return Actions.ConvertDeclToDeclGroup(nullptr); 159 160 return Actions.ActOnForwardClassDeclaration(atLoc, ClassNames.data(), 161 ClassLocs.data(), 162 ClassTypeParams, 163 ClassNames.size()); 164 } 165 166 void Parser::CheckNestedObjCContexts(SourceLocation AtLoc) 167 { 168 Sema::ObjCContainerKind ock = Actions.getObjCContainerKind(); 169 if (ock == Sema::OCK_None) 170 return; 171 172 Decl *Decl = Actions.getObjCDeclContext(); 173 if (CurParsedObjCImpl) { 174 CurParsedObjCImpl->finish(AtLoc); 175 } else { 176 Actions.ActOnAtEnd(getCurScope(), AtLoc); 177 } 178 Diag(AtLoc, diag::err_objc_missing_end) 179 << FixItHint::CreateInsertion(AtLoc, "@end\n"); 180 if (Decl) 181 Diag(Decl->getBeginLoc(), diag::note_objc_container_start) << (int)ock; 182 } 183 184 /// 185 /// objc-interface: 186 /// objc-class-interface-attributes[opt] objc-class-interface 187 /// objc-category-interface 188 /// 189 /// objc-class-interface: 190 /// '@' 'interface' identifier objc-type-parameter-list[opt] 191 /// objc-superclass[opt] objc-protocol-refs[opt] 192 /// objc-class-instance-variables[opt] 193 /// objc-interface-decl-list 194 /// @end 195 /// 196 /// objc-category-interface: 197 /// '@' 'interface' identifier objc-type-parameter-list[opt] 198 /// '(' identifier[opt] ')' objc-protocol-refs[opt] 199 /// objc-interface-decl-list 200 /// @end 201 /// 202 /// objc-superclass: 203 /// ':' identifier objc-type-arguments[opt] 204 /// 205 /// objc-class-interface-attributes: 206 /// __attribute__((visibility("default"))) 207 /// __attribute__((visibility("hidden"))) 208 /// __attribute__((deprecated)) 209 /// __attribute__((unavailable)) 210 /// __attribute__((objc_exception)) - used by NSException on 64-bit 211 /// __attribute__((objc_root_class)) 212 /// 213 Decl *Parser::ParseObjCAtInterfaceDeclaration(SourceLocation AtLoc, 214 ParsedAttributes &attrs) { 215 assert(Tok.isObjCAtKeyword(tok::objc_interface) && 216 "ParseObjCAtInterfaceDeclaration(): Expected @interface"); 217 CheckNestedObjCContexts(AtLoc); 218 ConsumeToken(); // the "interface" identifier 219 220 // Code completion after '@interface'. 221 if (Tok.is(tok::code_completion)) { 222 Actions.CodeCompleteObjCInterfaceDecl(getCurScope()); 223 cutOffParsing(); 224 return nullptr; 225 } 226 227 MaybeSkipAttributes(tok::objc_interface); 228 229 if (expectIdentifier()) 230 return nullptr; // missing class or category name. 231 232 // We have a class or category name - consume it. 233 IdentifierInfo *nameId = Tok.getIdentifierInfo(); 234 SourceLocation nameLoc = ConsumeToken(); 235 236 // Parse the objc-type-parameter-list or objc-protocol-refs. For the latter 237 // case, LAngleLoc will be valid and ProtocolIdents will capture the 238 // protocol references (that have not yet been resolved). 239 SourceLocation LAngleLoc, EndProtoLoc; 240 SmallVector<IdentifierLocPair, 8> ProtocolIdents; 241 ObjCTypeParamList *typeParameterList = nullptr; 242 ObjCTypeParamListScope typeParamScope(Actions, getCurScope()); 243 if (Tok.is(tok::less)) 244 typeParameterList = parseObjCTypeParamListOrProtocolRefs( 245 typeParamScope, LAngleLoc, ProtocolIdents, EndProtoLoc); 246 247 if (Tok.is(tok::l_paren) && 248 !isKnownToBeTypeSpecifier(GetLookAheadToken(1))) { // we have a category. 249 250 BalancedDelimiterTracker T(*this, tok::l_paren); 251 T.consumeOpen(); 252 253 SourceLocation categoryLoc; 254 IdentifierInfo *categoryId = nullptr; 255 if (Tok.is(tok::code_completion)) { 256 Actions.CodeCompleteObjCInterfaceCategory(getCurScope(), nameId, nameLoc); 257 cutOffParsing(); 258 return nullptr; 259 } 260 261 // For ObjC2, the category name is optional (not an error). 262 if (Tok.is(tok::identifier)) { 263 categoryId = Tok.getIdentifierInfo(); 264 categoryLoc = ConsumeToken(); 265 } 266 else if (!getLangOpts().ObjC) { 267 Diag(Tok, diag::err_expected) 268 << tok::identifier; // missing category name. 269 return nullptr; 270 } 271 272 T.consumeClose(); 273 if (T.getCloseLocation().isInvalid()) 274 return nullptr; 275 276 // Next, we need to check for any protocol references. 277 assert(LAngleLoc.isInvalid() && "Cannot have already parsed protocols"); 278 SmallVector<Decl *, 8> ProtocolRefs; 279 SmallVector<SourceLocation, 8> ProtocolLocs; 280 if (Tok.is(tok::less) && 281 ParseObjCProtocolReferences(ProtocolRefs, ProtocolLocs, true, true, 282 LAngleLoc, EndProtoLoc, 283 /*consumeLastToken=*/true)) 284 return nullptr; 285 286 Decl *CategoryType = Actions.ActOnStartCategoryInterface( 287 AtLoc, nameId, nameLoc, typeParameterList, categoryId, categoryLoc, 288 ProtocolRefs.data(), ProtocolRefs.size(), ProtocolLocs.data(), 289 EndProtoLoc, attrs); 290 291 if (Tok.is(tok::l_brace)) 292 ParseObjCClassInstanceVariables(CategoryType, tok::objc_private, AtLoc); 293 294 ParseObjCInterfaceDeclList(tok::objc_not_keyword, CategoryType); 295 296 return CategoryType; 297 } 298 // Parse a class interface. 299 IdentifierInfo *superClassId = nullptr; 300 SourceLocation superClassLoc; 301 SourceLocation typeArgsLAngleLoc; 302 SmallVector<ParsedType, 4> typeArgs; 303 SourceLocation typeArgsRAngleLoc; 304 SmallVector<Decl *, 4> protocols; 305 SmallVector<SourceLocation, 4> protocolLocs; 306 if (Tok.is(tok::colon)) { // a super class is specified. 307 ConsumeToken(); 308 309 // Code completion of superclass names. 310 if (Tok.is(tok::code_completion)) { 311 Actions.CodeCompleteObjCSuperclass(getCurScope(), nameId, nameLoc); 312 cutOffParsing(); 313 return nullptr; 314 } 315 316 if (expectIdentifier()) 317 return nullptr; // missing super class name. 318 superClassId = Tok.getIdentifierInfo(); 319 superClassLoc = ConsumeToken(); 320 321 // Type arguments for the superclass or protocol conformances. 322 if (Tok.is(tok::less)) { 323 parseObjCTypeArgsOrProtocolQualifiers( 324 nullptr, typeArgsLAngleLoc, typeArgs, typeArgsRAngleLoc, LAngleLoc, 325 protocols, protocolLocs, EndProtoLoc, 326 /*consumeLastToken=*/true, 327 /*warnOnIncompleteProtocols=*/true); 328 if (Tok.is(tok::eof)) 329 return nullptr; 330 } 331 } 332 333 // Next, we need to check for any protocol references. 334 if (LAngleLoc.isValid()) { 335 if (!ProtocolIdents.empty()) { 336 // We already parsed the protocols named when we thought we had a 337 // type parameter list. Translate them into actual protocol references. 338 for (const auto &pair : ProtocolIdents) { 339 protocolLocs.push_back(pair.second); 340 } 341 Actions.FindProtocolDeclaration(/*WarnOnDeclarations=*/true, 342 /*ForObjCContainer=*/true, 343 ProtocolIdents, protocols); 344 } 345 } else if (protocols.empty() && Tok.is(tok::less) && 346 ParseObjCProtocolReferences(protocols, protocolLocs, true, true, 347 LAngleLoc, EndProtoLoc, 348 /*consumeLastToken=*/true)) { 349 return nullptr; 350 } 351 352 if (Tok.isNot(tok::less)) 353 Actions.ActOnTypedefedProtocols(protocols, protocolLocs, 354 superClassId, superClassLoc); 355 356 Decl *ClsType = Actions.ActOnStartClassInterface( 357 getCurScope(), AtLoc, nameId, nameLoc, typeParameterList, superClassId, 358 superClassLoc, typeArgs, 359 SourceRange(typeArgsLAngleLoc, typeArgsRAngleLoc), protocols.data(), 360 protocols.size(), protocolLocs.data(), EndProtoLoc, attrs); 361 362 if (Tok.is(tok::l_brace)) 363 ParseObjCClassInstanceVariables(ClsType, tok::objc_protected, AtLoc); 364 365 ParseObjCInterfaceDeclList(tok::objc_interface, ClsType); 366 367 return ClsType; 368 } 369 370 /// Add an attribute for a context-sensitive type nullability to the given 371 /// declarator. 372 static void addContextSensitiveTypeNullability(Parser &P, 373 Declarator &D, 374 NullabilityKind nullability, 375 SourceLocation nullabilityLoc, 376 bool &addedToDeclSpec) { 377 // Create the attribute. 378 auto getNullabilityAttr = [&](AttributePool &Pool) -> ParsedAttr * { 379 return Pool.create(P.getNullabilityKeyword(nullability), 380 SourceRange(nullabilityLoc), nullptr, SourceLocation(), 381 nullptr, 0, ParsedAttr::AS_ContextSensitiveKeyword); 382 }; 383 384 if (D.getNumTypeObjects() > 0) { 385 // Add the attribute to the declarator chunk nearest the declarator. 386 D.getTypeObject(0).getAttrs().addAtEnd( 387 getNullabilityAttr(D.getAttributePool())); 388 } else if (!addedToDeclSpec) { 389 // Otherwise, just put it on the declaration specifiers (if one 390 // isn't there already). 391 D.getMutableDeclSpec().getAttributes().addAtEnd( 392 getNullabilityAttr(D.getMutableDeclSpec().getAttributes().getPool())); 393 addedToDeclSpec = true; 394 } 395 } 396 397 /// Parse an Objective-C type parameter list, if present, or capture 398 /// the locations of the protocol identifiers for a list of protocol 399 /// references. 400 /// 401 /// objc-type-parameter-list: 402 /// '<' objc-type-parameter (',' objc-type-parameter)* '>' 403 /// 404 /// objc-type-parameter: 405 /// objc-type-parameter-variance? identifier objc-type-parameter-bound[opt] 406 /// 407 /// objc-type-parameter-bound: 408 /// ':' type-name 409 /// 410 /// objc-type-parameter-variance: 411 /// '__covariant' 412 /// '__contravariant' 413 /// 414 /// \param lAngleLoc The location of the starting '<'. 415 /// 416 /// \param protocolIdents Will capture the list of identifiers, if the 417 /// angle brackets contain a list of protocol references rather than a 418 /// type parameter list. 419 /// 420 /// \param rAngleLoc The location of the ending '>'. 421 ObjCTypeParamList *Parser::parseObjCTypeParamListOrProtocolRefs( 422 ObjCTypeParamListScope &Scope, SourceLocation &lAngleLoc, 423 SmallVectorImpl<IdentifierLocPair> &protocolIdents, 424 SourceLocation &rAngleLoc, bool mayBeProtocolList) { 425 assert(Tok.is(tok::less) && "Not at the beginning of a type parameter list"); 426 427 // Within the type parameter list, don't treat '>' as an operator. 428 GreaterThanIsOperatorScope G(GreaterThanIsOperator, false); 429 430 // Local function to "flush" the protocol identifiers, turning them into 431 // type parameters. 432 SmallVector<Decl *, 4> typeParams; 433 auto makeProtocolIdentsIntoTypeParameters = [&]() { 434 unsigned index = 0; 435 for (const auto &pair : protocolIdents) { 436 DeclResult typeParam = Actions.actOnObjCTypeParam( 437 getCurScope(), ObjCTypeParamVariance::Invariant, SourceLocation(), 438 index++, pair.first, pair.second, SourceLocation(), nullptr); 439 if (typeParam.isUsable()) 440 typeParams.push_back(typeParam.get()); 441 } 442 443 protocolIdents.clear(); 444 mayBeProtocolList = false; 445 }; 446 447 bool invalid = false; 448 lAngleLoc = ConsumeToken(); 449 450 do { 451 // Parse the variance, if any. 452 SourceLocation varianceLoc; 453 ObjCTypeParamVariance variance = ObjCTypeParamVariance::Invariant; 454 if (Tok.is(tok::kw___covariant) || Tok.is(tok::kw___contravariant)) { 455 variance = Tok.is(tok::kw___covariant) 456 ? ObjCTypeParamVariance::Covariant 457 : ObjCTypeParamVariance::Contravariant; 458 varianceLoc = ConsumeToken(); 459 460 // Once we've seen a variance specific , we know this is not a 461 // list of protocol references. 462 if (mayBeProtocolList) { 463 // Up until now, we have been queuing up parameters because they 464 // might be protocol references. Turn them into parameters now. 465 makeProtocolIdentsIntoTypeParameters(); 466 } 467 } 468 469 // Parse the identifier. 470 if (!Tok.is(tok::identifier)) { 471 // Code completion. 472 if (Tok.is(tok::code_completion)) { 473 // FIXME: If these aren't protocol references, we'll need different 474 // completions. 475 Actions.CodeCompleteObjCProtocolReferences(protocolIdents); 476 cutOffParsing(); 477 478 // FIXME: Better recovery here?. 479 return nullptr; 480 } 481 482 Diag(Tok, diag::err_objc_expected_type_parameter); 483 invalid = true; 484 break; 485 } 486 487 IdentifierInfo *paramName = Tok.getIdentifierInfo(); 488 SourceLocation paramLoc = ConsumeToken(); 489 490 // If there is a bound, parse it. 491 SourceLocation colonLoc; 492 TypeResult boundType; 493 if (TryConsumeToken(tok::colon, colonLoc)) { 494 // Once we've seen a bound, we know this is not a list of protocol 495 // references. 496 if (mayBeProtocolList) { 497 // Up until now, we have been queuing up parameters because they 498 // might be protocol references. Turn them into parameters now. 499 makeProtocolIdentsIntoTypeParameters(); 500 } 501 502 // type-name 503 boundType = ParseTypeName(); 504 if (boundType.isInvalid()) 505 invalid = true; 506 } else if (mayBeProtocolList) { 507 // If this could still be a protocol list, just capture the identifier. 508 // We don't want to turn it into a parameter. 509 protocolIdents.push_back(std::make_pair(paramName, paramLoc)); 510 continue; 511 } 512 513 // Create the type parameter. 514 DeclResult typeParam = Actions.actOnObjCTypeParam( 515 getCurScope(), variance, varianceLoc, typeParams.size(), paramName, 516 paramLoc, colonLoc, boundType.isUsable() ? boundType.get() : nullptr); 517 if (typeParam.isUsable()) 518 typeParams.push_back(typeParam.get()); 519 } while (TryConsumeToken(tok::comma)); 520 521 // Parse the '>'. 522 if (invalid) { 523 SkipUntil(tok::greater, tok::at, StopBeforeMatch); 524 if (Tok.is(tok::greater)) 525 ConsumeToken(); 526 } else if (ParseGreaterThanInTemplateList(lAngleLoc, rAngleLoc, 527 /*ConsumeLastToken=*/true, 528 /*ObjCGenericList=*/true)) { 529 SkipUntil({tok::greater, tok::greaterequal, tok::at, tok::minus, 530 tok::minus, tok::plus, tok::colon, tok::l_paren, tok::l_brace, 531 tok::comma, tok::semi }, 532 StopBeforeMatch); 533 if (Tok.is(tok::greater)) 534 ConsumeToken(); 535 } 536 537 if (mayBeProtocolList) { 538 // A type parameter list must be followed by either a ':' (indicating the 539 // presence of a superclass) or a '(' (indicating that this is a category 540 // or extension). This disambiguates between an objc-type-parameter-list 541 // and a objc-protocol-refs. 542 if (Tok.isNot(tok::colon) && Tok.isNot(tok::l_paren)) { 543 // Returning null indicates that we don't have a type parameter list. 544 // The results the caller needs to handle the protocol references are 545 // captured in the reference parameters already. 546 return nullptr; 547 } 548 549 // We have a type parameter list that looks like a list of protocol 550 // references. Turn that parameter list into type parameters. 551 makeProtocolIdentsIntoTypeParameters(); 552 } 553 554 // Form the type parameter list and enter its scope. 555 ObjCTypeParamList *list = Actions.actOnObjCTypeParamList( 556 getCurScope(), 557 lAngleLoc, 558 typeParams, 559 rAngleLoc); 560 Scope.enter(list); 561 562 // Clear out the angle locations; they're used by the caller to indicate 563 // whether there are any protocol references. 564 lAngleLoc = SourceLocation(); 565 rAngleLoc = SourceLocation(); 566 return invalid ? nullptr : list; 567 } 568 569 /// Parse an objc-type-parameter-list. 570 ObjCTypeParamList *Parser::parseObjCTypeParamList() { 571 SourceLocation lAngleLoc; 572 SmallVector<IdentifierLocPair, 1> protocolIdents; 573 SourceLocation rAngleLoc; 574 575 ObjCTypeParamListScope Scope(Actions, getCurScope()); 576 return parseObjCTypeParamListOrProtocolRefs(Scope, lAngleLoc, protocolIdents, 577 rAngleLoc, 578 /*mayBeProtocolList=*/false); 579 } 580 581 /// objc-interface-decl-list: 582 /// empty 583 /// objc-interface-decl-list objc-property-decl [OBJC2] 584 /// objc-interface-decl-list objc-method-requirement [OBJC2] 585 /// objc-interface-decl-list objc-method-proto ';' 586 /// objc-interface-decl-list declaration 587 /// objc-interface-decl-list ';' 588 /// 589 /// objc-method-requirement: [OBJC2] 590 /// @required 591 /// @optional 592 /// 593 void Parser::ParseObjCInterfaceDeclList(tok::ObjCKeywordKind contextKey, 594 Decl *CDecl) { 595 SmallVector<Decl *, 32> allMethods; 596 SmallVector<DeclGroupPtrTy, 8> allTUVariables; 597 tok::ObjCKeywordKind MethodImplKind = tok::objc_not_keyword; 598 599 SourceRange AtEnd; 600 601 while (1) { 602 // If this is a method prototype, parse it. 603 if (Tok.isOneOf(tok::minus, tok::plus)) { 604 if (Decl *methodPrototype = 605 ParseObjCMethodPrototype(MethodImplKind, false)) 606 allMethods.push_back(methodPrototype); 607 // Consume the ';' here, since ParseObjCMethodPrototype() is re-used for 608 // method definitions. 609 if (ExpectAndConsumeSemi(diag::err_expected_semi_after_method_proto)) { 610 // We didn't find a semi and we error'ed out. Skip until a ';' or '@'. 611 SkipUntil(tok::at, StopAtSemi | StopBeforeMatch); 612 if (Tok.is(tok::semi)) 613 ConsumeToken(); 614 } 615 continue; 616 } 617 if (Tok.is(tok::l_paren)) { 618 Diag(Tok, diag::err_expected_minus_or_plus); 619 ParseObjCMethodDecl(Tok.getLocation(), 620 tok::minus, 621 MethodImplKind, false); 622 continue; 623 } 624 // Ignore excess semicolons. 625 if (Tok.is(tok::semi)) { 626 // FIXME: This should use ConsumeExtraSemi() for extraneous semicolons, 627 // to make -Wextra-semi diagnose them. 628 ConsumeToken(); 629 continue; 630 } 631 632 // If we got to the end of the file, exit the loop. 633 if (isEofOrEom()) 634 break; 635 636 // Code completion within an Objective-C interface. 637 if (Tok.is(tok::code_completion)) { 638 Actions.CodeCompleteOrdinaryName(getCurScope(), 639 CurParsedObjCImpl? Sema::PCC_ObjCImplementation 640 : Sema::PCC_ObjCInterface); 641 return cutOffParsing(); 642 } 643 644 // If we don't have an @ directive, parse it as a function definition. 645 if (Tok.isNot(tok::at)) { 646 // The code below does not consume '}'s because it is afraid of eating the 647 // end of a namespace. Because of the way this code is structured, an 648 // erroneous r_brace would cause an infinite loop if not handled here. 649 if (Tok.is(tok::r_brace)) 650 break; 651 652 ParsedAttributesWithRange attrs(AttrFactory); 653 654 // Since we call ParseDeclarationOrFunctionDefinition() instead of 655 // ParseExternalDeclaration() below (so that this doesn't parse nested 656 // @interfaces), this needs to duplicate some code from the latter. 657 if (Tok.isOneOf(tok::kw_static_assert, tok::kw__Static_assert)) { 658 SourceLocation DeclEnd; 659 allTUVariables.push_back( 660 ParseDeclaration(DeclaratorContext::File, DeclEnd, attrs)); 661 continue; 662 } 663 664 allTUVariables.push_back(ParseDeclarationOrFunctionDefinition(attrs)); 665 continue; 666 } 667 668 // Otherwise, we have an @ directive, eat the @. 669 SourceLocation AtLoc = ConsumeToken(); // the "@" 670 if (Tok.is(tok::code_completion)) { 671 Actions.CodeCompleteObjCAtDirective(getCurScope()); 672 return cutOffParsing(); 673 } 674 675 tok::ObjCKeywordKind DirectiveKind = Tok.getObjCKeywordID(); 676 677 if (DirectiveKind == tok::objc_end) { // @end -> terminate list 678 AtEnd.setBegin(AtLoc); 679 AtEnd.setEnd(Tok.getLocation()); 680 break; 681 } else if (DirectiveKind == tok::objc_not_keyword) { 682 Diag(Tok, diag::err_objc_unknown_at); 683 SkipUntil(tok::semi); 684 continue; 685 } 686 687 // Eat the identifier. 688 ConsumeToken(); 689 690 switch (DirectiveKind) { 691 default: 692 // FIXME: If someone forgets an @end on a protocol, this loop will 693 // continue to eat up tons of stuff and spew lots of nonsense errors. It 694 // would probably be better to bail out if we saw an @class or @interface 695 // or something like that. 696 Diag(AtLoc, diag::err_objc_illegal_interface_qual); 697 // Skip until we see an '@' or '}' or ';'. 698 SkipUntil(tok::r_brace, tok::at, StopAtSemi); 699 break; 700 701 case tok::objc_implementation: 702 case tok::objc_interface: 703 Diag(AtLoc, diag::err_objc_missing_end) 704 << FixItHint::CreateInsertion(AtLoc, "@end\n"); 705 Diag(CDecl->getBeginLoc(), diag::note_objc_container_start) 706 << (int)Actions.getObjCContainerKind(); 707 ConsumeToken(); 708 break; 709 710 case tok::objc_required: 711 case tok::objc_optional: 712 // This is only valid on protocols. 713 if (contextKey != tok::objc_protocol) 714 Diag(AtLoc, diag::err_objc_directive_only_in_protocol); 715 else 716 MethodImplKind = DirectiveKind; 717 break; 718 719 case tok::objc_property: 720 ObjCDeclSpec OCDS; 721 SourceLocation LParenLoc; 722 // Parse property attribute list, if any. 723 if (Tok.is(tok::l_paren)) { 724 LParenLoc = Tok.getLocation(); 725 ParseObjCPropertyAttribute(OCDS); 726 } 727 728 bool addedToDeclSpec = false; 729 auto ObjCPropertyCallback = [&](ParsingFieldDeclarator &FD) { 730 if (FD.D.getIdentifier() == nullptr) { 731 Diag(AtLoc, diag::err_objc_property_requires_field_name) 732 << FD.D.getSourceRange(); 733 return; 734 } 735 if (FD.BitfieldSize) { 736 Diag(AtLoc, diag::err_objc_property_bitfield) 737 << FD.D.getSourceRange(); 738 return; 739 } 740 741 // Map a nullability property attribute to a context-sensitive keyword 742 // attribute. 743 if (OCDS.getPropertyAttributes() & 744 ObjCPropertyAttribute::kind_nullability) 745 addContextSensitiveTypeNullability(*this, FD.D, OCDS.getNullability(), 746 OCDS.getNullabilityLoc(), 747 addedToDeclSpec); 748 749 // Install the property declarator into interfaceDecl. 750 IdentifierInfo *SelName = 751 OCDS.getGetterName() ? OCDS.getGetterName() : FD.D.getIdentifier(); 752 753 Selector GetterSel = PP.getSelectorTable().getNullarySelector(SelName); 754 IdentifierInfo *SetterName = OCDS.getSetterName(); 755 Selector SetterSel; 756 if (SetterName) 757 SetterSel = PP.getSelectorTable().getSelector(1, &SetterName); 758 else 759 SetterSel = SelectorTable::constructSetterSelector( 760 PP.getIdentifierTable(), PP.getSelectorTable(), 761 FD.D.getIdentifier()); 762 Decl *Property = Actions.ActOnProperty( 763 getCurScope(), AtLoc, LParenLoc, FD, OCDS, GetterSel, SetterSel, 764 MethodImplKind); 765 766 FD.complete(Property); 767 }; 768 769 // Parse all the comma separated declarators. 770 ParsingDeclSpec DS(*this); 771 ParseStructDeclaration(DS, ObjCPropertyCallback); 772 773 ExpectAndConsume(tok::semi, diag::err_expected_semi_decl_list); 774 break; 775 } 776 } 777 778 // We break out of the big loop in two cases: when we see @end or when we see 779 // EOF. In the former case, eat the @end. In the later case, emit an error. 780 if (Tok.is(tok::code_completion)) { 781 Actions.CodeCompleteObjCAtDirective(getCurScope()); 782 return cutOffParsing(); 783 } else if (Tok.isObjCAtKeyword(tok::objc_end)) { 784 ConsumeToken(); // the "end" identifier 785 } else { 786 Diag(Tok, diag::err_objc_missing_end) 787 << FixItHint::CreateInsertion(Tok.getLocation(), "\n@end\n"); 788 Diag(CDecl->getBeginLoc(), diag::note_objc_container_start) 789 << (int)Actions.getObjCContainerKind(); 790 AtEnd.setBegin(Tok.getLocation()); 791 AtEnd.setEnd(Tok.getLocation()); 792 } 793 794 // Insert collected methods declarations into the @interface object. 795 // This passes in an invalid SourceLocation for AtEndLoc when EOF is hit. 796 Actions.ActOnAtEnd(getCurScope(), AtEnd, allMethods, allTUVariables); 797 } 798 799 /// Diagnose redundant or conflicting nullability information. 800 static void diagnoseRedundantPropertyNullability(Parser &P, 801 ObjCDeclSpec &DS, 802 NullabilityKind nullability, 803 SourceLocation nullabilityLoc){ 804 if (DS.getNullability() == nullability) { 805 P.Diag(nullabilityLoc, diag::warn_nullability_duplicate) 806 << DiagNullabilityKind(nullability, true) 807 << SourceRange(DS.getNullabilityLoc()); 808 return; 809 } 810 811 P.Diag(nullabilityLoc, diag::err_nullability_conflicting) 812 << DiagNullabilityKind(nullability, true) 813 << DiagNullabilityKind(DS.getNullability(), true) 814 << SourceRange(DS.getNullabilityLoc()); 815 } 816 817 /// Parse property attribute declarations. 818 /// 819 /// property-attr-decl: '(' property-attrlist ')' 820 /// property-attrlist: 821 /// property-attribute 822 /// property-attrlist ',' property-attribute 823 /// property-attribute: 824 /// getter '=' identifier 825 /// setter '=' identifier ':' 826 /// direct 827 /// readonly 828 /// readwrite 829 /// assign 830 /// retain 831 /// copy 832 /// nonatomic 833 /// atomic 834 /// strong 835 /// weak 836 /// unsafe_unretained 837 /// nonnull 838 /// nullable 839 /// null_unspecified 840 /// null_resettable 841 /// class 842 /// 843 void Parser::ParseObjCPropertyAttribute(ObjCDeclSpec &DS) { 844 assert(Tok.getKind() == tok::l_paren); 845 BalancedDelimiterTracker T(*this, tok::l_paren); 846 T.consumeOpen(); 847 848 while (1) { 849 if (Tok.is(tok::code_completion)) { 850 Actions.CodeCompleteObjCPropertyFlags(getCurScope(), DS); 851 return cutOffParsing(); 852 } 853 const IdentifierInfo *II = Tok.getIdentifierInfo(); 854 855 // If this is not an identifier at all, bail out early. 856 if (!II) { 857 T.consumeClose(); 858 return; 859 } 860 861 SourceLocation AttrName = ConsumeToken(); // consume last attribute name 862 863 if (II->isStr("readonly")) 864 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_readonly); 865 else if (II->isStr("assign")) 866 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_assign); 867 else if (II->isStr("unsafe_unretained")) 868 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_unsafe_unretained); 869 else if (II->isStr("readwrite")) 870 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_readwrite); 871 else if (II->isStr("retain")) 872 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_retain); 873 else if (II->isStr("strong")) 874 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_strong); 875 else if (II->isStr("copy")) 876 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_copy); 877 else if (II->isStr("nonatomic")) 878 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_nonatomic); 879 else if (II->isStr("atomic")) 880 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_atomic); 881 else if (II->isStr("weak")) 882 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_weak); 883 else if (II->isStr("getter") || II->isStr("setter")) { 884 bool IsSetter = II->getNameStart()[0] == 's'; 885 886 // getter/setter require extra treatment. 887 unsigned DiagID = IsSetter ? diag::err_objc_expected_equal_for_setter : 888 diag::err_objc_expected_equal_for_getter; 889 890 if (ExpectAndConsume(tok::equal, DiagID)) { 891 SkipUntil(tok::r_paren, StopAtSemi); 892 return; 893 } 894 895 if (Tok.is(tok::code_completion)) { 896 if (IsSetter) 897 Actions.CodeCompleteObjCPropertySetter(getCurScope()); 898 else 899 Actions.CodeCompleteObjCPropertyGetter(getCurScope()); 900 return cutOffParsing(); 901 } 902 903 SourceLocation SelLoc; 904 IdentifierInfo *SelIdent = ParseObjCSelectorPiece(SelLoc); 905 906 if (!SelIdent) { 907 Diag(Tok, diag::err_objc_expected_selector_for_getter_setter) 908 << IsSetter; 909 SkipUntil(tok::r_paren, StopAtSemi); 910 return; 911 } 912 913 if (IsSetter) { 914 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_setter); 915 DS.setSetterName(SelIdent, SelLoc); 916 917 if (ExpectAndConsume(tok::colon, 918 diag::err_expected_colon_after_setter_name)) { 919 SkipUntil(tok::r_paren, StopAtSemi); 920 return; 921 } 922 } else { 923 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_getter); 924 DS.setGetterName(SelIdent, SelLoc); 925 } 926 } else if (II->isStr("nonnull")) { 927 if (DS.getPropertyAttributes() & ObjCPropertyAttribute::kind_nullability) 928 diagnoseRedundantPropertyNullability(*this, DS, 929 NullabilityKind::NonNull, 930 Tok.getLocation()); 931 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_nullability); 932 DS.setNullability(Tok.getLocation(), NullabilityKind::NonNull); 933 } else if (II->isStr("nullable")) { 934 if (DS.getPropertyAttributes() & ObjCPropertyAttribute::kind_nullability) 935 diagnoseRedundantPropertyNullability(*this, DS, 936 NullabilityKind::Nullable, 937 Tok.getLocation()); 938 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_nullability); 939 DS.setNullability(Tok.getLocation(), NullabilityKind::Nullable); 940 } else if (II->isStr("null_unspecified")) { 941 if (DS.getPropertyAttributes() & ObjCPropertyAttribute::kind_nullability) 942 diagnoseRedundantPropertyNullability(*this, DS, 943 NullabilityKind::Unspecified, 944 Tok.getLocation()); 945 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_nullability); 946 DS.setNullability(Tok.getLocation(), NullabilityKind::Unspecified); 947 } else if (II->isStr("null_resettable")) { 948 if (DS.getPropertyAttributes() & ObjCPropertyAttribute::kind_nullability) 949 diagnoseRedundantPropertyNullability(*this, DS, 950 NullabilityKind::Unspecified, 951 Tok.getLocation()); 952 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_nullability); 953 DS.setNullability(Tok.getLocation(), NullabilityKind::Unspecified); 954 955 // Also set the null_resettable bit. 956 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_null_resettable); 957 } else if (II->isStr("class")) { 958 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_class); 959 } else if (II->isStr("direct")) { 960 DS.setPropertyAttributes(ObjCPropertyAttribute::kind_direct); 961 } else { 962 Diag(AttrName, diag::err_objc_expected_property_attr) << II; 963 SkipUntil(tok::r_paren, StopAtSemi); 964 return; 965 } 966 967 if (Tok.isNot(tok::comma)) 968 break; 969 970 ConsumeToken(); 971 } 972 973 T.consumeClose(); 974 } 975 976 /// objc-method-proto: 977 /// objc-instance-method objc-method-decl objc-method-attributes[opt] 978 /// objc-class-method objc-method-decl objc-method-attributes[opt] 979 /// 980 /// objc-instance-method: '-' 981 /// objc-class-method: '+' 982 /// 983 /// objc-method-attributes: [OBJC2] 984 /// __attribute__((deprecated)) 985 /// 986 Decl *Parser::ParseObjCMethodPrototype(tok::ObjCKeywordKind MethodImplKind, 987 bool MethodDefinition) { 988 assert(Tok.isOneOf(tok::minus, tok::plus) && "expected +/-"); 989 990 tok::TokenKind methodType = Tok.getKind(); 991 SourceLocation mLoc = ConsumeToken(); 992 Decl *MDecl = ParseObjCMethodDecl(mLoc, methodType, MethodImplKind, 993 MethodDefinition); 994 // Since this rule is used for both method declarations and definitions, 995 // the caller is (optionally) responsible for consuming the ';'. 996 return MDecl; 997 } 998 999 /// objc-selector: 1000 /// identifier 1001 /// one of 1002 /// enum struct union if else while do for switch case default 1003 /// break continue return goto asm sizeof typeof __alignof 1004 /// unsigned long const short volatile signed restrict _Complex 1005 /// in out inout bycopy byref oneway int char float double void _Bool 1006 /// 1007 IdentifierInfo *Parser::ParseObjCSelectorPiece(SourceLocation &SelectorLoc) { 1008 1009 switch (Tok.getKind()) { 1010 default: 1011 return nullptr; 1012 case tok::colon: 1013 // Empty selector piece uses the location of the ':'. 1014 SelectorLoc = Tok.getLocation(); 1015 return nullptr; 1016 case tok::ampamp: 1017 case tok::ampequal: 1018 case tok::amp: 1019 case tok::pipe: 1020 case tok::tilde: 1021 case tok::exclaim: 1022 case tok::exclaimequal: 1023 case tok::pipepipe: 1024 case tok::pipeequal: 1025 case tok::caret: 1026 case tok::caretequal: { 1027 std::string ThisTok(PP.getSpelling(Tok)); 1028 if (isLetter(ThisTok[0])) { 1029 IdentifierInfo *II = &PP.getIdentifierTable().get(ThisTok); 1030 Tok.setKind(tok::identifier); 1031 SelectorLoc = ConsumeToken(); 1032 return II; 1033 } 1034 return nullptr; 1035 } 1036 1037 case tok::identifier: 1038 case tok::kw_asm: 1039 case tok::kw_auto: 1040 case tok::kw_bool: 1041 case tok::kw_break: 1042 case tok::kw_case: 1043 case tok::kw_catch: 1044 case tok::kw_char: 1045 case tok::kw_class: 1046 case tok::kw_const: 1047 case tok::kw_const_cast: 1048 case tok::kw_continue: 1049 case tok::kw_default: 1050 case tok::kw_delete: 1051 case tok::kw_do: 1052 case tok::kw_double: 1053 case tok::kw_dynamic_cast: 1054 case tok::kw_else: 1055 case tok::kw_enum: 1056 case tok::kw_explicit: 1057 case tok::kw_export: 1058 case tok::kw_extern: 1059 case tok::kw_false: 1060 case tok::kw_float: 1061 case tok::kw_for: 1062 case tok::kw_friend: 1063 case tok::kw_goto: 1064 case tok::kw_if: 1065 case tok::kw_inline: 1066 case tok::kw_int: 1067 case tok::kw_long: 1068 case tok::kw_mutable: 1069 case tok::kw_namespace: 1070 case tok::kw_new: 1071 case tok::kw_operator: 1072 case tok::kw_private: 1073 case tok::kw_protected: 1074 case tok::kw_public: 1075 case tok::kw_register: 1076 case tok::kw_reinterpret_cast: 1077 case tok::kw_restrict: 1078 case tok::kw_return: 1079 case tok::kw_short: 1080 case tok::kw_signed: 1081 case tok::kw_sizeof: 1082 case tok::kw_static: 1083 case tok::kw_static_cast: 1084 case tok::kw_struct: 1085 case tok::kw_switch: 1086 case tok::kw_template: 1087 case tok::kw_this: 1088 case tok::kw_throw: 1089 case tok::kw_true: 1090 case tok::kw_try: 1091 case tok::kw_typedef: 1092 case tok::kw_typeid: 1093 case tok::kw_typename: 1094 case tok::kw_typeof: 1095 case tok::kw_union: 1096 case tok::kw_unsigned: 1097 case tok::kw_using: 1098 case tok::kw_virtual: 1099 case tok::kw_void: 1100 case tok::kw_volatile: 1101 case tok::kw_wchar_t: 1102 case tok::kw_while: 1103 case tok::kw__Bool: 1104 case tok::kw__Complex: 1105 case tok::kw___alignof: 1106 case tok::kw___auto_type: 1107 IdentifierInfo *II = Tok.getIdentifierInfo(); 1108 SelectorLoc = ConsumeToken(); 1109 return II; 1110 } 1111 } 1112 1113 /// objc-for-collection-in: 'in' 1114 /// 1115 bool Parser::isTokIdentifier_in() const { 1116 // FIXME: May have to do additional look-ahead to only allow for 1117 // valid tokens following an 'in'; such as an identifier, unary operators, 1118 // '[' etc. 1119 return (getLangOpts().ObjC && Tok.is(tok::identifier) && 1120 Tok.getIdentifierInfo() == ObjCTypeQuals[objc_in]); 1121 } 1122 1123 /// ParseObjCTypeQualifierList - This routine parses the objective-c's type 1124 /// qualifier list and builds their bitmask representation in the input 1125 /// argument. 1126 /// 1127 /// objc-type-qualifiers: 1128 /// objc-type-qualifier 1129 /// objc-type-qualifiers objc-type-qualifier 1130 /// 1131 /// objc-type-qualifier: 1132 /// 'in' 1133 /// 'out' 1134 /// 'inout' 1135 /// 'oneway' 1136 /// 'bycopy' 1137 /// 'byref' 1138 /// 'nonnull' 1139 /// 'nullable' 1140 /// 'null_unspecified' 1141 /// 1142 void Parser::ParseObjCTypeQualifierList(ObjCDeclSpec &DS, 1143 DeclaratorContext Context) { 1144 assert(Context == DeclaratorContext::ObjCParameter || 1145 Context == DeclaratorContext::ObjCResult); 1146 1147 while (1) { 1148 if (Tok.is(tok::code_completion)) { 1149 Actions.CodeCompleteObjCPassingType( 1150 getCurScope(), DS, Context == DeclaratorContext::ObjCParameter); 1151 return cutOffParsing(); 1152 } 1153 1154 if (Tok.isNot(tok::identifier)) 1155 return; 1156 1157 const IdentifierInfo *II = Tok.getIdentifierInfo(); 1158 for (unsigned i = 0; i != objc_NumQuals; ++i) { 1159 if (II != ObjCTypeQuals[i] || 1160 NextToken().is(tok::less) || 1161 NextToken().is(tok::coloncolon)) 1162 continue; 1163 1164 ObjCDeclSpec::ObjCDeclQualifier Qual; 1165 NullabilityKind Nullability; 1166 switch (i) { 1167 default: llvm_unreachable("Unknown decl qualifier"); 1168 case objc_in: Qual = ObjCDeclSpec::DQ_In; break; 1169 case objc_out: Qual = ObjCDeclSpec::DQ_Out; break; 1170 case objc_inout: Qual = ObjCDeclSpec::DQ_Inout; break; 1171 case objc_oneway: Qual = ObjCDeclSpec::DQ_Oneway; break; 1172 case objc_bycopy: Qual = ObjCDeclSpec::DQ_Bycopy; break; 1173 case objc_byref: Qual = ObjCDeclSpec::DQ_Byref; break; 1174 1175 case objc_nonnull: 1176 Qual = ObjCDeclSpec::DQ_CSNullability; 1177 Nullability = NullabilityKind::NonNull; 1178 break; 1179 1180 case objc_nullable: 1181 Qual = ObjCDeclSpec::DQ_CSNullability; 1182 Nullability = NullabilityKind::Nullable; 1183 break; 1184 1185 case objc_null_unspecified: 1186 Qual = ObjCDeclSpec::DQ_CSNullability; 1187 Nullability = NullabilityKind::Unspecified; 1188 break; 1189 } 1190 1191 // FIXME: Diagnose redundant specifiers. 1192 DS.setObjCDeclQualifier(Qual); 1193 if (Qual == ObjCDeclSpec::DQ_CSNullability) 1194 DS.setNullability(Tok.getLocation(), Nullability); 1195 1196 ConsumeToken(); 1197 II = nullptr; 1198 break; 1199 } 1200 1201 // If this wasn't a recognized qualifier, bail out. 1202 if (II) return; 1203 } 1204 } 1205 1206 /// Take all the decl attributes out of the given list and add 1207 /// them to the given attribute set. 1208 static void takeDeclAttributes(ParsedAttributesView &attrs, 1209 ParsedAttributesView &from) { 1210 for (auto &AL : llvm::reverse(from)) { 1211 if (!AL.isUsedAsTypeAttr()) { 1212 from.remove(&AL); 1213 attrs.addAtEnd(&AL); 1214 } 1215 } 1216 } 1217 1218 /// takeDeclAttributes - Take all the decl attributes from the given 1219 /// declarator and add them to the given list. 1220 static void takeDeclAttributes(ParsedAttributes &attrs, 1221 Declarator &D) { 1222 // First, take ownership of all attributes. 1223 attrs.getPool().takeAllFrom(D.getAttributePool()); 1224 attrs.getPool().takeAllFrom(D.getDeclSpec().getAttributePool()); 1225 1226 // Now actually move the attributes over. 1227 takeDeclAttributes(attrs, D.getMutableDeclSpec().getAttributes()); 1228 takeDeclAttributes(attrs, D.getAttributes()); 1229 for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) 1230 takeDeclAttributes(attrs, D.getTypeObject(i).getAttrs()); 1231 } 1232 1233 /// objc-type-name: 1234 /// '(' objc-type-qualifiers[opt] type-name ')' 1235 /// '(' objc-type-qualifiers[opt] ')' 1236 /// 1237 ParsedType Parser::ParseObjCTypeName(ObjCDeclSpec &DS, 1238 DeclaratorContext context, 1239 ParsedAttributes *paramAttrs) { 1240 assert(context == DeclaratorContext::ObjCParameter || 1241 context == DeclaratorContext::ObjCResult); 1242 assert((paramAttrs != nullptr) == 1243 (context == DeclaratorContext::ObjCParameter)); 1244 1245 assert(Tok.is(tok::l_paren) && "expected ("); 1246 1247 BalancedDelimiterTracker T(*this, tok::l_paren); 1248 T.consumeOpen(); 1249 1250 ObjCDeclContextSwitch ObjCDC(*this); 1251 1252 // Parse type qualifiers, in, inout, etc. 1253 ParseObjCTypeQualifierList(DS, context); 1254 SourceLocation TypeStartLoc = Tok.getLocation(); 1255 1256 ParsedType Ty; 1257 if (isTypeSpecifierQualifier() || isObjCInstancetype()) { 1258 // Parse an abstract declarator. 1259 DeclSpec declSpec(AttrFactory); 1260 declSpec.setObjCQualifiers(&DS); 1261 DeclSpecContext dsContext = DeclSpecContext::DSC_normal; 1262 if (context == DeclaratorContext::ObjCResult) 1263 dsContext = DeclSpecContext::DSC_objc_method_result; 1264 ParseSpecifierQualifierList(declSpec, AS_none, dsContext); 1265 Declarator declarator(declSpec, context); 1266 ParseDeclarator(declarator); 1267 1268 // If that's not invalid, extract a type. 1269 if (!declarator.isInvalidType()) { 1270 // Map a nullability specifier to a context-sensitive keyword attribute. 1271 bool addedToDeclSpec = false; 1272 if (DS.getObjCDeclQualifier() & ObjCDeclSpec::DQ_CSNullability) 1273 addContextSensitiveTypeNullability(*this, declarator, 1274 DS.getNullability(), 1275 DS.getNullabilityLoc(), 1276 addedToDeclSpec); 1277 1278 TypeResult type = Actions.ActOnTypeName(getCurScope(), declarator); 1279 if (!type.isInvalid()) 1280 Ty = type.get(); 1281 1282 // If we're parsing a parameter, steal all the decl attributes 1283 // and add them to the decl spec. 1284 if (context == DeclaratorContext::ObjCParameter) 1285 takeDeclAttributes(*paramAttrs, declarator); 1286 } 1287 } 1288 1289 if (Tok.is(tok::r_paren)) 1290 T.consumeClose(); 1291 else if (Tok.getLocation() == TypeStartLoc) { 1292 // If we didn't eat any tokens, then this isn't a type. 1293 Diag(Tok, diag::err_expected_type); 1294 SkipUntil(tok::r_paren, StopAtSemi); 1295 } else { 1296 // Otherwise, we found *something*, but didn't get a ')' in the right 1297 // place. Emit an error then return what we have as the type. 1298 T.consumeClose(); 1299 } 1300 return Ty; 1301 } 1302 1303 /// objc-method-decl: 1304 /// objc-selector 1305 /// objc-keyword-selector objc-parmlist[opt] 1306 /// objc-type-name objc-selector 1307 /// objc-type-name objc-keyword-selector objc-parmlist[opt] 1308 /// 1309 /// objc-keyword-selector: 1310 /// objc-keyword-decl 1311 /// objc-keyword-selector objc-keyword-decl 1312 /// 1313 /// objc-keyword-decl: 1314 /// objc-selector ':' objc-type-name objc-keyword-attributes[opt] identifier 1315 /// objc-selector ':' objc-keyword-attributes[opt] identifier 1316 /// ':' objc-type-name objc-keyword-attributes[opt] identifier 1317 /// ':' objc-keyword-attributes[opt] identifier 1318 /// 1319 /// objc-parmlist: 1320 /// objc-parms objc-ellipsis[opt] 1321 /// 1322 /// objc-parms: 1323 /// objc-parms , parameter-declaration 1324 /// 1325 /// objc-ellipsis: 1326 /// , ... 1327 /// 1328 /// objc-keyword-attributes: [OBJC2] 1329 /// __attribute__((unused)) 1330 /// 1331 Decl *Parser::ParseObjCMethodDecl(SourceLocation mLoc, 1332 tok::TokenKind mType, 1333 tok::ObjCKeywordKind MethodImplKind, 1334 bool MethodDefinition) { 1335 ParsingDeclRAIIObject PD(*this, ParsingDeclRAIIObject::NoParent); 1336 1337 if (Tok.is(tok::code_completion)) { 1338 Actions.CodeCompleteObjCMethodDecl(getCurScope(), mType == tok::minus, 1339 /*ReturnType=*/nullptr); 1340 cutOffParsing(); 1341 return nullptr; 1342 } 1343 1344 // Parse the return type if present. 1345 ParsedType ReturnType; 1346 ObjCDeclSpec DSRet; 1347 if (Tok.is(tok::l_paren)) 1348 ReturnType = 1349 ParseObjCTypeName(DSRet, DeclaratorContext::ObjCResult, nullptr); 1350 1351 // If attributes exist before the method, parse them. 1352 ParsedAttributes methodAttrs(AttrFactory); 1353 if (getLangOpts().ObjC) 1354 MaybeParseGNUAttributes(methodAttrs); 1355 MaybeParseCXX11Attributes(methodAttrs); 1356 1357 if (Tok.is(tok::code_completion)) { 1358 Actions.CodeCompleteObjCMethodDecl(getCurScope(), mType == tok::minus, 1359 ReturnType); 1360 cutOffParsing(); 1361 return nullptr; 1362 } 1363 1364 // Now parse the selector. 1365 SourceLocation selLoc; 1366 IdentifierInfo *SelIdent = ParseObjCSelectorPiece(selLoc); 1367 1368 // An unnamed colon is valid. 1369 if (!SelIdent && Tok.isNot(tok::colon)) { // missing selector name. 1370 Diag(Tok, diag::err_expected_selector_for_method) 1371 << SourceRange(mLoc, Tok.getLocation()); 1372 // Skip until we get a ; or @. 1373 SkipUntil(tok::at, StopAtSemi | StopBeforeMatch); 1374 return nullptr; 1375 } 1376 1377 SmallVector<DeclaratorChunk::ParamInfo, 8> CParamInfo; 1378 if (Tok.isNot(tok::colon)) { 1379 // If attributes exist after the method, parse them. 1380 if (getLangOpts().ObjC) 1381 MaybeParseGNUAttributes(methodAttrs); 1382 MaybeParseCXX11Attributes(methodAttrs); 1383 1384 Selector Sel = PP.getSelectorTable().getNullarySelector(SelIdent); 1385 Decl *Result = Actions.ActOnMethodDeclaration( 1386 getCurScope(), mLoc, Tok.getLocation(), mType, DSRet, ReturnType, 1387 selLoc, Sel, nullptr, CParamInfo.data(), CParamInfo.size(), methodAttrs, 1388 MethodImplKind, false, MethodDefinition); 1389 PD.complete(Result); 1390 return Result; 1391 } 1392 1393 SmallVector<IdentifierInfo *, 12> KeyIdents; 1394 SmallVector<SourceLocation, 12> KeyLocs; 1395 SmallVector<Sema::ObjCArgInfo, 12> ArgInfos; 1396 ParseScope PrototypeScope(this, Scope::FunctionPrototypeScope | 1397 Scope::FunctionDeclarationScope | Scope::DeclScope); 1398 1399 AttributePool allParamAttrs(AttrFactory); 1400 while (1) { 1401 ParsedAttributes paramAttrs(AttrFactory); 1402 Sema::ObjCArgInfo ArgInfo; 1403 1404 // Each iteration parses a single keyword argument. 1405 if (ExpectAndConsume(tok::colon)) 1406 break; 1407 1408 ArgInfo.Type = nullptr; 1409 if (Tok.is(tok::l_paren)) // Parse the argument type if present. 1410 ArgInfo.Type = ParseObjCTypeName( 1411 ArgInfo.DeclSpec, DeclaratorContext::ObjCParameter, ¶mAttrs); 1412 1413 // If attributes exist before the argument name, parse them. 1414 // Regardless, collect all the attributes we've parsed so far. 1415 if (getLangOpts().ObjC) 1416 MaybeParseGNUAttributes(paramAttrs); 1417 MaybeParseCXX11Attributes(paramAttrs); 1418 ArgInfo.ArgAttrs = paramAttrs; 1419 1420 // Code completion for the next piece of the selector. 1421 if (Tok.is(tok::code_completion)) { 1422 KeyIdents.push_back(SelIdent); 1423 Actions.CodeCompleteObjCMethodDeclSelector(getCurScope(), 1424 mType == tok::minus, 1425 /*AtParameterName=*/true, 1426 ReturnType, KeyIdents); 1427 cutOffParsing(); 1428 return nullptr; 1429 } 1430 1431 if (expectIdentifier()) 1432 break; // missing argument name. 1433 1434 ArgInfo.Name = Tok.getIdentifierInfo(); 1435 ArgInfo.NameLoc = Tok.getLocation(); 1436 ConsumeToken(); // Eat the identifier. 1437 1438 ArgInfos.push_back(ArgInfo); 1439 KeyIdents.push_back(SelIdent); 1440 KeyLocs.push_back(selLoc); 1441 1442 // Make sure the attributes persist. 1443 allParamAttrs.takeAllFrom(paramAttrs.getPool()); 1444 1445 // Code completion for the next piece of the selector. 1446 if (Tok.is(tok::code_completion)) { 1447 Actions.CodeCompleteObjCMethodDeclSelector(getCurScope(), 1448 mType == tok::minus, 1449 /*AtParameterName=*/false, 1450 ReturnType, KeyIdents); 1451 cutOffParsing(); 1452 return nullptr; 1453 } 1454 1455 // Check for another keyword selector. 1456 SelIdent = ParseObjCSelectorPiece(selLoc); 1457 if (!SelIdent && Tok.isNot(tok::colon)) 1458 break; 1459 if (!SelIdent) { 1460 SourceLocation ColonLoc = Tok.getLocation(); 1461 if (PP.getLocForEndOfToken(ArgInfo.NameLoc) == ColonLoc) { 1462 Diag(ArgInfo.NameLoc, diag::warn_missing_selector_name) << ArgInfo.Name; 1463 Diag(ArgInfo.NameLoc, diag::note_missing_selector_name) << ArgInfo.Name; 1464 Diag(ColonLoc, diag::note_force_empty_selector_name) << ArgInfo.Name; 1465 } 1466 } 1467 // We have a selector or a colon, continue parsing. 1468 } 1469 1470 bool isVariadic = false; 1471 bool cStyleParamWarned = false; 1472 // Parse the (optional) parameter list. 1473 while (Tok.is(tok::comma)) { 1474 ConsumeToken(); 1475 if (Tok.is(tok::ellipsis)) { 1476 isVariadic = true; 1477 ConsumeToken(); 1478 break; 1479 } 1480 if (!cStyleParamWarned) { 1481 Diag(Tok, diag::warn_cstyle_param); 1482 cStyleParamWarned = true; 1483 } 1484 DeclSpec DS(AttrFactory); 1485 ParseDeclarationSpecifiers(DS); 1486 // Parse the declarator. 1487 Declarator ParmDecl(DS, DeclaratorContext::Prototype); 1488 ParseDeclarator(ParmDecl); 1489 IdentifierInfo *ParmII = ParmDecl.getIdentifier(); 1490 Decl *Param = Actions.ActOnParamDeclarator(getCurScope(), ParmDecl); 1491 CParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII, 1492 ParmDecl.getIdentifierLoc(), 1493 Param, 1494 nullptr)); 1495 } 1496 1497 // FIXME: Add support for optional parameter list... 1498 // If attributes exist after the method, parse them. 1499 if (getLangOpts().ObjC) 1500 MaybeParseGNUAttributes(methodAttrs); 1501 MaybeParseCXX11Attributes(methodAttrs); 1502 1503 if (KeyIdents.size() == 0) 1504 return nullptr; 1505 1506 Selector Sel = PP.getSelectorTable().getSelector(KeyIdents.size(), 1507 &KeyIdents[0]); 1508 Decl *Result = Actions.ActOnMethodDeclaration( 1509 getCurScope(), mLoc, Tok.getLocation(), mType, DSRet, ReturnType, KeyLocs, 1510 Sel, &ArgInfos[0], CParamInfo.data(), CParamInfo.size(), methodAttrs, 1511 MethodImplKind, isVariadic, MethodDefinition); 1512 1513 PD.complete(Result); 1514 return Result; 1515 } 1516 1517 /// objc-protocol-refs: 1518 /// '<' identifier-list '>' 1519 /// 1520 bool Parser:: 1521 ParseObjCProtocolReferences(SmallVectorImpl<Decl *> &Protocols, 1522 SmallVectorImpl<SourceLocation> &ProtocolLocs, 1523 bool WarnOnDeclarations, bool ForObjCContainer, 1524 SourceLocation &LAngleLoc, SourceLocation &EndLoc, 1525 bool consumeLastToken) { 1526 assert(Tok.is(tok::less) && "expected <"); 1527 1528 LAngleLoc = ConsumeToken(); // the "<" 1529 1530 SmallVector<IdentifierLocPair, 8> ProtocolIdents; 1531 1532 while (1) { 1533 if (Tok.is(tok::code_completion)) { 1534 Actions.CodeCompleteObjCProtocolReferences(ProtocolIdents); 1535 cutOffParsing(); 1536 return true; 1537 } 1538 1539 if (expectIdentifier()) { 1540 SkipUntil(tok::greater, StopAtSemi); 1541 return true; 1542 } 1543 ProtocolIdents.push_back(std::make_pair(Tok.getIdentifierInfo(), 1544 Tok.getLocation())); 1545 ProtocolLocs.push_back(Tok.getLocation()); 1546 ConsumeToken(); 1547 1548 if (!TryConsumeToken(tok::comma)) 1549 break; 1550 } 1551 1552 // Consume the '>'. 1553 if (ParseGreaterThanInTemplateList(LAngleLoc, EndLoc, consumeLastToken, 1554 /*ObjCGenericList=*/false)) 1555 return true; 1556 1557 // Convert the list of protocols identifiers into a list of protocol decls. 1558 Actions.FindProtocolDeclaration(WarnOnDeclarations, ForObjCContainer, 1559 ProtocolIdents, Protocols); 1560 return false; 1561 } 1562 1563 TypeResult Parser::parseObjCProtocolQualifierType(SourceLocation &rAngleLoc) { 1564 assert(Tok.is(tok::less) && "Protocol qualifiers start with '<'"); 1565 assert(getLangOpts().ObjC && "Protocol qualifiers only exist in Objective-C"); 1566 1567 SourceLocation lAngleLoc; 1568 SmallVector<Decl *, 8> protocols; 1569 SmallVector<SourceLocation, 8> protocolLocs; 1570 (void)ParseObjCProtocolReferences(protocols, protocolLocs, false, false, 1571 lAngleLoc, rAngleLoc, 1572 /*consumeLastToken=*/true); 1573 TypeResult result = Actions.actOnObjCProtocolQualifierType(lAngleLoc, 1574 protocols, 1575 protocolLocs, 1576 rAngleLoc); 1577 if (result.isUsable()) { 1578 Diag(lAngleLoc, diag::warn_objc_protocol_qualifier_missing_id) 1579 << FixItHint::CreateInsertion(lAngleLoc, "id") 1580 << SourceRange(lAngleLoc, rAngleLoc); 1581 } 1582 1583 return result; 1584 } 1585 1586 /// Parse Objective-C type arguments or protocol qualifiers. 1587 /// 1588 /// objc-type-arguments: 1589 /// '<' type-name '...'[opt] (',' type-name '...'[opt])* '>' 1590 /// 1591 void Parser::parseObjCTypeArgsOrProtocolQualifiers( 1592 ParsedType baseType, 1593 SourceLocation &typeArgsLAngleLoc, 1594 SmallVectorImpl<ParsedType> &typeArgs, 1595 SourceLocation &typeArgsRAngleLoc, 1596 SourceLocation &protocolLAngleLoc, 1597 SmallVectorImpl<Decl *> &protocols, 1598 SmallVectorImpl<SourceLocation> &protocolLocs, 1599 SourceLocation &protocolRAngleLoc, 1600 bool consumeLastToken, 1601 bool warnOnIncompleteProtocols) { 1602 assert(Tok.is(tok::less) && "Not at the start of type args or protocols"); 1603 SourceLocation lAngleLoc = ConsumeToken(); 1604 1605 // Whether all of the elements we've parsed thus far are single 1606 // identifiers, which might be types or might be protocols. 1607 bool allSingleIdentifiers = true; 1608 SmallVector<IdentifierInfo *, 4> identifiers; 1609 SmallVectorImpl<SourceLocation> &identifierLocs = protocolLocs; 1610 1611 // Parse a list of comma-separated identifiers, bailing out if we 1612 // see something different. 1613 do { 1614 // Parse a single identifier. 1615 if (Tok.is(tok::identifier) && 1616 (NextToken().is(tok::comma) || 1617 NextToken().is(tok::greater) || 1618 NextToken().is(tok::greatergreater))) { 1619 identifiers.push_back(Tok.getIdentifierInfo()); 1620 identifierLocs.push_back(ConsumeToken()); 1621 continue; 1622 } 1623 1624 if (Tok.is(tok::code_completion)) { 1625 // FIXME: Also include types here. 1626 SmallVector<IdentifierLocPair, 4> identifierLocPairs; 1627 for (unsigned i = 0, n = identifiers.size(); i != n; ++i) { 1628 identifierLocPairs.push_back(IdentifierLocPair(identifiers[i], 1629 identifierLocs[i])); 1630 } 1631 1632 QualType BaseT = Actions.GetTypeFromParser(baseType); 1633 if (!BaseT.isNull() && BaseT->acceptsObjCTypeParams()) { 1634 Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Type); 1635 } else { 1636 Actions.CodeCompleteObjCProtocolReferences(identifierLocPairs); 1637 } 1638 cutOffParsing(); 1639 return; 1640 } 1641 1642 allSingleIdentifiers = false; 1643 break; 1644 } while (TryConsumeToken(tok::comma)); 1645 1646 // If we parsed an identifier list, semantic analysis sorts out 1647 // whether it refers to protocols or to type arguments. 1648 if (allSingleIdentifiers) { 1649 // Parse the closing '>'. 1650 SourceLocation rAngleLoc; 1651 (void)ParseGreaterThanInTemplateList(lAngleLoc, rAngleLoc, consumeLastToken, 1652 /*ObjCGenericList=*/true); 1653 1654 // Let Sema figure out what we parsed. 1655 Actions.actOnObjCTypeArgsOrProtocolQualifiers(getCurScope(), 1656 baseType, 1657 lAngleLoc, 1658 identifiers, 1659 identifierLocs, 1660 rAngleLoc, 1661 typeArgsLAngleLoc, 1662 typeArgs, 1663 typeArgsRAngleLoc, 1664 protocolLAngleLoc, 1665 protocols, 1666 protocolRAngleLoc, 1667 warnOnIncompleteProtocols); 1668 return; 1669 } 1670 1671 // We parsed an identifier list but stumbled into non single identifiers, this 1672 // means we might (a) check that what we already parsed is a legitimate type 1673 // (not a protocol or unknown type) and (b) parse the remaining ones, which 1674 // must all be type args. 1675 1676 // Convert the identifiers into type arguments. 1677 bool invalid = false; 1678 IdentifierInfo *foundProtocolId = nullptr, *foundValidTypeId = nullptr; 1679 SourceLocation foundProtocolSrcLoc, foundValidTypeSrcLoc; 1680 SmallVector<IdentifierInfo *, 2> unknownTypeArgs; 1681 SmallVector<SourceLocation, 2> unknownTypeArgsLoc; 1682 1683 for (unsigned i = 0, n = identifiers.size(); i != n; ++i) { 1684 ParsedType typeArg 1685 = Actions.getTypeName(*identifiers[i], identifierLocs[i], getCurScope()); 1686 if (typeArg) { 1687 DeclSpec DS(AttrFactory); 1688 const char *prevSpec = nullptr; 1689 unsigned diagID; 1690 DS.SetTypeSpecType(TST_typename, identifierLocs[i], prevSpec, diagID, 1691 typeArg, Actions.getASTContext().getPrintingPolicy()); 1692 1693 // Form a declarator to turn this into a type. 1694 Declarator D(DS, DeclaratorContext::TypeName); 1695 TypeResult fullTypeArg = Actions.ActOnTypeName(getCurScope(), D); 1696 if (fullTypeArg.isUsable()) { 1697 typeArgs.push_back(fullTypeArg.get()); 1698 if (!foundValidTypeId) { 1699 foundValidTypeId = identifiers[i]; 1700 foundValidTypeSrcLoc = identifierLocs[i]; 1701 } 1702 } else { 1703 invalid = true; 1704 unknownTypeArgs.push_back(identifiers[i]); 1705 unknownTypeArgsLoc.push_back(identifierLocs[i]); 1706 } 1707 } else { 1708 invalid = true; 1709 if (!Actions.LookupProtocol(identifiers[i], identifierLocs[i])) { 1710 unknownTypeArgs.push_back(identifiers[i]); 1711 unknownTypeArgsLoc.push_back(identifierLocs[i]); 1712 } else if (!foundProtocolId) { 1713 foundProtocolId = identifiers[i]; 1714 foundProtocolSrcLoc = identifierLocs[i]; 1715 } 1716 } 1717 } 1718 1719 // Continue parsing type-names. 1720 do { 1721 Token CurTypeTok = Tok; 1722 TypeResult typeArg = ParseTypeName(); 1723 1724 // Consume the '...' for a pack expansion. 1725 SourceLocation ellipsisLoc; 1726 TryConsumeToken(tok::ellipsis, ellipsisLoc); 1727 if (typeArg.isUsable() && ellipsisLoc.isValid()) { 1728 typeArg = Actions.ActOnPackExpansion(typeArg.get(), ellipsisLoc); 1729 } 1730 1731 if (typeArg.isUsable()) { 1732 typeArgs.push_back(typeArg.get()); 1733 if (!foundValidTypeId) { 1734 foundValidTypeId = CurTypeTok.getIdentifierInfo(); 1735 foundValidTypeSrcLoc = CurTypeTok.getLocation(); 1736 } 1737 } else { 1738 invalid = true; 1739 } 1740 } while (TryConsumeToken(tok::comma)); 1741 1742 // Diagnose the mix between type args and protocols. 1743 if (foundProtocolId && foundValidTypeId) 1744 Actions.DiagnoseTypeArgsAndProtocols(foundProtocolId, foundProtocolSrcLoc, 1745 foundValidTypeId, 1746 foundValidTypeSrcLoc); 1747 1748 // Diagnose unknown arg types. 1749 ParsedType T; 1750 if (unknownTypeArgs.size()) 1751 for (unsigned i = 0, e = unknownTypeArgsLoc.size(); i < e; ++i) 1752 Actions.DiagnoseUnknownTypeName(unknownTypeArgs[i], unknownTypeArgsLoc[i], 1753 getCurScope(), nullptr, T); 1754 1755 // Parse the closing '>'. 1756 SourceLocation rAngleLoc; 1757 (void)ParseGreaterThanInTemplateList(lAngleLoc, rAngleLoc, consumeLastToken, 1758 /*ObjCGenericList=*/true); 1759 1760 if (invalid) { 1761 typeArgs.clear(); 1762 return; 1763 } 1764 1765 // Record left/right angle locations. 1766 typeArgsLAngleLoc = lAngleLoc; 1767 typeArgsRAngleLoc = rAngleLoc; 1768 } 1769 1770 void Parser::parseObjCTypeArgsAndProtocolQualifiers( 1771 ParsedType baseType, 1772 SourceLocation &typeArgsLAngleLoc, 1773 SmallVectorImpl<ParsedType> &typeArgs, 1774 SourceLocation &typeArgsRAngleLoc, 1775 SourceLocation &protocolLAngleLoc, 1776 SmallVectorImpl<Decl *> &protocols, 1777 SmallVectorImpl<SourceLocation> &protocolLocs, 1778 SourceLocation &protocolRAngleLoc, 1779 bool consumeLastToken) { 1780 assert(Tok.is(tok::less)); 1781 1782 // Parse the first angle-bracket-delimited clause. 1783 parseObjCTypeArgsOrProtocolQualifiers(baseType, 1784 typeArgsLAngleLoc, 1785 typeArgs, 1786 typeArgsRAngleLoc, 1787 protocolLAngleLoc, 1788 protocols, 1789 protocolLocs, 1790 protocolRAngleLoc, 1791 consumeLastToken, 1792 /*warnOnIncompleteProtocols=*/false); 1793 if (Tok.is(tok::eof)) // Nothing else to do here... 1794 return; 1795 1796 // An Objective-C object pointer followed by type arguments 1797 // can then be followed again by a set of protocol references, e.g., 1798 // \c NSArray<NSView><NSTextDelegate> 1799 if ((consumeLastToken && Tok.is(tok::less)) || 1800 (!consumeLastToken && NextToken().is(tok::less))) { 1801 // If we aren't consuming the last token, the prior '>' is still hanging 1802 // there. Consume it before we parse the protocol qualifiers. 1803 if (!consumeLastToken) 1804 ConsumeToken(); 1805 1806 if (!protocols.empty()) { 1807 SkipUntilFlags skipFlags = SkipUntilFlags(); 1808 if (!consumeLastToken) 1809 skipFlags = skipFlags | StopBeforeMatch; 1810 Diag(Tok, diag::err_objc_type_args_after_protocols) 1811 << SourceRange(protocolLAngleLoc, protocolRAngleLoc); 1812 SkipUntil(tok::greater, tok::greatergreater, skipFlags); 1813 } else { 1814 ParseObjCProtocolReferences(protocols, protocolLocs, 1815 /*WarnOnDeclarations=*/false, 1816 /*ForObjCContainer=*/false, 1817 protocolLAngleLoc, protocolRAngleLoc, 1818 consumeLastToken); 1819 } 1820 } 1821 } 1822 1823 TypeResult Parser::parseObjCTypeArgsAndProtocolQualifiers( 1824 SourceLocation loc, 1825 ParsedType type, 1826 bool consumeLastToken, 1827 SourceLocation &endLoc) { 1828 assert(Tok.is(tok::less)); 1829 SourceLocation typeArgsLAngleLoc; 1830 SmallVector<ParsedType, 4> typeArgs; 1831 SourceLocation typeArgsRAngleLoc; 1832 SourceLocation protocolLAngleLoc; 1833 SmallVector<Decl *, 4> protocols; 1834 SmallVector<SourceLocation, 4> protocolLocs; 1835 SourceLocation protocolRAngleLoc; 1836 1837 // Parse type arguments and protocol qualifiers. 1838 parseObjCTypeArgsAndProtocolQualifiers(type, typeArgsLAngleLoc, typeArgs, 1839 typeArgsRAngleLoc, protocolLAngleLoc, 1840 protocols, protocolLocs, 1841 protocolRAngleLoc, consumeLastToken); 1842 1843 if (Tok.is(tok::eof)) 1844 return true; // Invalid type result. 1845 1846 // Compute the location of the last token. 1847 if (consumeLastToken) 1848 endLoc = PrevTokLocation; 1849 else 1850 endLoc = Tok.getLocation(); 1851 1852 return Actions.actOnObjCTypeArgsAndProtocolQualifiers( 1853 getCurScope(), 1854 loc, 1855 type, 1856 typeArgsLAngleLoc, 1857 typeArgs, 1858 typeArgsRAngleLoc, 1859 protocolLAngleLoc, 1860 protocols, 1861 protocolLocs, 1862 protocolRAngleLoc); 1863 } 1864 1865 void Parser::HelperActionsForIvarDeclarations(Decl *interfaceDecl, SourceLocation atLoc, 1866 BalancedDelimiterTracker &T, 1867 SmallVectorImpl<Decl *> &AllIvarDecls, 1868 bool RBraceMissing) { 1869 if (!RBraceMissing) 1870 T.consumeClose(); 1871 1872 Actions.ActOnObjCContainerStartDefinition(interfaceDecl); 1873 Actions.ActOnLastBitfield(T.getCloseLocation(), AllIvarDecls); 1874 Actions.ActOnObjCContainerFinishDefinition(); 1875 // Call ActOnFields() even if we don't have any decls. This is useful 1876 // for code rewriting tools that need to be aware of the empty list. 1877 Actions.ActOnFields(getCurScope(), atLoc, interfaceDecl, AllIvarDecls, 1878 T.getOpenLocation(), T.getCloseLocation(), 1879 ParsedAttributesView()); 1880 } 1881 1882 /// objc-class-instance-variables: 1883 /// '{' objc-instance-variable-decl-list[opt] '}' 1884 /// 1885 /// objc-instance-variable-decl-list: 1886 /// objc-visibility-spec 1887 /// objc-instance-variable-decl ';' 1888 /// ';' 1889 /// objc-instance-variable-decl-list objc-visibility-spec 1890 /// objc-instance-variable-decl-list objc-instance-variable-decl ';' 1891 /// objc-instance-variable-decl-list static_assert-declaration 1892 /// objc-instance-variable-decl-list ';' 1893 /// 1894 /// objc-visibility-spec: 1895 /// @private 1896 /// @protected 1897 /// @public 1898 /// @package [OBJC2] 1899 /// 1900 /// objc-instance-variable-decl: 1901 /// struct-declaration 1902 /// 1903 void Parser::ParseObjCClassInstanceVariables(Decl *interfaceDecl, 1904 tok::ObjCKeywordKind visibility, 1905 SourceLocation atLoc) { 1906 assert(Tok.is(tok::l_brace) && "expected {"); 1907 SmallVector<Decl *, 32> AllIvarDecls; 1908 1909 ParseScope ClassScope(this, Scope::DeclScope|Scope::ClassScope); 1910 ObjCDeclContextSwitch ObjCDC(*this); 1911 1912 BalancedDelimiterTracker T(*this, tok::l_brace); 1913 T.consumeOpen(); 1914 // While we still have something to read, read the instance variables. 1915 while (Tok.isNot(tok::r_brace) && !isEofOrEom()) { 1916 // Each iteration of this loop reads one objc-instance-variable-decl. 1917 1918 // Check for extraneous top-level semicolon. 1919 if (Tok.is(tok::semi)) { 1920 ConsumeExtraSemi(InstanceVariableList); 1921 continue; 1922 } 1923 1924 // Set the default visibility to private. 1925 if (TryConsumeToken(tok::at)) { // parse objc-visibility-spec 1926 if (Tok.is(tok::code_completion)) { 1927 Actions.CodeCompleteObjCAtVisibility(getCurScope()); 1928 return cutOffParsing(); 1929 } 1930 1931 switch (Tok.getObjCKeywordID()) { 1932 case tok::objc_private: 1933 case tok::objc_public: 1934 case tok::objc_protected: 1935 case tok::objc_package: 1936 visibility = Tok.getObjCKeywordID(); 1937 ConsumeToken(); 1938 continue; 1939 1940 case tok::objc_end: 1941 Diag(Tok, diag::err_objc_unexpected_atend); 1942 Tok.setLocation(Tok.getLocation().getLocWithOffset(-1)); 1943 Tok.setKind(tok::at); 1944 Tok.setLength(1); 1945 PP.EnterToken(Tok, /*IsReinject*/true); 1946 HelperActionsForIvarDeclarations(interfaceDecl, atLoc, 1947 T, AllIvarDecls, true); 1948 return; 1949 1950 default: 1951 Diag(Tok, diag::err_objc_illegal_visibility_spec); 1952 continue; 1953 } 1954 } 1955 1956 if (Tok.is(tok::code_completion)) { 1957 Actions.CodeCompleteOrdinaryName(getCurScope(), 1958 Sema::PCC_ObjCInstanceVariableList); 1959 return cutOffParsing(); 1960 } 1961 1962 // This needs to duplicate a small amount of code from 1963 // ParseStructUnionBody() for things that should work in both 1964 // C struct and in Objective-C class instance variables. 1965 if (Tok.isOneOf(tok::kw_static_assert, tok::kw__Static_assert)) { 1966 SourceLocation DeclEnd; 1967 ParseStaticAssertDeclaration(DeclEnd); 1968 continue; 1969 } 1970 1971 auto ObjCIvarCallback = [&](ParsingFieldDeclarator &FD) { 1972 Actions.ActOnObjCContainerStartDefinition(interfaceDecl); 1973 // Install the declarator into the interface decl. 1974 FD.D.setObjCIvar(true); 1975 Decl *Field = Actions.ActOnIvar( 1976 getCurScope(), FD.D.getDeclSpec().getSourceRange().getBegin(), FD.D, 1977 FD.BitfieldSize, visibility); 1978 Actions.ActOnObjCContainerFinishDefinition(); 1979 if (Field) 1980 AllIvarDecls.push_back(Field); 1981 FD.complete(Field); 1982 }; 1983 1984 // Parse all the comma separated declarators. 1985 ParsingDeclSpec DS(*this); 1986 ParseStructDeclaration(DS, ObjCIvarCallback); 1987 1988 if (Tok.is(tok::semi)) { 1989 ConsumeToken(); 1990 } else { 1991 Diag(Tok, diag::err_expected_semi_decl_list); 1992 // Skip to end of block or statement 1993 SkipUntil(tok::r_brace, StopAtSemi | StopBeforeMatch); 1994 } 1995 } 1996 HelperActionsForIvarDeclarations(interfaceDecl, atLoc, 1997 T, AllIvarDecls, false); 1998 } 1999 2000 /// objc-protocol-declaration: 2001 /// objc-protocol-definition 2002 /// objc-protocol-forward-reference 2003 /// 2004 /// objc-protocol-definition: 2005 /// \@protocol identifier 2006 /// objc-protocol-refs[opt] 2007 /// objc-interface-decl-list 2008 /// \@end 2009 /// 2010 /// objc-protocol-forward-reference: 2011 /// \@protocol identifier-list ';' 2012 /// 2013 /// "\@protocol identifier ;" should be resolved as "\@protocol 2014 /// identifier-list ;": objc-interface-decl-list may not start with a 2015 /// semicolon in the first alternative if objc-protocol-refs are omitted. 2016 Parser::DeclGroupPtrTy 2017 Parser::ParseObjCAtProtocolDeclaration(SourceLocation AtLoc, 2018 ParsedAttributes &attrs) { 2019 assert(Tok.isObjCAtKeyword(tok::objc_protocol) && 2020 "ParseObjCAtProtocolDeclaration(): Expected @protocol"); 2021 ConsumeToken(); // the "protocol" identifier 2022 2023 if (Tok.is(tok::code_completion)) { 2024 Actions.CodeCompleteObjCProtocolDecl(getCurScope()); 2025 cutOffParsing(); 2026 return nullptr; 2027 } 2028 2029 MaybeSkipAttributes(tok::objc_protocol); 2030 2031 if (expectIdentifier()) 2032 return nullptr; // missing protocol name. 2033 // Save the protocol name, then consume it. 2034 IdentifierInfo *protocolName = Tok.getIdentifierInfo(); 2035 SourceLocation nameLoc = ConsumeToken(); 2036 2037 if (TryConsumeToken(tok::semi)) { // forward declaration of one protocol. 2038 IdentifierLocPair ProtoInfo(protocolName, nameLoc); 2039 return Actions.ActOnForwardProtocolDeclaration(AtLoc, ProtoInfo, attrs); 2040 } 2041 2042 CheckNestedObjCContexts(AtLoc); 2043 2044 if (Tok.is(tok::comma)) { // list of forward declarations. 2045 SmallVector<IdentifierLocPair, 8> ProtocolRefs; 2046 ProtocolRefs.push_back(std::make_pair(protocolName, nameLoc)); 2047 2048 // Parse the list of forward declarations. 2049 while (1) { 2050 ConsumeToken(); // the ',' 2051 if (expectIdentifier()) { 2052 SkipUntil(tok::semi); 2053 return nullptr; 2054 } 2055 ProtocolRefs.push_back(IdentifierLocPair(Tok.getIdentifierInfo(), 2056 Tok.getLocation())); 2057 ConsumeToken(); // the identifier 2058 2059 if (Tok.isNot(tok::comma)) 2060 break; 2061 } 2062 // Consume the ';'. 2063 if (ExpectAndConsume(tok::semi, diag::err_expected_after, "@protocol")) 2064 return nullptr; 2065 2066 return Actions.ActOnForwardProtocolDeclaration(AtLoc, ProtocolRefs, attrs); 2067 } 2068 2069 // Last, and definitely not least, parse a protocol declaration. 2070 SourceLocation LAngleLoc, EndProtoLoc; 2071 2072 SmallVector<Decl *, 8> ProtocolRefs; 2073 SmallVector<SourceLocation, 8> ProtocolLocs; 2074 if (Tok.is(tok::less) && 2075 ParseObjCProtocolReferences(ProtocolRefs, ProtocolLocs, false, true, 2076 LAngleLoc, EndProtoLoc, 2077 /*consumeLastToken=*/true)) 2078 return nullptr; 2079 2080 Decl *ProtoType = Actions.ActOnStartProtocolInterface( 2081 AtLoc, protocolName, nameLoc, ProtocolRefs.data(), ProtocolRefs.size(), 2082 ProtocolLocs.data(), EndProtoLoc, attrs); 2083 2084 ParseObjCInterfaceDeclList(tok::objc_protocol, ProtoType); 2085 return Actions.ConvertDeclToDeclGroup(ProtoType); 2086 } 2087 2088 /// objc-implementation: 2089 /// objc-class-implementation-prologue 2090 /// objc-category-implementation-prologue 2091 /// 2092 /// objc-class-implementation-prologue: 2093 /// @implementation identifier objc-superclass[opt] 2094 /// objc-class-instance-variables[opt] 2095 /// 2096 /// objc-category-implementation-prologue: 2097 /// @implementation identifier ( identifier ) 2098 Parser::DeclGroupPtrTy 2099 Parser::ParseObjCAtImplementationDeclaration(SourceLocation AtLoc, 2100 ParsedAttributes &Attrs) { 2101 assert(Tok.isObjCAtKeyword(tok::objc_implementation) && 2102 "ParseObjCAtImplementationDeclaration(): Expected @implementation"); 2103 CheckNestedObjCContexts(AtLoc); 2104 ConsumeToken(); // the "implementation" identifier 2105 2106 // Code completion after '@implementation'. 2107 if (Tok.is(tok::code_completion)) { 2108 Actions.CodeCompleteObjCImplementationDecl(getCurScope()); 2109 cutOffParsing(); 2110 return nullptr; 2111 } 2112 2113 MaybeSkipAttributes(tok::objc_implementation); 2114 2115 if (expectIdentifier()) 2116 return nullptr; // missing class or category name. 2117 // We have a class or category name - consume it. 2118 IdentifierInfo *nameId = Tok.getIdentifierInfo(); 2119 SourceLocation nameLoc = ConsumeToken(); // consume class or category name 2120 Decl *ObjCImpDecl = nullptr; 2121 2122 // Neither a type parameter list nor a list of protocol references is 2123 // permitted here. Parse and diagnose them. 2124 if (Tok.is(tok::less)) { 2125 SourceLocation lAngleLoc, rAngleLoc; 2126 SmallVector<IdentifierLocPair, 8> protocolIdents; 2127 SourceLocation diagLoc = Tok.getLocation(); 2128 ObjCTypeParamListScope typeParamScope(Actions, getCurScope()); 2129 if (parseObjCTypeParamListOrProtocolRefs(typeParamScope, lAngleLoc, 2130 protocolIdents, rAngleLoc)) { 2131 Diag(diagLoc, diag::err_objc_parameterized_implementation) 2132 << SourceRange(diagLoc, PrevTokLocation); 2133 } else if (lAngleLoc.isValid()) { 2134 Diag(lAngleLoc, diag::err_unexpected_protocol_qualifier) 2135 << FixItHint::CreateRemoval(SourceRange(lAngleLoc, rAngleLoc)); 2136 } 2137 } 2138 2139 if (Tok.is(tok::l_paren)) { 2140 // we have a category implementation. 2141 ConsumeParen(); 2142 SourceLocation categoryLoc, rparenLoc; 2143 IdentifierInfo *categoryId = nullptr; 2144 2145 if (Tok.is(tok::code_completion)) { 2146 Actions.CodeCompleteObjCImplementationCategory(getCurScope(), nameId, nameLoc); 2147 cutOffParsing(); 2148 return nullptr; 2149 } 2150 2151 if (Tok.is(tok::identifier)) { 2152 categoryId = Tok.getIdentifierInfo(); 2153 categoryLoc = ConsumeToken(); 2154 } else { 2155 Diag(Tok, diag::err_expected) 2156 << tok::identifier; // missing category name. 2157 return nullptr; 2158 } 2159 if (Tok.isNot(tok::r_paren)) { 2160 Diag(Tok, diag::err_expected) << tok::r_paren; 2161 SkipUntil(tok::r_paren); // don't stop at ';' 2162 return nullptr; 2163 } 2164 rparenLoc = ConsumeParen(); 2165 if (Tok.is(tok::less)) { // we have illegal '<' try to recover 2166 Diag(Tok, diag::err_unexpected_protocol_qualifier); 2167 SourceLocation protocolLAngleLoc, protocolRAngleLoc; 2168 SmallVector<Decl *, 4> protocols; 2169 SmallVector<SourceLocation, 4> protocolLocs; 2170 (void)ParseObjCProtocolReferences(protocols, protocolLocs, 2171 /*warnOnIncompleteProtocols=*/false, 2172 /*ForObjCContainer=*/false, 2173 protocolLAngleLoc, protocolRAngleLoc, 2174 /*consumeLastToken=*/true); 2175 } 2176 ObjCImpDecl = Actions.ActOnStartCategoryImplementation( 2177 AtLoc, nameId, nameLoc, categoryId, categoryLoc, Attrs); 2178 2179 } else { 2180 // We have a class implementation 2181 SourceLocation superClassLoc; 2182 IdentifierInfo *superClassId = nullptr; 2183 if (TryConsumeToken(tok::colon)) { 2184 // We have a super class 2185 if (expectIdentifier()) 2186 return nullptr; // missing super class name. 2187 superClassId = Tok.getIdentifierInfo(); 2188 superClassLoc = ConsumeToken(); // Consume super class name 2189 } 2190 ObjCImpDecl = Actions.ActOnStartClassImplementation( 2191 AtLoc, nameId, nameLoc, superClassId, superClassLoc, Attrs); 2192 2193 if (Tok.is(tok::l_brace)) // we have ivars 2194 ParseObjCClassInstanceVariables(ObjCImpDecl, tok::objc_private, AtLoc); 2195 else if (Tok.is(tok::less)) { // we have illegal '<' try to recover 2196 Diag(Tok, diag::err_unexpected_protocol_qualifier); 2197 2198 SourceLocation protocolLAngleLoc, protocolRAngleLoc; 2199 SmallVector<Decl *, 4> protocols; 2200 SmallVector<SourceLocation, 4> protocolLocs; 2201 (void)ParseObjCProtocolReferences(protocols, protocolLocs, 2202 /*warnOnIncompleteProtocols=*/false, 2203 /*ForObjCContainer=*/false, 2204 protocolLAngleLoc, protocolRAngleLoc, 2205 /*consumeLastToken=*/true); 2206 } 2207 } 2208 assert(ObjCImpDecl); 2209 2210 SmallVector<Decl *, 8> DeclsInGroup; 2211 2212 { 2213 ObjCImplParsingDataRAII ObjCImplParsing(*this, ObjCImpDecl); 2214 while (!ObjCImplParsing.isFinished() && !isEofOrEom()) { 2215 ParsedAttributesWithRange attrs(AttrFactory); 2216 MaybeParseCXX11Attributes(attrs); 2217 if (DeclGroupPtrTy DGP = ParseExternalDeclaration(attrs)) { 2218 DeclGroupRef DG = DGP.get(); 2219 DeclsInGroup.append(DG.begin(), DG.end()); 2220 } 2221 } 2222 } 2223 2224 return Actions.ActOnFinishObjCImplementation(ObjCImpDecl, DeclsInGroup); 2225 } 2226 2227 Parser::DeclGroupPtrTy 2228 Parser::ParseObjCAtEndDeclaration(SourceRange atEnd) { 2229 assert(Tok.isObjCAtKeyword(tok::objc_end) && 2230 "ParseObjCAtEndDeclaration(): Expected @end"); 2231 ConsumeToken(); // the "end" identifier 2232 if (CurParsedObjCImpl) 2233 CurParsedObjCImpl->finish(atEnd); 2234 else 2235 // missing @implementation 2236 Diag(atEnd.getBegin(), diag::err_expected_objc_container); 2237 return nullptr; 2238 } 2239 2240 Parser::ObjCImplParsingDataRAII::~ObjCImplParsingDataRAII() { 2241 if (!Finished) { 2242 finish(P.Tok.getLocation()); 2243 if (P.isEofOrEom()) { 2244 P.Diag(P.Tok, diag::err_objc_missing_end) 2245 << FixItHint::CreateInsertion(P.Tok.getLocation(), "\n@end\n"); 2246 P.Diag(Dcl->getBeginLoc(), diag::note_objc_container_start) 2247 << Sema::OCK_Implementation; 2248 } 2249 } 2250 P.CurParsedObjCImpl = nullptr; 2251 assert(LateParsedObjCMethods.empty()); 2252 } 2253 2254 void Parser::ObjCImplParsingDataRAII::finish(SourceRange AtEnd) { 2255 assert(!Finished); 2256 P.Actions.DefaultSynthesizeProperties(P.getCurScope(), Dcl, AtEnd.getBegin()); 2257 for (size_t i = 0; i < LateParsedObjCMethods.size(); ++i) 2258 P.ParseLexedObjCMethodDefs(*LateParsedObjCMethods[i], 2259 true/*Methods*/); 2260 2261 P.Actions.ActOnAtEnd(P.getCurScope(), AtEnd); 2262 2263 if (HasCFunction) 2264 for (size_t i = 0; i < LateParsedObjCMethods.size(); ++i) 2265 P.ParseLexedObjCMethodDefs(*LateParsedObjCMethods[i], 2266 false/*c-functions*/); 2267 2268 /// Clear and free the cached objc methods. 2269 for (LateParsedObjCMethodContainer::iterator 2270 I = LateParsedObjCMethods.begin(), 2271 E = LateParsedObjCMethods.end(); I != E; ++I) 2272 delete *I; 2273 LateParsedObjCMethods.clear(); 2274 2275 Finished = true; 2276 } 2277 2278 /// compatibility-alias-decl: 2279 /// @compatibility_alias alias-name class-name ';' 2280 /// 2281 Decl *Parser::ParseObjCAtAliasDeclaration(SourceLocation atLoc) { 2282 assert(Tok.isObjCAtKeyword(tok::objc_compatibility_alias) && 2283 "ParseObjCAtAliasDeclaration(): Expected @compatibility_alias"); 2284 ConsumeToken(); // consume compatibility_alias 2285 if (expectIdentifier()) 2286 return nullptr; 2287 IdentifierInfo *aliasId = Tok.getIdentifierInfo(); 2288 SourceLocation aliasLoc = ConsumeToken(); // consume alias-name 2289 if (expectIdentifier()) 2290 return nullptr; 2291 IdentifierInfo *classId = Tok.getIdentifierInfo(); 2292 SourceLocation classLoc = ConsumeToken(); // consume class-name; 2293 ExpectAndConsume(tok::semi, diag::err_expected_after, "@compatibility_alias"); 2294 return Actions.ActOnCompatibilityAlias(atLoc, aliasId, aliasLoc, 2295 classId, classLoc); 2296 } 2297 2298 /// property-synthesis: 2299 /// @synthesize property-ivar-list ';' 2300 /// 2301 /// property-ivar-list: 2302 /// property-ivar 2303 /// property-ivar-list ',' property-ivar 2304 /// 2305 /// property-ivar: 2306 /// identifier 2307 /// identifier '=' identifier 2308 /// 2309 Decl *Parser::ParseObjCPropertySynthesize(SourceLocation atLoc) { 2310 assert(Tok.isObjCAtKeyword(tok::objc_synthesize) && 2311 "ParseObjCPropertySynthesize(): Expected '@synthesize'"); 2312 ConsumeToken(); // consume synthesize 2313 2314 while (true) { 2315 if (Tok.is(tok::code_completion)) { 2316 Actions.CodeCompleteObjCPropertyDefinition(getCurScope()); 2317 cutOffParsing(); 2318 return nullptr; 2319 } 2320 2321 if (Tok.isNot(tok::identifier)) { 2322 Diag(Tok, diag::err_synthesized_property_name); 2323 SkipUntil(tok::semi); 2324 return nullptr; 2325 } 2326 2327 IdentifierInfo *propertyIvar = nullptr; 2328 IdentifierInfo *propertyId = Tok.getIdentifierInfo(); 2329 SourceLocation propertyLoc = ConsumeToken(); // consume property name 2330 SourceLocation propertyIvarLoc; 2331 if (TryConsumeToken(tok::equal)) { 2332 // property '=' ivar-name 2333 if (Tok.is(tok::code_completion)) { 2334 Actions.CodeCompleteObjCPropertySynthesizeIvar(getCurScope(), propertyId); 2335 cutOffParsing(); 2336 return nullptr; 2337 } 2338 2339 if (expectIdentifier()) 2340 break; 2341 propertyIvar = Tok.getIdentifierInfo(); 2342 propertyIvarLoc = ConsumeToken(); // consume ivar-name 2343 } 2344 Actions.ActOnPropertyImplDecl( 2345 getCurScope(), atLoc, propertyLoc, true, 2346 propertyId, propertyIvar, propertyIvarLoc, 2347 ObjCPropertyQueryKind::OBJC_PR_query_unknown); 2348 if (Tok.isNot(tok::comma)) 2349 break; 2350 ConsumeToken(); // consume ',' 2351 } 2352 ExpectAndConsume(tok::semi, diag::err_expected_after, "@synthesize"); 2353 return nullptr; 2354 } 2355 2356 /// property-dynamic: 2357 /// @dynamic property-list 2358 /// 2359 /// property-list: 2360 /// identifier 2361 /// property-list ',' identifier 2362 /// 2363 Decl *Parser::ParseObjCPropertyDynamic(SourceLocation atLoc) { 2364 assert(Tok.isObjCAtKeyword(tok::objc_dynamic) && 2365 "ParseObjCPropertyDynamic(): Expected '@dynamic'"); 2366 ConsumeToken(); // consume dynamic 2367 2368 bool isClassProperty = false; 2369 if (Tok.is(tok::l_paren)) { 2370 ConsumeParen(); 2371 const IdentifierInfo *II = Tok.getIdentifierInfo(); 2372 2373 if (!II) { 2374 Diag(Tok, diag::err_objc_expected_property_attr) << II; 2375 SkipUntil(tok::r_paren, StopAtSemi); 2376 } else { 2377 SourceLocation AttrName = ConsumeToken(); // consume attribute name 2378 if (II->isStr("class")) { 2379 isClassProperty = true; 2380 if (Tok.isNot(tok::r_paren)) { 2381 Diag(Tok, diag::err_expected) << tok::r_paren; 2382 SkipUntil(tok::r_paren, StopAtSemi); 2383 } else 2384 ConsumeParen(); 2385 } else { 2386 Diag(AttrName, diag::err_objc_expected_property_attr) << II; 2387 SkipUntil(tok::r_paren, StopAtSemi); 2388 } 2389 } 2390 } 2391 2392 while (true) { 2393 if (Tok.is(tok::code_completion)) { 2394 Actions.CodeCompleteObjCPropertyDefinition(getCurScope()); 2395 cutOffParsing(); 2396 return nullptr; 2397 } 2398 2399 if (expectIdentifier()) { 2400 SkipUntil(tok::semi); 2401 return nullptr; 2402 } 2403 2404 IdentifierInfo *propertyId = Tok.getIdentifierInfo(); 2405 SourceLocation propertyLoc = ConsumeToken(); // consume property name 2406 Actions.ActOnPropertyImplDecl( 2407 getCurScope(), atLoc, propertyLoc, false, 2408 propertyId, nullptr, SourceLocation(), 2409 isClassProperty ? ObjCPropertyQueryKind::OBJC_PR_query_class : 2410 ObjCPropertyQueryKind::OBJC_PR_query_unknown); 2411 2412 if (Tok.isNot(tok::comma)) 2413 break; 2414 ConsumeToken(); // consume ',' 2415 } 2416 ExpectAndConsume(tok::semi, diag::err_expected_after, "@dynamic"); 2417 return nullptr; 2418 } 2419 2420 /// objc-throw-statement: 2421 /// throw expression[opt]; 2422 /// 2423 StmtResult Parser::ParseObjCThrowStmt(SourceLocation atLoc) { 2424 ExprResult Res; 2425 ConsumeToken(); // consume throw 2426 if (Tok.isNot(tok::semi)) { 2427 Res = ParseExpression(); 2428 if (Res.isInvalid()) { 2429 SkipUntil(tok::semi); 2430 return StmtError(); 2431 } 2432 } 2433 // consume ';' 2434 ExpectAndConsume(tok::semi, diag::err_expected_after, "@throw"); 2435 return Actions.ActOnObjCAtThrowStmt(atLoc, Res.get(), getCurScope()); 2436 } 2437 2438 /// objc-synchronized-statement: 2439 /// @synchronized '(' expression ')' compound-statement 2440 /// 2441 StmtResult 2442 Parser::ParseObjCSynchronizedStmt(SourceLocation atLoc) { 2443 ConsumeToken(); // consume synchronized 2444 if (Tok.isNot(tok::l_paren)) { 2445 Diag(Tok, diag::err_expected_lparen_after) << "@synchronized"; 2446 return StmtError(); 2447 } 2448 2449 // The operand is surrounded with parentheses. 2450 ConsumeParen(); // '(' 2451 ExprResult operand(ParseExpression()); 2452 2453 if (Tok.is(tok::r_paren)) { 2454 ConsumeParen(); // ')' 2455 } else { 2456 if (!operand.isInvalid()) 2457 Diag(Tok, diag::err_expected) << tok::r_paren; 2458 2459 // Skip forward until we see a left brace, but don't consume it. 2460 SkipUntil(tok::l_brace, StopAtSemi | StopBeforeMatch); 2461 } 2462 2463 // Require a compound statement. 2464 if (Tok.isNot(tok::l_brace)) { 2465 if (!operand.isInvalid()) 2466 Diag(Tok, diag::err_expected) << tok::l_brace; 2467 return StmtError(); 2468 } 2469 2470 // Check the @synchronized operand now. 2471 if (!operand.isInvalid()) 2472 operand = Actions.ActOnObjCAtSynchronizedOperand(atLoc, operand.get()); 2473 2474 // Parse the compound statement within a new scope. 2475 ParseScope bodyScope(this, Scope::DeclScope | Scope::CompoundStmtScope); 2476 StmtResult body(ParseCompoundStatementBody()); 2477 bodyScope.Exit(); 2478 2479 // If there was a semantic or parse error earlier with the 2480 // operand, fail now. 2481 if (operand.isInvalid()) 2482 return StmtError(); 2483 2484 if (body.isInvalid()) 2485 body = Actions.ActOnNullStmt(Tok.getLocation()); 2486 2487 return Actions.ActOnObjCAtSynchronizedStmt(atLoc, operand.get(), body.get()); 2488 } 2489 2490 /// objc-try-catch-statement: 2491 /// @try compound-statement objc-catch-list[opt] 2492 /// @try compound-statement objc-catch-list[opt] @finally compound-statement 2493 /// 2494 /// objc-catch-list: 2495 /// @catch ( parameter-declaration ) compound-statement 2496 /// objc-catch-list @catch ( catch-parameter-declaration ) compound-statement 2497 /// catch-parameter-declaration: 2498 /// parameter-declaration 2499 /// '...' [OBJC2] 2500 /// 2501 StmtResult Parser::ParseObjCTryStmt(SourceLocation atLoc) { 2502 bool catch_or_finally_seen = false; 2503 2504 ConsumeToken(); // consume try 2505 if (Tok.isNot(tok::l_brace)) { 2506 Diag(Tok, diag::err_expected) << tok::l_brace; 2507 return StmtError(); 2508 } 2509 StmtVector CatchStmts; 2510 StmtResult FinallyStmt; 2511 ParseScope TryScope(this, Scope::DeclScope | Scope::CompoundStmtScope); 2512 StmtResult TryBody(ParseCompoundStatementBody()); 2513 TryScope.Exit(); 2514 if (TryBody.isInvalid()) 2515 TryBody = Actions.ActOnNullStmt(Tok.getLocation()); 2516 2517 while (Tok.is(tok::at)) { 2518 // At this point, we need to lookahead to determine if this @ is the start 2519 // of an @catch or @finally. We don't want to consume the @ token if this 2520 // is an @try or @encode or something else. 2521 Token AfterAt = GetLookAheadToken(1); 2522 if (!AfterAt.isObjCAtKeyword(tok::objc_catch) && 2523 !AfterAt.isObjCAtKeyword(tok::objc_finally)) 2524 break; 2525 2526 SourceLocation AtCatchFinallyLoc = ConsumeToken(); 2527 if (Tok.isObjCAtKeyword(tok::objc_catch)) { 2528 Decl *FirstPart = nullptr; 2529 ConsumeToken(); // consume catch 2530 if (Tok.is(tok::l_paren)) { 2531 ConsumeParen(); 2532 ParseScope CatchScope(this, Scope::DeclScope | 2533 Scope::CompoundStmtScope | 2534 Scope::AtCatchScope); 2535 if (Tok.isNot(tok::ellipsis)) { 2536 DeclSpec DS(AttrFactory); 2537 ParseDeclarationSpecifiers(DS); 2538 Declarator ParmDecl(DS, DeclaratorContext::ObjCCatch); 2539 ParseDeclarator(ParmDecl); 2540 2541 // Inform the actions module about the declarator, so it 2542 // gets added to the current scope. 2543 FirstPart = Actions.ActOnObjCExceptionDecl(getCurScope(), ParmDecl); 2544 } else 2545 ConsumeToken(); // consume '...' 2546 2547 SourceLocation RParenLoc; 2548 2549 if (Tok.is(tok::r_paren)) 2550 RParenLoc = ConsumeParen(); 2551 else // Skip over garbage, until we get to ')'. Eat the ')'. 2552 SkipUntil(tok::r_paren, StopAtSemi); 2553 2554 StmtResult CatchBody(true); 2555 if (Tok.is(tok::l_brace)) 2556 CatchBody = ParseCompoundStatementBody(); 2557 else 2558 Diag(Tok, diag::err_expected) << tok::l_brace; 2559 if (CatchBody.isInvalid()) 2560 CatchBody = Actions.ActOnNullStmt(Tok.getLocation()); 2561 2562 StmtResult Catch = Actions.ActOnObjCAtCatchStmt(AtCatchFinallyLoc, 2563 RParenLoc, 2564 FirstPart, 2565 CatchBody.get()); 2566 if (!Catch.isInvalid()) 2567 CatchStmts.push_back(Catch.get()); 2568 2569 } else { 2570 Diag(AtCatchFinallyLoc, diag::err_expected_lparen_after) 2571 << "@catch clause"; 2572 return StmtError(); 2573 } 2574 catch_or_finally_seen = true; 2575 } else { 2576 assert(Tok.isObjCAtKeyword(tok::objc_finally) && "Lookahead confused?"); 2577 ConsumeToken(); // consume finally 2578 ParseScope FinallyScope(this, 2579 Scope::DeclScope | Scope::CompoundStmtScope); 2580 2581 bool ShouldCapture = 2582 getTargetInfo().getTriple().isWindowsMSVCEnvironment(); 2583 if (ShouldCapture) 2584 Actions.ActOnCapturedRegionStart(Tok.getLocation(), getCurScope(), 2585 CR_ObjCAtFinally, 1); 2586 2587 StmtResult FinallyBody(true); 2588 if (Tok.is(tok::l_brace)) 2589 FinallyBody = ParseCompoundStatementBody(); 2590 else 2591 Diag(Tok, diag::err_expected) << tok::l_brace; 2592 2593 if (FinallyBody.isInvalid()) { 2594 FinallyBody = Actions.ActOnNullStmt(Tok.getLocation()); 2595 if (ShouldCapture) 2596 Actions.ActOnCapturedRegionError(); 2597 } else if (ShouldCapture) { 2598 FinallyBody = Actions.ActOnCapturedRegionEnd(FinallyBody.get()); 2599 } 2600 2601 FinallyStmt = Actions.ActOnObjCAtFinallyStmt(AtCatchFinallyLoc, 2602 FinallyBody.get()); 2603 catch_or_finally_seen = true; 2604 break; 2605 } 2606 } 2607 if (!catch_or_finally_seen) { 2608 Diag(atLoc, diag::err_missing_catch_finally); 2609 return StmtError(); 2610 } 2611 2612 return Actions.ActOnObjCAtTryStmt(atLoc, TryBody.get(), 2613 CatchStmts, 2614 FinallyStmt.get()); 2615 } 2616 2617 /// objc-autoreleasepool-statement: 2618 /// @autoreleasepool compound-statement 2619 /// 2620 StmtResult 2621 Parser::ParseObjCAutoreleasePoolStmt(SourceLocation atLoc) { 2622 ConsumeToken(); // consume autoreleasepool 2623 if (Tok.isNot(tok::l_brace)) { 2624 Diag(Tok, diag::err_expected) << tok::l_brace; 2625 return StmtError(); 2626 } 2627 // Enter a scope to hold everything within the compound stmt. Compound 2628 // statements can always hold declarations. 2629 ParseScope BodyScope(this, Scope::DeclScope | Scope::CompoundStmtScope); 2630 2631 StmtResult AutoreleasePoolBody(ParseCompoundStatementBody()); 2632 2633 BodyScope.Exit(); 2634 if (AutoreleasePoolBody.isInvalid()) 2635 AutoreleasePoolBody = Actions.ActOnNullStmt(Tok.getLocation()); 2636 return Actions.ActOnObjCAutoreleasePoolStmt(atLoc, 2637 AutoreleasePoolBody.get()); 2638 } 2639 2640 /// StashAwayMethodOrFunctionBodyTokens - Consume the tokens and store them 2641 /// for later parsing. 2642 void Parser::StashAwayMethodOrFunctionBodyTokens(Decl *MDecl) { 2643 if (SkipFunctionBodies && (!MDecl || Actions.canSkipFunctionBody(MDecl)) && 2644 trySkippingFunctionBody()) { 2645 Actions.ActOnSkippedFunctionBody(MDecl); 2646 return; 2647 } 2648 2649 LexedMethod* LM = new LexedMethod(this, MDecl); 2650 CurParsedObjCImpl->LateParsedObjCMethods.push_back(LM); 2651 CachedTokens &Toks = LM->Toks; 2652 // Begin by storing the '{' or 'try' or ':' token. 2653 Toks.push_back(Tok); 2654 if (Tok.is(tok::kw_try)) { 2655 ConsumeToken(); 2656 if (Tok.is(tok::colon)) { 2657 Toks.push_back(Tok); 2658 ConsumeToken(); 2659 while (Tok.isNot(tok::l_brace)) { 2660 ConsumeAndStoreUntil(tok::l_paren, Toks, /*StopAtSemi=*/false); 2661 ConsumeAndStoreUntil(tok::r_paren, Toks, /*StopAtSemi=*/false); 2662 } 2663 } 2664 Toks.push_back(Tok); // also store '{' 2665 } 2666 else if (Tok.is(tok::colon)) { 2667 ConsumeToken(); 2668 // FIXME: This is wrong, due to C++11 braced initialization. 2669 while (Tok.isNot(tok::l_brace)) { 2670 ConsumeAndStoreUntil(tok::l_paren, Toks, /*StopAtSemi=*/false); 2671 ConsumeAndStoreUntil(tok::r_paren, Toks, /*StopAtSemi=*/false); 2672 } 2673 Toks.push_back(Tok); // also store '{' 2674 } 2675 ConsumeBrace(); 2676 // Consume everything up to (and including) the matching right brace. 2677 ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/false); 2678 while (Tok.is(tok::kw_catch)) { 2679 ConsumeAndStoreUntil(tok::l_brace, Toks, /*StopAtSemi=*/false); 2680 ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/false); 2681 } 2682 } 2683 2684 /// objc-method-def: objc-method-proto ';'[opt] '{' body '}' 2685 /// 2686 Decl *Parser::ParseObjCMethodDefinition() { 2687 Decl *MDecl = ParseObjCMethodPrototype(); 2688 2689 PrettyDeclStackTraceEntry CrashInfo(Actions.Context, MDecl, Tok.getLocation(), 2690 "parsing Objective-C method"); 2691 2692 // parse optional ';' 2693 if (Tok.is(tok::semi)) { 2694 if (CurParsedObjCImpl) { 2695 Diag(Tok, diag::warn_semicolon_before_method_body) 2696 << FixItHint::CreateRemoval(Tok.getLocation()); 2697 } 2698 ConsumeToken(); 2699 } 2700 2701 // We should have an opening brace now. 2702 if (Tok.isNot(tok::l_brace)) { 2703 Diag(Tok, diag::err_expected_method_body); 2704 2705 // Skip over garbage, until we get to '{'. Don't eat the '{'. 2706 SkipUntil(tok::l_brace, StopAtSemi | StopBeforeMatch); 2707 2708 // If we didn't find the '{', bail out. 2709 if (Tok.isNot(tok::l_brace)) 2710 return nullptr; 2711 } 2712 2713 if (!MDecl) { 2714 ConsumeBrace(); 2715 SkipUntil(tok::r_brace); 2716 return nullptr; 2717 } 2718 2719 // Allow the rest of sema to find private method decl implementations. 2720 Actions.AddAnyMethodToGlobalPool(MDecl); 2721 assert (CurParsedObjCImpl 2722 && "ParseObjCMethodDefinition - Method out of @implementation"); 2723 // Consume the tokens and store them for later parsing. 2724 StashAwayMethodOrFunctionBodyTokens(MDecl); 2725 return MDecl; 2726 } 2727 2728 StmtResult Parser::ParseObjCAtStatement(SourceLocation AtLoc, 2729 ParsedStmtContext StmtCtx) { 2730 if (Tok.is(tok::code_completion)) { 2731 Actions.CodeCompleteObjCAtStatement(getCurScope()); 2732 cutOffParsing(); 2733 return StmtError(); 2734 } 2735 2736 if (Tok.isObjCAtKeyword(tok::objc_try)) 2737 return ParseObjCTryStmt(AtLoc); 2738 2739 if (Tok.isObjCAtKeyword(tok::objc_throw)) 2740 return ParseObjCThrowStmt(AtLoc); 2741 2742 if (Tok.isObjCAtKeyword(tok::objc_synchronized)) 2743 return ParseObjCSynchronizedStmt(AtLoc); 2744 2745 if (Tok.isObjCAtKeyword(tok::objc_autoreleasepool)) 2746 return ParseObjCAutoreleasePoolStmt(AtLoc); 2747 2748 if (Tok.isObjCAtKeyword(tok::objc_import) && 2749 getLangOpts().DebuggerSupport) { 2750 SkipUntil(tok::semi); 2751 return Actions.ActOnNullStmt(Tok.getLocation()); 2752 } 2753 2754 ExprStatementTokLoc = AtLoc; 2755 ExprResult Res(ParseExpressionWithLeadingAt(AtLoc)); 2756 if (Res.isInvalid()) { 2757 // If the expression is invalid, skip ahead to the next semicolon. Not 2758 // doing this opens us up to the possibility of infinite loops if 2759 // ParseExpression does not consume any tokens. 2760 SkipUntil(tok::semi); 2761 return StmtError(); 2762 } 2763 2764 // Otherwise, eat the semicolon. 2765 ExpectAndConsumeSemi(diag::err_expected_semi_after_expr); 2766 return handleExprStmt(Res, StmtCtx); 2767 } 2768 2769 ExprResult Parser::ParseObjCAtExpression(SourceLocation AtLoc) { 2770 switch (Tok.getKind()) { 2771 case tok::code_completion: 2772 Actions.CodeCompleteObjCAtExpression(getCurScope()); 2773 cutOffParsing(); 2774 return ExprError(); 2775 2776 case tok::minus: 2777 case tok::plus: { 2778 tok::TokenKind Kind = Tok.getKind(); 2779 SourceLocation OpLoc = ConsumeToken(); 2780 2781 if (!Tok.is(tok::numeric_constant)) { 2782 const char *Symbol = nullptr; 2783 switch (Kind) { 2784 case tok::minus: Symbol = "-"; break; 2785 case tok::plus: Symbol = "+"; break; 2786 default: llvm_unreachable("missing unary operator case"); 2787 } 2788 Diag(Tok, diag::err_nsnumber_nonliteral_unary) 2789 << Symbol; 2790 return ExprError(); 2791 } 2792 2793 ExprResult Lit(Actions.ActOnNumericConstant(Tok)); 2794 if (Lit.isInvalid()) { 2795 return Lit; 2796 } 2797 ConsumeToken(); // Consume the literal token. 2798 2799 Lit = Actions.ActOnUnaryOp(getCurScope(), OpLoc, Kind, Lit.get()); 2800 if (Lit.isInvalid()) 2801 return Lit; 2802 2803 return ParsePostfixExpressionSuffix( 2804 Actions.BuildObjCNumericLiteral(AtLoc, Lit.get())); 2805 } 2806 2807 case tok::string_literal: // primary-expression: string-literal 2808 case tok::wide_string_literal: 2809 return ParsePostfixExpressionSuffix(ParseObjCStringLiteral(AtLoc)); 2810 2811 case tok::char_constant: 2812 return ParsePostfixExpressionSuffix(ParseObjCCharacterLiteral(AtLoc)); 2813 2814 case tok::numeric_constant: 2815 return ParsePostfixExpressionSuffix(ParseObjCNumericLiteral(AtLoc)); 2816 2817 case tok::kw_true: // Objective-C++, etc. 2818 case tok::kw___objc_yes: // c/c++/objc/objc++ __objc_yes 2819 return ParsePostfixExpressionSuffix(ParseObjCBooleanLiteral(AtLoc, true)); 2820 case tok::kw_false: // Objective-C++, etc. 2821 case tok::kw___objc_no: // c/c++/objc/objc++ __objc_no 2822 return ParsePostfixExpressionSuffix(ParseObjCBooleanLiteral(AtLoc, false)); 2823 2824 case tok::l_square: 2825 // Objective-C array literal 2826 return ParsePostfixExpressionSuffix(ParseObjCArrayLiteral(AtLoc)); 2827 2828 case tok::l_brace: 2829 // Objective-C dictionary literal 2830 return ParsePostfixExpressionSuffix(ParseObjCDictionaryLiteral(AtLoc)); 2831 2832 case tok::l_paren: 2833 // Objective-C boxed expression 2834 return ParsePostfixExpressionSuffix(ParseObjCBoxedExpr(AtLoc)); 2835 2836 default: 2837 if (Tok.getIdentifierInfo() == nullptr) 2838 return ExprError(Diag(AtLoc, diag::err_unexpected_at)); 2839 2840 switch (Tok.getIdentifierInfo()->getObjCKeywordID()) { 2841 case tok::objc_encode: 2842 return ParsePostfixExpressionSuffix(ParseObjCEncodeExpression(AtLoc)); 2843 case tok::objc_protocol: 2844 return ParsePostfixExpressionSuffix(ParseObjCProtocolExpression(AtLoc)); 2845 case tok::objc_selector: 2846 return ParsePostfixExpressionSuffix(ParseObjCSelectorExpression(AtLoc)); 2847 case tok::objc_available: 2848 return ParseAvailabilityCheckExpr(AtLoc); 2849 default: { 2850 const char *str = nullptr; 2851 // Only provide the @try/@finally/@autoreleasepool fixit when we're sure 2852 // that this is a proper statement where such directives could actually 2853 // occur. 2854 if (GetLookAheadToken(1).is(tok::l_brace) && 2855 ExprStatementTokLoc == AtLoc) { 2856 char ch = Tok.getIdentifierInfo()->getNameStart()[0]; 2857 str = 2858 ch == 't' ? "try" 2859 : (ch == 'f' ? "finally" 2860 : (ch == 'a' ? "autoreleasepool" : nullptr)); 2861 } 2862 if (str) { 2863 SourceLocation kwLoc = Tok.getLocation(); 2864 return ExprError(Diag(AtLoc, diag::err_unexpected_at) << 2865 FixItHint::CreateReplacement(kwLoc, str)); 2866 } 2867 else 2868 return ExprError(Diag(AtLoc, diag::err_unexpected_at)); 2869 } 2870 } 2871 } 2872 } 2873 2874 /// Parse the receiver of an Objective-C++ message send. 2875 /// 2876 /// This routine parses the receiver of a message send in 2877 /// Objective-C++ either as a type or as an expression. Note that this 2878 /// routine must not be called to parse a send to 'super', since it 2879 /// has no way to return such a result. 2880 /// 2881 /// \param IsExpr Whether the receiver was parsed as an expression. 2882 /// 2883 /// \param TypeOrExpr If the receiver was parsed as an expression (\c 2884 /// IsExpr is true), the parsed expression. If the receiver was parsed 2885 /// as a type (\c IsExpr is false), the parsed type. 2886 /// 2887 /// \returns True if an error occurred during parsing or semantic 2888 /// analysis, in which case the arguments do not have valid 2889 /// values. Otherwise, returns false for a successful parse. 2890 /// 2891 /// objc-receiver: [C++] 2892 /// 'super' [not parsed here] 2893 /// expression 2894 /// simple-type-specifier 2895 /// typename-specifier 2896 bool Parser::ParseObjCXXMessageReceiver(bool &IsExpr, void *&TypeOrExpr) { 2897 InMessageExpressionRAIIObject InMessage(*this, true); 2898 2899 if (Tok.isOneOf(tok::identifier, tok::coloncolon, tok::kw_typename, 2900 tok::annot_cxxscope)) 2901 TryAnnotateTypeOrScopeToken(); 2902 2903 if (!Actions.isSimpleTypeSpecifier(Tok.getKind())) { 2904 // objc-receiver: 2905 // expression 2906 // Make sure any typos in the receiver are corrected or diagnosed, so that 2907 // proper recovery can happen. FIXME: Perhaps filter the corrected expr to 2908 // only the things that are valid ObjC receivers? 2909 ExprResult Receiver = Actions.CorrectDelayedTyposInExpr(ParseExpression()); 2910 if (Receiver.isInvalid()) 2911 return true; 2912 2913 IsExpr = true; 2914 TypeOrExpr = Receiver.get(); 2915 return false; 2916 } 2917 2918 // objc-receiver: 2919 // typename-specifier 2920 // simple-type-specifier 2921 // expression (that starts with one of the above) 2922 DeclSpec DS(AttrFactory); 2923 ParseCXXSimpleTypeSpecifier(DS); 2924 2925 if (Tok.is(tok::l_paren)) { 2926 // If we see an opening parentheses at this point, we are 2927 // actually parsing an expression that starts with a 2928 // function-style cast, e.g., 2929 // 2930 // postfix-expression: 2931 // simple-type-specifier ( expression-list [opt] ) 2932 // typename-specifier ( expression-list [opt] ) 2933 // 2934 // Parse the remainder of this case, then the (optional) 2935 // postfix-expression suffix, followed by the (optional) 2936 // right-hand side of the binary expression. We have an 2937 // instance method. 2938 ExprResult Receiver = ParseCXXTypeConstructExpression(DS); 2939 if (!Receiver.isInvalid()) 2940 Receiver = ParsePostfixExpressionSuffix(Receiver.get()); 2941 if (!Receiver.isInvalid()) 2942 Receiver = ParseRHSOfBinaryExpression(Receiver.get(), prec::Comma); 2943 if (Receiver.isInvalid()) 2944 return true; 2945 2946 IsExpr = true; 2947 TypeOrExpr = Receiver.get(); 2948 return false; 2949 } 2950 2951 // We have a class message. Turn the simple-type-specifier or 2952 // typename-specifier we parsed into a type and parse the 2953 // remainder of the class message. 2954 Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName); 2955 TypeResult Type = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo); 2956 if (Type.isInvalid()) 2957 return true; 2958 2959 IsExpr = false; 2960 TypeOrExpr = Type.get().getAsOpaquePtr(); 2961 return false; 2962 } 2963 2964 /// Determine whether the parser is currently referring to a an 2965 /// Objective-C message send, using a simplified heuristic to avoid overhead. 2966 /// 2967 /// This routine will only return true for a subset of valid message-send 2968 /// expressions. 2969 bool Parser::isSimpleObjCMessageExpression() { 2970 assert(Tok.is(tok::l_square) && getLangOpts().ObjC && 2971 "Incorrect start for isSimpleObjCMessageExpression"); 2972 return GetLookAheadToken(1).is(tok::identifier) && 2973 GetLookAheadToken(2).is(tok::identifier); 2974 } 2975 2976 bool Parser::isStartOfObjCClassMessageMissingOpenBracket() { 2977 if (!getLangOpts().ObjC || !NextToken().is(tok::identifier) || 2978 InMessageExpression) 2979 return false; 2980 2981 TypeResult Type; 2982 2983 if (Tok.is(tok::annot_typename)) 2984 Type = getTypeAnnotation(Tok); 2985 else if (Tok.is(tok::identifier)) 2986 Type = Actions.getTypeName(*Tok.getIdentifierInfo(), Tok.getLocation(), 2987 getCurScope()); 2988 else 2989 return false; 2990 2991 // FIXME: Should not be querying properties of types from the parser. 2992 if (Type.isUsable() && Type.get().get()->isObjCObjectOrInterfaceType()) { 2993 const Token &AfterNext = GetLookAheadToken(2); 2994 if (AfterNext.isOneOf(tok::colon, tok::r_square)) { 2995 if (Tok.is(tok::identifier)) 2996 TryAnnotateTypeOrScopeToken(); 2997 2998 return Tok.is(tok::annot_typename); 2999 } 3000 } 3001 3002 return false; 3003 } 3004 3005 /// objc-message-expr: 3006 /// '[' objc-receiver objc-message-args ']' 3007 /// 3008 /// objc-receiver: [C] 3009 /// 'super' 3010 /// expression 3011 /// class-name 3012 /// type-name 3013 /// 3014 ExprResult Parser::ParseObjCMessageExpression() { 3015 assert(Tok.is(tok::l_square) && "'[' expected"); 3016 SourceLocation LBracLoc = ConsumeBracket(); // consume '[' 3017 3018 if (Tok.is(tok::code_completion)) { 3019 Actions.CodeCompleteObjCMessageReceiver(getCurScope()); 3020 cutOffParsing(); 3021 return ExprError(); 3022 } 3023 3024 InMessageExpressionRAIIObject InMessage(*this, true); 3025 3026 if (getLangOpts().CPlusPlus) { 3027 // We completely separate the C and C++ cases because C++ requires 3028 // more complicated (read: slower) parsing. 3029 3030 // Handle send to super. 3031 // FIXME: This doesn't benefit from the same typo-correction we 3032 // get in Objective-C. 3033 if (Tok.is(tok::identifier) && Tok.getIdentifierInfo() == Ident_super && 3034 NextToken().isNot(tok::period) && getCurScope()->isInObjcMethodScope()) 3035 return ParseObjCMessageExpressionBody(LBracLoc, ConsumeToken(), nullptr, 3036 nullptr); 3037 3038 // Parse the receiver, which is either a type or an expression. 3039 bool IsExpr; 3040 void *TypeOrExpr = nullptr; 3041 if (ParseObjCXXMessageReceiver(IsExpr, TypeOrExpr)) { 3042 SkipUntil(tok::r_square, StopAtSemi); 3043 return ExprError(); 3044 } 3045 3046 if (IsExpr) 3047 return ParseObjCMessageExpressionBody(LBracLoc, SourceLocation(), nullptr, 3048 static_cast<Expr *>(TypeOrExpr)); 3049 3050 return ParseObjCMessageExpressionBody(LBracLoc, SourceLocation(), 3051 ParsedType::getFromOpaquePtr(TypeOrExpr), 3052 nullptr); 3053 } 3054 3055 if (Tok.is(tok::identifier)) { 3056 IdentifierInfo *Name = Tok.getIdentifierInfo(); 3057 SourceLocation NameLoc = Tok.getLocation(); 3058 ParsedType ReceiverType; 3059 switch (Actions.getObjCMessageKind(getCurScope(), Name, NameLoc, 3060 Name == Ident_super, 3061 NextToken().is(tok::period), 3062 ReceiverType)) { 3063 case Sema::ObjCSuperMessage: 3064 return ParseObjCMessageExpressionBody(LBracLoc, ConsumeToken(), nullptr, 3065 nullptr); 3066 3067 case Sema::ObjCClassMessage: 3068 if (!ReceiverType) { 3069 SkipUntil(tok::r_square, StopAtSemi); 3070 return ExprError(); 3071 } 3072 3073 ConsumeToken(); // the type name 3074 3075 // Parse type arguments and protocol qualifiers. 3076 if (Tok.is(tok::less)) { 3077 SourceLocation NewEndLoc; 3078 TypeResult NewReceiverType 3079 = parseObjCTypeArgsAndProtocolQualifiers(NameLoc, ReceiverType, 3080 /*consumeLastToken=*/true, 3081 NewEndLoc); 3082 if (!NewReceiverType.isUsable()) { 3083 SkipUntil(tok::r_square, StopAtSemi); 3084 return ExprError(); 3085 } 3086 3087 ReceiverType = NewReceiverType.get(); 3088 } 3089 3090 return ParseObjCMessageExpressionBody(LBracLoc, SourceLocation(), 3091 ReceiverType, nullptr); 3092 3093 case Sema::ObjCInstanceMessage: 3094 // Fall through to parse an expression. 3095 break; 3096 } 3097 } 3098 3099 // Otherwise, an arbitrary expression can be the receiver of a send. 3100 ExprResult Res = Actions.CorrectDelayedTyposInExpr(ParseExpression()); 3101 if (Res.isInvalid()) { 3102 SkipUntil(tok::r_square, StopAtSemi); 3103 return Res; 3104 } 3105 3106 return ParseObjCMessageExpressionBody(LBracLoc, SourceLocation(), nullptr, 3107 Res.get()); 3108 } 3109 3110 /// Parse the remainder of an Objective-C message following the 3111 /// '[' objc-receiver. 3112 /// 3113 /// This routine handles sends to super, class messages (sent to a 3114 /// class name), and instance messages (sent to an object), and the 3115 /// target is represented by \p SuperLoc, \p ReceiverType, or \p 3116 /// ReceiverExpr, respectively. Only one of these parameters may have 3117 /// a valid value. 3118 /// 3119 /// \param LBracLoc The location of the opening '['. 3120 /// 3121 /// \param SuperLoc If this is a send to 'super', the location of the 3122 /// 'super' keyword that indicates a send to the superclass. 3123 /// 3124 /// \param ReceiverType If this is a class message, the type of the 3125 /// class we are sending a message to. 3126 /// 3127 /// \param ReceiverExpr If this is an instance message, the expression 3128 /// used to compute the receiver object. 3129 /// 3130 /// objc-message-args: 3131 /// objc-selector 3132 /// objc-keywordarg-list 3133 /// 3134 /// objc-keywordarg-list: 3135 /// objc-keywordarg 3136 /// objc-keywordarg-list objc-keywordarg 3137 /// 3138 /// objc-keywordarg: 3139 /// selector-name[opt] ':' objc-keywordexpr 3140 /// 3141 /// objc-keywordexpr: 3142 /// nonempty-expr-list 3143 /// 3144 /// nonempty-expr-list: 3145 /// assignment-expression 3146 /// nonempty-expr-list , assignment-expression 3147 /// 3148 ExprResult 3149 Parser::ParseObjCMessageExpressionBody(SourceLocation LBracLoc, 3150 SourceLocation SuperLoc, 3151 ParsedType ReceiverType, 3152 Expr *ReceiverExpr) { 3153 InMessageExpressionRAIIObject InMessage(*this, true); 3154 3155 if (Tok.is(tok::code_completion)) { 3156 if (SuperLoc.isValid()) 3157 Actions.CodeCompleteObjCSuperMessage(getCurScope(), SuperLoc, None, 3158 false); 3159 else if (ReceiverType) 3160 Actions.CodeCompleteObjCClassMessage(getCurScope(), ReceiverType, None, 3161 false); 3162 else 3163 Actions.CodeCompleteObjCInstanceMessage(getCurScope(), ReceiverExpr, 3164 None, false); 3165 cutOffParsing(); 3166 return ExprError(); 3167 } 3168 3169 // Parse objc-selector 3170 SourceLocation Loc; 3171 IdentifierInfo *selIdent = ParseObjCSelectorPiece(Loc); 3172 3173 SmallVector<IdentifierInfo *, 12> KeyIdents; 3174 SmallVector<SourceLocation, 12> KeyLocs; 3175 ExprVector KeyExprs; 3176 3177 if (Tok.is(tok::colon)) { 3178 while (1) { 3179 // Each iteration parses a single keyword argument. 3180 KeyIdents.push_back(selIdent); 3181 KeyLocs.push_back(Loc); 3182 3183 if (ExpectAndConsume(tok::colon)) { 3184 // We must manually skip to a ']', otherwise the expression skipper will 3185 // stop at the ']' when it skips to the ';'. We want it to skip beyond 3186 // the enclosing expression. 3187 SkipUntil(tok::r_square, StopAtSemi); 3188 return ExprError(); 3189 } 3190 3191 /// Parse the expression after ':' 3192 3193 if (Tok.is(tok::code_completion)) { 3194 if (SuperLoc.isValid()) 3195 Actions.CodeCompleteObjCSuperMessage(getCurScope(), SuperLoc, 3196 KeyIdents, 3197 /*AtArgumentExpression=*/true); 3198 else if (ReceiverType) 3199 Actions.CodeCompleteObjCClassMessage(getCurScope(), ReceiverType, 3200 KeyIdents, 3201 /*AtArgumentExpression=*/true); 3202 else 3203 Actions.CodeCompleteObjCInstanceMessage(getCurScope(), ReceiverExpr, 3204 KeyIdents, 3205 /*AtArgumentExpression=*/true); 3206 3207 cutOffParsing(); 3208 return ExprError(); 3209 } 3210 3211 ExprResult Expr; 3212 if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) { 3213 Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists); 3214 Expr = ParseBraceInitializer(); 3215 } else 3216 Expr = ParseAssignmentExpression(); 3217 3218 ExprResult Res(Expr); 3219 if (Res.isInvalid()) { 3220 // We must manually skip to a ']', otherwise the expression skipper will 3221 // stop at the ']' when it skips to the ';'. We want it to skip beyond 3222 // the enclosing expression. 3223 SkipUntil(tok::r_square, StopAtSemi); 3224 return Res; 3225 } 3226 3227 // We have a valid expression. 3228 KeyExprs.push_back(Res.get()); 3229 3230 // Code completion after each argument. 3231 if (Tok.is(tok::code_completion)) { 3232 if (SuperLoc.isValid()) 3233 Actions.CodeCompleteObjCSuperMessage(getCurScope(), SuperLoc, 3234 KeyIdents, 3235 /*AtArgumentExpression=*/false); 3236 else if (ReceiverType) 3237 Actions.CodeCompleteObjCClassMessage(getCurScope(), ReceiverType, 3238 KeyIdents, 3239 /*AtArgumentExpression=*/false); 3240 else 3241 Actions.CodeCompleteObjCInstanceMessage(getCurScope(), ReceiverExpr, 3242 KeyIdents, 3243 /*AtArgumentExpression=*/false); 3244 cutOffParsing(); 3245 return ExprError(); 3246 } 3247 3248 // Check for another keyword selector. 3249 selIdent = ParseObjCSelectorPiece(Loc); 3250 if (!selIdent && Tok.isNot(tok::colon)) 3251 break; 3252 // We have a selector or a colon, continue parsing. 3253 } 3254 // Parse the, optional, argument list, comma separated. 3255 while (Tok.is(tok::comma)) { 3256 SourceLocation commaLoc = ConsumeToken(); // Eat the ','. 3257 /// Parse the expression after ',' 3258 ExprResult Res(ParseAssignmentExpression()); 3259 if (Tok.is(tok::colon)) 3260 Res = Actions.CorrectDelayedTyposInExpr(Res); 3261 if (Res.isInvalid()) { 3262 if (Tok.is(tok::colon)) { 3263 Diag(commaLoc, diag::note_extra_comma_message_arg) << 3264 FixItHint::CreateRemoval(commaLoc); 3265 } 3266 // We must manually skip to a ']', otherwise the expression skipper will 3267 // stop at the ']' when it skips to the ';'. We want it to skip beyond 3268 // the enclosing expression. 3269 SkipUntil(tok::r_square, StopAtSemi); 3270 return Res; 3271 } 3272 3273 // We have a valid expression. 3274 KeyExprs.push_back(Res.get()); 3275 } 3276 } else if (!selIdent) { 3277 Diag(Tok, diag::err_expected) << tok::identifier; // missing selector name. 3278 3279 // We must manually skip to a ']', otherwise the expression skipper will 3280 // stop at the ']' when it skips to the ';'. We want it to skip beyond 3281 // the enclosing expression. 3282 SkipUntil(tok::r_square, StopAtSemi); 3283 return ExprError(); 3284 } 3285 3286 if (Tok.isNot(tok::r_square)) { 3287 Diag(Tok, diag::err_expected) 3288 << (Tok.is(tok::identifier) ? tok::colon : tok::r_square); 3289 // We must manually skip to a ']', otherwise the expression skipper will 3290 // stop at the ']' when it skips to the ';'. We want it to skip beyond 3291 // the enclosing expression. 3292 SkipUntil(tok::r_square, StopAtSemi); 3293 return ExprError(); 3294 } 3295 3296 SourceLocation RBracLoc = ConsumeBracket(); // consume ']' 3297 3298 unsigned nKeys = KeyIdents.size(); 3299 if (nKeys == 0) { 3300 KeyIdents.push_back(selIdent); 3301 KeyLocs.push_back(Loc); 3302 } 3303 Selector Sel = PP.getSelectorTable().getSelector(nKeys, &KeyIdents[0]); 3304 3305 if (SuperLoc.isValid()) 3306 return Actions.ActOnSuperMessage(getCurScope(), SuperLoc, Sel, 3307 LBracLoc, KeyLocs, RBracLoc, KeyExprs); 3308 else if (ReceiverType) 3309 return Actions.ActOnClassMessage(getCurScope(), ReceiverType, Sel, 3310 LBracLoc, KeyLocs, RBracLoc, KeyExprs); 3311 return Actions.ActOnInstanceMessage(getCurScope(), ReceiverExpr, Sel, 3312 LBracLoc, KeyLocs, RBracLoc, KeyExprs); 3313 } 3314 3315 ExprResult Parser::ParseObjCStringLiteral(SourceLocation AtLoc) { 3316 ExprResult Res(ParseStringLiteralExpression()); 3317 if (Res.isInvalid()) return Res; 3318 3319 // @"foo" @"bar" is a valid concatenated string. Eat any subsequent string 3320 // expressions. At this point, we know that the only valid thing that starts 3321 // with '@' is an @"". 3322 SmallVector<SourceLocation, 4> AtLocs; 3323 ExprVector AtStrings; 3324 AtLocs.push_back(AtLoc); 3325 AtStrings.push_back(Res.get()); 3326 3327 while (Tok.is(tok::at)) { 3328 AtLocs.push_back(ConsumeToken()); // eat the @. 3329 3330 // Invalid unless there is a string literal. 3331 if (!isTokenStringLiteral()) 3332 return ExprError(Diag(Tok, diag::err_objc_concat_string)); 3333 3334 ExprResult Lit(ParseStringLiteralExpression()); 3335 if (Lit.isInvalid()) 3336 return Lit; 3337 3338 AtStrings.push_back(Lit.get()); 3339 } 3340 3341 return Actions.ParseObjCStringLiteral(AtLocs.data(), AtStrings); 3342 } 3343 3344 /// ParseObjCBooleanLiteral - 3345 /// objc-scalar-literal : '@' boolean-keyword 3346 /// ; 3347 /// boolean-keyword: 'true' | 'false' | '__objc_yes' | '__objc_no' 3348 /// ; 3349 ExprResult Parser::ParseObjCBooleanLiteral(SourceLocation AtLoc, 3350 bool ArgValue) { 3351 SourceLocation EndLoc = ConsumeToken(); // consume the keyword. 3352 return Actions.ActOnObjCBoolLiteral(AtLoc, EndLoc, ArgValue); 3353 } 3354 3355 /// ParseObjCCharacterLiteral - 3356 /// objc-scalar-literal : '@' character-literal 3357 /// ; 3358 ExprResult Parser::ParseObjCCharacterLiteral(SourceLocation AtLoc) { 3359 ExprResult Lit(Actions.ActOnCharacterConstant(Tok)); 3360 if (Lit.isInvalid()) { 3361 return Lit; 3362 } 3363 ConsumeToken(); // Consume the literal token. 3364 return Actions.BuildObjCNumericLiteral(AtLoc, Lit.get()); 3365 } 3366 3367 /// ParseObjCNumericLiteral - 3368 /// objc-scalar-literal : '@' scalar-literal 3369 /// ; 3370 /// scalar-literal : | numeric-constant /* any numeric constant. */ 3371 /// ; 3372 ExprResult Parser::ParseObjCNumericLiteral(SourceLocation AtLoc) { 3373 ExprResult Lit(Actions.ActOnNumericConstant(Tok)); 3374 if (Lit.isInvalid()) { 3375 return Lit; 3376 } 3377 ConsumeToken(); // Consume the literal token. 3378 return Actions.BuildObjCNumericLiteral(AtLoc, Lit.get()); 3379 } 3380 3381 /// ParseObjCBoxedExpr - 3382 /// objc-box-expression: 3383 /// @( assignment-expression ) 3384 ExprResult 3385 Parser::ParseObjCBoxedExpr(SourceLocation AtLoc) { 3386 if (Tok.isNot(tok::l_paren)) 3387 return ExprError(Diag(Tok, diag::err_expected_lparen_after) << "@"); 3388 3389 BalancedDelimiterTracker T(*this, tok::l_paren); 3390 T.consumeOpen(); 3391 ExprResult ValueExpr(ParseAssignmentExpression()); 3392 if (T.consumeClose()) 3393 return ExprError(); 3394 3395 if (ValueExpr.isInvalid()) 3396 return ExprError(); 3397 3398 // Wrap the sub-expression in a parenthesized expression, to distinguish 3399 // a boxed expression from a literal. 3400 SourceLocation LPLoc = T.getOpenLocation(), RPLoc = T.getCloseLocation(); 3401 ValueExpr = Actions.ActOnParenExpr(LPLoc, RPLoc, ValueExpr.get()); 3402 return Actions.BuildObjCBoxedExpr(SourceRange(AtLoc, RPLoc), 3403 ValueExpr.get()); 3404 } 3405 3406 ExprResult Parser::ParseObjCArrayLiteral(SourceLocation AtLoc) { 3407 ExprVector ElementExprs; // array elements. 3408 ConsumeBracket(); // consume the l_square. 3409 3410 bool HasInvalidEltExpr = false; 3411 while (Tok.isNot(tok::r_square)) { 3412 // Parse list of array element expressions (all must be id types). 3413 ExprResult Res(ParseAssignmentExpression()); 3414 if (Res.isInvalid()) { 3415 // We must manually skip to a ']', otherwise the expression skipper will 3416 // stop at the ']' when it skips to the ';'. We want it to skip beyond 3417 // the enclosing expression. 3418 SkipUntil(tok::r_square, StopAtSemi); 3419 return Res; 3420 } 3421 3422 Res = Actions.CorrectDelayedTyposInExpr(Res.get()); 3423 if (Res.isInvalid()) 3424 HasInvalidEltExpr = true; 3425 3426 // Parse the ellipsis that indicates a pack expansion. 3427 if (Tok.is(tok::ellipsis)) 3428 Res = Actions.ActOnPackExpansion(Res.get(), ConsumeToken()); 3429 if (Res.isInvalid()) 3430 HasInvalidEltExpr = true; 3431 3432 ElementExprs.push_back(Res.get()); 3433 3434 if (Tok.is(tok::comma)) 3435 ConsumeToken(); // Eat the ','. 3436 else if (Tok.isNot(tok::r_square)) 3437 return ExprError(Diag(Tok, diag::err_expected_either) << tok::r_square 3438 << tok::comma); 3439 } 3440 SourceLocation EndLoc = ConsumeBracket(); // location of ']' 3441 3442 if (HasInvalidEltExpr) 3443 return ExprError(); 3444 3445 MultiExprArg Args(ElementExprs); 3446 return Actions.BuildObjCArrayLiteral(SourceRange(AtLoc, EndLoc), Args); 3447 } 3448 3449 ExprResult Parser::ParseObjCDictionaryLiteral(SourceLocation AtLoc) { 3450 SmallVector<ObjCDictionaryElement, 4> Elements; // dictionary elements. 3451 ConsumeBrace(); // consume the l_square. 3452 bool HasInvalidEltExpr = false; 3453 while (Tok.isNot(tok::r_brace)) { 3454 // Parse the comma separated key : value expressions. 3455 ExprResult KeyExpr; 3456 { 3457 ColonProtectionRAIIObject X(*this); 3458 KeyExpr = ParseAssignmentExpression(); 3459 if (KeyExpr.isInvalid()) { 3460 // We must manually skip to a '}', otherwise the expression skipper will 3461 // stop at the '}' when it skips to the ';'. We want it to skip beyond 3462 // the enclosing expression. 3463 SkipUntil(tok::r_brace, StopAtSemi); 3464 return KeyExpr; 3465 } 3466 } 3467 3468 if (ExpectAndConsume(tok::colon)) { 3469 SkipUntil(tok::r_brace, StopAtSemi); 3470 return ExprError(); 3471 } 3472 3473 ExprResult ValueExpr(ParseAssignmentExpression()); 3474 if (ValueExpr.isInvalid()) { 3475 // We must manually skip to a '}', otherwise the expression skipper will 3476 // stop at the '}' when it skips to the ';'. We want it to skip beyond 3477 // the enclosing expression. 3478 SkipUntil(tok::r_brace, StopAtSemi); 3479 return ValueExpr; 3480 } 3481 3482 // Check the key and value for possible typos 3483 KeyExpr = Actions.CorrectDelayedTyposInExpr(KeyExpr.get()); 3484 ValueExpr = Actions.CorrectDelayedTyposInExpr(ValueExpr.get()); 3485 if (KeyExpr.isInvalid() || ValueExpr.isInvalid()) 3486 HasInvalidEltExpr = true; 3487 3488 // Parse the ellipsis that designates this as a pack expansion. Do not 3489 // ActOnPackExpansion here, leave it to template instantiation time where 3490 // we can get better diagnostics. 3491 SourceLocation EllipsisLoc; 3492 if (getLangOpts().CPlusPlus) 3493 TryConsumeToken(tok::ellipsis, EllipsisLoc); 3494 3495 // We have a valid expression. Collect it in a vector so we can 3496 // build the argument list. 3497 ObjCDictionaryElement Element = { 3498 KeyExpr.get(), ValueExpr.get(), EllipsisLoc, None 3499 }; 3500 Elements.push_back(Element); 3501 3502 if (!TryConsumeToken(tok::comma) && Tok.isNot(tok::r_brace)) 3503 return ExprError(Diag(Tok, diag::err_expected_either) << tok::r_brace 3504 << tok::comma); 3505 } 3506 SourceLocation EndLoc = ConsumeBrace(); 3507 3508 if (HasInvalidEltExpr) 3509 return ExprError(); 3510 3511 // Create the ObjCDictionaryLiteral. 3512 return Actions.BuildObjCDictionaryLiteral(SourceRange(AtLoc, EndLoc), 3513 Elements); 3514 } 3515 3516 /// objc-encode-expression: 3517 /// \@encode ( type-name ) 3518 ExprResult 3519 Parser::ParseObjCEncodeExpression(SourceLocation AtLoc) { 3520 assert(Tok.isObjCAtKeyword(tok::objc_encode) && "Not an @encode expression!"); 3521 3522 SourceLocation EncLoc = ConsumeToken(); 3523 3524 if (Tok.isNot(tok::l_paren)) 3525 return ExprError(Diag(Tok, diag::err_expected_lparen_after) << "@encode"); 3526 3527 BalancedDelimiterTracker T(*this, tok::l_paren); 3528 T.consumeOpen(); 3529 3530 TypeResult Ty = ParseTypeName(); 3531 3532 T.consumeClose(); 3533 3534 if (Ty.isInvalid()) 3535 return ExprError(); 3536 3537 return Actions.ParseObjCEncodeExpression(AtLoc, EncLoc, T.getOpenLocation(), 3538 Ty.get(), T.getCloseLocation()); 3539 } 3540 3541 /// objc-protocol-expression 3542 /// \@protocol ( protocol-name ) 3543 ExprResult 3544 Parser::ParseObjCProtocolExpression(SourceLocation AtLoc) { 3545 SourceLocation ProtoLoc = ConsumeToken(); 3546 3547 if (Tok.isNot(tok::l_paren)) 3548 return ExprError(Diag(Tok, diag::err_expected_lparen_after) << "@protocol"); 3549 3550 BalancedDelimiterTracker T(*this, tok::l_paren); 3551 T.consumeOpen(); 3552 3553 if (expectIdentifier()) 3554 return ExprError(); 3555 3556 IdentifierInfo *protocolId = Tok.getIdentifierInfo(); 3557 SourceLocation ProtoIdLoc = ConsumeToken(); 3558 3559 T.consumeClose(); 3560 3561 return Actions.ParseObjCProtocolExpression(protocolId, AtLoc, ProtoLoc, 3562 T.getOpenLocation(), ProtoIdLoc, 3563 T.getCloseLocation()); 3564 } 3565 3566 /// objc-selector-expression 3567 /// @selector '(' '('[opt] objc-keyword-selector ')'[opt] ')' 3568 ExprResult Parser::ParseObjCSelectorExpression(SourceLocation AtLoc) { 3569 SourceLocation SelectorLoc = ConsumeToken(); 3570 3571 if (Tok.isNot(tok::l_paren)) 3572 return ExprError(Diag(Tok, diag::err_expected_lparen_after) << "@selector"); 3573 3574 SmallVector<IdentifierInfo *, 12> KeyIdents; 3575 SourceLocation sLoc; 3576 3577 BalancedDelimiterTracker T(*this, tok::l_paren); 3578 T.consumeOpen(); 3579 bool HasOptionalParen = Tok.is(tok::l_paren); 3580 if (HasOptionalParen) 3581 ConsumeParen(); 3582 3583 if (Tok.is(tok::code_completion)) { 3584 Actions.CodeCompleteObjCSelector(getCurScope(), KeyIdents); 3585 cutOffParsing(); 3586 return ExprError(); 3587 } 3588 3589 IdentifierInfo *SelIdent = ParseObjCSelectorPiece(sLoc); 3590 if (!SelIdent && // missing selector name. 3591 Tok.isNot(tok::colon) && Tok.isNot(tok::coloncolon)) 3592 return ExprError(Diag(Tok, diag::err_expected) << tok::identifier); 3593 3594 KeyIdents.push_back(SelIdent); 3595 3596 unsigned nColons = 0; 3597 if (Tok.isNot(tok::r_paren)) { 3598 while (1) { 3599 if (TryConsumeToken(tok::coloncolon)) { // Handle :: in C++. 3600 ++nColons; 3601 KeyIdents.push_back(nullptr); 3602 } else if (ExpectAndConsume(tok::colon)) // Otherwise expect ':'. 3603 return ExprError(); 3604 ++nColons; 3605 3606 if (Tok.is(tok::r_paren)) 3607 break; 3608 3609 if (Tok.is(tok::code_completion)) { 3610 Actions.CodeCompleteObjCSelector(getCurScope(), KeyIdents); 3611 cutOffParsing(); 3612 return ExprError(); 3613 } 3614 3615 // Check for another keyword selector. 3616 SourceLocation Loc; 3617 SelIdent = ParseObjCSelectorPiece(Loc); 3618 KeyIdents.push_back(SelIdent); 3619 if (!SelIdent && Tok.isNot(tok::colon) && Tok.isNot(tok::coloncolon)) 3620 break; 3621 } 3622 } 3623 if (HasOptionalParen && Tok.is(tok::r_paren)) 3624 ConsumeParen(); // ')' 3625 T.consumeClose(); 3626 Selector Sel = PP.getSelectorTable().getSelector(nColons, &KeyIdents[0]); 3627 return Actions.ParseObjCSelectorExpression(Sel, AtLoc, SelectorLoc, 3628 T.getOpenLocation(), 3629 T.getCloseLocation(), 3630 !HasOptionalParen); 3631 } 3632 3633 void Parser::ParseLexedObjCMethodDefs(LexedMethod &LM, bool parseMethod) { 3634 // MCDecl might be null due to error in method or c-function prototype, etc. 3635 Decl *MCDecl = LM.D; 3636 bool skip = MCDecl && 3637 ((parseMethod && !Actions.isObjCMethodDecl(MCDecl)) || 3638 (!parseMethod && Actions.isObjCMethodDecl(MCDecl))); 3639 if (skip) 3640 return; 3641 3642 // Save the current token position. 3643 SourceLocation OrigLoc = Tok.getLocation(); 3644 3645 assert(!LM.Toks.empty() && "ParseLexedObjCMethodDef - Empty body!"); 3646 // Store an artificial EOF token to ensure that we don't run off the end of 3647 // the method's body when we come to parse it. 3648 Token Eof; 3649 Eof.startToken(); 3650 Eof.setKind(tok::eof); 3651 Eof.setEofData(MCDecl); 3652 Eof.setLocation(OrigLoc); 3653 LM.Toks.push_back(Eof); 3654 // Append the current token at the end of the new token stream so that it 3655 // doesn't get lost. 3656 LM.Toks.push_back(Tok); 3657 PP.EnterTokenStream(LM.Toks, true, /*IsReinject*/true); 3658 3659 // Consume the previously pushed token. 3660 ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true); 3661 3662 assert(Tok.isOneOf(tok::l_brace, tok::kw_try, tok::colon) && 3663 "Inline objective-c method not starting with '{' or 'try' or ':'"); 3664 // Enter a scope for the method or c-function body. 3665 ParseScope BodyScope(this, (parseMethod ? Scope::ObjCMethodScope : 0) | 3666 Scope::FnScope | Scope::DeclScope | 3667 Scope::CompoundStmtScope); 3668 3669 // Tell the actions module that we have entered a method or c-function definition 3670 // with the specified Declarator for the method/function. 3671 if (parseMethod) 3672 Actions.ActOnStartOfObjCMethodDef(getCurScope(), MCDecl); 3673 else 3674 Actions.ActOnStartOfFunctionDef(getCurScope(), MCDecl); 3675 if (Tok.is(tok::kw_try)) 3676 ParseFunctionTryBlock(MCDecl, BodyScope); 3677 else { 3678 if (Tok.is(tok::colon)) 3679 ParseConstructorInitializer(MCDecl); 3680 else 3681 Actions.ActOnDefaultCtorInitializers(MCDecl); 3682 ParseFunctionStatementBody(MCDecl, BodyScope); 3683 } 3684 3685 if (Tok.getLocation() != OrigLoc) { 3686 // Due to parsing error, we either went over the cached tokens or 3687 // there are still cached tokens left. If it's the latter case skip the 3688 // leftover tokens. 3689 // Since this is an uncommon situation that should be avoided, use the 3690 // expensive isBeforeInTranslationUnit call. 3691 if (PP.getSourceManager().isBeforeInTranslationUnit(Tok.getLocation(), 3692 OrigLoc)) 3693 while (Tok.getLocation() != OrigLoc && Tok.isNot(tok::eof)) 3694 ConsumeAnyToken(); 3695 } 3696 // Clean up the remaining EOF token. 3697 ConsumeAnyToken(); 3698 } 3699