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