contrib/llvm/tools/clang/lib/Parse/ParseObjc.cpp

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