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