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