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