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 "clang/Parse/DeclSpec.h"
  16 #include "clang/Parse/Scope.h"
  17 #include "clang/Parse/ParseDiagnostic.h"
  18 #include "llvm/ADT/SmallVector.h"
  19 using namespace clang;
  20
  21
  22 /// ParseObjCAtDirectives - Handle parts of the external-declaration production:
  23 ///       external-declaration: [C99 6.9]
  24 /// [OBJC]  objc-class-definition
  25 /// [OBJC]  objc-class-declaration
  26 /// [OBJC]  objc-alias-declaration
  27 /// [OBJC]  objc-protocol-definition
  28 /// [OBJC]  objc-method-definition
  29 /// [OBJC]  '@' 'end'
  30 Parser::DeclPtrTy Parser::ParseObjCAtDirectives() {
  31   SourceLocation AtLoc = ConsumeToken(); // the "@"
  32
  33   switch (Tok.getObjCKeywordID()) {
  34   case tok::objc_class:
  35     return ParseObjCAtClassDeclaration(AtLoc);
  36   case tok::objc_interface:
  37     return ParseObjCAtInterfaceDeclaration(AtLoc);
  38   case tok::objc_protocol:
  39     return ParseObjCAtProtocolDeclaration(AtLoc);
  40   case tok::objc_implementation:
  41     return ParseObjCAtImplementationDeclaration(AtLoc);
  42   case tok::objc_end:
  43     return ParseObjCAtEndDeclaration(AtLoc);
  44   case tok::objc_compatibility_alias:
  45     return ParseObjCAtAliasDeclaration(AtLoc);
  46   case tok::objc_synthesize:
  47     return ParseObjCPropertySynthesize(AtLoc);
  48   case tok::objc_dynamic:
  49     return ParseObjCPropertyDynamic(AtLoc);
  50   default:
  51     Diag(AtLoc, diag::err_unexpected_at);
  52     SkipUntil(tok::semi);
  53     return DeclPtrTy();
  54   }
  55 }
  56
  57 ///
  58 /// objc-class-declaration:
  59 ///    '@' 'class' identifier-list ';'
  60 ///
  61 Parser::DeclPtrTy Parser::ParseObjCAtClassDeclaration(SourceLocation atLoc) {
  62   ConsumeToken(); // the identifier "class"
  63   llvm::SmallVector<IdentifierInfo *, 8> ClassNames;
  64
  65   while (1) {
  66     if (Tok.isNot(tok::identifier)) {
  67       Diag(Tok, diag::err_expected_ident);
  68       SkipUntil(tok::semi);
  69       return DeclPtrTy();
  70     }
  71     ClassNames.push_back(Tok.getIdentifierInfo());
  72     ConsumeToken();
  73
  74     if (Tok.isNot(tok::comma))
  75       break;
  76
  77     ConsumeToken();
  78   }
  79
  80   // Consume the ';'.
  81   if (ExpectAndConsume(tok::semi, diag::err_expected_semi_after, "@class"))
  82     return DeclPtrTy();
  83
  84   return Actions.ActOnForwardClassDeclaration(atLoc,
  85                                       &ClassNames[0], ClassNames.size());
  86 }
  87
  88 ///
  89 ///   objc-interface:
  90 ///     objc-class-interface-attributes[opt] objc-class-interface
  91 ///     objc-category-interface
  92 ///
  93 ///   objc-class-interface:
  94 ///     '@' 'interface' identifier objc-superclass[opt]
  95 ///       objc-protocol-refs[opt]
  96 ///       objc-class-instance-variables[opt]
  97 ///       objc-interface-decl-list
  98 ///     @end
  99 ///
 100 ///   objc-category-interface:
 101 ///     '@' 'interface' identifier '(' identifier[opt] ')'
 102 ///       objc-protocol-refs[opt]
 103 ///       objc-interface-decl-list
 104 ///     @end
 105 ///
 106 ///   objc-superclass:
 107 ///     ':' identifier
 108 ///
 109 ///   objc-class-interface-attributes:
 110 ///     __attribute__((visibility("default")))
 111 ///     __attribute__((visibility("hidden")))
 112 ///     __attribute__((deprecated))
 113 ///     __attribute__((unavailable))
 114 ///     __attribute__((objc_exception)) - used by NSException on 64-bit
 115 ///
 116 Parser::DeclPtrTy Parser::ParseObjCAtInterfaceDeclaration(
 117   SourceLocation atLoc, AttributeList *attrList) {
 118   assert(Tok.isObjCAtKeyword(tok::objc_interface) &&
 119          "ParseObjCAtInterfaceDeclaration(): Expected @interface");
 120   ConsumeToken(); // the "interface" identifier
 121
 122   if (Tok.isNot(tok::identifier)) {
 123     Diag(Tok, diag::err_expected_ident); // missing class or category name.
 124     return DeclPtrTy();
 125   }
 126   // We have a class or category name - consume it.
 127   IdentifierInfo *nameId = Tok.getIdentifierInfo();
 128   SourceLocation nameLoc = ConsumeToken();
 129
 130   if (Tok.is(tok::l_paren)) { // we have a category.
 131     SourceLocation lparenLoc = ConsumeParen();
 132     SourceLocation categoryLoc, rparenLoc;
 133     IdentifierInfo *categoryId = 0;
 134
 135     // For ObjC2, the category name is optional (not an error).
 136     if (Tok.is(tok::identifier)) {
 137       categoryId = Tok.getIdentifierInfo();
 138       categoryLoc = ConsumeToken();
 139     } else if (!getLang().ObjC2) {
 140       Diag(Tok, diag::err_expected_ident); // missing category name.
 141       return DeclPtrTy();
 142     }
 143     if (Tok.isNot(tok::r_paren)) {
 144       Diag(Tok, diag::err_expected_rparen);
 145       SkipUntil(tok::r_paren, false); // don't stop at ';'
 146       return DeclPtrTy();
 147     }
 148     rparenLoc = ConsumeParen();
 149
 150     // Next, we need to check for any protocol references.
 151     SourceLocation EndProtoLoc;
 152     llvm::SmallVector<DeclPtrTy, 8> ProtocolRefs;
 153     if (Tok.is(tok::less) &&
 154         ParseObjCProtocolReferences(ProtocolRefs, true, EndProtoLoc))
 155       return DeclPtrTy();
 156
 157     if (attrList) // categories don't support attributes.
 158       Diag(Tok, diag::err_objc_no_attributes_on_category);
 159
 160     DeclPtrTy CategoryType =
 161       Actions.ActOnStartCategoryInterface(atLoc,
 162                                           nameId, nameLoc,
 163                                           categoryId, categoryLoc,
 164                                           ProtocolRefs.data(),
 165                                           ProtocolRefs.size(),
 166                                           EndProtoLoc);
 167
 168     ParseObjCInterfaceDeclList(CategoryType, tok::objc_not_keyword);
 169     return CategoryType;
 170   }
 171   // Parse a class interface.
 172   IdentifierInfo *superClassId = 0;
 173   SourceLocation superClassLoc;
 174
 175   if (Tok.is(tok::colon)) { // a super class is specified.
 176     ConsumeToken();
 177     if (Tok.isNot(tok::identifier)) {
 178       Diag(Tok, diag::err_expected_ident); // missing super class name.
 179       return DeclPtrTy();
 180     }
 181     superClassId = Tok.getIdentifierInfo();
 182     superClassLoc = ConsumeToken();
 183   }
 184   // Next, we need to check for any protocol references.
 185   llvm::SmallVector<Action::DeclPtrTy, 8> ProtocolRefs;
 186   SourceLocation EndProtoLoc;
 187   if (Tok.is(tok::less) &&
 188       ParseObjCProtocolReferences(ProtocolRefs, true, EndProtoLoc))
 189     return DeclPtrTy();
 190
 191   DeclPtrTy ClsType =
 192     Actions.ActOnStartClassInterface(atLoc, nameId, nameLoc,
 193                                      superClassId, superClassLoc,
 194                                      ProtocolRefs.data(), ProtocolRefs.size(),
 195                                      EndProtoLoc, attrList);
 196
 197   if (Tok.is(tok::l_brace))
 198     ParseObjCClassInstanceVariables(ClsType, atLoc);
 199
 200   ParseObjCInterfaceDeclList(ClsType, tok::objc_interface);
 201   return ClsType;
 202 }
 203
 204 ///   objc-interface-decl-list:
 205 ///     empty
 206 ///     objc-interface-decl-list objc-property-decl [OBJC2]
 207 ///     objc-interface-decl-list objc-method-requirement [OBJC2]
 208 ///     objc-interface-decl-list objc-method-proto ';'
 209 ///     objc-interface-decl-list declaration
 210 ///     objc-interface-decl-list ';'
 211 ///
 212 ///   objc-method-requirement: [OBJC2]
 213 ///     @required
 214 ///     @optional
 215 ///
 216 void Parser::ParseObjCInterfaceDeclList(DeclPtrTy interfaceDecl,
 217                                         tok::ObjCKeywordKind contextKey) {
 218   llvm::SmallVector<DeclPtrTy, 32> allMethods;
 219   llvm::SmallVector<DeclPtrTy, 16> allProperties;
 220   llvm::SmallVector<DeclGroupPtrTy, 8> allTUVariables;
 221   tok::ObjCKeywordKind MethodImplKind = tok::objc_not_keyword;
 222
 223   SourceLocation AtEndLoc;
 224
 225   while (1) {
 226     // If this is a method prototype, parse it.
 227     if (Tok.is(tok::minus) || Tok.is(tok::plus)) {
 228       DeclPtrTy methodPrototype =
 229         ParseObjCMethodPrototype(interfaceDecl, MethodImplKind);
 230       allMethods.push_back(methodPrototype);
 231       // Consume the ';' here, since ParseObjCMethodPrototype() is re-used for
 232       // method definitions.
 233       ExpectAndConsume(tok::semi, diag::err_expected_semi_after_method_proto,
 234                        "", tok::semi);
 235       continue;
 236     }
 237
 238     // Ignore excess semicolons.
 239     if (Tok.is(tok::semi)) {
 240       ConsumeToken();
 241       continue;
 242     }
 243
 244     // If we got to the end of the file, exit the loop.
 245     if (Tok.is(tok::eof))
 246       break;
 247
 248     // If we don't have an @ directive, parse it as a function definition.
 249     if (Tok.isNot(tok::at)) {
 250       // The code below does not consume '}'s because it is afraid of eating the
 251       // end of a namespace.  Because of the way this code is structured, an
 252       // erroneous r_brace would cause an infinite loop if not handled here.
 253       if (Tok.is(tok::r_brace))
 254         break;
 255
 256       // FIXME: as the name implies, this rule allows function definitions.
 257       // We could pass a flag or check for functions during semantic analysis.
 258       allTUVariables.push_back(ParseDeclarationOrFunctionDefinition());
 259       continue;
 260     }
 261
 262     // Otherwise, we have an @ directive, eat the @.
 263     SourceLocation AtLoc = ConsumeToken(); // the "@"
 264     tok::ObjCKeywordKind DirectiveKind = Tok.getObjCKeywordID();
 265
 266     if (DirectiveKind == tok::objc_end) { // @end -> terminate list
 267       AtEndLoc = AtLoc;
 268       break;
 269     }
 270
 271     // Eat the identifier.
 272     ConsumeToken();
 273
 274     switch (DirectiveKind) {
 275     default:
 276       // FIXME: If someone forgets an @end on a protocol, this loop will
 277       // continue to eat up tons of stuff and spew lots of nonsense errors.  It
 278       // would probably be better to bail out if we saw an @class or @interface
 279       // or something like that.
 280       Diag(AtLoc, diag::err_objc_illegal_interface_qual);
 281       // Skip until we see an '@' or '}' or ';'.
 282       SkipUntil(tok::r_brace, tok::at);
 283       break;
 284
 285     case tok::objc_required:
 286     case tok::objc_optional:
 287       // This is only valid on protocols.
 288       // FIXME: Should this check for ObjC2 being enabled?
 289       if (contextKey != tok::objc_protocol)
 290         Diag(AtLoc, diag::err_objc_directive_only_in_protocol);
 291       else
 292         MethodImplKind = DirectiveKind;
 293       break;
 294
 295     case tok::objc_property:
 296       if (!getLang().ObjC2)
 297         Diag(AtLoc, diag::err_objc_propertoes_require_objc2);
 298
 299       ObjCDeclSpec OCDS;
 300       // Parse property attribute list, if any.
 301       if (Tok.is(tok::l_paren))
 302         ParseObjCPropertyAttribute(OCDS);
 303
 304       // Parse all the comma separated declarators.
 305       DeclSpec DS;
 306       llvm::SmallVector<FieldDeclarator, 8> FieldDeclarators;
 307       ParseStructDeclaration(DS, FieldDeclarators);
 308
 309       ExpectAndConsume(tok::semi, diag::err_expected_semi_decl_list, "",
 310                        tok::at);
 311
 312       // Convert them all to property declarations.
 313       for (unsigned i = 0, e = FieldDeclarators.size(); i != e; ++i) {
 314         FieldDeclarator &FD = FieldDeclarators[i];
 315         if (FD.D.getIdentifier() == 0) {
 316           Diag(AtLoc, diag::err_objc_property_requires_field_name)
 317             << FD.D.getSourceRange();
 318           continue;
 319         }
 320         if (FD.BitfieldSize) {
 321           Diag(AtLoc, diag::err_objc_property_bitfield)
 322             << FD.D.getSourceRange();
 323           continue;
 324         }
 325
 326         // Install the property declarator into interfaceDecl.
 327         IdentifierInfo *SelName =
 328           OCDS.getGetterName() ? OCDS.getGetterName() : FD.D.getIdentifier();
 329
 330         Selector GetterSel =
 331           PP.getSelectorTable().getNullarySelector(SelName);
 332         IdentifierInfo *SetterName = OCDS.getSetterName();
 333         Selector SetterSel;
 334         if (SetterName)
 335           SetterSel = PP.getSelectorTable().getSelector(1, &SetterName);
 336         else
 337           SetterSel = SelectorTable::constructSetterName(PP.getIdentifierTable(),
 338                                                          PP.getSelectorTable(),
 339                                                          FD.D.getIdentifier());
 340         bool isOverridingProperty = false;
 341         DeclPtrTy Property = Actions.ActOnProperty(CurScope, AtLoc, FD, OCDS,
 342                                                    GetterSel, SetterSel,
 343                                                    interfaceDecl,
 344                                                    &isOverridingProperty,
 345                                                    MethodImplKind);
 346         if (!isOverridingProperty)
 347           allProperties.push_back(Property);
 348       }
 349       break;
 350     }
 351   }
 352
 353   // We break out of the big loop in two cases: when we see @end or when we see
 354   // EOF.  In the former case, eat the @end.  In the later case, emit an error.
 355   if (Tok.isObjCAtKeyword(tok::objc_end))
 356     ConsumeToken(); // the "end" identifier
 357   else
 358     Diag(Tok, diag::err_objc_missing_end);
 359
 360   // Insert collected methods declarations into the @interface object.
 361   // This passes in an invalid SourceLocation for AtEndLoc when EOF is hit.
 362   Actions.ActOnAtEnd(AtEndLoc, interfaceDecl,
 363                      allMethods.data(), allMethods.size(),
 364                      allProperties.data(), allProperties.size(),
 365                      allTUVariables.data(), allTUVariables.size());
 366 }
 367
 368 ///   Parse property attribute declarations.
 369 ///
 370 ///   property-attr-decl: '(' property-attrlist ')'
 371 ///   property-attrlist:
 372 ///     property-attribute
 373 ///     property-attrlist ',' property-attribute
 374 ///   property-attribute:
 375 ///     getter '=' identifier
 376 ///     setter '=' identifier ':'
 377 ///     readonly
 378 ///     readwrite
 379 ///     assign
 380 ///     retain
 381 ///     copy
 382 ///     nonatomic
 383 ///
 384 void Parser::ParseObjCPropertyAttribute(ObjCDeclSpec &DS) {
 385   assert(Tok.getKind() == tok::l_paren);
 386   SourceLocation LHSLoc = ConsumeParen(); // consume '('
 387
 388   while (1) {
 389     const IdentifierInfo *II = Tok.getIdentifierInfo();
 390
 391     // If this is not an identifier at all, bail out early.
 392     if (II == 0) {
 393       MatchRHSPunctuation(tok::r_paren, LHSLoc);
 394       return;
 395     }
 396
 397     SourceLocation AttrName = ConsumeToken(); // consume last attribute name
 398
 399     if (II->isStr("readonly"))
 400       DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_readonly);
 401     else if (II->isStr("assign"))
 402       DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_assign);
 403     else if (II->isStr("readwrite"))
 404       DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_readwrite);
 405     else if (II->isStr("retain"))
 406       DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_retain);
 407     else if (II->isStr("copy"))
 408       DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_copy);
 409     else if (II->isStr("nonatomic"))
 410       DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_nonatomic);
 411     else if (II->isStr("getter") || II->isStr("setter")) {
 412       // getter/setter require extra treatment.
 413       if (ExpectAndConsume(tok::equal, diag::err_objc_expected_equal, "",
 414                            tok::r_paren))
 415         return;
 416
 417       if (Tok.isNot(tok::identifier)) {
 418         Diag(Tok, diag::err_expected_ident);
 419         SkipUntil(tok::r_paren);
 420         return;
 421       }
 422
 423       if (II->getName()[0] == 's') {
 424         DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_setter);
 425         DS.setSetterName(Tok.getIdentifierInfo());
 426         ConsumeToken();  // consume method name
 427
 428         if (ExpectAndConsume(tok::colon, diag::err_expected_colon, "",
 429                              tok::r_paren))
 430           return;
 431       } else {
 432         DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_getter);
 433         DS.setGetterName(Tok.getIdentifierInfo());
 434         ConsumeToken();  // consume method name
 435       }
 436     } else {
 437       Diag(AttrName, diag::err_objc_expected_property_attr) << II;
 438       SkipUntil(tok::r_paren);
 439       return;
 440     }
 441
 442     if (Tok.isNot(tok::comma))
 443       break;
 444
 445     ConsumeToken();
 446   }
 447
 448   MatchRHSPunctuation(tok::r_paren, LHSLoc);
 449 }
 450
 451 ///   objc-method-proto:
 452 ///     objc-instance-method objc-method-decl objc-method-attributes[opt]
 453 ///     objc-class-method objc-method-decl objc-method-attributes[opt]
 454 ///
 455 ///   objc-instance-method: '-'
 456 ///   objc-class-method: '+'
 457 ///
 458 ///   objc-method-attributes:         [OBJC2]
 459 ///     __attribute__((deprecated))
 460 ///
 461 Parser::DeclPtrTy Parser::ParseObjCMethodPrototype(DeclPtrTy IDecl,
 462                                           tok::ObjCKeywordKind MethodImplKind) {
 463   assert((Tok.is(tok::minus) || Tok.is(tok::plus)) && "expected +/-");
 464
 465   tok::TokenKind methodType = Tok.getKind();
 466   SourceLocation mLoc = ConsumeToken();
 467
 468   DeclPtrTy MDecl = ParseObjCMethodDecl(mLoc, methodType, IDecl,MethodImplKind);
 469   // Since this rule is used for both method declarations and definitions,
 470   // the caller is (optionally) responsible for consuming the ';'.
 471   return MDecl;
 472 }
 473
 474 ///   objc-selector:
 475 ///     identifier
 476 ///     one of
 477 ///       enum struct union if else while do for switch case default
 478 ///       break continue return goto asm sizeof typeof __alignof
 479 ///       unsigned long const short volatile signed restrict _Complex
 480 ///       in out inout bycopy byref oneway int char float double void _Bool
 481 ///
 482 IdentifierInfo *Parser::ParseObjCSelectorPiece(SourceLocation &SelectorLoc) {
 483   switch (Tok.getKind()) {
 484   default:
 485     return 0;
 486   case tok::identifier:
 487   case tok::kw_asm:
 488   case tok::kw_auto:
 489   case tok::kw_bool:
 490   case tok::kw_break:
 491   case tok::kw_case:
 492   case tok::kw_catch:
 493   case tok::kw_char:
 494   case tok::kw_class:
 495   case tok::kw_const:
 496   case tok::kw_const_cast:
 497   case tok::kw_continue:
 498   case tok::kw_default:
 499   case tok::kw_delete:
 500   case tok::kw_do:
 501   case tok::kw_double:
 502   case tok::kw_dynamic_cast:
 503   case tok::kw_else:
 504   case tok::kw_enum:
 505   case tok::kw_explicit:
 506   case tok::kw_export:
 507   case tok::kw_extern:
 508   case tok::kw_false:
 509   case tok::kw_float:
 510   case tok::kw_for:
 511   case tok::kw_friend:
 512   case tok::kw_goto:
 513   case tok::kw_if:
 514   case tok::kw_inline:
 515   case tok::kw_int:
 516   case tok::kw_long:
 517   case tok::kw_mutable:
 518   case tok::kw_namespace:
 519   case tok::kw_new:
 520   case tok::kw_operator:
 521   case tok::kw_private:
 522   case tok::kw_protected:
 523   case tok::kw_public:
 524   case tok::kw_register:
 525   case tok::kw_reinterpret_cast:
 526   case tok::kw_restrict:
 527   case tok::kw_return:
 528   case tok::kw_short:
 529   case tok::kw_signed:
 530   case tok::kw_sizeof:
 531   case tok::kw_static:
 532   case tok::kw_static_cast:
 533   case tok::kw_struct:
 534   case tok::kw_switch:
 535   case tok::kw_template:
 536   case tok::kw_this:
 537   case tok::kw_throw:
 538   case tok::kw_true:
 539   case tok::kw_try:
 540   case tok::kw_typedef:
 541   case tok::kw_typeid:
 542   case tok::kw_typename:
 543   case tok::kw_typeof:
 544   case tok::kw_union:
 545   case tok::kw_unsigned:
 546   case tok::kw_using:
 547   case tok::kw_virtual:
 548   case tok::kw_void:
 549   case tok::kw_volatile:
 550   case tok::kw_wchar_t:
 551   case tok::kw_while:
 552   case tok::kw__Bool:
 553   case tok::kw__Complex:
 554   case tok::kw___alignof:
 555     IdentifierInfo *II = Tok.getIdentifierInfo();
 556     SelectorLoc = ConsumeToken();
 557     return II;
 558   }
 559 }
 560
 561 ///  objc-for-collection-in: 'in'
 562 ///
 563 bool Parser::isTokIdentifier_in() const {
 564   // FIXME: May have to do additional look-ahead to only allow for
 565   // valid tokens following an 'in'; such as an identifier, unary operators,
 566   // '[' etc.
 567   return (getLang().ObjC2 && Tok.is(tok::identifier) &&
 568           Tok.getIdentifierInfo() == ObjCTypeQuals[objc_in]);
 569 }
 570
 571 /// ParseObjCTypeQualifierList - This routine parses the objective-c's type
 572 /// qualifier list and builds their bitmask representation in the input
 573 /// argument.
 574 ///
 575 ///   objc-type-qualifiers:
 576 ///     objc-type-qualifier
 577 ///     objc-type-qualifiers objc-type-qualifier
 578 ///
 579 void Parser::ParseObjCTypeQualifierList(ObjCDeclSpec &DS) {
 580   while (1) {
 581     if (Tok.isNot(tok::identifier))
 582       return;
 583
 584     const IdentifierInfo *II = Tok.getIdentifierInfo();
 585     for (unsigned i = 0; i != objc_NumQuals; ++i) {
 586       if (II != ObjCTypeQuals[i])
 587         continue;
 588
 589       ObjCDeclSpec::ObjCDeclQualifier Qual;
 590       switch (i) {
 591       default: assert(0 && "Unknown decl qualifier");
 592       case objc_in:     Qual = ObjCDeclSpec::DQ_In; break;
 593       case objc_out:    Qual = ObjCDeclSpec::DQ_Out; break;
 594       case objc_inout:  Qual = ObjCDeclSpec::DQ_Inout; break;
 595       case objc_oneway: Qual = ObjCDeclSpec::DQ_Oneway; break;
 596       case objc_bycopy: Qual = ObjCDeclSpec::DQ_Bycopy; break;
 597       case objc_byref:  Qual = ObjCDeclSpec::DQ_Byref; break;
 598       }
 599       DS.setObjCDeclQualifier(Qual);
 600       ConsumeToken();
 601       II = 0;
 602       break;
 603     }
 604
 605     // If this wasn't a recognized qualifier, bail out.
 606     if (II) return;
 607   }
 608 }
 609
 610 ///   objc-type-name:
 611 ///     '(' objc-type-qualifiers[opt] type-name ')'
 612 ///     '(' objc-type-qualifiers[opt] ')'
 613 ///
 614 Parser::TypeTy *Parser::ParseObjCTypeName(ObjCDeclSpec &DS) {
 615   assert(Tok.is(tok::l_paren) && "expected (");
 616
 617   SourceLocation LParenLoc = ConsumeParen();
 618   SourceLocation TypeStartLoc = Tok.getLocation();
 619
 620   // Parse type qualifiers, in, inout, etc.
 621   ParseObjCTypeQualifierList(DS);
 622
 623   TypeTy *Ty = 0;
 624   if (isTypeSpecifierQualifier()) {
 625     TypeResult TypeSpec = ParseTypeName();
 626     if (!TypeSpec.isInvalid())
 627       Ty = TypeSpec.get();
 628   }
 629
 630   if (Tok.is(tok::r_paren))
 631     ConsumeParen();
 632   else if (Tok.getLocation() == TypeStartLoc) {
 633     // If we didn't eat any tokens, then this isn't a type.
 634     Diag(Tok, diag::err_expected_type);
 635     SkipUntil(tok::r_paren);
 636   } else {
 637     // Otherwise, we found *something*, but didn't get a ')' in the right
 638     // place.  Emit an error then return what we have as the type.
 639     MatchRHSPunctuation(tok::r_paren, LParenLoc);
 640   }
 641   return Ty;
 642 }
 643
 644 ///   objc-method-decl:
 645 ///     objc-selector
 646 ///     objc-keyword-selector objc-parmlist[opt]
 647 ///     objc-type-name objc-selector
 648 ///     objc-type-name objc-keyword-selector objc-parmlist[opt]
 649 ///
 650 ///   objc-keyword-selector:
 651 ///     objc-keyword-decl
 652 ///     objc-keyword-selector objc-keyword-decl
 653 ///
 654 ///   objc-keyword-decl:
 655 ///     objc-selector ':' objc-type-name objc-keyword-attributes[opt] identifier
 656 ///     objc-selector ':' objc-keyword-attributes[opt] identifier
 657 ///     ':' objc-type-name objc-keyword-attributes[opt] identifier
 658 ///     ':' objc-keyword-attributes[opt] identifier
 659 ///
 660 ///   objc-parmlist:
 661 ///     objc-parms objc-ellipsis[opt]
 662 ///
 663 ///   objc-parms:
 664 ///     objc-parms , parameter-declaration
 665 ///
 666 ///   objc-ellipsis:
 667 ///     , ...
 668 ///
 669 ///   objc-keyword-attributes:         [OBJC2]
 670 ///     __attribute__((unused))
 671 ///
 672 Parser::DeclPtrTy Parser::ParseObjCMethodDecl(SourceLocation mLoc,
 673                                               tok::TokenKind mType,
 674                                               DeclPtrTy IDecl,
 675                                           tok::ObjCKeywordKind MethodImplKind) {
 676   // Parse the return type if present.
 677   TypeTy *ReturnType = 0;
 678   ObjCDeclSpec DSRet;
 679   if (Tok.is(tok::l_paren))
 680     ReturnType = ParseObjCTypeName(DSRet);
 681
 682   SourceLocation selLoc;
 683   IdentifierInfo *SelIdent = ParseObjCSelectorPiece(selLoc);
 684
 685   // An unnamed colon is valid.
 686   if (!SelIdent && Tok.isNot(tok::colon)) { // missing selector name.
 687     Diag(Tok, diag::err_expected_selector_for_method)
 688       << SourceRange(mLoc, Tok.getLocation());
 689     // Skip until we get a ; or {}.
 690     SkipUntil(tok::r_brace);
 691     return DeclPtrTy();
 692   }
 693
 694   llvm::SmallVector<Declarator, 8> CargNames;
 695   if (Tok.isNot(tok::colon)) {
 696     // If attributes exist after the method, parse them.
 697     AttributeList *MethodAttrs = 0;
 698     if (getLang().ObjC2 && Tok.is(tok::kw___attribute))
 699       MethodAttrs = ParseAttributes();
 700
 701     Selector Sel = PP.getSelectorTable().getNullarySelector(SelIdent);
 702     return Actions.ActOnMethodDeclaration(mLoc, Tok.getLocation(),
 703                                           mType, IDecl, DSRet, ReturnType, Sel,
 704                                           0, CargNames, MethodAttrs,
 705                                           MethodImplKind);
 706   }
 707
 708   llvm::SmallVector<IdentifierInfo *, 12> KeyIdents;
 709   llvm::SmallVector<Action::ObjCArgInfo, 12> ArgInfos;
 710
 711   while (1) {
 712     Action::ObjCArgInfo ArgInfo;
 713
 714     // Each iteration parses a single keyword argument.
 715     if (Tok.isNot(tok::colon)) {
 716       Diag(Tok, diag::err_expected_colon);
 717       break;
 718     }
 719     ConsumeToken(); // Eat the ':'.
 720
 721     ArgInfo.Type = 0;
 722     if (Tok.is(tok::l_paren)) // Parse the argument type if present.
 723       ArgInfo.Type = ParseObjCTypeName(ArgInfo.DeclSpec);
 724
 725     // If attributes exist before the argument name, parse them.
 726     ArgInfo.ArgAttrs = 0;
 727     if (getLang().ObjC2 && Tok.is(tok::kw___attribute))
 728       ArgInfo.ArgAttrs = ParseAttributes();
 729
 730     if (Tok.isNot(tok::identifier)) {
 731       Diag(Tok, diag::err_expected_ident); // missing argument name.
 732       break;
 733     }
 734
 735     ArgInfo.Name = Tok.getIdentifierInfo();
 736     ArgInfo.NameLoc = Tok.getLocation();
 737     ConsumeToken(); // Eat the identifier.
 738
 739     ArgInfos.push_back(ArgInfo);
 740     KeyIdents.push_back(SelIdent);
 741
 742     // Check for another keyword selector.
 743     SourceLocation Loc;
 744     SelIdent = ParseObjCSelectorPiece(Loc);
 745     if (!SelIdent && Tok.isNot(tok::colon))
 746       break;
 747     // We have a selector or a colon, continue parsing.
 748   }
 749
 750   bool isVariadic = false;
 751
 752   // Parse the (optional) parameter list.
 753   while (Tok.is(tok::comma)) {
 754     ConsumeToken();
 755     if (Tok.is(tok::ellipsis)) {
 756       isVariadic = true;
 757       ConsumeToken();
 758       break;
 759     }
 760     DeclSpec DS;
 761     ParseDeclarationSpecifiers(DS);
 762     // Parse the declarator.
 763     Declarator ParmDecl(DS, Declarator::PrototypeContext);
 764     ParseDeclarator(ParmDecl);
 765     CargNames.push_back(ParmDecl);
 766   }
 767
 768   // FIXME: Add support for optional parmameter list...
 769   // If attributes exist after the method, parse them.
 770   AttributeList *MethodAttrs = 0;
 771   if (getLang().ObjC2 && Tok.is(tok::kw___attribute))
 772     MethodAttrs = ParseAttributes();
 773
 774   Selector Sel = PP.getSelectorTable().getSelector(KeyIdents.size(),
 775                                                    &KeyIdents[0]);
 776   return Actions.ActOnMethodDeclaration(mLoc, Tok.getLocation(),
 777                                         mType, IDecl, DSRet, ReturnType, Sel,
 778                                         &ArgInfos[0], CargNames, MethodAttrs,
 779                                         MethodImplKind, isVariadic);
 780 }
 781
 782 ///   objc-protocol-refs:
 783 ///     '<' identifier-list '>'
 784 ///
 785 bool Parser::
 786 ParseObjCProtocolReferences(llvm::SmallVectorImpl<Action::DeclPtrTy> &Protocols,
 787                             bool WarnOnDeclarations, SourceLocation &EndLoc) {
 788   assert(Tok.is(tok::less) && "expected <");
 789
 790   ConsumeToken(); // the "<"
 791
 792   llvm::SmallVector<IdentifierLocPair, 8> ProtocolIdents;
 793
 794   while (1) {
 795     if (Tok.isNot(tok::identifier)) {
 796       Diag(Tok, diag::err_expected_ident);
 797       SkipUntil(tok::greater);
 798       return true;
 799     }
 800     ProtocolIdents.push_back(std::make_pair(Tok.getIdentifierInfo(),
 801                                        Tok.getLocation()));
 802     ConsumeToken();
 803
 804     if (Tok.isNot(tok::comma))
 805       break;
 806     ConsumeToken();
 807   }
 808
 809   // Consume the '>'.
 810   if (Tok.isNot(tok::greater)) {
 811     Diag(Tok, diag::err_expected_greater);
 812     return true;
 813   }
 814
 815   EndLoc = ConsumeAnyToken();
 816
 817   // Convert the list of protocols identifiers into a list of protocol decls.
 818   Actions.FindProtocolDeclaration(WarnOnDeclarations,
 819                                   &ProtocolIdents[0], ProtocolIdents.size(),
 820                                   Protocols);
 821   return false;
 822 }
 823
 824 ///   objc-class-instance-variables:
 825 ///     '{' objc-instance-variable-decl-list[opt] '}'
 826 ///
 827 ///   objc-instance-variable-decl-list:
 828 ///     objc-visibility-spec
 829 ///     objc-instance-variable-decl ';'
 830 ///     ';'
 831 ///     objc-instance-variable-decl-list objc-visibility-spec
 832 ///     objc-instance-variable-decl-list objc-instance-variable-decl ';'
 833 ///     objc-instance-variable-decl-list ';'
 834 ///
 835 ///   objc-visibility-spec:
 836 ///     @private
 837 ///     @protected
 838 ///     @public
 839 ///     @package [OBJC2]
 840 ///
 841 ///   objc-instance-variable-decl:
 842 ///     struct-declaration
 843 ///
 844 void Parser::ParseObjCClassInstanceVariables(DeclPtrTy interfaceDecl,
 845                                              SourceLocation atLoc) {
 846   assert(Tok.is(tok::l_brace) && "expected {");
 847   llvm::SmallVector<DeclPtrTy, 32> AllIvarDecls;
 848   llvm::SmallVector<FieldDeclarator, 8> FieldDeclarators;
 849
 850   ParseScope ClassScope(this, Scope::DeclScope|Scope::ClassScope);
 851
 852   SourceLocation LBraceLoc = ConsumeBrace(); // the "{"
 853
 854   tok::ObjCKeywordKind visibility = tok::objc_protected;
 855   // While we still have something to read, read the instance variables.
 856   while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) {
 857     // Each iteration of this loop reads one objc-instance-variable-decl.
 858
 859     // Check for extraneous top-level semicolon.
 860     if (Tok.is(tok::semi)) {
 861       Diag(Tok, diag::ext_extra_struct_semi);
 862       ConsumeToken();
 863       continue;
 864     }
 865
 866     // Set the default visibility to private.
 867     if (Tok.is(tok::at)) { // parse objc-visibility-spec
 868       ConsumeToken(); // eat the @ sign
 869       switch (Tok.getObjCKeywordID()) {
 870       case tok::objc_private:
 871       case tok::objc_public:
 872       case tok::objc_protected:
 873       case tok::objc_package:
 874         visibility = Tok.getObjCKeywordID();
 875         ConsumeToken();
 876         continue;
 877       default:
 878         Diag(Tok, diag::err_objc_illegal_visibility_spec);
 879         continue;
 880       }
 881     }
 882
 883     // Parse all the comma separated declarators.
 884     DeclSpec DS;
 885     FieldDeclarators.clear();
 886     ParseStructDeclaration(DS, FieldDeclarators);
 887
 888     // Convert them all to fields.
 889     for (unsigned i = 0, e = FieldDeclarators.size(); i != e; ++i) {
 890       FieldDeclarator &FD = FieldDeclarators[i];
 891       // Install the declarator into interfaceDecl.
 892       DeclPtrTy Field = Actions.ActOnIvar(CurScope,
 893                                           DS.getSourceRange().getBegin(),
 894                                           FD.D, FD.BitfieldSize, visibility);
 895       AllIvarDecls.push_back(Field);
 896     }
 897
 898     if (Tok.is(tok::semi)) {
 899       ConsumeToken();
 900     } else {
 901       Diag(Tok, diag::err_expected_semi_decl_list);
 902       // Skip to end of block or statement
 903       SkipUntil(tok::r_brace, true, true);
 904     }
 905   }
 906   SourceLocation RBraceLoc = MatchRHSPunctuation(tok::r_brace, LBraceLoc);
 907   // Call ActOnFields() even if we don't have any decls. This is useful
 908   // for code rewriting tools that need to be aware of the empty list.
 909   Actions.ActOnFields(CurScope, atLoc, interfaceDecl,
 910                       AllIvarDecls.data(), AllIvarDecls.size(),
 911                       LBraceLoc, RBraceLoc, 0);
 912   return;
 913 }
 914
 915 ///   objc-protocol-declaration:
 916 ///     objc-protocol-definition
 917 ///     objc-protocol-forward-reference
 918 ///
 919 ///   objc-protocol-definition:
 920 ///     @protocol identifier
 921 ///       objc-protocol-refs[opt]
 922 ///       objc-interface-decl-list
 923 ///     @end
 924 ///
 925 ///   objc-protocol-forward-reference:
 926 ///     @protocol identifier-list ';'
 927 ///
 928 ///   "@protocol identifier ;" should be resolved as "@protocol
 929 ///   identifier-list ;": objc-interface-decl-list may not start with a
 930 ///   semicolon in the first alternative if objc-protocol-refs are omitted.
 931 Parser::DeclPtrTy Parser::ParseObjCAtProtocolDeclaration(SourceLocation AtLoc,
 932                                                       AttributeList *attrList) {
 933   assert(Tok.isObjCAtKeyword(tok::objc_protocol) &&
 934          "ParseObjCAtProtocolDeclaration(): Expected @protocol");
 935   ConsumeToken(); // the "protocol" identifier
 936
 937   if (Tok.isNot(tok::identifier)) {
 938     Diag(Tok, diag::err_expected_ident); // missing protocol name.
 939     return DeclPtrTy();
 940   }
 941   // Save the protocol name, then consume it.
 942   IdentifierInfo *protocolName = Tok.getIdentifierInfo();
 943   SourceLocation nameLoc = ConsumeToken();
 944
 945   if (Tok.is(tok::semi)) { // forward declaration of one protocol.
 946     IdentifierLocPair ProtoInfo(protocolName, nameLoc);
 947     ConsumeToken();
 948     return Actions.ActOnForwardProtocolDeclaration(AtLoc, &ProtoInfo, 1,
 949                                                    attrList);
 950   }
 951
 952   if (Tok.is(tok::comma)) { // list of forward declarations.
 953     llvm::SmallVector<IdentifierLocPair, 8> ProtocolRefs;
 954     ProtocolRefs.push_back(std::make_pair(protocolName, nameLoc));
 955
 956     // Parse the list of forward declarations.
 957     while (1) {
 958       ConsumeToken(); // the ','
 959       if (Tok.isNot(tok::identifier)) {
 960         Diag(Tok, diag::err_expected_ident);
 961         SkipUntil(tok::semi);
 962         return DeclPtrTy();
 963       }
 964       ProtocolRefs.push_back(IdentifierLocPair(Tok.getIdentifierInfo(),
 965                                                Tok.getLocation()));
 966       ConsumeToken(); // the identifier
 967
 968       if (Tok.isNot(tok::comma))
 969         break;
 970     }
 971     // Consume the ';'.
 972     if (ExpectAndConsume(tok::semi, diag::err_expected_semi_after, "@protocol"))
 973       return DeclPtrTy();
 974
 975     return Actions.ActOnForwardProtocolDeclaration(AtLoc,
 976                                                    &ProtocolRefs[0],
 977                                                    ProtocolRefs.size(),
 978                                                    attrList);
 979   }
 980
 981   // Last, and definitely not least, parse a protocol declaration.
 982   SourceLocation EndProtoLoc;
 983
 984   llvm::SmallVector<DeclPtrTy, 8> ProtocolRefs;
 985   if (Tok.is(tok::less) &&
 986       ParseObjCProtocolReferences(ProtocolRefs, false, EndProtoLoc))
 987     return DeclPtrTy();
 988
 989   DeclPtrTy ProtoType =
 990     Actions.ActOnStartProtocolInterface(AtLoc, protocolName, nameLoc,
 991                                         ProtocolRefs.data(),
 992                                         ProtocolRefs.size(),
 993                                         EndProtoLoc, attrList);
 994   ParseObjCInterfaceDeclList(ProtoType, tok::objc_protocol);
 995   return ProtoType;
 996 }
 997
 998 ///   objc-implementation:
 999 ///     objc-class-implementation-prologue
1000 ///     objc-category-implementation-prologue
1001 ///
1002 ///   objc-class-implementation-prologue:
1003 ///     @implementation identifier objc-superclass[opt]
1004 ///       objc-class-instance-variables[opt]
1005 ///
1006 ///   objc-category-implementation-prologue:
1007 ///     @implementation identifier ( identifier )
1008 Parser::DeclPtrTy Parser::ParseObjCAtImplementationDeclaration(
1009   SourceLocation atLoc) {
1010   assert(Tok.isObjCAtKeyword(tok::objc_implementation) &&
1011          "ParseObjCAtImplementationDeclaration(): Expected @implementation");
1012   ConsumeToken(); // the "implementation" identifier
1013
1014   if (Tok.isNot(tok::identifier)) {
1015     Diag(Tok, diag::err_expected_ident); // missing class or category name.
1016     return DeclPtrTy();
1017   }
1018   // We have a class or category name - consume it.
1019   IdentifierInfo *nameId = Tok.getIdentifierInfo();
1020   SourceLocation nameLoc = ConsumeToken(); // consume class or category name
1021
1022   if (Tok.is(tok::l_paren)) {
1023     // we have a category implementation.
1024     SourceLocation lparenLoc = ConsumeParen();
1025     SourceLocation categoryLoc, rparenLoc;
1026     IdentifierInfo *categoryId = 0;
1027
1028     if (Tok.is(tok::identifier)) {
1029       categoryId = Tok.getIdentifierInfo();
1030       categoryLoc = ConsumeToken();
1031     } else {
1032       Diag(Tok, diag::err_expected_ident); // missing category name.
1033       return DeclPtrTy();
1034     }
1035     if (Tok.isNot(tok::r_paren)) {
1036       Diag(Tok, diag::err_expected_rparen);
1037       SkipUntil(tok::r_paren, false); // don't stop at ';'
1038       return DeclPtrTy();
1039     }
1040     rparenLoc = ConsumeParen();
1041     DeclPtrTy ImplCatType = Actions.ActOnStartCategoryImplementation(
1042                                     atLoc, nameId, nameLoc, categoryId,
1043                                     categoryLoc);
1044     ObjCImpDecl = ImplCatType;
1045     return DeclPtrTy();
1046   }
1047   // We have a class implementation
1048   SourceLocation superClassLoc;
1049   IdentifierInfo *superClassId = 0;
1050   if (Tok.is(tok::colon)) {
1051     // We have a super class
1052     ConsumeToken();
1053     if (Tok.isNot(tok::identifier)) {
1054       Diag(Tok, diag::err_expected_ident); // missing super class name.
1055       return DeclPtrTy();
1056     }
1057     superClassId = Tok.getIdentifierInfo();
1058     superClassLoc = ConsumeToken(); // Consume super class name
1059   }
1060   DeclPtrTy ImplClsType = Actions.ActOnStartClassImplementation(
1061                                   atLoc, nameId, nameLoc,
1062                                   superClassId, superClassLoc);
1063
1064   if (Tok.is(tok::l_brace)) // we have ivars
1065     ParseObjCClassInstanceVariables(ImplClsType/*FIXME*/, atLoc);
1066   ObjCImpDecl = ImplClsType;
1067
1068   return DeclPtrTy();
1069 }
1070
1071 Parser::DeclPtrTy Parser::ParseObjCAtEndDeclaration(SourceLocation atLoc) {
1072   assert(Tok.isObjCAtKeyword(tok::objc_end) &&
1073          "ParseObjCAtEndDeclaration(): Expected @end");
1074   DeclPtrTy Result = ObjCImpDecl;
1075   ConsumeToken(); // the "end" identifier
1076   if (ObjCImpDecl) {
1077     Actions.ActOnAtEnd(atLoc, ObjCImpDecl);
1078     ObjCImpDecl = DeclPtrTy();
1079   }
1080   else
1081     Diag(atLoc, diag::warn_expected_implementation); // missing @implementation
1082   return Result;
1083 }
1084
1085 ///   compatibility-alias-decl:
1086 ///     @compatibility_alias alias-name  class-name ';'
1087 ///
1088 Parser::DeclPtrTy Parser::ParseObjCAtAliasDeclaration(SourceLocation atLoc) {
1089   assert(Tok.isObjCAtKeyword(tok::objc_compatibility_alias) &&
1090          "ParseObjCAtAliasDeclaration(): Expected @compatibility_alias");
1091   ConsumeToken(); // consume compatibility_alias
1092   if (Tok.isNot(tok::identifier)) {
1093     Diag(Tok, diag::err_expected_ident);
1094     return DeclPtrTy();
1095   }
1096   IdentifierInfo *aliasId = Tok.getIdentifierInfo();
1097   SourceLocation aliasLoc = ConsumeToken(); // consume alias-name
1098   if (Tok.isNot(tok::identifier)) {
1099     Diag(Tok, diag::err_expected_ident);
1100     return DeclPtrTy();
1101   }
1102   IdentifierInfo *classId = Tok.getIdentifierInfo();
1103   SourceLocation classLoc = ConsumeToken(); // consume class-name;
1104   if (Tok.isNot(tok::semi)) {
1105     Diag(Tok, diag::err_expected_semi_after) << "@compatibility_alias";
1106     return DeclPtrTy();
1107   }
1108   return Actions.ActOnCompatiblityAlias(atLoc, aliasId, aliasLoc,
1109                                         classId, classLoc);
1110 }
1111
1112 ///   property-synthesis:
1113 ///     @synthesize property-ivar-list ';'
1114 ///
1115 ///   property-ivar-list:
1116 ///     property-ivar
1117 ///     property-ivar-list ',' property-ivar
1118 ///
1119 ///   property-ivar:
1120 ///     identifier
1121 ///     identifier '=' identifier
1122 ///
1123 Parser::DeclPtrTy Parser::ParseObjCPropertySynthesize(SourceLocation atLoc) {
1124   assert(Tok.isObjCAtKeyword(tok::objc_synthesize) &&
1125          "ParseObjCPropertyDynamic(): Expected '@synthesize'");
1126   SourceLocation loc = ConsumeToken(); // consume synthesize
1127   if (Tok.isNot(tok::identifier)) {
1128     Diag(Tok, diag::err_expected_ident);
1129     return DeclPtrTy();
1130   }
1131
1132   while (Tok.is(tok::identifier)) {
1133     IdentifierInfo *propertyIvar = 0;
1134     IdentifierInfo *propertyId = Tok.getIdentifierInfo();
1135     SourceLocation propertyLoc = ConsumeToken(); // consume property name
1136     if (Tok.is(tok::equal)) {
1137       // property '=' ivar-name
1138       ConsumeToken(); // consume '='
1139       if (Tok.isNot(tok::identifier)) {
1140         Diag(Tok, diag::err_expected_ident);
1141         break;
1142       }
1143       propertyIvar = Tok.getIdentifierInfo();
1144       ConsumeToken(); // consume ivar-name
1145     }
1146     Actions.ActOnPropertyImplDecl(atLoc, propertyLoc, true, ObjCImpDecl,
1147                                   propertyId, propertyIvar);
1148     if (Tok.isNot(tok::comma))
1149       break;
1150     ConsumeToken(); // consume ','
1151   }
1152   if (Tok.isNot(tok::semi))
1153     Diag(Tok, diag::err_expected_semi_after) << "@synthesize";
1154   return DeclPtrTy();
1155 }
1156
1157 ///   property-dynamic:
1158 ///     @dynamic  property-list
1159 ///
1160 ///   property-list:
1161 ///     identifier
1162 ///     property-list ',' identifier
1163 ///
1164 Parser::DeclPtrTy Parser::ParseObjCPropertyDynamic(SourceLocation atLoc) {
1165   assert(Tok.isObjCAtKeyword(tok::objc_dynamic) &&
1166          "ParseObjCPropertyDynamic(): Expected '@dynamic'");
1167   SourceLocation loc = ConsumeToken(); // consume dynamic
1168   if (Tok.isNot(tok::identifier)) {
1169     Diag(Tok, diag::err_expected_ident);
1170     return DeclPtrTy();
1171   }
1172   while (Tok.is(tok::identifier)) {
1173     IdentifierInfo *propertyId = Tok.getIdentifierInfo();
1174     SourceLocation propertyLoc = ConsumeToken(); // consume property name
1175     Actions.ActOnPropertyImplDecl(atLoc, propertyLoc, false, ObjCImpDecl,
1176                                   propertyId, 0);
1177
1178     if (Tok.isNot(tok::comma))
1179       break;
1180     ConsumeToken(); // consume ','
1181   }
1182   if (Tok.isNot(tok::semi))
1183     Diag(Tok, diag::err_expected_semi_after) << "@dynamic";
1184   return DeclPtrTy();
1185 }
1186
1187 ///  objc-throw-statement:
1188 ///    throw expression[opt];
1189 ///
1190 Parser::OwningStmtResult Parser::ParseObjCThrowStmt(SourceLocation atLoc) {
1191   OwningExprResult Res(Actions);
1192   ConsumeToken(); // consume throw
1193   if (Tok.isNot(tok::semi)) {
1194     Res = ParseExpression();
1195     if (Res.isInvalid()) {
1196       SkipUntil(tok::semi);
1197       return StmtError();
1198     }
1199   }
1200   ConsumeToken(); // consume ';'
1201   return Actions.ActOnObjCAtThrowStmt(atLoc, move(Res), CurScope);
1202 }
1203
1204 /// objc-synchronized-statement:
1205 ///   @synchronized '(' expression ')' compound-statement
1206 ///
1207 Parser::OwningStmtResult
1208 Parser::ParseObjCSynchronizedStmt(SourceLocation atLoc) {
1209   ConsumeToken(); // consume synchronized
1210   if (Tok.isNot(tok::l_paren)) {
1211     Diag(Tok, diag::err_expected_lparen_after) << "@synchronized";
1212     return StmtError();
1213   }
1214   ConsumeParen();  // '('
1215   OwningExprResult Res(ParseExpression());
1216   if (Res.isInvalid()) {
1217     SkipUntil(tok::semi);
1218     return StmtError();
1219   }
1220   if (Tok.isNot(tok::r_paren)) {
1221     Diag(Tok, diag::err_expected_lbrace);
1222     return StmtError();
1223   }
1224   ConsumeParen();  // ')'
1225   if (Tok.isNot(tok::l_brace)) {
1226     Diag(Tok, diag::err_expected_lbrace);
1227     return StmtError();
1228   }
1229   // Enter a scope to hold everything within the compound stmt.  Compound
1230   // statements can always hold declarations.
1231   ParseScope BodyScope(this, Scope::DeclScope);
1232
1233   OwningStmtResult SynchBody(ParseCompoundStatementBody());
1234
1235   BodyScope.Exit();
1236   if (SynchBody.isInvalid())
1237     SynchBody = Actions.ActOnNullStmt(Tok.getLocation());
1238   return Actions.ActOnObjCAtSynchronizedStmt(atLoc, move(Res), move(SynchBody));
1239 }
1240
1241 ///  objc-try-catch-statement:
1242 ///    @try compound-statement objc-catch-list[opt]
1243 ///    @try compound-statement objc-catch-list[opt] @finally compound-statement
1244 ///
1245 ///  objc-catch-list:
1246 ///    @catch ( parameter-declaration ) compound-statement
1247 ///    objc-catch-list @catch ( catch-parameter-declaration ) compound-statement
1248 ///  catch-parameter-declaration:
1249 ///     parameter-declaration
1250 ///     '...' [OBJC2]
1251 ///
1252 Parser::OwningStmtResult Parser::ParseObjCTryStmt(SourceLocation atLoc) {
1253   bool catch_or_finally_seen = false;
1254
1255   ConsumeToken(); // consume try
1256   if (Tok.isNot(tok::l_brace)) {
1257     Diag(Tok, diag::err_expected_lbrace);
1258     return StmtError();
1259   }
1260   OwningStmtResult CatchStmts(Actions);
1261   OwningStmtResult FinallyStmt(Actions);
1262   ParseScope TryScope(this, Scope::DeclScope);
1263   OwningStmtResult TryBody(ParseCompoundStatementBody());
1264   TryScope.Exit();
1265   if (TryBody.isInvalid())
1266     TryBody = Actions.ActOnNullStmt(Tok.getLocation());
1267
1268   while (Tok.is(tok::at)) {
1269     // At this point, we need to lookahead to determine if this @ is the start
1270     // of an @catch or @finally.  We don't want to consume the @ token if this
1271     // is an @try or @encode or something else.
1272     Token AfterAt = GetLookAheadToken(1);
1273     if (!AfterAt.isObjCAtKeyword(tok::objc_catch) &&
1274         !AfterAt.isObjCAtKeyword(tok::objc_finally))
1275       break;
1276
1277     SourceLocation AtCatchFinallyLoc = ConsumeToken();
1278     if (Tok.isObjCAtKeyword(tok::objc_catch)) {
1279       DeclPtrTy FirstPart;
1280       ConsumeToken(); // consume catch
1281       if (Tok.is(tok::l_paren)) {
1282         ConsumeParen();
1283         ParseScope CatchScope(this, Scope::DeclScope|Scope::AtCatchScope);
1284         if (Tok.isNot(tok::ellipsis)) {
1285           DeclSpec DS;
1286           ParseDeclarationSpecifiers(DS);
1287           // For some odd reason, the name of the exception variable is
1288           // optional. As a result, we need to use "PrototypeContext", because
1289           // we must accept either 'declarator' or 'abstract-declarator' here.
1290           Declarator ParmDecl(DS, Declarator::PrototypeContext);
1291           ParseDeclarator(ParmDecl);
1292
1293           // Inform the actions module about the parameter declarator, so it
1294           // gets added to the current scope.
1295           FirstPart = Actions.ActOnParamDeclarator(CurScope, ParmDecl);
1296         } else
1297           ConsumeToken(); // consume '...'
1298
1299         SourceLocation RParenLoc;
1300
1301         if (Tok.is(tok::r_paren))
1302           RParenLoc = ConsumeParen();
1303         else // Skip over garbage, until we get to ')'.  Eat the ')'.
1304           SkipUntil(tok::r_paren, true, false);
1305
1306         OwningStmtResult CatchBody(Actions, true);
1307         if (Tok.is(tok::l_brace))
1308           CatchBody = ParseCompoundStatementBody();
1309         else
1310           Diag(Tok, diag::err_expected_lbrace);
1311         if (CatchBody.isInvalid())
1312           CatchBody = Actions.ActOnNullStmt(Tok.getLocation());
1313         CatchStmts = Actions.ActOnObjCAtCatchStmt(AtCatchFinallyLoc,
1314                         RParenLoc, FirstPart, move(CatchBody),
1315                         move(CatchStmts));
1316       } else {
1317         Diag(AtCatchFinallyLoc, diag::err_expected_lparen_after)
1318           << "@catch clause";
1319         return StmtError();
1320       }
1321       catch_or_finally_seen = true;
1322     } else {
1323       assert(Tok.isObjCAtKeyword(tok::objc_finally) && "Lookahead confused?");
1324       ConsumeToken(); // consume finally
1325       ParseScope FinallyScope(this, Scope::DeclScope);
1326
1327       OwningStmtResult FinallyBody(Actions, true);
1328       if (Tok.is(tok::l_brace))
1329         FinallyBody = ParseCompoundStatementBody();
1330       else
1331         Diag(Tok, diag::err_expected_lbrace);
1332       if (FinallyBody.isInvalid())
1333         FinallyBody = Actions.ActOnNullStmt(Tok.getLocation());
1334       FinallyStmt = Actions.ActOnObjCAtFinallyStmt(AtCatchFinallyLoc,
1335                                                    move(FinallyBody));
1336       catch_or_finally_seen = true;
1337       break;
1338     }
1339   }
1340   if (!catch_or_finally_seen) {
1341     Diag(atLoc, diag::err_missing_catch_finally);
1342     return StmtError();
1343   }
1344   return Actions.ActOnObjCAtTryStmt(atLoc, move(TryBody), move(CatchStmts),
1345                                     move(FinallyStmt));
1346 }
1347
1348 ///   objc-method-def: objc-method-proto ';'[opt] '{' body '}'
1349 ///
1350 Parser::DeclPtrTy Parser::ParseObjCMethodDefinition() {
1351   DeclPtrTy MDecl = ParseObjCMethodPrototype(ObjCImpDecl);
1352
1353   PrettyStackTraceActionsDecl CrashInfo(MDecl, Tok.getLocation(), Actions,
1354                                         PP.getSourceManager(),
1355                                         "parsing Objective-C method");
1356
1357   // parse optional ';'
1358   if (Tok.is(tok::semi))
1359     ConsumeToken();
1360
1361   // We should have an opening brace now.
1362   if (Tok.isNot(tok::l_brace)) {
1363     Diag(Tok, diag::err_expected_method_body);
1364
1365     // Skip over garbage, until we get to '{'.  Don't eat the '{'.
1366     SkipUntil(tok::l_brace, true, true);
1367
1368     // If we didn't find the '{', bail out.
1369     if (Tok.isNot(tok::l_brace))
1370       return DeclPtrTy();
1371   }
1372   SourceLocation BraceLoc = Tok.getLocation();
1373
1374   // Enter a scope for the method body.
1375   ParseScope BodyScope(this, Scope::FnScope|Scope::DeclScope);
1376
1377   // Tell the actions module that we have entered a method definition with the
1378   // specified Declarator for the method.
1379   Actions.ActOnStartOfObjCMethodDef(CurScope, MDecl);
1380
1381   OwningStmtResult FnBody(ParseCompoundStatementBody());
1382
1383   // If the function body could not be parsed, make a bogus compoundstmt.
1384   if (FnBody.isInvalid())
1385     FnBody = Actions.ActOnCompoundStmt(BraceLoc, BraceLoc,
1386                                        MultiStmtArg(Actions), false);
1387
1388   // TODO: Pass argument information.
1389   Actions.ActOnFinishFunctionBody(MDecl, move(FnBody));
1390
1391   // Leave the function body scope.
1392   BodyScope.Exit();
1393
1394   return MDecl;
1395 }
1396
1397 Parser::OwningStmtResult Parser::ParseObjCAtStatement(SourceLocation AtLoc) {
1398   if (Tok.isObjCAtKeyword(tok::objc_try)) {
1399     return ParseObjCTryStmt(AtLoc);
1400   } else if (Tok.isObjCAtKeyword(tok::objc_throw))
1401     return ParseObjCThrowStmt(AtLoc);
1402   else if (Tok.isObjCAtKeyword(tok::objc_synchronized))
1403     return ParseObjCSynchronizedStmt(AtLoc);
1404   OwningExprResult Res(ParseExpressionWithLeadingAt(AtLoc));
1405   if (Res.isInvalid()) {
1406     // If the expression is invalid, skip ahead to the next semicolon. Not
1407     // doing this opens us up to the possibility of infinite loops if
1408     // ParseExpression does not consume any tokens.
1409     SkipUntil(tok::semi);
1410     return StmtError();
1411   }
1412   // Otherwise, eat the semicolon.
1413   ExpectAndConsume(tok::semi, diag::err_expected_semi_after_expr);
1414   return Actions.ActOnExprStmt(Actions.FullExpr(Res));
1415 }
1416
1417 Parser::OwningExprResult Parser::ParseObjCAtExpression(SourceLocation AtLoc) {
1418   switch (Tok.getKind()) {
1419   case tok::string_literal:    // primary-expression: string-literal
1420   case tok::wide_string_literal:
1421     return ParsePostfixExpressionSuffix(ParseObjCStringLiteral(AtLoc));
1422   default:
1423     if (Tok.getIdentifierInfo() == 0)
1424       return ExprError(Diag(AtLoc, diag::err_unexpected_at));
1425
1426     switch (Tok.getIdentifierInfo()->getObjCKeywordID()) {
1427     case tok::objc_encode:
1428       return ParsePostfixExpressionSuffix(ParseObjCEncodeExpression(AtLoc));
1429     case tok::objc_protocol:
1430       return ParsePostfixExpressionSuffix(ParseObjCProtocolExpression(AtLoc));
1431     case tok::objc_selector:
1432       return ParsePostfixExpressionSuffix(ParseObjCSelectorExpression(AtLoc));
1433     default:
1434       return ExprError(Diag(AtLoc, diag::err_unexpected_at));
1435     }
1436   }
1437 }
1438
1439 ///   objc-message-expr:
1440 ///     '[' objc-receiver objc-message-args ']'
1441 ///
1442 ///   objc-receiver:
1443 ///     expression
1444 ///     class-name
1445 ///     type-name
1446 Parser::OwningExprResult Parser::ParseObjCMessageExpression() {
1447   assert(Tok.is(tok::l_square) && "'[' expected");
1448   SourceLocation LBracLoc = ConsumeBracket(); // consume '['
1449
1450   // Parse receiver
1451   if (isTokObjCMessageIdentifierReceiver()) {
1452     IdentifierInfo *ReceiverName = Tok.getIdentifierInfo();
1453     if (ReceiverName != Ident_super || GetLookAheadToken(1).isNot(tok::period)) {
1454       SourceLocation NameLoc = ConsumeToken();
1455       return ParseObjCMessageExpressionBody(LBracLoc, NameLoc, ReceiverName,
1456                                             ExprArg(Actions));
1457     }
1458   }
1459
1460   OwningExprResult Res(ParseExpression());
1461   if (Res.isInvalid()) {
1462     SkipUntil(tok::r_square);
1463     return move(Res);
1464   }
1465
1466   return ParseObjCMessageExpressionBody(LBracLoc, SourceLocation(),
1467                                         0, move(Res));
1468 }
1469
1470 /// ParseObjCMessageExpressionBody - Having parsed "'[' objc-receiver", parse
1471 /// the rest of a message expression.
1472 ///
1473 ///   objc-message-args:
1474 ///     objc-selector
1475 ///     objc-keywordarg-list
1476 ///
1477 ///   objc-keywordarg-list:
1478 ///     objc-keywordarg
1479 ///     objc-keywordarg-list objc-keywordarg
1480 ///
1481 ///   objc-keywordarg:
1482 ///     selector-name[opt] ':' objc-keywordexpr
1483 ///
1484 ///   objc-keywordexpr:
1485 ///     nonempty-expr-list
1486 ///
1487 ///   nonempty-expr-list:
1488 ///     assignment-expression
1489 ///     nonempty-expr-list , assignment-expression
1490 ///
1491 Parser::OwningExprResult
1492 Parser::ParseObjCMessageExpressionBody(SourceLocation LBracLoc,
1493                                        SourceLocation NameLoc,
1494                                        IdentifierInfo *ReceiverName,
1495                                        ExprArg ReceiverExpr) {
1496   // Parse objc-selector
1497   SourceLocation Loc;
1498   IdentifierInfo *selIdent = ParseObjCSelectorPiece(Loc);
1499
1500   SourceLocation SelectorLoc = Loc;
1501
1502   llvm::SmallVector<IdentifierInfo *, 12> KeyIdents;
1503   ExprVector KeyExprs(Actions);
1504
1505   if (Tok.is(tok::colon)) {
1506     while (1) {
1507       // Each iteration parses a single keyword argument.
1508       KeyIdents.push_back(selIdent);
1509
1510       if (Tok.isNot(tok::colon)) {
1511         Diag(Tok, diag::err_expected_colon);
1512         // We must manually skip to a ']', otherwise the expression skipper will
1513         // stop at the ']' when it skips to the ';'.  We want it to skip beyond
1514         // the enclosing expression.
1515         SkipUntil(tok::r_square);
1516         return ExprError();
1517       }
1518
1519       ConsumeToken(); // Eat the ':'.
1520       ///  Parse the expression after ':'
1521       OwningExprResult Res(ParseAssignmentExpression());
1522       if (Res.isInvalid()) {
1523         // We must manually skip to a ']', otherwise the expression skipper will
1524         // stop at the ']' when it skips to the ';'.  We want it to skip beyond
1525         // the enclosing expression.
1526         SkipUntil(tok::r_square);
1527         return move(Res);
1528       }
1529
1530       // We have a valid expression.
1531       KeyExprs.push_back(Res.release());
1532
1533       // Check for another keyword selector.
1534       selIdent = ParseObjCSelectorPiece(Loc);
1535       if (!selIdent && Tok.isNot(tok::colon))
1536         break;
1537       // We have a selector or a colon, continue parsing.
1538     }
1539     // Parse the, optional, argument list, comma separated.
1540     while (Tok.is(tok::comma)) {
1541       ConsumeToken(); // Eat the ','.
1542       ///  Parse the expression after ','
1543       OwningExprResult Res(ParseAssignmentExpression());
1544       if (Res.isInvalid()) {
1545         // We must manually skip to a ']', otherwise the expression skipper will
1546         // stop at the ']' when it skips to the ';'.  We want it to skip beyond
1547         // the enclosing expression.
1548         SkipUntil(tok::r_square);
1549         return move(Res);
1550       }
1551
1552       // We have a valid expression.
1553       KeyExprs.push_back(Res.release());
1554     }
1555   } else if (!selIdent) {
1556     Diag(Tok, diag::err_expected_ident); // missing selector name.
1557
1558     // We must manually skip to a ']', otherwise the expression skipper will
1559     // stop at the ']' when it skips to the ';'.  We want it to skip beyond
1560     // the enclosing expression.
1561     SkipUntil(tok::r_square);
1562     return ExprError();
1563   }
1564
1565   if (Tok.isNot(tok::r_square)) {
1566     Diag(Tok, diag::err_expected_rsquare);
1567     // We must manually skip to a ']', otherwise the expression skipper will
1568     // stop at the ']' when it skips to the ';'.  We want it to skip beyond
1569     // the enclosing expression.
1570     SkipUntil(tok::r_square);
1571     return ExprError();
1572   }
1573
1574   SourceLocation RBracLoc = ConsumeBracket(); // consume ']'
1575
1576   unsigned nKeys = KeyIdents.size();
1577   if (nKeys == 0)
1578     KeyIdents.push_back(selIdent);
1579   Selector Sel = PP.getSelectorTable().getSelector(nKeys, &KeyIdents[0]);
1580
1581   // We've just parsed a keyword message.
1582   if (ReceiverName)
1583     return Owned(Actions.ActOnClassMessage(CurScope, ReceiverName, Sel,
1584                                            LBracLoc, NameLoc, SelectorLoc,
1585                                            RBracLoc,
1586                                            KeyExprs.take(), KeyExprs.size()));
1587   return Owned(Actions.ActOnInstanceMessage(ReceiverExpr.release(), Sel,
1588                                             LBracLoc, SelectorLoc, RBracLoc,
1589                                             KeyExprs.take(), KeyExprs.size()));
1590 }
1591
1592 Parser::OwningExprResult Parser::ParseObjCStringLiteral(SourceLocation AtLoc) {
1593   OwningExprResult Res(ParseStringLiteralExpression());
1594   if (Res.isInvalid()) return move(Res);
1595
1596   // @"foo" @"bar" is a valid concatenated string.  Eat any subsequent string
1597   // expressions.  At this point, we know that the only valid thing that starts
1598   // with '@' is an @"".
1599   llvm::SmallVector<SourceLocation, 4> AtLocs;
1600   ExprVector AtStrings(Actions);
1601   AtLocs.push_back(AtLoc);
1602   AtStrings.push_back(Res.release());
1603
1604   while (Tok.is(tok::at)) {
1605     AtLocs.push_back(ConsumeToken()); // eat the @.
1606
1607     // Invalid unless there is a string literal.
1608     if (!isTokenStringLiteral())
1609       return ExprError(Diag(Tok, diag::err_objc_concat_string));
1610
1611     OwningExprResult Lit(ParseStringLiteralExpression());
1612     if (Lit.isInvalid())
1613       return move(Lit);
1614
1615     AtStrings.push_back(Lit.release());
1616   }
1617
1618   return Owned(Actions.ParseObjCStringLiteral(&AtLocs[0], AtStrings.take(),
1619                                               AtStrings.size()));
1620 }
1621
1622 ///    objc-encode-expression:
1623 ///      @encode ( type-name )
1624 Parser::OwningExprResult
1625 Parser::ParseObjCEncodeExpression(SourceLocation AtLoc) {
1626   assert(Tok.isObjCAtKeyword(tok::objc_encode) && "Not an @encode expression!");
1627
1628   SourceLocation EncLoc = ConsumeToken();
1629
1630   if (Tok.isNot(tok::l_paren))
1631     return ExprError(Diag(Tok, diag::err_expected_lparen_after) << "@encode");
1632
1633   SourceLocation LParenLoc = ConsumeParen();
1634
1635   TypeResult Ty = ParseTypeName();
1636
1637   SourceLocation RParenLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc);
1638
1639   if (Ty.isInvalid())
1640     return ExprError();
1641
1642   return Owned(Actions.ParseObjCEncodeExpression(AtLoc, EncLoc, LParenLoc,
1643                                                  Ty.get(), RParenLoc));
1644 }
1645
1646 ///     objc-protocol-expression
1647 ///       @protocol ( protocol-name )
1648 Parser::OwningExprResult
1649 Parser::ParseObjCProtocolExpression(SourceLocation AtLoc) {
1650   SourceLocation ProtoLoc = ConsumeToken();
1651
1652   if (Tok.isNot(tok::l_paren))
1653     return ExprError(Diag(Tok, diag::err_expected_lparen_after) << "@protocol");
1654
1655   SourceLocation LParenLoc = ConsumeParen();
1656
1657   if (Tok.isNot(tok::identifier))
1658     return ExprError(Diag(Tok, diag::err_expected_ident));
1659
1660   IdentifierInfo *protocolId = Tok.getIdentifierInfo();
1661   ConsumeToken();
1662
1663   SourceLocation RParenLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc);
1664
1665   return Owned(Actions.ParseObjCProtocolExpression(protocolId, AtLoc, ProtoLoc,
1666                                                    LParenLoc, RParenLoc));
1667 }
1668
1669 ///     objc-selector-expression
1670 ///       @selector '(' objc-keyword-selector ')'
1671 Parser::OwningExprResult
1672 Parser::ParseObjCSelectorExpression(SourceLocation AtLoc) {
1673   SourceLocation SelectorLoc = ConsumeToken();
1674
1675   if (Tok.isNot(tok::l_paren))
1676     return ExprError(Diag(Tok, diag::err_expected_lparen_after) << "@selector");
1677
1678   llvm::SmallVector<IdentifierInfo *, 12> KeyIdents;
1679   SourceLocation LParenLoc = ConsumeParen();
1680   SourceLocation sLoc;
1681   IdentifierInfo *SelIdent = ParseObjCSelectorPiece(sLoc);
1682   if (!SelIdent && Tok.isNot(tok::colon)) // missing selector name.
1683     return ExprError(Diag(Tok, diag::err_expected_ident));
1684
1685   KeyIdents.push_back(SelIdent);
1686   unsigned nColons = 0;
1687   if (Tok.isNot(tok::r_paren)) {
1688     while (1) {
1689       if (Tok.isNot(tok::colon))
1690         return ExprError(Diag(Tok, diag::err_expected_colon));
1691
1692       nColons++;
1693       ConsumeToken(); // Eat the ':'.
1694       if (Tok.is(tok::r_paren))
1695         break;
1696       // Check for another keyword selector.
1697       SourceLocation Loc;
1698       SelIdent = ParseObjCSelectorPiece(Loc);
1699       KeyIdents.push_back(SelIdent);
1700       if (!SelIdent && Tok.isNot(tok::colon))
1701         break;
1702     }
1703   }
1704   SourceLocation RParenLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc);
1705   Selector Sel = PP.getSelectorTable().getSelector(nColons, &KeyIdents[0]);
1706   return Owned(Actions.ParseObjCSelectorExpression(Sel, AtLoc, SelectorLoc,
1707                                                    LParenLoc, RParenLoc));
1708  }