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