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