clang  7.0.0
ParseObjc.cpp
Go to the documentation of this file.
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 "clang/AST/ASTContext.h"
17 #include "clang/Basic/CharInfo.h"
20 #include "clang/Sema/DeclSpec.h"
21 #include "clang/Sema/Scope.h"
22 #include "llvm/ADT/SmallVector.h"
23 #include "llvm/ADT/StringExtras.h"
24 
25 using namespace clang;
26 
27 /// Skips attributes after an Objective-C @ directive. Emits a diagnostic.
28 void Parser::MaybeSkipAttributes(tok::ObjCKeywordKind Kind) {
29  ParsedAttributes attrs(AttrFactory);
30  if (Tok.is(tok::kw___attribute)) {
31  if (Kind == tok::objc_interface || Kind == tok::objc_protocol)
32  Diag(Tok, diag::err_objc_postfix_attribute_hint)
33  << (Kind == tok::objc_protocol);
34  else
35  Diag(Tok, diag::err_objc_postfix_attribute);
36  ParseGNUAttributes(attrs);
37  }
38 }
39 
40 /// ParseObjCAtDirectives - Handle parts of the external-declaration production:
41 /// external-declaration: [C99 6.9]
42 /// [OBJC] objc-class-definition
43 /// [OBJC] objc-class-declaration
44 /// [OBJC] objc-alias-declaration
45 /// [OBJC] objc-protocol-definition
46 /// [OBJC] objc-method-definition
47 /// [OBJC] '@' 'end'
49 Parser::ParseObjCAtDirectives(ParsedAttributesWithRange &Attrs) {
50  SourceLocation AtLoc = ConsumeToken(); // the "@"
51 
52  if (Tok.is(tok::code_completion)) {
54  cutOffParsing();
55  return nullptr;
56  }
57 
58  Decl *SingleDecl = nullptr;
59  switch (Tok.getObjCKeywordID()) {
60  case tok::objc_class:
61  return ParseObjCAtClassDeclaration(AtLoc);
62  case tok::objc_interface:
63  SingleDecl = ParseObjCAtInterfaceDeclaration(AtLoc, Attrs);
64  break;
65  case tok::objc_protocol:
66  return ParseObjCAtProtocolDeclaration(AtLoc, Attrs);
67  case tok::objc_implementation:
68  return ParseObjCAtImplementationDeclaration(AtLoc);
69  case tok::objc_end:
70  return ParseObjCAtEndDeclaration(AtLoc);
71  case tok::objc_compatibility_alias:
72  SingleDecl = ParseObjCAtAliasDeclaration(AtLoc);
73  break;
74  case tok::objc_synthesize:
75  SingleDecl = ParseObjCPropertySynthesize(AtLoc);
76  break;
77  case tok::objc_dynamic:
78  SingleDecl = ParseObjCPropertyDynamic(AtLoc);
79  break;
80  case tok::objc_import:
81  if (getLangOpts().Modules || getLangOpts().DebuggerSupport) {
82  SingleDecl = ParseModuleImport(AtLoc);
83  break;
84  }
85  Diag(AtLoc, diag::err_atimport);
86  SkipUntil(tok::semi);
87  return Actions.ConvertDeclToDeclGroup(nullptr);
88  default:
89  Diag(AtLoc, diag::err_unexpected_at);
90  SkipUntil(tok::semi);
91  SingleDecl = nullptr;
92  break;
93  }
94  return Actions.ConvertDeclToDeclGroup(SingleDecl);
95 }
96 
97 /// Class to handle popping type parameters when leaving the scope.
99  Sema &Actions;
100  Scope *S;
101  ObjCTypeParamList *Params;
102 
103 public:
105  : Actions(Actions), S(S), Params(nullptr) {}
106 
108  leave();
109  }
110 
112  assert(!Params);
113  Params = P;
114  }
115 
116  void leave() {
117  if (Params)
118  Actions.popObjCTypeParamList(S, Params);
119  Params = nullptr;
120  }
121 };
122 
123 ///
124 /// objc-class-declaration:
125 /// '@' 'class' objc-class-forward-decl (',' objc-class-forward-decl)* ';'
126 ///
127 /// objc-class-forward-decl:
128 /// identifier objc-type-parameter-list[opt]
129 ///
131 Parser::ParseObjCAtClassDeclaration(SourceLocation atLoc) {
132  ConsumeToken(); // the identifier "class"
135  SmallVector<ObjCTypeParamList *, 8> ClassTypeParams;
136 
137  while (1) {
138  MaybeSkipAttributes(tok::objc_class);
139  if (expectIdentifier()) {
140  SkipUntil(tok::semi);
141  return Actions.ConvertDeclToDeclGroup(nullptr);
142  }
143  ClassNames.push_back(Tok.getIdentifierInfo());
144  ClassLocs.push_back(Tok.getLocation());
145  ConsumeToken();
146 
147  // Parse the optional objc-type-parameter-list.
148  ObjCTypeParamList *TypeParams = nullptr;
149  if (Tok.is(tok::less))
150  TypeParams = parseObjCTypeParamList();
151  ClassTypeParams.push_back(TypeParams);
152  if (!TryConsumeToken(tok::comma))
153  break;
154  }
155 
156  // Consume the ';'.
157  if (ExpectAndConsume(tok::semi, diag::err_expected_after, "@class"))
158  return Actions.ConvertDeclToDeclGroup(nullptr);
159 
160  return Actions.ActOnForwardClassDeclaration(atLoc, ClassNames.data(),
161  ClassLocs.data(),
162  ClassTypeParams,
163  ClassNames.size());
164 }
165 
166 void Parser::CheckNestedObjCContexts(SourceLocation AtLoc)
167 {
168  Sema::ObjCContainerKind ock = Actions.getObjCContainerKind();
169  if (ock == Sema::OCK_None)
170  return;
171 
172  Decl *Decl = Actions.getObjCDeclContext();
173  if (CurParsedObjCImpl) {
174  CurParsedObjCImpl->finish(AtLoc);
175  } else {
176  Actions.ActOnAtEnd(getCurScope(), AtLoc);
177  }
178  Diag(AtLoc, diag::err_objc_missing_end)
179  << FixItHint::CreateInsertion(AtLoc, "@end\n");
180  if (Decl)
181  Diag(Decl->getLocStart(), diag::note_objc_container_start)
182  << (int) ock;
183 }
184 
185 ///
186 /// objc-interface:
187 /// objc-class-interface-attributes[opt] objc-class-interface
188 /// objc-category-interface
189 ///
190 /// objc-class-interface:
191 /// '@' 'interface' identifier objc-type-parameter-list[opt]
192 /// objc-superclass[opt] objc-protocol-refs[opt]
193 /// objc-class-instance-variables[opt]
194 /// objc-interface-decl-list
195 /// @end
196 ///
197 /// objc-category-interface:
198 /// '@' 'interface' identifier objc-type-parameter-list[opt]
199 /// '(' identifier[opt] ')' objc-protocol-refs[opt]
200 /// objc-interface-decl-list
201 /// @end
202 ///
203 /// objc-superclass:
204 /// ':' identifier objc-type-arguments[opt]
205 ///
206 /// objc-class-interface-attributes:
207 /// __attribute__((visibility("default")))
208 /// __attribute__((visibility("hidden")))
209 /// __attribute__((deprecated))
210 /// __attribute__((unavailable))
211 /// __attribute__((objc_exception)) - used by NSException on 64-bit
212 /// __attribute__((objc_root_class))
213 ///
214 Decl *Parser::ParseObjCAtInterfaceDeclaration(SourceLocation AtLoc,
215  ParsedAttributes &attrs) {
216  assert(Tok.isObjCAtKeyword(tok::objc_interface) &&
217  "ParseObjCAtInterfaceDeclaration(): Expected @interface");
218  CheckNestedObjCContexts(AtLoc);
219  ConsumeToken(); // the "interface" identifier
220 
221  // Code completion after '@interface'.
222  if (Tok.is(tok::code_completion)) {
223  Actions.CodeCompleteObjCInterfaceDecl(getCurScope());
224  cutOffParsing();
225  return nullptr;
226  }
227 
228  MaybeSkipAttributes(tok::objc_interface);
229 
230  if (expectIdentifier())
231  return nullptr; // missing class or category name.
232 
233  // We have a class or category name - consume it.
234  IdentifierInfo *nameId = Tok.getIdentifierInfo();
235  SourceLocation nameLoc = ConsumeToken();
236 
237  // Parse the objc-type-parameter-list or objc-protocol-refs. For the latter
238  // case, LAngleLoc will be valid and ProtocolIdents will capture the
239  // protocol references (that have not yet been resolved).
240  SourceLocation LAngleLoc, EndProtoLoc;
241  SmallVector<IdentifierLocPair, 8> ProtocolIdents;
242  ObjCTypeParamList *typeParameterList = nullptr;
243  ObjCTypeParamListScope typeParamScope(Actions, getCurScope());
244  if (Tok.is(tok::less))
245  typeParameterList = parseObjCTypeParamListOrProtocolRefs(
246  typeParamScope, LAngleLoc, ProtocolIdents, EndProtoLoc);
247 
248  if (Tok.is(tok::l_paren) &&
249  !isKnownToBeTypeSpecifier(GetLookAheadToken(1))) { // we have a category.
250 
251  BalancedDelimiterTracker T(*this, tok::l_paren);
252  T.consumeOpen();
253 
254  SourceLocation categoryLoc;
255  IdentifierInfo *categoryId = nullptr;
256  if (Tok.is(tok::code_completion)) {
257  Actions.CodeCompleteObjCInterfaceCategory(getCurScope(), nameId, nameLoc);
258  cutOffParsing();
259  return nullptr;
260  }
261 
262  // For ObjC2, the category name is optional (not an error).
263  if (Tok.is(tok::identifier)) {
264  categoryId = Tok.getIdentifierInfo();
265  categoryLoc = ConsumeToken();
266  }
267  else if (!getLangOpts().ObjC2) {
268  Diag(Tok, diag::err_expected)
269  << tok::identifier; // missing category name.
270  return nullptr;
271  }
272 
273  T.consumeClose();
274  if (T.getCloseLocation().isInvalid())
275  return nullptr;
276 
277  // Next, we need to check for any protocol references.
278  assert(LAngleLoc.isInvalid() && "Cannot have already parsed protocols");
279  SmallVector<Decl *, 8> ProtocolRefs;
280  SmallVector<SourceLocation, 8> ProtocolLocs;
281  if (Tok.is(tok::less) &&
282  ParseObjCProtocolReferences(ProtocolRefs, ProtocolLocs, true, true,
283  LAngleLoc, EndProtoLoc,
284  /*consumeLastToken=*/true))
285  return nullptr;
286 
287  Decl *CategoryType = Actions.ActOnStartCategoryInterface(
288  AtLoc, nameId, nameLoc, typeParameterList, categoryId, categoryLoc,
289  ProtocolRefs.data(), ProtocolRefs.size(), ProtocolLocs.data(),
290  EndProtoLoc, attrs);
291 
292  if (Tok.is(tok::l_brace))
293  ParseObjCClassInstanceVariables(CategoryType, tok::objc_private, AtLoc);
294 
295  ParseObjCInterfaceDeclList(tok::objc_not_keyword, CategoryType);
296 
297  return CategoryType;
298  }
299  // Parse a class interface.
300  IdentifierInfo *superClassId = nullptr;
301  SourceLocation superClassLoc;
302  SourceLocation typeArgsLAngleLoc;
304  SourceLocation typeArgsRAngleLoc;
305  SmallVector<Decl *, 4> protocols;
306  SmallVector<SourceLocation, 4> protocolLocs;
307  if (Tok.is(tok::colon)) { // a super class is specified.
308  ConsumeToken();
309 
310  // Code completion of superclass names.
311  if (Tok.is(tok::code_completion)) {
312  Actions.CodeCompleteObjCSuperclass(getCurScope(), nameId, nameLoc);
313  cutOffParsing();
314  return nullptr;
315  }
316 
317  if (expectIdentifier())
318  return nullptr; // missing super class name.
319  superClassId = Tok.getIdentifierInfo();
320  superClassLoc = ConsumeToken();
321 
322  // Type arguments for the superclass or protocol conformances.
323  if (Tok.is(tok::less)) {
324  parseObjCTypeArgsOrProtocolQualifiers(
325  nullptr, typeArgsLAngleLoc, typeArgs, typeArgsRAngleLoc, LAngleLoc,
326  protocols, protocolLocs, EndProtoLoc,
327  /*consumeLastToken=*/true,
328  /*warnOnIncompleteProtocols=*/true);
329  if (Tok.is(tok::eof))
330  return nullptr;
331  }
332  }
333 
334  // Next, we need to check for any protocol references.
335  if (LAngleLoc.isValid()) {
336  if (!ProtocolIdents.empty()) {
337  // We already parsed the protocols named when we thought we had a
338  // type parameter list. Translate them into actual protocol references.
339  for (const auto &pair : ProtocolIdents) {
340  protocolLocs.push_back(pair.second);
341  }
342  Actions.FindProtocolDeclaration(/*WarnOnDeclarations=*/true,
343  /*ForObjCContainer=*/true,
344  ProtocolIdents, protocols);
345  }
346  } else if (protocols.empty() && Tok.is(tok::less) &&
347  ParseObjCProtocolReferences(protocols, protocolLocs, true, true,
348  LAngleLoc, EndProtoLoc,
349  /*consumeLastToken=*/true)) {
350  return nullptr;
351  }
352 
353  if (Tok.isNot(tok::less))
354  Actions.ActOnTypedefedProtocols(protocols, protocolLocs,
355  superClassId, superClassLoc);
356 
357  Decl *ClsType = Actions.ActOnStartClassInterface(
358  getCurScope(), AtLoc, nameId, nameLoc, typeParameterList, superClassId,
359  superClassLoc, typeArgs,
360  SourceRange(typeArgsLAngleLoc, typeArgsRAngleLoc), protocols.data(),
361  protocols.size(), protocolLocs.data(), EndProtoLoc, attrs);
362 
363  if (Tok.is(tok::l_brace))
364  ParseObjCClassInstanceVariables(ClsType, tok::objc_protected, AtLoc);
365 
366  ParseObjCInterfaceDeclList(tok::objc_interface, ClsType);
367 
368  return ClsType;
369 }
370 
371 /// Add an attribute for a context-sensitive type nullability to the given
372 /// declarator.
374  Declarator &D,
375  NullabilityKind nullability,
376  SourceLocation nullabilityLoc,
377  bool &addedToDeclSpec) {
378  // Create the attribute.
379  auto getNullabilityAttr = [&](AttributePool &Pool) -> ParsedAttr * {
380  return Pool.create(P.getNullabilityKeyword(nullability),
381  SourceRange(nullabilityLoc), nullptr, SourceLocation(),
383  };
384 
385  if (D.getNumTypeObjects() > 0) {
386  // Add the attribute to the declarator chunk nearest the declarator.
388  getNullabilityAttr(D.getAttributePool()));
389  } else if (!addedToDeclSpec) {
390  // Otherwise, just put it on the declaration specifiers (if one
391  // isn't there already).
393  getNullabilityAttr(D.getMutableDeclSpec().getAttributes().getPool()));
394  addedToDeclSpec = true;
395  }
396 }
397 
398 /// Parse an Objective-C type parameter list, if present, or capture
399 /// the locations of the protocol identifiers for a list of protocol
400 /// references.
401 ///
402 /// objc-type-parameter-list:
403 /// '<' objc-type-parameter (',' objc-type-parameter)* '>'
404 ///
405 /// objc-type-parameter:
406 /// objc-type-parameter-variance? identifier objc-type-parameter-bound[opt]
407 ///
408 /// objc-type-parameter-bound:
409 /// ':' type-name
410 ///
411 /// objc-type-parameter-variance:
412 /// '__covariant'
413 /// '__contravariant'
414 ///
415 /// \param lAngleLoc The location of the starting '<'.
416 ///
417 /// \param protocolIdents Will capture the list of identifiers, if the
418 /// angle brackets contain a list of protocol references rather than a
419 /// type parameter list.
420 ///
421 /// \param rAngleLoc The location of the ending '>'.
422 ObjCTypeParamList *Parser::parseObjCTypeParamListOrProtocolRefs(
423  ObjCTypeParamListScope &Scope, SourceLocation &lAngleLoc,
424  SmallVectorImpl<IdentifierLocPair> &protocolIdents,
425  SourceLocation &rAngleLoc, bool mayBeProtocolList) {
426  assert(Tok.is(tok::less) && "Not at the beginning of a type parameter list");
427 
428  // Within the type parameter list, don't treat '>' as an operator.
429  GreaterThanIsOperatorScope G(GreaterThanIsOperator, false);
430 
431  // Local function to "flush" the protocol identifiers, turning them into
432  // type parameters.
433  SmallVector<Decl *, 4> typeParams;
434  auto makeProtocolIdentsIntoTypeParameters = [&]() {
435  unsigned index = 0;
436  for (const auto &pair : protocolIdents) {
437  DeclResult typeParam = Actions.actOnObjCTypeParam(
439  index++, pair.first, pair.second, SourceLocation(), nullptr);
440  if (typeParam.isUsable())
441  typeParams.push_back(typeParam.get());
442  }
443 
444  protocolIdents.clear();
445  mayBeProtocolList = false;
446  };
447 
448  bool invalid = false;
449  lAngleLoc = ConsumeToken();
450 
451  do {
452  // Parse the variance, if any.
453  SourceLocation varianceLoc;
455  if (Tok.is(tok::kw___covariant) || Tok.is(tok::kw___contravariant)) {
456  variance = Tok.is(tok::kw___covariant)
459  varianceLoc = ConsumeToken();
460 
461  // Once we've seen a variance specific , we know this is not a
462  // list of protocol references.
463  if (mayBeProtocolList) {
464  // Up until now, we have been queuing up parameters because they
465  // might be protocol references. Turn them into parameters now.
466  makeProtocolIdentsIntoTypeParameters();
467  }
468  }
469 
470  // Parse the identifier.
471  if (!Tok.is(tok::identifier)) {
472  // Code completion.
473  if (Tok.is(tok::code_completion)) {
474  // FIXME: If these aren't protocol references, we'll need different
475  // completions.
476  Actions.CodeCompleteObjCProtocolReferences(protocolIdents);
477  cutOffParsing();
478 
479  // FIXME: Better recovery here?.
480  return nullptr;
481  }
482 
483  Diag(Tok, diag::err_objc_expected_type_parameter);
484  invalid = true;
485  break;
486  }
487 
488  IdentifierInfo *paramName = Tok.getIdentifierInfo();
489  SourceLocation paramLoc = ConsumeToken();
490 
491  // If there is a bound, parse it.
492  SourceLocation colonLoc;
493  TypeResult boundType;
494  if (TryConsumeToken(tok::colon, colonLoc)) {
495  // Once we've seen a bound, we know this is not a list of protocol
496  // references.
497  if (mayBeProtocolList) {
498  // Up until now, we have been queuing up parameters because they
499  // might be protocol references. Turn them into parameters now.
500  makeProtocolIdentsIntoTypeParameters();
501  }
502 
503  // type-name
504  boundType = ParseTypeName();
505  if (boundType.isInvalid())
506  invalid = true;
507  } else if (mayBeProtocolList) {
508  // If this could still be a protocol list, just capture the identifier.
509  // We don't want to turn it into a parameter.
510  protocolIdents.push_back(std::make_pair(paramName, paramLoc));
511  continue;
512  }
513 
514  // Create the type parameter.
515  DeclResult typeParam = Actions.actOnObjCTypeParam(
516  getCurScope(), variance, varianceLoc, typeParams.size(), paramName,
517  paramLoc, colonLoc, boundType.isUsable() ? boundType.get() : nullptr);
518  if (typeParam.isUsable())
519  typeParams.push_back(typeParam.get());
520  } while (TryConsumeToken(tok::comma));
521 
522  // Parse the '>'.
523  if (invalid) {
524  SkipUntil(tok::greater, tok::at, StopBeforeMatch);
525  if (Tok.is(tok::greater))
526  ConsumeToken();
527  } else if (ParseGreaterThanInTemplateList(rAngleLoc,
528  /*ConsumeLastToken=*/true,
529  /*ObjCGenericList=*/true)) {
530  Diag(lAngleLoc, diag::note_matching) << "'<'";
531  SkipUntil({tok::greater, tok::greaterequal, tok::at, tok::minus,
532  tok::minus, tok::plus, tok::colon, tok::l_paren, tok::l_brace,
533  tok::comma, tok::semi },
535  if (Tok.is(tok::greater))
536  ConsumeToken();
537  }
538 
539  if (mayBeProtocolList) {
540  // A type parameter list must be followed by either a ':' (indicating the
541  // presence of a superclass) or a '(' (indicating that this is a category
542  // or extension). This disambiguates between an objc-type-parameter-list
543  // and a objc-protocol-refs.
544  if (Tok.isNot(tok::colon) && Tok.isNot(tok::l_paren)) {
545  // Returning null indicates that we don't have a type parameter list.
546  // The results the caller needs to handle the protocol references are
547  // captured in the reference parameters already.
548  return nullptr;
549  }
550 
551  // We have a type parameter list that looks like a list of protocol
552  // references. Turn that parameter list into type parameters.
553  makeProtocolIdentsIntoTypeParameters();
554  }
555 
556  // Form the type parameter list and enter its scope.
557  ObjCTypeParamList *list = Actions.actOnObjCTypeParamList(
558  getCurScope(),
559  lAngleLoc,
560  typeParams,
561  rAngleLoc);
562  Scope.enter(list);
563 
564  // Clear out the angle locations; they're used by the caller to indicate
565  // whether there are any protocol references.
566  lAngleLoc = SourceLocation();
567  rAngleLoc = SourceLocation();
568  return invalid ? nullptr : list;
569 }
570 
571 /// Parse an objc-type-parameter-list.
572 ObjCTypeParamList *Parser::parseObjCTypeParamList() {
573  SourceLocation lAngleLoc;
574  SmallVector<IdentifierLocPair, 1> protocolIdents;
575  SourceLocation rAngleLoc;
576 
577  ObjCTypeParamListScope Scope(Actions, getCurScope());
578  return parseObjCTypeParamListOrProtocolRefs(Scope, lAngleLoc, protocolIdents,
579  rAngleLoc,
580  /*mayBeProtocolList=*/false);
581 }
582 
583 /// objc-interface-decl-list:
584 /// empty
585 /// objc-interface-decl-list objc-property-decl [OBJC2]
586 /// objc-interface-decl-list objc-method-requirement [OBJC2]
587 /// objc-interface-decl-list objc-method-proto ';'
588 /// objc-interface-decl-list declaration
589 /// objc-interface-decl-list ';'
590 ///
591 /// objc-method-requirement: [OBJC2]
592 /// @required
593 /// @optional
594 ///
595 void Parser::ParseObjCInterfaceDeclList(tok::ObjCKeywordKind contextKey,
596  Decl *CDecl) {
597  SmallVector<Decl *, 32> allMethods;
598  SmallVector<DeclGroupPtrTy, 8> allTUVariables;
599  tok::ObjCKeywordKind MethodImplKind = tok::objc_not_keyword;
600 
601  SourceRange AtEnd;
602 
603  while (1) {
604  // If this is a method prototype, parse it.
605  if (Tok.isOneOf(tok::minus, tok::plus)) {
606  if (Decl *methodPrototype =
607  ParseObjCMethodPrototype(MethodImplKind, false))
608  allMethods.push_back(methodPrototype);
609  // Consume the ';' here, since ParseObjCMethodPrototype() is re-used for
610  // method definitions.
611  if (ExpectAndConsumeSemi(diag::err_expected_semi_after_method_proto)) {
612  // We didn't find a semi and we error'ed out. Skip until a ';' or '@'.
614  if (Tok.is(tok::semi))
615  ConsumeToken();
616  }
617  continue;
618  }
619  if (Tok.is(tok::l_paren)) {
620  Diag(Tok, diag::err_expected_minus_or_plus);
621  ParseObjCMethodDecl(Tok.getLocation(),
622  tok::minus,
623  MethodImplKind, false);
624  continue;
625  }
626  // Ignore excess semicolons.
627  if (Tok.is(tok::semi)) {
628  ConsumeToken();
629  continue;
630  }
631 
632  // If we got to the end of the file, exit the loop.
633  if (isEofOrEom())
634  break;
635 
636  // Code completion within an Objective-C interface.
637  if (Tok.is(tok::code_completion)) {
638  Actions.CodeCompleteOrdinaryName(getCurScope(),
639  CurParsedObjCImpl? Sema::PCC_ObjCImplementation
641  return cutOffParsing();
642  }
643 
644  // If we don't have an @ directive, parse it as a function definition.
645  if (Tok.isNot(tok::at)) {
646  // The code below does not consume '}'s because it is afraid of eating the
647  // end of a namespace. Because of the way this code is structured, an
648  // erroneous r_brace would cause an infinite loop if not handled here.
649  if (Tok.is(tok::r_brace))
650  break;
651  ParsedAttributesWithRange attrs(AttrFactory);
652  allTUVariables.push_back(ParseDeclarationOrFunctionDefinition(attrs));
653  continue;
654  }
655 
656  // Otherwise, we have an @ directive, eat the @.
657  SourceLocation AtLoc = ConsumeToken(); // the "@"
658  if (Tok.is(tok::code_completion)) {
659  Actions.CodeCompleteObjCAtDirective(getCurScope());
660  return cutOffParsing();
661  }
662 
663  tok::ObjCKeywordKind DirectiveKind = Tok.getObjCKeywordID();
664 
665  if (DirectiveKind == tok::objc_end) { // @end -> terminate list
666  AtEnd.setBegin(AtLoc);
667  AtEnd.setEnd(Tok.getLocation());
668  break;
669  } else if (DirectiveKind == tok::objc_not_keyword) {
670  Diag(Tok, diag::err_objc_unknown_at);
671  SkipUntil(tok::semi);
672  continue;
673  }
674 
675  // Eat the identifier.
676  ConsumeToken();
677 
678  switch (DirectiveKind) {
679  default:
680  // FIXME: If someone forgets an @end on a protocol, this loop will
681  // continue to eat up tons of stuff and spew lots of nonsense errors. It
682  // would probably be better to bail out if we saw an @class or @interface
683  // or something like that.
684  Diag(AtLoc, diag::err_objc_illegal_interface_qual);
685  // Skip until we see an '@' or '}' or ';'.
686  SkipUntil(tok::r_brace, tok::at, StopAtSemi);
687  break;
688 
689  case tok::objc_implementation:
690  case tok::objc_interface:
691  Diag(AtLoc, diag::err_objc_missing_end)
692  << FixItHint::CreateInsertion(AtLoc, "@end\n");
693  Diag(CDecl->getLocStart(), diag::note_objc_container_start)
694  << (int) Actions.getObjCContainerKind();
695  ConsumeToken();
696  break;
697 
698  case tok::objc_required:
699  case tok::objc_optional:
700  // This is only valid on protocols.
701  // FIXME: Should this check for ObjC2 being enabled?
702  if (contextKey != tok::objc_protocol)
703  Diag(AtLoc, diag::err_objc_directive_only_in_protocol);
704  else
705  MethodImplKind = DirectiveKind;
706  break;
707 
708  case tok::objc_property:
709  if (!getLangOpts().ObjC2)
710  Diag(AtLoc, diag::err_objc_properties_require_objc2);
711 
712  ObjCDeclSpec OCDS;
713  SourceLocation LParenLoc;
714  // Parse property attribute list, if any.
715  if (Tok.is(tok::l_paren)) {
716  LParenLoc = Tok.getLocation();
717  ParseObjCPropertyAttribute(OCDS);
718  }
719 
720  bool addedToDeclSpec = false;
721  auto ObjCPropertyCallback = [&](ParsingFieldDeclarator &FD) {
722  if (FD.D.getIdentifier() == nullptr) {
723  Diag(AtLoc, diag::err_objc_property_requires_field_name)
724  << FD.D.getSourceRange();
725  return;
726  }
727  if (FD.BitfieldSize) {
728  Diag(AtLoc, diag::err_objc_property_bitfield)
729  << FD.D.getSourceRange();
730  return;
731  }
732 
733  // Map a nullability property attribute to a context-sensitive keyword
734  // attribute.
737  OCDS.getNullabilityLoc(),
738  addedToDeclSpec);
739 
740  // Install the property declarator into interfaceDecl.
741  IdentifierInfo *SelName =
742  OCDS.getGetterName() ? OCDS.getGetterName() : FD.D.getIdentifier();
743 
744  Selector GetterSel = PP.getSelectorTable().getNullarySelector(SelName);
745  IdentifierInfo *SetterName = OCDS.getSetterName();
746  Selector SetterSel;
747  if (SetterName)
748  SetterSel = PP.getSelectorTable().getSelector(1, &SetterName);
749  else
751  PP.getIdentifierTable(), PP.getSelectorTable(),
752  FD.D.getIdentifier());
753  Decl *Property = Actions.ActOnProperty(
754  getCurScope(), AtLoc, LParenLoc, FD, OCDS, GetterSel, SetterSel,
755  MethodImplKind);
756 
757  FD.complete(Property);
758  };
759 
760  // Parse all the comma separated declarators.
761  ParsingDeclSpec DS(*this);
762  ParseStructDeclaration(DS, ObjCPropertyCallback);
763 
764  ExpectAndConsume(tok::semi, diag::err_expected_semi_decl_list);
765  break;
766  }
767  }
768 
769  // We break out of the big loop in two cases: when we see @end or when we see
770  // EOF. In the former case, eat the @end. In the later case, emit an error.
771  if (Tok.is(tok::code_completion)) {
772  Actions.CodeCompleteObjCAtDirective(getCurScope());
773  return cutOffParsing();
774  } else if (Tok.isObjCAtKeyword(tok::objc_end)) {
775  ConsumeToken(); // the "end" identifier
776  } else {
777  Diag(Tok, diag::err_objc_missing_end)
778  << FixItHint::CreateInsertion(Tok.getLocation(), "\n@end\n");
779  Diag(CDecl->getLocStart(), diag::note_objc_container_start)
780  << (int) Actions.getObjCContainerKind();
781  AtEnd.setBegin(Tok.getLocation());
782  AtEnd.setEnd(Tok.getLocation());
783  }
784 
785  // Insert collected methods declarations into the @interface object.
786  // This passes in an invalid SourceLocation for AtEndLoc when EOF is hit.
787  Actions.ActOnAtEnd(getCurScope(), AtEnd, allMethods, allTUVariables);
788 }
789 
790 /// Diagnose redundant or conflicting nullability information.
792  ObjCDeclSpec &DS,
793  NullabilityKind nullability,
794  SourceLocation nullabilityLoc){
795  if (DS.getNullability() == nullability) {
796  P.Diag(nullabilityLoc, diag::warn_nullability_duplicate)
797  << DiagNullabilityKind(nullability, true)
799  return;
800  }
801 
802  P.Diag(nullabilityLoc, diag::err_nullability_conflicting)
803  << DiagNullabilityKind(nullability, true)
804  << DiagNullabilityKind(DS.getNullability(), true)
806 }
807 
808 /// Parse property attribute declarations.
809 ///
810 /// property-attr-decl: '(' property-attrlist ')'
811 /// property-attrlist:
812 /// property-attribute
813 /// property-attrlist ',' property-attribute
814 /// property-attribute:
815 /// getter '=' identifier
816 /// setter '=' identifier ':'
817 /// readonly
818 /// readwrite
819 /// assign
820 /// retain
821 /// copy
822 /// nonatomic
823 /// atomic
824 /// strong
825 /// weak
826 /// unsafe_unretained
827 /// nonnull
828 /// nullable
829 /// null_unspecified
830 /// null_resettable
831 /// class
832 ///
833 void Parser::ParseObjCPropertyAttribute(ObjCDeclSpec &DS) {
834  assert(Tok.getKind() == tok::l_paren);
835  BalancedDelimiterTracker T(*this, tok::l_paren);
836  T.consumeOpen();
837 
838  while (1) {
839  if (Tok.is(tok::code_completion)) {
840  Actions.CodeCompleteObjCPropertyFlags(getCurScope(), DS);
841  return cutOffParsing();
842  }
843  const IdentifierInfo *II = Tok.getIdentifierInfo();
844 
845  // If this is not an identifier at all, bail out early.
846  if (!II) {
847  T.consumeClose();
848  return;
849  }
850 
851  SourceLocation AttrName = ConsumeToken(); // consume last attribute name
852 
853  if (II->isStr("readonly"))
855  else if (II->isStr("assign"))
857  else if (II->isStr("unsafe_unretained"))
859  else if (II->isStr("readwrite"))
861  else if (II->isStr("retain"))
863  else if (II->isStr("strong"))
865  else if (II->isStr("copy"))
867  else if (II->isStr("nonatomic"))
869  else if (II->isStr("atomic"))
871  else if (II->isStr("weak"))
873  else if (II->isStr("getter") || II->isStr("setter")) {
874  bool IsSetter = II->getNameStart()[0] == 's';
875 
876  // getter/setter require extra treatment.
877  unsigned DiagID = IsSetter ? diag::err_objc_expected_equal_for_setter :
878  diag::err_objc_expected_equal_for_getter;
879 
880  if (ExpectAndConsume(tok::equal, DiagID)) {
881  SkipUntil(tok::r_paren, StopAtSemi);
882  return;
883  }
884 
885  if (Tok.is(tok::code_completion)) {
886  if (IsSetter)
887  Actions.CodeCompleteObjCPropertySetter(getCurScope());
888  else
889  Actions.CodeCompleteObjCPropertyGetter(getCurScope());
890  return cutOffParsing();
891  }
892 
893  SourceLocation SelLoc;
894  IdentifierInfo *SelIdent = ParseObjCSelectorPiece(SelLoc);
895 
896  if (!SelIdent) {
897  Diag(Tok, diag::err_objc_expected_selector_for_getter_setter)
898  << IsSetter;
899  SkipUntil(tok::r_paren, StopAtSemi);
900  return;
901  }
902 
903  if (IsSetter) {
905  DS.setSetterName(SelIdent, SelLoc);
906 
907  if (ExpectAndConsume(tok::colon,
908  diag::err_expected_colon_after_setter_name)) {
909  SkipUntil(tok::r_paren, StopAtSemi);
910  return;
911  }
912  } else {
914  DS.setGetterName(SelIdent, SelLoc);
915  }
916  } else if (II->isStr("nonnull")) {
920  Tok.getLocation());
922  DS.setNullability(Tok.getLocation(), NullabilityKind::NonNull);
923  } else if (II->isStr("nullable")) {
927  Tok.getLocation());
929  DS.setNullability(Tok.getLocation(), NullabilityKind::Nullable);
930  } else if (II->isStr("null_unspecified")) {
934  Tok.getLocation());
936  DS.setNullability(Tok.getLocation(), NullabilityKind::Unspecified);
937  } else if (II->isStr("null_resettable")) {
941  Tok.getLocation());
943  DS.setNullability(Tok.getLocation(), NullabilityKind::Unspecified);
944 
945  // Also set the null_resettable bit.
947  } else if (II->isStr("class")) {
949  } else {
950  Diag(AttrName, diag::err_objc_expected_property_attr) << II;
951  SkipUntil(tok::r_paren, StopAtSemi);
952  return;
953  }
954 
955  if (Tok.isNot(tok::comma))
956  break;
957 
958  ConsumeToken();
959  }
960 
961  T.consumeClose();
962 }
963 
964 /// objc-method-proto:
965 /// objc-instance-method objc-method-decl objc-method-attributes[opt]
966 /// objc-class-method objc-method-decl objc-method-attributes[opt]
967 ///
968 /// objc-instance-method: '-'
969 /// objc-class-method: '+'
970 ///
971 /// objc-method-attributes: [OBJC2]
972 /// __attribute__((deprecated))
973 ///
974 Decl *Parser::ParseObjCMethodPrototype(tok::ObjCKeywordKind MethodImplKind,
975  bool MethodDefinition) {
976  assert(Tok.isOneOf(tok::minus, tok::plus) && "expected +/-");
977 
978  tok::TokenKind methodType = Tok.getKind();
979  SourceLocation mLoc = ConsumeToken();
980  Decl *MDecl = ParseObjCMethodDecl(mLoc, methodType, MethodImplKind,
981  MethodDefinition);
982  // Since this rule is used for both method declarations and definitions,
983  // the caller is (optionally) responsible for consuming the ';'.
984  return MDecl;
985 }
986 
987 /// objc-selector:
988 /// identifier
989 /// one of
990 /// enum struct union if else while do for switch case default
991 /// break continue return goto asm sizeof typeof __alignof
992 /// unsigned long const short volatile signed restrict _Complex
993 /// in out inout bycopy byref oneway int char float double void _Bool
994 ///
995 IdentifierInfo *Parser::ParseObjCSelectorPiece(SourceLocation &SelectorLoc) {
996 
997  switch (Tok.getKind()) {
998  default:
999  return nullptr;
1000  case tok::colon:
1001  // Empty selector piece uses the location of the ':'.
1002  SelectorLoc = Tok.getLocation();
1003  return nullptr;
1004  case tok::ampamp:
1005  case tok::ampequal:
1006  case tok::amp:
1007  case tok::pipe:
1008  case tok::tilde:
1009  case tok::exclaim:
1010  case tok::exclaimequal:
1011  case tok::pipepipe:
1012  case tok::pipeequal:
1013  case tok::caret:
1014  case tok::caretequal: {
1015  std::string ThisTok(PP.getSpelling(Tok));
1016  if (isLetter(ThisTok[0])) {
1017  IdentifierInfo *II = &PP.getIdentifierTable().get(ThisTok);
1018  Tok.setKind(tok::identifier);
1019  SelectorLoc = ConsumeToken();
1020  return II;
1021  }
1022  return nullptr;
1023  }
1024 
1025  case tok::identifier:
1026  case tok::kw_asm:
1027  case tok::kw_auto:
1028  case tok::kw_bool:
1029  case tok::kw_break:
1030  case tok::kw_case:
1031  case tok::kw_catch:
1032  case tok::kw_char:
1033  case tok::kw_class:
1034  case tok::kw_const:
1035  case tok::kw_const_cast:
1036  case tok::kw_continue:
1037  case tok::kw_default:
1038  case tok::kw_delete:
1039  case tok::kw_do:
1040  case tok::kw_double:
1041  case tok::kw_dynamic_cast:
1042  case tok::kw_else:
1043  case tok::kw_enum:
1044  case tok::kw_explicit:
1045  case tok::kw_export:
1046  case tok::kw_extern:
1047  case tok::kw_false:
1048  case tok::kw_float:
1049  case tok::kw_for:
1050  case tok::kw_friend:
1051  case tok::kw_goto:
1052  case tok::kw_if:
1053  case tok::kw_inline:
1054  case tok::kw_int:
1055  case tok::kw_long:
1056  case tok::kw_mutable:
1057  case tok::kw_namespace:
1058  case tok::kw_new:
1059  case tok::kw_operator:
1060  case tok::kw_private:
1061  case tok::kw_protected:
1062  case tok::kw_public:
1063  case tok::kw_register:
1064  case tok::kw_reinterpret_cast:
1065  case tok::kw_restrict:
1066  case tok::kw_return:
1067  case tok::kw_short:
1068  case tok::kw_signed:
1069  case tok::kw_sizeof:
1070  case tok::kw_static:
1071  case tok::kw_static_cast:
1072  case tok::kw_struct:
1073  case tok::kw_switch:
1074  case tok::kw_template:
1075  case tok::kw_this:
1076  case tok::kw_throw:
1077  case tok::kw_true:
1078  case tok::kw_try:
1079  case tok::kw_typedef:
1080  case tok::kw_typeid:
1081  case tok::kw_typename:
1082  case tok::kw_typeof:
1083  case tok::kw_union:
1084  case tok::kw_unsigned:
1085  case tok::kw_using:
1086  case tok::kw_virtual:
1087  case tok::kw_void:
1088  case tok::kw_volatile:
1089  case tok::kw_wchar_t:
1090  case tok::kw_while:
1091  case tok::kw__Bool:
1092  case tok::kw__Complex:
1093  case tok::kw___alignof:
1094  case tok::kw___auto_type:
1095  IdentifierInfo *II = Tok.getIdentifierInfo();
1096  SelectorLoc = ConsumeToken();
1097  return II;
1098  }
1099 }
1100 
1101 /// objc-for-collection-in: 'in'
1102 ///
1103 bool Parser::isTokIdentifier_in() const {
1104  // FIXME: May have to do additional look-ahead to only allow for
1105  // valid tokens following an 'in'; such as an identifier, unary operators,
1106  // '[' etc.
1107  return (getLangOpts().ObjC2 && Tok.is(tok::identifier) &&
1108  Tok.getIdentifierInfo() == ObjCTypeQuals[objc_in]);
1109 }
1110 
1111 /// ParseObjCTypeQualifierList - This routine parses the objective-c's type
1112 /// qualifier list and builds their bitmask representation in the input
1113 /// argument.
1114 ///
1115 /// objc-type-qualifiers:
1116 /// objc-type-qualifier
1117 /// objc-type-qualifiers objc-type-qualifier
1118 ///
1119 /// objc-type-qualifier:
1120 /// 'in'
1121 /// 'out'
1122 /// 'inout'
1123 /// 'oneway'
1124 /// 'bycopy'
1125 /// 'byref'
1126 /// 'nonnull'
1127 /// 'nullable'
1128 /// 'null_unspecified'
1129 ///
1130 void Parser::ParseObjCTypeQualifierList(ObjCDeclSpec &DS,
1131  DeclaratorContext Context) {
1132  assert(Context == DeclaratorContext::ObjCParameterContext ||
1134 
1135  while (1) {
1136  if (Tok.is(tok::code_completion)) {
1137  Actions.CodeCompleteObjCPassingType(getCurScope(), DS,
1139  return cutOffParsing();
1140  }
1141 
1142  if (Tok.isNot(tok::identifier))
1143  return;
1144 
1145  const IdentifierInfo *II = Tok.getIdentifierInfo();
1146  for (unsigned i = 0; i != objc_NumQuals; ++i) {
1147  if (II != ObjCTypeQuals[i] ||
1148  NextToken().is(tok::less) ||
1149  NextToken().is(tok::coloncolon))
1150  continue;
1151 
1154  switch (i) {
1155  default: llvm_unreachable("Unknown decl qualifier");
1156  case objc_in: Qual = ObjCDeclSpec::DQ_In; break;
1157  case objc_out: Qual = ObjCDeclSpec::DQ_Out; break;
1158  case objc_inout: Qual = ObjCDeclSpec::DQ_Inout; break;
1159  case objc_oneway: Qual = ObjCDeclSpec::DQ_Oneway; break;
1160  case objc_bycopy: Qual = ObjCDeclSpec::DQ_Bycopy; break;
1161  case objc_byref: Qual = ObjCDeclSpec::DQ_Byref; break;
1162 
1163  case objc_nonnull:
1165  Nullability = NullabilityKind::NonNull;
1166  break;
1167 
1168  case objc_nullable:
1170  Nullability = NullabilityKind::Nullable;
1171  break;
1172 
1173  case objc_null_unspecified:
1175  Nullability = NullabilityKind::Unspecified;
1176  break;
1177  }
1178 
1179  // FIXME: Diagnose redundant specifiers.
1180  DS.setObjCDeclQualifier(Qual);
1181  if (Qual == ObjCDeclSpec::DQ_CSNullability)
1182  DS.setNullability(Tok.getLocation(), Nullability);
1183 
1184  ConsumeToken();
1185  II = nullptr;
1186  break;
1187  }
1188 
1189  // If this wasn't a recognized qualifier, bail out.
1190  if (II) return;
1191  }
1192 }
1193 
1194 /// Take all the decl attributes out of the given list and add
1195 /// them to the given attribute set.
1197  ParsedAttributesView &from) {
1198  for (auto &AL : llvm::reverse(from)) {
1199  if (!AL.isUsedAsTypeAttr()) {
1200  from.remove(&AL);
1201  attrs.addAtStart(&AL);
1202  }
1203  }
1204 }
1205 
1206 /// takeDeclAttributes - Take all the decl attributes from the given
1207 /// declarator and add them to the given list.
1209  Declarator &D) {
1210  // First, take ownership of all attributes.
1211  attrs.getPool().takeAllFrom(D.getAttributePool());
1213 
1214  // Now actually move the attributes over.
1216  takeDeclAttributes(attrs, D.getAttributes());
1217  for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i)
1218  takeDeclAttributes(attrs, D.getTypeObject(i).getAttrs());
1219 }
1220 
1221 /// objc-type-name:
1222 /// '(' objc-type-qualifiers[opt] type-name ')'
1223 /// '(' objc-type-qualifiers[opt] ')'
1224 ///
1225 ParsedType Parser::ParseObjCTypeName(ObjCDeclSpec &DS,
1226  DeclaratorContext context,
1227  ParsedAttributes *paramAttrs) {
1228  assert(context == DeclaratorContext::ObjCParameterContext ||
1230  assert((paramAttrs != nullptr) ==
1232 
1233  assert(Tok.is(tok::l_paren) && "expected (");
1234 
1235  BalancedDelimiterTracker T(*this, tok::l_paren);
1236  T.consumeOpen();
1237 
1238  SourceLocation TypeStartLoc = Tok.getLocation();
1239  ObjCDeclContextSwitch ObjCDC(*this);
1240 
1241  // Parse type qualifiers, in, inout, etc.
1242  ParseObjCTypeQualifierList(DS, context);
1243 
1244  ParsedType Ty;
1245  if (isTypeSpecifierQualifier() || isObjCInstancetype()) {
1246  // Parse an abstract declarator.
1247  DeclSpec declSpec(AttrFactory);
1248  declSpec.setObjCQualifiers(&DS);
1249  DeclSpecContext dsContext = DeclSpecContext::DSC_normal;
1250  if (context == DeclaratorContext::ObjCResultContext)
1251  dsContext = DeclSpecContext::DSC_objc_method_result;
1252  ParseSpecifierQualifierList(declSpec, AS_none, dsContext);
1253  Declarator declarator(declSpec, context);
1254  ParseDeclarator(declarator);
1255 
1256  // If that's not invalid, extract a type.
1257  if (!declarator.isInvalidType()) {
1258  // Map a nullability specifier to a context-sensitive keyword attribute.
1259  bool addedToDeclSpec = false;
1261  addContextSensitiveTypeNullability(*this, declarator,
1262  DS.getNullability(),
1263  DS.getNullabilityLoc(),
1264  addedToDeclSpec);
1265 
1266  TypeResult type = Actions.ActOnTypeName(getCurScope(), declarator);
1267  if (!type.isInvalid())
1268  Ty = type.get();
1269 
1270  // If we're parsing a parameter, steal all the decl attributes
1271  // and add them to the decl spec.
1273  takeDeclAttributes(*paramAttrs, declarator);
1274  }
1275  }
1276 
1277  if (Tok.is(tok::r_paren))
1278  T.consumeClose();
1279  else if (Tok.getLocation() == TypeStartLoc) {
1280  // If we didn't eat any tokens, then this isn't a type.
1281  Diag(Tok, diag::err_expected_type);
1282  SkipUntil(tok::r_paren, StopAtSemi);
1283  } else {
1284  // Otherwise, we found *something*, but didn't get a ')' in the right
1285  // place. Emit an error then return what we have as the type.
1286  T.consumeClose();
1287  }
1288  return Ty;
1289 }
1290 
1291 /// objc-method-decl:
1292 /// objc-selector
1293 /// objc-keyword-selector objc-parmlist[opt]
1294 /// objc-type-name objc-selector
1295 /// objc-type-name objc-keyword-selector objc-parmlist[opt]
1296 ///
1297 /// objc-keyword-selector:
1298 /// objc-keyword-decl
1299 /// objc-keyword-selector objc-keyword-decl
1300 ///
1301 /// objc-keyword-decl:
1302 /// objc-selector ':' objc-type-name objc-keyword-attributes[opt] identifier
1303 /// objc-selector ':' objc-keyword-attributes[opt] identifier
1304 /// ':' objc-type-name objc-keyword-attributes[opt] identifier
1305 /// ':' objc-keyword-attributes[opt] identifier
1306 ///
1307 /// objc-parmlist:
1308 /// objc-parms objc-ellipsis[opt]
1309 ///
1310 /// objc-parms:
1311 /// objc-parms , parameter-declaration
1312 ///
1313 /// objc-ellipsis:
1314 /// , ...
1315 ///
1316 /// objc-keyword-attributes: [OBJC2]
1317 /// __attribute__((unused))
1318 ///
1319 Decl *Parser::ParseObjCMethodDecl(SourceLocation mLoc,
1320  tok::TokenKind mType,
1321  tok::ObjCKeywordKind MethodImplKind,
1322  bool MethodDefinition) {
1324 
1325  if (Tok.is(tok::code_completion)) {
1326  Actions.CodeCompleteObjCMethodDecl(getCurScope(), mType == tok::minus,
1327  /*ReturnType=*/nullptr);
1328  cutOffParsing();
1329  return nullptr;
1330  }
1331 
1332  // Parse the return type if present.
1333  ParsedType ReturnType;
1334  ObjCDeclSpec DSRet;
1335  if (Tok.is(tok::l_paren))
1336  ReturnType = ParseObjCTypeName(DSRet, DeclaratorContext::ObjCResultContext,
1337  nullptr);
1338 
1339  // If attributes exist before the method, parse them.
1340  ParsedAttributes methodAttrs(AttrFactory);
1341  if (getLangOpts().ObjC2)
1342  MaybeParseGNUAttributes(methodAttrs);
1343  MaybeParseCXX11Attributes(methodAttrs);
1344 
1345  if (Tok.is(tok::code_completion)) {
1346  Actions.CodeCompleteObjCMethodDecl(getCurScope(), mType == tok::minus,
1347  ReturnType);
1348  cutOffParsing();
1349  return nullptr;
1350  }
1351 
1352  // Now parse the selector.
1353  SourceLocation selLoc;
1354  IdentifierInfo *SelIdent = ParseObjCSelectorPiece(selLoc);
1355 
1356  // An unnamed colon is valid.
1357  if (!SelIdent && Tok.isNot(tok::colon)) { // missing selector name.
1358  Diag(Tok, diag::err_expected_selector_for_method)
1359  << SourceRange(mLoc, Tok.getLocation());
1360  // Skip until we get a ; or @.
1361  SkipUntil(tok::at, StopAtSemi | StopBeforeMatch);
1362  return nullptr;
1363  }
1364 
1366  if (Tok.isNot(tok::colon)) {
1367  // If attributes exist after the method, parse them.
1368  if (getLangOpts().ObjC2)
1369  MaybeParseGNUAttributes(methodAttrs);
1370  MaybeParseCXX11Attributes(methodAttrs);
1371 
1372  Selector Sel = PP.getSelectorTable().getNullarySelector(SelIdent);
1373  Decl *Result = Actions.ActOnMethodDeclaration(
1374  getCurScope(), mLoc, Tok.getLocation(), mType, DSRet, ReturnType,
1375  selLoc, Sel, nullptr, CParamInfo.data(), CParamInfo.size(), methodAttrs,
1376  MethodImplKind, false, MethodDefinition);
1377  PD.complete(Result);
1378  return Result;
1379  }
1380 
1384  ParseScope PrototypeScope(this, Scope::FunctionPrototypeScope |
1386 
1387  AttributePool allParamAttrs(AttrFactory);
1388  while (1) {
1389  ParsedAttributes paramAttrs(AttrFactory);
1390  Sema::ObjCArgInfo ArgInfo;
1391 
1392  // Each iteration parses a single keyword argument.
1393  if (ExpectAndConsume(tok::colon))
1394  break;
1395 
1396  ArgInfo.Type = nullptr;
1397  if (Tok.is(tok::l_paren)) // Parse the argument type if present.
1398  ArgInfo.Type = ParseObjCTypeName(ArgInfo.DeclSpec,
1400  &paramAttrs);
1401 
1402  // If attributes exist before the argument name, parse them.
1403  // Regardless, collect all the attributes we've parsed so far.
1404  if (getLangOpts().ObjC2)
1405  MaybeParseGNUAttributes(paramAttrs);
1406  MaybeParseCXX11Attributes(paramAttrs);
1407  ArgInfo.ArgAttrs = paramAttrs;
1408 
1409  // Code completion for the next piece of the selector.
1410  if (Tok.is(tok::code_completion)) {
1411  KeyIdents.push_back(SelIdent);
1412  Actions.CodeCompleteObjCMethodDeclSelector(getCurScope(),
1413  mType == tok::minus,
1414  /*AtParameterName=*/true,
1415  ReturnType, KeyIdents);
1416  cutOffParsing();
1417  return nullptr;
1418  }
1419 
1420  if (expectIdentifier())
1421  break; // missing argument name.
1422 
1423  ArgInfo.Name = Tok.getIdentifierInfo();
1424  ArgInfo.NameLoc = Tok.getLocation();
1425  ConsumeToken(); // Eat the identifier.
1426 
1427  ArgInfos.push_back(ArgInfo);
1428  KeyIdents.push_back(SelIdent);
1429  KeyLocs.push_back(selLoc);
1430 
1431  // Make sure the attributes persist.
1432  allParamAttrs.takeAllFrom(paramAttrs.getPool());
1433 
1434  // Code completion for the next piece of the selector.
1435  if (Tok.is(tok::code_completion)) {
1436  Actions.CodeCompleteObjCMethodDeclSelector(getCurScope(),
1437  mType == tok::minus,
1438  /*AtParameterName=*/false,
1439  ReturnType, KeyIdents);
1440  cutOffParsing();
1441  return nullptr;
1442  }
1443 
1444  // Check for another keyword selector.
1445  SelIdent = ParseObjCSelectorPiece(selLoc);
1446  if (!SelIdent && Tok.isNot(tok::colon))
1447  break;
1448  if (!SelIdent) {
1449  SourceLocation ColonLoc = Tok.getLocation();
1450  if (PP.getLocForEndOfToken(ArgInfo.NameLoc) == ColonLoc) {
1451  Diag(ArgInfo.NameLoc, diag::warn_missing_selector_name) << ArgInfo.Name;
1452  Diag(ArgInfo.NameLoc, diag::note_missing_selector_name) << ArgInfo.Name;
1453  Diag(ColonLoc, diag::note_force_empty_selector_name) << ArgInfo.Name;
1454  }
1455  }
1456  // We have a selector or a colon, continue parsing.
1457  }
1458 
1459  bool isVariadic = false;
1460  bool cStyleParamWarned = false;
1461  // Parse the (optional) parameter list.
1462  while (Tok.is(tok::comma)) {
1463  ConsumeToken();
1464  if (Tok.is(tok::ellipsis)) {
1465  isVariadic = true;
1466  ConsumeToken();
1467  break;
1468  }
1469  if (!cStyleParamWarned) {
1470  Diag(Tok, diag::warn_cstyle_param);
1471  cStyleParamWarned = true;
1472  }
1473  DeclSpec DS(AttrFactory);
1474  ParseDeclarationSpecifiers(DS);
1475  // Parse the declarator.
1477  ParseDeclarator(ParmDecl);
1478  IdentifierInfo *ParmII = ParmDecl.getIdentifier();
1479  Decl *Param = Actions.ActOnParamDeclarator(getCurScope(), ParmDecl);
1480  CParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII,
1481  ParmDecl.getIdentifierLoc(),
1482  Param,
1483  nullptr));
1484  }
1485 
1486  // FIXME: Add support for optional parameter list...
1487  // If attributes exist after the method, parse them.
1488  if (getLangOpts().ObjC2)
1489  MaybeParseGNUAttributes(methodAttrs);
1490  MaybeParseCXX11Attributes(methodAttrs);
1491 
1492  if (KeyIdents.size() == 0)
1493  return nullptr;
1494 
1495  Selector Sel = PP.getSelectorTable().getSelector(KeyIdents.size(),
1496  &KeyIdents[0]);
1497  Decl *Result = Actions.ActOnMethodDeclaration(
1498  getCurScope(), mLoc, Tok.getLocation(), mType, DSRet, ReturnType, KeyLocs,
1499  Sel, &ArgInfos[0], CParamInfo.data(), CParamInfo.size(), methodAttrs,
1500  MethodImplKind, isVariadic, MethodDefinition);
1501 
1502  PD.complete(Result);
1503  return Result;
1504 }
1505 
1506 /// objc-protocol-refs:
1507 /// '<' identifier-list '>'
1508 ///
1509 bool Parser::
1510 ParseObjCProtocolReferences(SmallVectorImpl<Decl *> &Protocols,
1511  SmallVectorImpl<SourceLocation> &ProtocolLocs,
1512  bool WarnOnDeclarations, bool ForObjCContainer,
1513  SourceLocation &LAngleLoc, SourceLocation &EndLoc,
1514  bool consumeLastToken) {
1515  assert(Tok.is(tok::less) && "expected <");
1516 
1517  LAngleLoc = ConsumeToken(); // the "<"
1518 
1519  SmallVector<IdentifierLocPair, 8> ProtocolIdents;
1520 
1521  while (1) {
1522  if (Tok.is(tok::code_completion)) {
1523  Actions.CodeCompleteObjCProtocolReferences(ProtocolIdents);
1524  cutOffParsing();
1525  return true;
1526  }
1527 
1528  if (expectIdentifier()) {
1529  SkipUntil(tok::greater, StopAtSemi);
1530  return true;
1531  }
1532  ProtocolIdents.push_back(std::make_pair(Tok.getIdentifierInfo(),
1533  Tok.getLocation()));
1534  ProtocolLocs.push_back(Tok.getLocation());
1535  ConsumeToken();
1536 
1537  if (!TryConsumeToken(tok::comma))
1538  break;
1539  }
1540 
1541  // Consume the '>'.
1542  if (ParseGreaterThanInTemplateList(EndLoc, consumeLastToken,
1543  /*ObjCGenericList=*/false))
1544  return true;
1545 
1546  // Convert the list of protocols identifiers into a list of protocol decls.
1547  Actions.FindProtocolDeclaration(WarnOnDeclarations, ForObjCContainer,
1548  ProtocolIdents, Protocols);
1549  return false;
1550 }
1551 
1552 TypeResult Parser::parseObjCProtocolQualifierType(SourceLocation &rAngleLoc) {
1553  assert(Tok.is(tok::less) && "Protocol qualifiers start with '<'");
1554  assert(getLangOpts().ObjC1 && "Protocol qualifiers only exist in Objective-C");
1555 
1556  SourceLocation lAngleLoc;
1557  SmallVector<Decl *, 8> protocols;
1558  SmallVector<SourceLocation, 8> protocolLocs;
1559  (void)ParseObjCProtocolReferences(protocols, protocolLocs, false, false,
1560  lAngleLoc, rAngleLoc,
1561  /*consumeLastToken=*/true);
1562  TypeResult result = Actions.actOnObjCProtocolQualifierType(lAngleLoc,
1563  protocols,
1564  protocolLocs,
1565  rAngleLoc);
1566  if (result.isUsable()) {
1567  Diag(lAngleLoc, diag::warn_objc_protocol_qualifier_missing_id)
1568  << FixItHint::CreateInsertion(lAngleLoc, "id")
1569  << SourceRange(lAngleLoc, rAngleLoc);
1570  }
1571 
1572  return result;
1573 }
1574 
1575 /// Parse Objective-C type arguments or protocol qualifiers.
1576 ///
1577 /// objc-type-arguments:
1578 /// '<' type-name '...'[opt] (',' type-name '...'[opt])* '>'
1579 ///
1580 void Parser::parseObjCTypeArgsOrProtocolQualifiers(
1581  ParsedType baseType,
1582  SourceLocation &typeArgsLAngleLoc,
1583  SmallVectorImpl<ParsedType> &typeArgs,
1584  SourceLocation &typeArgsRAngleLoc,
1585  SourceLocation &protocolLAngleLoc,
1586  SmallVectorImpl<Decl *> &protocols,
1587  SmallVectorImpl<SourceLocation> &protocolLocs,
1588  SourceLocation &protocolRAngleLoc,
1589  bool consumeLastToken,
1590  bool warnOnIncompleteProtocols) {
1591  assert(Tok.is(tok::less) && "Not at the start of type args or protocols");
1592  SourceLocation lAngleLoc = ConsumeToken();
1593 
1594  // Whether all of the elements we've parsed thus far are single
1595  // identifiers, which might be types or might be protocols.
1596  bool allSingleIdentifiers = true;
1598  SmallVectorImpl<SourceLocation> &identifierLocs = protocolLocs;
1599 
1600  // Parse a list of comma-separated identifiers, bailing out if we
1601  // see something different.
1602  do {
1603  // Parse a single identifier.
1604  if (Tok.is(tok::identifier) &&
1605  (NextToken().is(tok::comma) ||
1606  NextToken().is(tok::greater) ||
1607  NextToken().is(tok::greatergreater))) {
1608  identifiers.push_back(Tok.getIdentifierInfo());
1609  identifierLocs.push_back(ConsumeToken());
1610  continue;
1611  }
1612 
1613  if (Tok.is(tok::code_completion)) {
1614  // FIXME: Also include types here.
1615  SmallVector<IdentifierLocPair, 4> identifierLocPairs;
1616  for (unsigned i = 0, n = identifiers.size(); i != n; ++i) {
1617  identifierLocPairs.push_back(IdentifierLocPair(identifiers[i],
1618  identifierLocs[i]));
1619  }
1620 
1621  QualType BaseT = Actions.GetTypeFromParser(baseType);
1622  if (!BaseT.isNull() && BaseT->acceptsObjCTypeParams()) {
1623  Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Type);
1624  } else {
1625  Actions.CodeCompleteObjCProtocolReferences(identifierLocPairs);
1626  }
1627  cutOffParsing();
1628  return;
1629  }
1630 
1631  allSingleIdentifiers = false;
1632  break;
1633  } while (TryConsumeToken(tok::comma));
1634 
1635  // If we parsed an identifier list, semantic analysis sorts out
1636  // whether it refers to protocols or to type arguments.
1637  if (allSingleIdentifiers) {
1638  // Parse the closing '>'.
1639  SourceLocation rAngleLoc;
1640  (void)ParseGreaterThanInTemplateList(rAngleLoc, consumeLastToken,
1641  /*ObjCGenericList=*/true);
1642 
1643  // Let Sema figure out what we parsed.
1644  Actions.actOnObjCTypeArgsOrProtocolQualifiers(getCurScope(),
1645  baseType,
1646  lAngleLoc,
1647  identifiers,
1648  identifierLocs,
1649  rAngleLoc,
1650  typeArgsLAngleLoc,
1651  typeArgs,
1652  typeArgsRAngleLoc,
1653  protocolLAngleLoc,
1654  protocols,
1655  protocolRAngleLoc,
1656  warnOnIncompleteProtocols);
1657  return;
1658  }
1659 
1660  // We parsed an identifier list but stumbled into non single identifiers, this
1661  // means we might (a) check that what we already parsed is a legitimate type
1662  // (not a protocol or unknown type) and (b) parse the remaining ones, which
1663  // must all be type args.
1664 
1665  // Convert the identifiers into type arguments.
1666  bool invalid = false;
1667  IdentifierInfo *foundProtocolId = nullptr, *foundValidTypeId = nullptr;
1668  SourceLocation foundProtocolSrcLoc, foundValidTypeSrcLoc;
1669  SmallVector<IdentifierInfo *, 2> unknownTypeArgs;
1670  SmallVector<SourceLocation, 2> unknownTypeArgsLoc;
1671 
1672  for (unsigned i = 0, n = identifiers.size(); i != n; ++i) {
1673  ParsedType typeArg
1674  = Actions.getTypeName(*identifiers[i], identifierLocs[i], getCurScope());
1675  if (typeArg) {
1676  DeclSpec DS(AttrFactory);
1677  const char *prevSpec = nullptr;
1678  unsigned diagID;
1679  DS.SetTypeSpecType(TST_typename, identifierLocs[i], prevSpec, diagID,
1680  typeArg, Actions.getASTContext().getPrintingPolicy());
1681 
1682  // Form a declarator to turn this into a type.
1684  TypeResult fullTypeArg = Actions.ActOnTypeName(getCurScope(), D);
1685  if (fullTypeArg.isUsable()) {
1686  typeArgs.push_back(fullTypeArg.get());
1687  if (!foundValidTypeId) {
1688  foundValidTypeId = identifiers[i];
1689  foundValidTypeSrcLoc = identifierLocs[i];
1690  }
1691  } else {
1692  invalid = true;
1693  unknownTypeArgs.push_back(identifiers[i]);
1694  unknownTypeArgsLoc.push_back(identifierLocs[i]);
1695  }
1696  } else {
1697  invalid = true;
1698  if (!Actions.LookupProtocol(identifiers[i], identifierLocs[i])) {
1699  unknownTypeArgs.push_back(identifiers[i]);
1700  unknownTypeArgsLoc.push_back(identifierLocs[i]);
1701  } else if (!foundProtocolId) {
1702  foundProtocolId = identifiers[i];
1703  foundProtocolSrcLoc = identifierLocs[i];
1704  }
1705  }
1706  }
1707 
1708  // Continue parsing type-names.
1709  do {
1710  Token CurTypeTok = Tok;
1711  TypeResult typeArg = ParseTypeName();
1712 
1713  // Consume the '...' for a pack expansion.
1714  SourceLocation ellipsisLoc;
1715  TryConsumeToken(tok::ellipsis, ellipsisLoc);
1716  if (typeArg.isUsable() && ellipsisLoc.isValid()) {
1717  typeArg = Actions.ActOnPackExpansion(typeArg.get(), ellipsisLoc);
1718  }
1719 
1720  if (typeArg.isUsable()) {
1721  typeArgs.push_back(typeArg.get());
1722  if (!foundValidTypeId) {
1723  foundValidTypeId = CurTypeTok.getIdentifierInfo();
1724  foundValidTypeSrcLoc = CurTypeTok.getLocation();
1725  }
1726  } else {
1727  invalid = true;
1728  }
1729  } while (TryConsumeToken(tok::comma));
1730 
1731  // Diagnose the mix between type args and protocols.
1732  if (foundProtocolId && foundValidTypeId)
1733  Actions.DiagnoseTypeArgsAndProtocols(foundProtocolId, foundProtocolSrcLoc,
1734  foundValidTypeId,
1735  foundValidTypeSrcLoc);
1736 
1737  // Diagnose unknown arg types.
1738  ParsedType T;
1739  if (unknownTypeArgs.size())
1740  for (unsigned i = 0, e = unknownTypeArgsLoc.size(); i < e; ++i)
1741  Actions.DiagnoseUnknownTypeName(unknownTypeArgs[i], unknownTypeArgsLoc[i],
1742  getCurScope(), nullptr, T);
1743 
1744  // Parse the closing '>'.
1745  SourceLocation rAngleLoc;
1746  (void)ParseGreaterThanInTemplateList(rAngleLoc, consumeLastToken,
1747  /*ObjCGenericList=*/true);
1748 
1749  if (invalid) {
1750  typeArgs.clear();
1751  return;
1752  }
1753 
1754  // Record left/right angle locations.
1755  typeArgsLAngleLoc = lAngleLoc;
1756  typeArgsRAngleLoc = rAngleLoc;
1757 }
1758 
1759 void Parser::parseObjCTypeArgsAndProtocolQualifiers(
1760  ParsedType baseType,
1761  SourceLocation &typeArgsLAngleLoc,
1762  SmallVectorImpl<ParsedType> &typeArgs,
1763  SourceLocation &typeArgsRAngleLoc,
1764  SourceLocation &protocolLAngleLoc,
1765  SmallVectorImpl<Decl *> &protocols,
1766  SmallVectorImpl<SourceLocation> &protocolLocs,
1767  SourceLocation &protocolRAngleLoc,
1768  bool consumeLastToken) {
1769  assert(Tok.is(tok::less));
1770 
1771  // Parse the first angle-bracket-delimited clause.
1772  parseObjCTypeArgsOrProtocolQualifiers(baseType,
1773  typeArgsLAngleLoc,
1774  typeArgs,
1775  typeArgsRAngleLoc,
1776  protocolLAngleLoc,
1777  protocols,
1778  protocolLocs,
1779  protocolRAngleLoc,
1780  consumeLastToken,
1781  /*warnOnIncompleteProtocols=*/false);
1782  if (Tok.is(tok::eof)) // Nothing else to do here...
1783  return;
1784 
1785  // An Objective-C object pointer followed by type arguments
1786  // can then be followed again by a set of protocol references, e.g.,
1787  // \c NSArray<NSView><NSTextDelegate>
1788  if ((consumeLastToken && Tok.is(tok::less)) ||
1789  (!consumeLastToken && NextToken().is(tok::less))) {
1790  // If we aren't consuming the last token, the prior '>' is still hanging
1791  // there. Consume it before we parse the protocol qualifiers.
1792  if (!consumeLastToken)
1793  ConsumeToken();
1794 
1795  if (!protocols.empty()) {
1796  SkipUntilFlags skipFlags = SkipUntilFlags();
1797  if (!consumeLastToken)
1798  skipFlags = skipFlags | StopBeforeMatch;
1799  Diag(Tok, diag::err_objc_type_args_after_protocols)
1800  << SourceRange(protocolLAngleLoc, protocolRAngleLoc);
1801  SkipUntil(tok::greater, tok::greatergreater, skipFlags);
1802  } else {
1803  ParseObjCProtocolReferences(protocols, protocolLocs,
1804  /*WarnOnDeclarations=*/false,
1805  /*ForObjCContainer=*/false,
1806  protocolLAngleLoc, protocolRAngleLoc,
1807  consumeLastToken);
1808  }
1809  }
1810 }
1811 
1812 TypeResult Parser::parseObjCTypeArgsAndProtocolQualifiers(
1813  SourceLocation loc,
1814  ParsedType type,
1815  bool consumeLastToken,
1816  SourceLocation &endLoc) {
1817  assert(Tok.is(tok::less));
1818  SourceLocation typeArgsLAngleLoc;
1819  SmallVector<ParsedType, 4> typeArgs;
1820  SourceLocation typeArgsRAngleLoc;
1821  SourceLocation protocolLAngleLoc;
1822  SmallVector<Decl *, 4> protocols;
1823  SmallVector<SourceLocation, 4> protocolLocs;
1824  SourceLocation protocolRAngleLoc;
1825 
1826  // Parse type arguments and protocol qualifiers.
1827  parseObjCTypeArgsAndProtocolQualifiers(type, typeArgsLAngleLoc, typeArgs,
1828  typeArgsRAngleLoc, protocolLAngleLoc,
1829  protocols, protocolLocs,
1830  protocolRAngleLoc, consumeLastToken);
1831 
1832  if (Tok.is(tok::eof))
1833  return true; // Invalid type result.
1834 
1835  // Compute the location of the last token.
1836  if (consumeLastToken)
1837  endLoc = PrevTokLocation;
1838  else
1839  endLoc = Tok.getLocation();
1840 
1841  return Actions.actOnObjCTypeArgsAndProtocolQualifiers(
1842  getCurScope(),
1843  loc,
1844  type,
1845  typeArgsLAngleLoc,
1846  typeArgs,
1847  typeArgsRAngleLoc,
1848  protocolLAngleLoc,
1849  protocols,
1850  protocolLocs,
1851  protocolRAngleLoc);
1852 }
1853 
1854 void Parser::HelperActionsForIvarDeclarations(Decl *interfaceDecl, SourceLocation atLoc,
1856  SmallVectorImpl<Decl *> &AllIvarDecls,
1857  bool RBraceMissing) {
1858  if (!RBraceMissing)
1859  T.consumeClose();
1860 
1861  Actions.ActOnObjCContainerStartDefinition(interfaceDecl);
1862  Actions.ActOnLastBitfield(T.getCloseLocation(), AllIvarDecls);
1863  Actions.ActOnObjCContainerFinishDefinition();
1864  // Call ActOnFields() even if we don't have any decls. This is useful
1865  // for code rewriting tools that need to be aware of the empty list.
1866  Actions.ActOnFields(getCurScope(), atLoc, interfaceDecl, AllIvarDecls,
1869 }
1870 
1871 /// objc-class-instance-variables:
1872 /// '{' objc-instance-variable-decl-list[opt] '}'
1873 ///
1874 /// objc-instance-variable-decl-list:
1875 /// objc-visibility-spec
1876 /// objc-instance-variable-decl ';'
1877 /// ';'
1878 /// objc-instance-variable-decl-list objc-visibility-spec
1879 /// objc-instance-variable-decl-list objc-instance-variable-decl ';'
1880 /// objc-instance-variable-decl-list ';'
1881 ///
1882 /// objc-visibility-spec:
1883 /// @private
1884 /// @protected
1885 /// @public
1886 /// @package [OBJC2]
1887 ///
1888 /// objc-instance-variable-decl:
1889 /// struct-declaration
1890 ///
1891 void Parser::ParseObjCClassInstanceVariables(Decl *interfaceDecl,
1892  tok::ObjCKeywordKind visibility,
1893  SourceLocation atLoc) {
1894  assert(Tok.is(tok::l_brace) && "expected {");
1895  SmallVector<Decl *, 32> AllIvarDecls;
1896 
1897  ParseScope ClassScope(this, Scope::DeclScope|Scope::ClassScope);
1898  ObjCDeclContextSwitch ObjCDC(*this);
1899 
1900  BalancedDelimiterTracker T(*this, tok::l_brace);
1901  T.consumeOpen();
1902  // While we still have something to read, read the instance variables.
1903  while (Tok.isNot(tok::r_brace) && !isEofOrEom()) {
1904  // Each iteration of this loop reads one objc-instance-variable-decl.
1905 
1906  // Check for extraneous top-level semicolon.
1907  if (Tok.is(tok::semi)) {
1908  ConsumeExtraSemi(InstanceVariableList);
1909  continue;
1910  }
1911 
1912  // Set the default visibility to private.
1913  if (TryConsumeToken(tok::at)) { // parse objc-visibility-spec
1914  if (Tok.is(tok::code_completion)) {
1915  Actions.CodeCompleteObjCAtVisibility(getCurScope());
1916  return cutOffParsing();
1917  }
1918 
1919  switch (Tok.getObjCKeywordID()) {
1920  case tok::objc_private:
1921  case tok::objc_public:
1922  case tok::objc_protected:
1923  case tok::objc_package:
1924  visibility = Tok.getObjCKeywordID();
1925  ConsumeToken();
1926  continue;
1927 
1928  case tok::objc_end:
1929  Diag(Tok, diag::err_objc_unexpected_atend);
1930  Tok.setLocation(Tok.getLocation().getLocWithOffset(-1));
1931  Tok.setKind(tok::at);
1932  Tok.setLength(1);
1933  PP.EnterToken(Tok);
1934  HelperActionsForIvarDeclarations(interfaceDecl, atLoc,
1935  T, AllIvarDecls, true);
1936  return;
1937 
1938  default:
1939  Diag(Tok, diag::err_objc_illegal_visibility_spec);
1940  continue;
1941  }
1942  }
1943 
1944  if (Tok.is(tok::code_completion)) {
1945  Actions.CodeCompleteOrdinaryName(getCurScope(),
1947  return cutOffParsing();
1948  }
1949 
1950  auto ObjCIvarCallback = [&](ParsingFieldDeclarator &FD) {
1951  Actions.ActOnObjCContainerStartDefinition(interfaceDecl);
1952  // Install the declarator into the interface decl.
1953  FD.D.setObjCIvar(true);
1954  Decl *Field = Actions.ActOnIvar(
1955  getCurScope(), FD.D.getDeclSpec().getSourceRange().getBegin(), FD.D,
1956  FD.BitfieldSize, visibility);
1957  Actions.ActOnObjCContainerFinishDefinition();
1958  if (Field)
1959  AllIvarDecls.push_back(Field);
1960  FD.complete(Field);
1961  };
1962 
1963  // Parse all the comma separated declarators.
1964  ParsingDeclSpec DS(*this);
1965  ParseStructDeclaration(DS, ObjCIvarCallback);
1966 
1967  if (Tok.is(tok::semi)) {
1968  ConsumeToken();
1969  } else {
1970  Diag(Tok, diag::err_expected_semi_decl_list);
1971  // Skip to end of block or statement
1972  SkipUntil(tok::r_brace, StopAtSemi | StopBeforeMatch);
1973  }
1974  }
1975  HelperActionsForIvarDeclarations(interfaceDecl, atLoc,
1976  T, AllIvarDecls, false);
1977 }
1978 
1979 /// objc-protocol-declaration:
1980 /// objc-protocol-definition
1981 /// objc-protocol-forward-reference
1982 ///
1983 /// objc-protocol-definition:
1984 /// \@protocol identifier
1985 /// objc-protocol-refs[opt]
1986 /// objc-interface-decl-list
1987 /// \@end
1988 ///
1989 /// objc-protocol-forward-reference:
1990 /// \@protocol identifier-list ';'
1991 ///
1992 /// "\@protocol identifier ;" should be resolved as "\@protocol
1993 /// identifier-list ;": objc-interface-decl-list may not start with a
1994 /// semicolon in the first alternative if objc-protocol-refs are omitted.
1996 Parser::ParseObjCAtProtocolDeclaration(SourceLocation AtLoc,
1997  ParsedAttributes &attrs) {
1998  assert(Tok.isObjCAtKeyword(tok::objc_protocol) &&
1999  "ParseObjCAtProtocolDeclaration(): Expected @protocol");
2000  ConsumeToken(); // the "protocol" identifier
2001 
2002  if (Tok.is(tok::code_completion)) {
2003  Actions.CodeCompleteObjCProtocolDecl(getCurScope());
2004  cutOffParsing();
2005  return nullptr;
2006  }
2007 
2008  MaybeSkipAttributes(tok::objc_protocol);
2009 
2010  if (expectIdentifier())
2011  return nullptr; // missing protocol name.
2012  // Save the protocol name, then consume it.
2013  IdentifierInfo *protocolName = Tok.getIdentifierInfo();
2014  SourceLocation nameLoc = ConsumeToken();
2015 
2016  if (TryConsumeToken(tok::semi)) { // forward declaration of one protocol.
2017  IdentifierLocPair ProtoInfo(protocolName, nameLoc);
2018  return Actions.ActOnForwardProtocolDeclaration(AtLoc, ProtoInfo, attrs);
2019  }
2020 
2021  CheckNestedObjCContexts(AtLoc);
2022 
2023  if (Tok.is(tok::comma)) { // list of forward declarations.
2024  SmallVector<IdentifierLocPair, 8> ProtocolRefs;
2025  ProtocolRefs.push_back(std::make_pair(protocolName, nameLoc));
2026 
2027  // Parse the list of forward declarations.
2028  while (1) {
2029  ConsumeToken(); // the ','
2030  if (expectIdentifier()) {
2031  SkipUntil(tok::semi);
2032  return nullptr;
2033  }
2034  ProtocolRefs.push_back(IdentifierLocPair(Tok.getIdentifierInfo(),
2035  Tok.getLocation()));
2036  ConsumeToken(); // the identifier
2037 
2038  if (Tok.isNot(tok::comma))
2039  break;
2040  }
2041  // Consume the ';'.
2042  if (ExpectAndConsume(tok::semi, diag::err_expected_after, "@protocol"))
2043  return nullptr;
2044 
2045  return Actions.ActOnForwardProtocolDeclaration(AtLoc, ProtocolRefs, attrs);
2046  }
2047 
2048  // Last, and definitely not least, parse a protocol declaration.
2049  SourceLocation LAngleLoc, EndProtoLoc;
2050 
2051  SmallVector<Decl *, 8> ProtocolRefs;
2052  SmallVector<SourceLocation, 8> ProtocolLocs;
2053  if (Tok.is(tok::less) &&
2054  ParseObjCProtocolReferences(ProtocolRefs, ProtocolLocs, false, true,
2055  LAngleLoc, EndProtoLoc,
2056  /*consumeLastToken=*/true))
2057  return nullptr;
2058 
2059  Decl *ProtoType = Actions.ActOnStartProtocolInterface(
2060  AtLoc, protocolName, nameLoc, ProtocolRefs.data(), ProtocolRefs.size(),
2061  ProtocolLocs.data(), EndProtoLoc, attrs);
2062 
2063  ParseObjCInterfaceDeclList(tok::objc_protocol, ProtoType);
2064  return Actions.ConvertDeclToDeclGroup(ProtoType);
2065 }
2066 
2067 /// objc-implementation:
2068 /// objc-class-implementation-prologue
2069 /// objc-category-implementation-prologue
2070 ///
2071 /// objc-class-implementation-prologue:
2072 /// @implementation identifier objc-superclass[opt]
2073 /// objc-class-instance-variables[opt]
2074 ///
2075 /// objc-category-implementation-prologue:
2076 /// @implementation identifier ( identifier )
2078 Parser::ParseObjCAtImplementationDeclaration(SourceLocation AtLoc) {
2079  assert(Tok.isObjCAtKeyword(tok::objc_implementation) &&
2080  "ParseObjCAtImplementationDeclaration(): Expected @implementation");
2081  CheckNestedObjCContexts(AtLoc);
2082  ConsumeToken(); // the "implementation" identifier
2083 
2084  // Code completion after '@implementation'.
2085  if (Tok.is(tok::code_completion)) {
2086  Actions.CodeCompleteObjCImplementationDecl(getCurScope());
2087  cutOffParsing();
2088  return nullptr;
2089  }
2090 
2091  MaybeSkipAttributes(tok::objc_implementation);
2092 
2093  if (expectIdentifier())
2094  return nullptr; // missing class or category name.
2095  // We have a class or category name - consume it.
2096  IdentifierInfo *nameId = Tok.getIdentifierInfo();
2097  SourceLocation nameLoc = ConsumeToken(); // consume class or category name
2098  Decl *ObjCImpDecl = nullptr;
2099 
2100  // Neither a type parameter list nor a list of protocol references is
2101  // permitted here. Parse and diagnose them.
2102  if (Tok.is(tok::less)) {
2103  SourceLocation lAngleLoc, rAngleLoc;
2104  SmallVector<IdentifierLocPair, 8> protocolIdents;
2105  SourceLocation diagLoc = Tok.getLocation();
2106  ObjCTypeParamListScope typeParamScope(Actions, getCurScope());
2107  if (parseObjCTypeParamListOrProtocolRefs(typeParamScope, lAngleLoc,
2108  protocolIdents, rAngleLoc)) {
2109  Diag(diagLoc, diag::err_objc_parameterized_implementation)
2110  << SourceRange(diagLoc, PrevTokLocation);
2111  } else if (lAngleLoc.isValid()) {
2112  Diag(lAngleLoc, diag::err_unexpected_protocol_qualifier)
2113  << FixItHint::CreateRemoval(SourceRange(lAngleLoc, rAngleLoc));
2114  }
2115  }
2116 
2117  if (Tok.is(tok::l_paren)) {
2118  // we have a category implementation.
2119  ConsumeParen();
2120  SourceLocation categoryLoc, rparenLoc;
2121  IdentifierInfo *categoryId = nullptr;
2122 
2123  if (Tok.is(tok::code_completion)) {
2124  Actions.CodeCompleteObjCImplementationCategory(getCurScope(), nameId, nameLoc);
2125  cutOffParsing();
2126  return nullptr;
2127  }
2128 
2129  if (Tok.is(tok::identifier)) {
2130  categoryId = Tok.getIdentifierInfo();
2131  categoryLoc = ConsumeToken();
2132  } else {
2133  Diag(Tok, diag::err_expected)
2134  << tok::identifier; // missing category name.
2135  return nullptr;
2136  }
2137  if (Tok.isNot(tok::r_paren)) {
2138  Diag(Tok, diag::err_expected) << tok::r_paren;
2139  SkipUntil(tok::r_paren); // don't stop at ';'
2140  return nullptr;
2141  }
2142  rparenLoc = ConsumeParen();
2143  if (Tok.is(tok::less)) { // we have illegal '<' try to recover
2144  Diag(Tok, diag::err_unexpected_protocol_qualifier);
2145  SourceLocation protocolLAngleLoc, protocolRAngleLoc;
2146  SmallVector<Decl *, 4> protocols;
2147  SmallVector<SourceLocation, 4> protocolLocs;
2148  (void)ParseObjCProtocolReferences(protocols, protocolLocs,
2149  /*warnOnIncompleteProtocols=*/false,
2150  /*ForObjCContainer=*/false,
2151  protocolLAngleLoc, protocolRAngleLoc,
2152  /*consumeLastToken=*/true);
2153  }
2154  ObjCImpDecl = Actions.ActOnStartCategoryImplementation(
2155  AtLoc, nameId, nameLoc, categoryId,
2156  categoryLoc);
2157 
2158  } else {
2159  // We have a class implementation
2160  SourceLocation superClassLoc;
2161  IdentifierInfo *superClassId = nullptr;
2162  if (TryConsumeToken(tok::colon)) {
2163  // We have a super class
2164  if (expectIdentifier())
2165  return nullptr; // missing super class name.
2166  superClassId = Tok.getIdentifierInfo();
2167  superClassLoc = ConsumeToken(); // Consume super class name
2168  }
2169  ObjCImpDecl = Actions.ActOnStartClassImplementation(
2170  AtLoc, nameId, nameLoc,
2171  superClassId, superClassLoc);
2172 
2173  if (Tok.is(tok::l_brace)) // we have ivars
2174  ParseObjCClassInstanceVariables(ObjCImpDecl, tok::objc_private, AtLoc);
2175  else if (Tok.is(tok::less)) { // we have illegal '<' try to recover
2176  Diag(Tok, diag::err_unexpected_protocol_qualifier);
2177 
2178  SourceLocation protocolLAngleLoc, protocolRAngleLoc;
2179  SmallVector<Decl *, 4> protocols;
2180  SmallVector<SourceLocation, 4> protocolLocs;
2181  (void)ParseObjCProtocolReferences(protocols, protocolLocs,
2182  /*warnOnIncompleteProtocols=*/false,
2183  /*ForObjCContainer=*/false,
2184  protocolLAngleLoc, protocolRAngleLoc,
2185  /*consumeLastToken=*/true);
2186  }
2187  }
2188  assert(ObjCImpDecl);
2189 
2190  SmallVector<Decl *, 8> DeclsInGroup;
2191 
2192  {
2193  ObjCImplParsingDataRAII ObjCImplParsing(*this, ObjCImpDecl);
2194  while (!ObjCImplParsing.isFinished() && !isEofOrEom()) {
2195  ParsedAttributesWithRange attrs(AttrFactory);
2196  MaybeParseCXX11Attributes(attrs);
2197  if (DeclGroupPtrTy DGP = ParseExternalDeclaration(attrs)) {
2198  DeclGroupRef DG = DGP.get();
2199  DeclsInGroup.append(DG.begin(), DG.end());
2200  }
2201  }
2202  }
2203 
2204  return Actions.ActOnFinishObjCImplementation(ObjCImpDecl, DeclsInGroup);
2205 }
2206 
2208 Parser::ParseObjCAtEndDeclaration(SourceRange atEnd) {
2209  assert(Tok.isObjCAtKeyword(tok::objc_end) &&
2210  "ParseObjCAtEndDeclaration(): Expected @end");
2211  ConsumeToken(); // the "end" identifier
2212  if (CurParsedObjCImpl)
2213  CurParsedObjCImpl->finish(atEnd);
2214  else
2215  // missing @implementation
2216  Diag(atEnd.getBegin(), diag::err_expected_objc_container);
2217  return nullptr;
2218 }
2219 
2220 Parser::ObjCImplParsingDataRAII::~ObjCImplParsingDataRAII() {
2221  if (!Finished) {
2222  finish(P.Tok.getLocation());
2223  if (P.isEofOrEom()) {
2224  P.Diag(P.Tok, diag::err_objc_missing_end)
2225  << FixItHint::CreateInsertion(P.Tok.getLocation(), "\n@end\n");
2226  P.Diag(Dcl->getLocStart(), diag::note_objc_container_start)
2228  }
2229  }
2230  P.CurParsedObjCImpl = nullptr;
2231  assert(LateParsedObjCMethods.empty());
2232 }
2233 
2234 void Parser::ObjCImplParsingDataRAII::finish(SourceRange AtEnd) {
2235  assert(!Finished);
2236  P.Actions.DefaultSynthesizeProperties(P.getCurScope(), Dcl, AtEnd.getBegin());
2237  for (size_t i = 0; i < LateParsedObjCMethods.size(); ++i)
2238  P.ParseLexedObjCMethodDefs(*LateParsedObjCMethods[i],
2239  true/*Methods*/);
2240 
2241  P.Actions.ActOnAtEnd(P.getCurScope(), AtEnd);
2242 
2243  if (HasCFunction)
2244  for (size_t i = 0; i < LateParsedObjCMethods.size(); ++i)
2245  P.ParseLexedObjCMethodDefs(*LateParsedObjCMethods[i],
2246  false/*c-functions*/);
2247 
2248  /// Clear and free the cached objc methods.
2249  for (LateParsedObjCMethodContainer::iterator
2250  I = LateParsedObjCMethods.begin(),
2251  E = LateParsedObjCMethods.end(); I != E; ++I)
2252  delete *I;
2253  LateParsedObjCMethods.clear();
2254 
2255  Finished = true;
2256 }
2257 
2258 /// compatibility-alias-decl:
2259 /// @compatibility_alias alias-name class-name ';'
2260 ///
2261 Decl *Parser::ParseObjCAtAliasDeclaration(SourceLocation atLoc) {
2262  assert(Tok.isObjCAtKeyword(tok::objc_compatibility_alias) &&
2263  "ParseObjCAtAliasDeclaration(): Expected @compatibility_alias");
2264  ConsumeToken(); // consume compatibility_alias
2265  if (expectIdentifier())
2266  return nullptr;
2267  IdentifierInfo *aliasId = Tok.getIdentifierInfo();
2268  SourceLocation aliasLoc = ConsumeToken(); // consume alias-name
2269  if (expectIdentifier())
2270  return nullptr;
2271  IdentifierInfo *classId = Tok.getIdentifierInfo();
2272  SourceLocation classLoc = ConsumeToken(); // consume class-name;
2273  ExpectAndConsume(tok::semi, diag::err_expected_after, "@compatibility_alias");
2274  return Actions.ActOnCompatibilityAlias(atLoc, aliasId, aliasLoc,
2275  classId, classLoc);
2276 }
2277 
2278 /// property-synthesis:
2279 /// @synthesize property-ivar-list ';'
2280 ///
2281 /// property-ivar-list:
2282 /// property-ivar
2283 /// property-ivar-list ',' property-ivar
2284 ///
2285 /// property-ivar:
2286 /// identifier
2287 /// identifier '=' identifier
2288 ///
2289 Decl *Parser::ParseObjCPropertySynthesize(SourceLocation atLoc) {
2290  assert(Tok.isObjCAtKeyword(tok::objc_synthesize) &&
2291  "ParseObjCPropertySynthesize(): Expected '@synthesize'");
2292  ConsumeToken(); // consume synthesize
2293 
2294  while (true) {
2295  if (Tok.is(tok::code_completion)) {
2296  Actions.CodeCompleteObjCPropertyDefinition(getCurScope());
2297  cutOffParsing();
2298  return nullptr;
2299  }
2300 
2301  if (Tok.isNot(tok::identifier)) {
2302  Diag(Tok, diag::err_synthesized_property_name);
2303  SkipUntil(tok::semi);
2304  return nullptr;
2305  }
2306 
2307  IdentifierInfo *propertyIvar = nullptr;
2308  IdentifierInfo *propertyId = Tok.getIdentifierInfo();
2309  SourceLocation propertyLoc = ConsumeToken(); // consume property name
2310  SourceLocation propertyIvarLoc;
2311  if (TryConsumeToken(tok::equal)) {
2312  // property '=' ivar-name
2313  if (Tok.is(tok::code_completion)) {
2314  Actions.CodeCompleteObjCPropertySynthesizeIvar(getCurScope(), propertyId);
2315  cutOffParsing();
2316  return nullptr;
2317  }
2318 
2319  if (expectIdentifier())
2320  break;
2321  propertyIvar = Tok.getIdentifierInfo();
2322  propertyIvarLoc = ConsumeToken(); // consume ivar-name
2323  }
2324  Actions.ActOnPropertyImplDecl(
2325  getCurScope(), atLoc, propertyLoc, true,
2326  propertyId, propertyIvar, propertyIvarLoc,
2328  if (Tok.isNot(tok::comma))
2329  break;
2330  ConsumeToken(); // consume ','
2331  }
2332  ExpectAndConsume(tok::semi, diag::err_expected_after, "@synthesize");
2333  return nullptr;
2334 }
2335 
2336 /// property-dynamic:
2337 /// @dynamic property-list
2338 ///
2339 /// property-list:
2340 /// identifier
2341 /// property-list ',' identifier
2342 ///
2343 Decl *Parser::ParseObjCPropertyDynamic(SourceLocation atLoc) {
2344  assert(Tok.isObjCAtKeyword(tok::objc_dynamic) &&
2345  "ParseObjCPropertyDynamic(): Expected '@dynamic'");
2346  ConsumeToken(); // consume dynamic
2347 
2348  bool isClassProperty = false;
2349  if (Tok.is(tok::l_paren)) {
2350  ConsumeParen();
2351  const IdentifierInfo *II = Tok.getIdentifierInfo();
2352 
2353  if (!II) {
2354  Diag(Tok, diag::err_objc_expected_property_attr) << II;
2355  SkipUntil(tok::r_paren, StopAtSemi);
2356  } else {
2357  SourceLocation AttrName = ConsumeToken(); // consume attribute name
2358  if (II->isStr("class")) {
2359  isClassProperty = true;
2360  if (Tok.isNot(tok::r_paren)) {
2361  Diag(Tok, diag::err_expected) << tok::r_paren;
2362  SkipUntil(tok::r_paren, StopAtSemi);
2363  } else
2364  ConsumeParen();
2365  } else {
2366  Diag(AttrName, diag::err_objc_expected_property_attr) << II;
2367  SkipUntil(tok::r_paren, StopAtSemi);
2368  }
2369  }
2370  }
2371 
2372  while (true) {
2373  if (Tok.is(tok::code_completion)) {
2374  Actions.CodeCompleteObjCPropertyDefinition(getCurScope());
2375  cutOffParsing();
2376  return nullptr;
2377  }
2378 
2379  if (expectIdentifier()) {
2380  SkipUntil(tok::semi);
2381  return nullptr;
2382  }
2383 
2384  IdentifierInfo *propertyId = Tok.getIdentifierInfo();
2385  SourceLocation propertyLoc = ConsumeToken(); // consume property name
2386  Actions.ActOnPropertyImplDecl(
2387  getCurScope(), atLoc, propertyLoc, false,
2388  propertyId, nullptr, SourceLocation(),
2389  isClassProperty ? ObjCPropertyQueryKind::OBJC_PR_query_class :
2391 
2392  if (Tok.isNot(tok::comma))
2393  break;
2394  ConsumeToken(); // consume ','
2395  }
2396  ExpectAndConsume(tok::semi, diag::err_expected_after, "@dynamic");
2397  return nullptr;
2398 }
2399 
2400 /// objc-throw-statement:
2401 /// throw expression[opt];
2402 ///
2403 StmtResult Parser::ParseObjCThrowStmt(SourceLocation atLoc) {
2404  ExprResult Res;
2405  ConsumeToken(); // consume throw
2406  if (Tok.isNot(tok::semi)) {
2407  Res = ParseExpression();
2408  if (Res.isInvalid()) {
2409  SkipUntil(tok::semi);
2410  return StmtError();
2411  }
2412  }
2413  // consume ';'
2414  ExpectAndConsume(tok::semi, diag::err_expected_after, "@throw");
2415  return Actions.ActOnObjCAtThrowStmt(atLoc, Res.get(), getCurScope());
2416 }
2417 
2418 /// objc-synchronized-statement:
2419 /// @synchronized '(' expression ')' compound-statement
2420 ///
2421 StmtResult
2422 Parser::ParseObjCSynchronizedStmt(SourceLocation atLoc) {
2423  ConsumeToken(); // consume synchronized
2424  if (Tok.isNot(tok::l_paren)) {
2425  Diag(Tok, diag::err_expected_lparen_after) << "@synchronized";
2426  return StmtError();
2427  }
2428 
2429  // The operand is surrounded with parentheses.
2430  ConsumeParen(); // '('
2431  ExprResult operand(ParseExpression());
2432 
2433  if (Tok.is(tok::r_paren)) {
2434  ConsumeParen(); // ')'
2435  } else {
2436  if (!operand.isInvalid())
2437  Diag(Tok, diag::err_expected) << tok::r_paren;
2438 
2439  // Skip forward until we see a left brace, but don't consume it.
2440  SkipUntil(tok::l_brace, StopAtSemi | StopBeforeMatch);
2441  }
2442 
2443  // Require a compound statement.
2444  if (Tok.isNot(tok::l_brace)) {
2445  if (!operand.isInvalid())
2446  Diag(Tok, diag::err_expected) << tok::l_brace;
2447  return StmtError();
2448  }
2449 
2450  // Check the @synchronized operand now.
2451  if (!operand.isInvalid())
2452  operand = Actions.ActOnObjCAtSynchronizedOperand(atLoc, operand.get());
2453 
2454  // Parse the compound statement within a new scope.
2455  ParseScope bodyScope(this, Scope::DeclScope | Scope::CompoundStmtScope);
2456  StmtResult body(ParseCompoundStatementBody());
2457  bodyScope.Exit();
2458 
2459  // If there was a semantic or parse error earlier with the
2460  // operand, fail now.
2461  if (operand.isInvalid())
2462  return StmtError();
2463 
2464  if (body.isInvalid())
2465  body = Actions.ActOnNullStmt(Tok.getLocation());
2466 
2467  return Actions.ActOnObjCAtSynchronizedStmt(atLoc, operand.get(), body.get());
2468 }
2469 
2470 /// objc-try-catch-statement:
2471 /// @try compound-statement objc-catch-list[opt]
2472 /// @try compound-statement objc-catch-list[opt] @finally compound-statement
2473 ///
2474 /// objc-catch-list:
2475 /// @catch ( parameter-declaration ) compound-statement
2476 /// objc-catch-list @catch ( catch-parameter-declaration ) compound-statement
2477 /// catch-parameter-declaration:
2478 /// parameter-declaration
2479 /// '...' [OBJC2]
2480 ///
2481 StmtResult Parser::ParseObjCTryStmt(SourceLocation atLoc) {
2482  bool catch_or_finally_seen = false;
2483 
2484  ConsumeToken(); // consume try
2485  if (Tok.isNot(tok::l_brace)) {
2486  Diag(Tok, diag::err_expected) << tok::l_brace;
2487  return StmtError();
2488  }
2489  StmtVector CatchStmts;
2490  StmtResult FinallyStmt;
2491  ParseScope TryScope(this, Scope::DeclScope | Scope::CompoundStmtScope);
2492  StmtResult TryBody(ParseCompoundStatementBody());
2493  TryScope.Exit();
2494  if (TryBody.isInvalid())
2495  TryBody = Actions.ActOnNullStmt(Tok.getLocation());
2496 
2497  while (Tok.is(tok::at)) {
2498  // At this point, we need to lookahead to determine if this @ is the start
2499  // of an @catch or @finally. We don't want to consume the @ token if this
2500  // is an @try or @encode or something else.
2501  Token AfterAt = GetLookAheadToken(1);
2502  if (!AfterAt.isObjCAtKeyword(tok::objc_catch) &&
2503  !AfterAt.isObjCAtKeyword(tok::objc_finally))
2504  break;
2505 
2506  SourceLocation AtCatchFinallyLoc = ConsumeToken();
2507  if (Tok.isObjCAtKeyword(tok::objc_catch)) {
2508  Decl *FirstPart = nullptr;
2509  ConsumeToken(); // consume catch
2510  if (Tok.is(tok::l_paren)) {
2511  ConsumeParen();
2512  ParseScope CatchScope(this, Scope::DeclScope |
2515  if (Tok.isNot(tok::ellipsis)) {
2516  DeclSpec DS(AttrFactory);
2517  ParseDeclarationSpecifiers(DS);
2519  ParseDeclarator(ParmDecl);
2520 
2521  // Inform the actions module about the declarator, so it
2522  // gets added to the current scope.
2523  FirstPart = Actions.ActOnObjCExceptionDecl(getCurScope(), ParmDecl);
2524  } else
2525  ConsumeToken(); // consume '...'
2526 
2527  SourceLocation RParenLoc;
2528 
2529  if (Tok.is(tok::r_paren))
2530  RParenLoc = ConsumeParen();
2531  else // Skip over garbage, until we get to ')'. Eat the ')'.
2532  SkipUntil(tok::r_paren, StopAtSemi);
2533 
2534  StmtResult CatchBody(true);
2535  if (Tok.is(tok::l_brace))
2536  CatchBody = ParseCompoundStatementBody();
2537  else
2538  Diag(Tok, diag::err_expected) << tok::l_brace;
2539  if (CatchBody.isInvalid())
2540  CatchBody = Actions.ActOnNullStmt(Tok.getLocation());
2541 
2542  StmtResult Catch = Actions.ActOnObjCAtCatchStmt(AtCatchFinallyLoc,
2543  RParenLoc,
2544  FirstPart,
2545  CatchBody.get());
2546  if (!Catch.isInvalid())
2547  CatchStmts.push_back(Catch.get());
2548 
2549  } else {
2550  Diag(AtCatchFinallyLoc, diag::err_expected_lparen_after)
2551  << "@catch clause";
2552  return StmtError();
2553  }
2554  catch_or_finally_seen = true;
2555  } else {
2556  assert(Tok.isObjCAtKeyword(tok::objc_finally) && "Lookahead confused?");
2557  ConsumeToken(); // consume finally
2558  ParseScope FinallyScope(this,
2560 
2561  bool ShouldCapture =
2562  getTargetInfo().getTriple().isWindowsMSVCEnvironment();
2563  if (ShouldCapture)
2564  Actions.ActOnCapturedRegionStart(Tok.getLocation(), getCurScope(),
2565  CR_ObjCAtFinally, 1);
2566 
2567  StmtResult FinallyBody(true);
2568  if (Tok.is(tok::l_brace))
2569  FinallyBody = ParseCompoundStatementBody();
2570  else
2571  Diag(Tok, diag::err_expected) << tok::l_brace;
2572 
2573  if (FinallyBody.isInvalid()) {
2574  FinallyBody = Actions.ActOnNullStmt(Tok.getLocation());
2575  if (ShouldCapture)
2576  Actions.ActOnCapturedRegionError();
2577  } else if (ShouldCapture) {
2578  FinallyBody = Actions.ActOnCapturedRegionEnd(FinallyBody.get());
2579  }
2580 
2581  FinallyStmt = Actions.ActOnObjCAtFinallyStmt(AtCatchFinallyLoc,
2582  FinallyBody.get());
2583  catch_or_finally_seen = true;
2584  break;
2585  }
2586  }
2587  if (!catch_or_finally_seen) {
2588  Diag(atLoc, diag::err_missing_catch_finally);
2589  return StmtError();
2590  }
2591 
2592  return Actions.ActOnObjCAtTryStmt(atLoc, TryBody.get(),
2593  CatchStmts,
2594  FinallyStmt.get());
2595 }
2596 
2597 /// objc-autoreleasepool-statement:
2598 /// @autoreleasepool compound-statement
2599 ///
2600 StmtResult
2601 Parser::ParseObjCAutoreleasePoolStmt(SourceLocation atLoc) {
2602  ConsumeToken(); // consume autoreleasepool
2603  if (Tok.isNot(tok::l_brace)) {
2604  Diag(Tok, diag::err_expected) << tok::l_brace;
2605  return StmtError();
2606  }
2607  // Enter a scope to hold everything within the compound stmt. Compound
2608  // statements can always hold declarations.
2609  ParseScope BodyScope(this, Scope::DeclScope | Scope::CompoundStmtScope);
2610 
2611  StmtResult AutoreleasePoolBody(ParseCompoundStatementBody());
2612 
2613  BodyScope.Exit();
2614  if (AutoreleasePoolBody.isInvalid())
2615  AutoreleasePoolBody = Actions.ActOnNullStmt(Tok.getLocation());
2616  return Actions.ActOnObjCAutoreleasePoolStmt(atLoc,
2617  AutoreleasePoolBody.get());
2618 }
2619 
2620 /// StashAwayMethodOrFunctionBodyTokens - Consume the tokens and store them
2621 /// for later parsing.
2622 void Parser::StashAwayMethodOrFunctionBodyTokens(Decl *MDecl) {
2623  if (SkipFunctionBodies && (!MDecl || Actions.canSkipFunctionBody(MDecl)) &&
2624  trySkippingFunctionBody()) {
2625  Actions.ActOnSkippedFunctionBody(MDecl);
2626  return;
2627  }
2628 
2629  LexedMethod* LM = new LexedMethod(this, MDecl);
2630  CurParsedObjCImpl->LateParsedObjCMethods.push_back(LM);
2631  CachedTokens &Toks = LM->Toks;
2632  // Begin by storing the '{' or 'try' or ':' token.
2633  Toks.push_back(Tok);
2634  if (Tok.is(tok::kw_try)) {
2635  ConsumeToken();
2636  if (Tok.is(tok::colon)) {
2637  Toks.push_back(Tok);
2638  ConsumeToken();
2639  while (Tok.isNot(tok::l_brace)) {
2640  ConsumeAndStoreUntil(tok::l_paren, Toks, /*StopAtSemi=*/false);
2641  ConsumeAndStoreUntil(tok::r_paren, Toks, /*StopAtSemi=*/false);
2642  }
2643  }
2644  Toks.push_back(Tok); // also store '{'
2645  }
2646  else if (Tok.is(tok::colon)) {
2647  ConsumeToken();
2648  // FIXME: This is wrong, due to C++11 braced initialization.
2649  while (Tok.isNot(tok::l_brace)) {
2650  ConsumeAndStoreUntil(tok::l_paren, Toks, /*StopAtSemi=*/false);
2651  ConsumeAndStoreUntil(tok::r_paren, Toks, /*StopAtSemi=*/false);
2652  }
2653  Toks.push_back(Tok); // also store '{'
2654  }
2655  ConsumeBrace();
2656  // Consume everything up to (and including) the matching right brace.
2657  ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/false);
2658  while (Tok.is(tok::kw_catch)) {
2659  ConsumeAndStoreUntil(tok::l_brace, Toks, /*StopAtSemi=*/false);
2660  ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/false);
2661  }
2662 }
2663 
2664 /// objc-method-def: objc-method-proto ';'[opt] '{' body '}'
2665 ///
2666 Decl *Parser::ParseObjCMethodDefinition() {
2667  Decl *MDecl = ParseObjCMethodPrototype();
2668 
2669  PrettyDeclStackTraceEntry CrashInfo(Actions.Context, MDecl, Tok.getLocation(),
2670  "parsing Objective-C method");
2671 
2672  // parse optional ';'
2673  if (Tok.is(tok::semi)) {
2674  if (CurParsedObjCImpl) {
2675  Diag(Tok, diag::warn_semicolon_before_method_body)
2676  << FixItHint::CreateRemoval(Tok.getLocation());
2677  }
2678  ConsumeToken();
2679  }
2680 
2681  // We should have an opening brace now.
2682  if (Tok.isNot(tok::l_brace)) {
2683  Diag(Tok, diag::err_expected_method_body);
2684 
2685  // Skip over garbage, until we get to '{'. Don't eat the '{'.
2686  SkipUntil(tok::l_brace, StopAtSemi | StopBeforeMatch);
2687 
2688  // If we didn't find the '{', bail out.
2689  if (Tok.isNot(tok::l_brace))
2690  return nullptr;
2691  }
2692 
2693  if (!MDecl) {
2694  ConsumeBrace();
2695  SkipUntil(tok::r_brace);
2696  return nullptr;
2697  }
2698 
2699  // Allow the rest of sema to find private method decl implementations.
2700  Actions.AddAnyMethodToGlobalPool(MDecl);
2701  assert (CurParsedObjCImpl
2702  && "ParseObjCMethodDefinition - Method out of @implementation");
2703  // Consume the tokens and store them for later parsing.
2704  StashAwayMethodOrFunctionBodyTokens(MDecl);
2705  return MDecl;
2706 }
2707 
2708 StmtResult Parser::ParseObjCAtStatement(SourceLocation AtLoc) {
2709  if (Tok.is(tok::code_completion)) {
2710  Actions.CodeCompleteObjCAtStatement(getCurScope());
2711  cutOffParsing();
2712  return StmtError();
2713  }
2714 
2715  if (Tok.isObjCAtKeyword(tok::objc_try))
2716  return ParseObjCTryStmt(AtLoc);
2717 
2718  if (Tok.isObjCAtKeyword(tok::objc_throw))
2719  return ParseObjCThrowStmt(AtLoc);
2720 
2721  if (Tok.isObjCAtKeyword(tok::objc_synchronized))
2722  return ParseObjCSynchronizedStmt(AtLoc);
2723 
2724  if (Tok.isObjCAtKeyword(tok::objc_autoreleasepool))
2725  return ParseObjCAutoreleasePoolStmt(AtLoc);
2726 
2727  if (Tok.isObjCAtKeyword(tok::objc_import) &&
2728  getLangOpts().DebuggerSupport) {
2729  SkipUntil(tok::semi);
2730  return Actions.ActOnNullStmt(Tok.getLocation());
2731  }
2732 
2733  ExprStatementTokLoc = AtLoc;
2734  ExprResult Res(ParseExpressionWithLeadingAt(AtLoc));
2735  if (Res.isInvalid()) {
2736  // If the expression is invalid, skip ahead to the next semicolon. Not
2737  // doing this opens us up to the possibility of infinite loops if
2738  // ParseExpression does not consume any tokens.
2739  SkipUntil(tok::semi);
2740  return StmtError();
2741  }
2742 
2743  // Otherwise, eat the semicolon.
2744  ExpectAndConsumeSemi(diag::err_expected_semi_after_expr);
2745  return Actions.ActOnExprStmt(Res);
2746 }
2747 
2748 ExprResult Parser::ParseObjCAtExpression(SourceLocation AtLoc) {
2749  switch (Tok.getKind()) {
2750  case tok::code_completion:
2751  Actions.CodeCompleteObjCAtExpression(getCurScope());
2752  cutOffParsing();
2753  return ExprError();
2754 
2755  case tok::minus:
2756  case tok::plus: {
2757  tok::TokenKind Kind = Tok.getKind();
2758  SourceLocation OpLoc = ConsumeToken();
2759 
2760  if (!Tok.is(tok::numeric_constant)) {
2761  const char *Symbol = nullptr;
2762  switch (Kind) {
2763  case tok::minus: Symbol = "-"; break;
2764  case tok::plus: Symbol = "+"; break;
2765  default: llvm_unreachable("missing unary operator case");
2766  }
2767  Diag(Tok, diag::err_nsnumber_nonliteral_unary)
2768  << Symbol;
2769  return ExprError();
2770  }
2771 
2772  ExprResult Lit(Actions.ActOnNumericConstant(Tok));
2773  if (Lit.isInvalid()) {
2774  return Lit;
2775  }
2776  ConsumeToken(); // Consume the literal token.
2777 
2778  Lit = Actions.ActOnUnaryOp(getCurScope(), OpLoc, Kind, Lit.get());
2779  if (Lit.isInvalid())
2780  return Lit;
2781 
2782  return ParsePostfixExpressionSuffix(
2783  Actions.BuildObjCNumericLiteral(AtLoc, Lit.get()));
2784  }
2785 
2786  case tok::string_literal: // primary-expression: string-literal
2787  case tok::wide_string_literal:
2788  return ParsePostfixExpressionSuffix(ParseObjCStringLiteral(AtLoc));
2789 
2790  case tok::char_constant:
2791  return ParsePostfixExpressionSuffix(ParseObjCCharacterLiteral(AtLoc));
2792 
2793  case tok::numeric_constant:
2794  return ParsePostfixExpressionSuffix(ParseObjCNumericLiteral(AtLoc));
2795 
2796  case tok::kw_true: // Objective-C++, etc.
2797  case tok::kw___objc_yes: // c/c++/objc/objc++ __objc_yes
2798  return ParsePostfixExpressionSuffix(ParseObjCBooleanLiteral(AtLoc, true));
2799  case tok::kw_false: // Objective-C++, etc.
2800  case tok::kw___objc_no: // c/c++/objc/objc++ __objc_no
2801  return ParsePostfixExpressionSuffix(ParseObjCBooleanLiteral(AtLoc, false));
2802 
2803  case tok::l_square:
2804  // Objective-C array literal
2805  return ParsePostfixExpressionSuffix(ParseObjCArrayLiteral(AtLoc));
2806 
2807  case tok::l_brace:
2808  // Objective-C dictionary literal
2809  return ParsePostfixExpressionSuffix(ParseObjCDictionaryLiteral(AtLoc));
2810 
2811  case tok::l_paren:
2812  // Objective-C boxed expression
2813  return ParsePostfixExpressionSuffix(ParseObjCBoxedExpr(AtLoc));
2814 
2815  default:
2816  if (Tok.getIdentifierInfo() == nullptr)
2817  return ExprError(Diag(AtLoc, diag::err_unexpected_at));
2818 
2819  switch (Tok.getIdentifierInfo()->getObjCKeywordID()) {
2820  case tok::objc_encode:
2821  return ParsePostfixExpressionSuffix(ParseObjCEncodeExpression(AtLoc));
2822  case tok::objc_protocol:
2823  return ParsePostfixExpressionSuffix(ParseObjCProtocolExpression(AtLoc));
2824  case tok::objc_selector:
2825  return ParsePostfixExpressionSuffix(ParseObjCSelectorExpression(AtLoc));
2826  case tok::objc_available:
2827  return ParseAvailabilityCheckExpr(AtLoc);
2828  default: {
2829  const char *str = nullptr;
2830  // Only provide the @try/@finally/@autoreleasepool fixit when we're sure
2831  // that this is a proper statement where such directives could actually
2832  // occur.
2833  if (GetLookAheadToken(1).is(tok::l_brace) &&
2834  ExprStatementTokLoc == AtLoc) {
2835  char ch = Tok.getIdentifierInfo()->getNameStart()[0];
2836  str =
2837  ch == 't' ? "try"
2838  : (ch == 'f' ? "finally"
2839  : (ch == 'a' ? "autoreleasepool" : nullptr));
2840  }
2841  if (str) {
2842  SourceLocation kwLoc = Tok.getLocation();
2843  return ExprError(Diag(AtLoc, diag::err_unexpected_at) <<
2844  FixItHint::CreateReplacement(kwLoc, str));
2845  }
2846  else
2847  return ExprError(Diag(AtLoc, diag::err_unexpected_at));
2848  }
2849  }
2850  }
2851 }
2852 
2853 /// Parse the receiver of an Objective-C++ message send.
2854 ///
2855 /// This routine parses the receiver of a message send in
2856 /// Objective-C++ either as a type or as an expression. Note that this
2857 /// routine must not be called to parse a send to 'super', since it
2858 /// has no way to return such a result.
2859 ///
2860 /// \param IsExpr Whether the receiver was parsed as an expression.
2861 ///
2862 /// \param TypeOrExpr If the receiver was parsed as an expression (\c
2863 /// IsExpr is true), the parsed expression. If the receiver was parsed
2864 /// as a type (\c IsExpr is false), the parsed type.
2865 ///
2866 /// \returns True if an error occurred during parsing or semantic
2867 /// analysis, in which case the arguments do not have valid
2868 /// values. Otherwise, returns false for a successful parse.
2869 ///
2870 /// objc-receiver: [C++]
2871 /// 'super' [not parsed here]
2872 /// expression
2873 /// simple-type-specifier
2874 /// typename-specifier
2875 bool Parser::ParseObjCXXMessageReceiver(bool &IsExpr, void *&TypeOrExpr) {
2876  InMessageExpressionRAIIObject InMessage(*this, true);
2877 
2878  if (Tok.isOneOf(tok::identifier, tok::coloncolon, tok::kw_typename,
2879  tok::annot_cxxscope))
2881 
2882  if (!Actions.isSimpleTypeSpecifier(Tok.getKind())) {
2883  // objc-receiver:
2884  // expression
2885  // Make sure any typos in the receiver are corrected or diagnosed, so that
2886  // proper recovery can happen. FIXME: Perhaps filter the corrected expr to
2887  // only the things that are valid ObjC receivers?
2888  ExprResult Receiver = Actions.CorrectDelayedTyposInExpr(ParseExpression());
2889  if (Receiver.isInvalid())
2890  return true;
2891 
2892  IsExpr = true;
2893  TypeOrExpr = Receiver.get();
2894  return false;
2895  }
2896 
2897  // objc-receiver:
2898  // typename-specifier
2899  // simple-type-specifier
2900  // expression (that starts with one of the above)
2901  DeclSpec DS(AttrFactory);
2902  ParseCXXSimpleTypeSpecifier(DS);
2903 
2904  if (Tok.is(tok::l_paren)) {
2905  // If we see an opening parentheses at this point, we are
2906  // actually parsing an expression that starts with a
2907  // function-style cast, e.g.,
2908  //
2909  // postfix-expression:
2910  // simple-type-specifier ( expression-list [opt] )
2911  // typename-specifier ( expression-list [opt] )
2912  //
2913  // Parse the remainder of this case, then the (optional)
2914  // postfix-expression suffix, followed by the (optional)
2915  // right-hand side of the binary expression. We have an
2916  // instance method.
2917  ExprResult Receiver = ParseCXXTypeConstructExpression(DS);
2918  if (!Receiver.isInvalid())
2919  Receiver = ParsePostfixExpressionSuffix(Receiver.get());
2920  if (!Receiver.isInvalid())
2921  Receiver = ParseRHSOfBinaryExpression(Receiver.get(), prec::Comma);
2922  if (Receiver.isInvalid())
2923  return true;
2924 
2925  IsExpr = true;
2926  TypeOrExpr = Receiver.get();
2927  return false;
2928  }
2929 
2930  // We have a class message. Turn the simple-type-specifier or
2931  // typename-specifier we parsed into a type and parse the
2932  // remainder of the class message.
2933  Declarator DeclaratorInfo(DS, DeclaratorContext::TypeNameContext);
2934  TypeResult Type = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
2935  if (Type.isInvalid())
2936  return true;
2937 
2938  IsExpr = false;
2939  TypeOrExpr = Type.get().getAsOpaquePtr();
2940  return false;
2941 }
2942 
2943 /// Determine whether the parser is currently referring to a an
2944 /// Objective-C message send, using a simplified heuristic to avoid overhead.
2945 ///
2946 /// This routine will only return true for a subset of valid message-send
2947 /// expressions.
2948 bool Parser::isSimpleObjCMessageExpression() {
2949  assert(Tok.is(tok::l_square) && getLangOpts().ObjC1 &&
2950  "Incorrect start for isSimpleObjCMessageExpression");
2951  return GetLookAheadToken(1).is(tok::identifier) &&
2952  GetLookAheadToken(2).is(tok::identifier);
2953 }
2954 
2955 bool Parser::isStartOfObjCClassMessageMissingOpenBracket() {
2956  if (!getLangOpts().ObjC1 || !NextToken().is(tok::identifier) ||
2957  InMessageExpression)
2958  return false;
2959 
2960  ParsedType Type;
2961 
2962  if (Tok.is(tok::annot_typename))
2963  Type = getTypeAnnotation(Tok);
2964  else if (Tok.is(tok::identifier))
2965  Type = Actions.getTypeName(*Tok.getIdentifierInfo(), Tok.getLocation(),
2966  getCurScope());
2967  else
2968  return false;
2969 
2970  if (!Type.get().isNull() && Type.get()->isObjCObjectOrInterfaceType()) {
2971  const Token &AfterNext = GetLookAheadToken(2);
2972  if (AfterNext.isOneOf(tok::colon, tok::r_square)) {
2973  if (Tok.is(tok::identifier))
2975 
2976  return Tok.is(tok::annot_typename);
2977  }
2978  }
2979 
2980  return false;
2981 }
2982 
2983 /// objc-message-expr:
2984 /// '[' objc-receiver objc-message-args ']'
2985 ///
2986 /// objc-receiver: [C]
2987 /// 'super'
2988 /// expression
2989 /// class-name
2990 /// type-name
2991 ///
2992 ExprResult Parser::ParseObjCMessageExpression() {
2993  assert(Tok.is(tok::l_square) && "'[' expected");
2994  SourceLocation LBracLoc = ConsumeBracket(); // consume '['
2995 
2996  if (Tok.is(tok::code_completion)) {
2997  Actions.CodeCompleteObjCMessageReceiver(getCurScope());
2998  cutOffParsing();
2999  return ExprError();
3000  }
3001 
3002  InMessageExpressionRAIIObject InMessage(*this, true);
3003 
3004  if (getLangOpts().CPlusPlus) {
3005  // We completely separate the C and C++ cases because C++ requires
3006  // more complicated (read: slower) parsing.
3007 
3008  // Handle send to super.
3009  // FIXME: This doesn't benefit from the same typo-correction we
3010  // get in Objective-C.
3011  if (Tok.is(tok::identifier) && Tok.getIdentifierInfo() == Ident_super &&
3012  NextToken().isNot(tok::period) && getCurScope()->isInObjcMethodScope())
3013  return ParseObjCMessageExpressionBody(LBracLoc, ConsumeToken(), nullptr,
3014  nullptr);
3015 
3016  // Parse the receiver, which is either a type or an expression.
3017  bool IsExpr;
3018  void *TypeOrExpr = nullptr;
3019  if (ParseObjCXXMessageReceiver(IsExpr, TypeOrExpr)) {
3020  SkipUntil(tok::r_square, StopAtSemi);
3021  return ExprError();
3022  }
3023 
3024  if (IsExpr)
3025  return ParseObjCMessageExpressionBody(LBracLoc, SourceLocation(), nullptr,
3026  static_cast<Expr *>(TypeOrExpr));
3027 
3028  return ParseObjCMessageExpressionBody(LBracLoc, SourceLocation(),
3029  ParsedType::getFromOpaquePtr(TypeOrExpr),
3030  nullptr);
3031  }
3032 
3033  if (Tok.is(tok::identifier)) {
3034  IdentifierInfo *Name = Tok.getIdentifierInfo();
3035  SourceLocation NameLoc = Tok.getLocation();
3036  ParsedType ReceiverType;
3037  switch (Actions.getObjCMessageKind(getCurScope(), Name, NameLoc,
3038  Name == Ident_super,
3039  NextToken().is(tok::period),
3040  ReceiverType)) {
3042  return ParseObjCMessageExpressionBody(LBracLoc, ConsumeToken(), nullptr,
3043  nullptr);
3044 
3046  if (!ReceiverType) {
3047  SkipUntil(tok::r_square, StopAtSemi);
3048  return ExprError();
3049  }
3050 
3051  ConsumeToken(); // the type name
3052 
3053  // Parse type arguments and protocol qualifiers.
3054  if (Tok.is(tok::less)) {
3055  SourceLocation NewEndLoc;
3056  TypeResult NewReceiverType
3057  = parseObjCTypeArgsAndProtocolQualifiers(NameLoc, ReceiverType,
3058  /*consumeLastToken=*/true,
3059  NewEndLoc);
3060  if (!NewReceiverType.isUsable()) {
3061  SkipUntil(tok::r_square, StopAtSemi);
3062  return ExprError();
3063  }
3064 
3065  ReceiverType = NewReceiverType.get();
3066  }
3067 
3068  return ParseObjCMessageExpressionBody(LBracLoc, SourceLocation(),
3069  ReceiverType, nullptr);
3070 
3072  // Fall through to parse an expression.
3073  break;
3074  }
3075  }
3076 
3077  // Otherwise, an arbitrary expression can be the receiver of a send.
3078  ExprResult Res = Actions.CorrectDelayedTyposInExpr(ParseExpression());
3079  if (Res.isInvalid()) {
3080  SkipUntil(tok::r_square, StopAtSemi);
3081  return Res;
3082  }
3083 
3084  return ParseObjCMessageExpressionBody(LBracLoc, SourceLocation(), nullptr,
3085  Res.get());
3086 }
3087 
3088 /// Parse the remainder of an Objective-C message following the
3089 /// '[' objc-receiver.
3090 ///
3091 /// This routine handles sends to super, class messages (sent to a
3092 /// class name), and instance messages (sent to an object), and the
3093 /// target is represented by \p SuperLoc, \p ReceiverType, or \p
3094 /// ReceiverExpr, respectively. Only one of these parameters may have
3095 /// a valid value.
3096 ///
3097 /// \param LBracLoc The location of the opening '['.
3098 ///
3099 /// \param SuperLoc If this is a send to 'super', the location of the
3100 /// 'super' keyword that indicates a send to the superclass.
3101 ///
3102 /// \param ReceiverType If this is a class message, the type of the
3103 /// class we are sending a message to.
3104 ///
3105 /// \param ReceiverExpr If this is an instance message, the expression
3106 /// used to compute the receiver object.
3107 ///
3108 /// objc-message-args:
3109 /// objc-selector
3110 /// objc-keywordarg-list
3111 ///
3112 /// objc-keywordarg-list:
3113 /// objc-keywordarg
3114 /// objc-keywordarg-list objc-keywordarg
3115 ///
3116 /// objc-keywordarg:
3117 /// selector-name[opt] ':' objc-keywordexpr
3118 ///
3119 /// objc-keywordexpr:
3120 /// nonempty-expr-list
3121 ///
3122 /// nonempty-expr-list:
3123 /// assignment-expression
3124 /// nonempty-expr-list , assignment-expression
3125 ///
3126 ExprResult
3127 Parser::ParseObjCMessageExpressionBody(SourceLocation LBracLoc,
3128  SourceLocation SuperLoc,
3129  ParsedType ReceiverType,
3130  Expr *ReceiverExpr) {
3131  InMessageExpressionRAIIObject InMessage(*this, true);
3132 
3133  if (Tok.is(tok::code_completion)) {
3134  if (SuperLoc.isValid())
3135  Actions.CodeCompleteObjCSuperMessage(getCurScope(), SuperLoc, None,
3136  false);
3137  else if (ReceiverType)
3138  Actions.CodeCompleteObjCClassMessage(getCurScope(), ReceiverType, None,
3139  false);
3140  else
3141  Actions.CodeCompleteObjCInstanceMessage(getCurScope(), ReceiverExpr,
3142  None, false);
3143  cutOffParsing();
3144  return ExprError();
3145  }
3146 
3147  // Parse objc-selector
3148  SourceLocation Loc;
3149  IdentifierInfo *selIdent = ParseObjCSelectorPiece(Loc);
3150 
3153  ExprVector KeyExprs;
3154 
3155  if (Tok.is(tok::colon)) {
3156  while (1) {
3157  // Each iteration parses a single keyword argument.
3158  KeyIdents.push_back(selIdent);
3159  KeyLocs.push_back(Loc);
3160 
3161  if (ExpectAndConsume(tok::colon)) {
3162  // We must manually skip to a ']', otherwise the expression skipper will
3163  // stop at the ']' when it skips to the ';'. We want it to skip beyond
3164  // the enclosing expression.
3165  SkipUntil(tok::r_square, StopAtSemi);
3166  return ExprError();
3167  }
3168 
3169  /// Parse the expression after ':'
3170 
3171  if (Tok.is(tok::code_completion)) {
3172  if (SuperLoc.isValid())
3173  Actions.CodeCompleteObjCSuperMessage(getCurScope(), SuperLoc,
3174  KeyIdents,
3175  /*AtArgumentEpression=*/true);
3176  else if (ReceiverType)
3177  Actions.CodeCompleteObjCClassMessage(getCurScope(), ReceiverType,
3178  KeyIdents,
3179  /*AtArgumentEpression=*/true);
3180  else
3181  Actions.CodeCompleteObjCInstanceMessage(getCurScope(), ReceiverExpr,
3182  KeyIdents,
3183  /*AtArgumentEpression=*/true);
3184 
3185  cutOffParsing();
3186  return ExprError();
3187  }
3188 
3189  ExprResult Expr;
3190  if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
3191  Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);
3192  Expr = ParseBraceInitializer();
3193  } else
3194  Expr = ParseAssignmentExpression();
3195 
3196  ExprResult Res(Expr);
3197  if (Res.isInvalid()) {
3198  // We must manually skip to a ']', otherwise the expression skipper will
3199  // stop at the ']' when it skips to the ';'. We want it to skip beyond
3200  // the enclosing expression.
3201  SkipUntil(tok::r_square, StopAtSemi);
3202  return Res;
3203  }
3204 
3205  // We have a valid expression.
3206  KeyExprs.push_back(Res.get());
3207 
3208  // Code completion after each argument.
3209  if (Tok.is(tok::code_completion)) {
3210  if (SuperLoc.isValid())
3211  Actions.CodeCompleteObjCSuperMessage(getCurScope(), SuperLoc,
3212  KeyIdents,
3213  /*AtArgumentEpression=*/false);
3214  else if (ReceiverType)
3215  Actions.CodeCompleteObjCClassMessage(getCurScope(), ReceiverType,
3216  KeyIdents,
3217  /*AtArgumentEpression=*/false);
3218  else
3219  Actions.CodeCompleteObjCInstanceMessage(getCurScope(), ReceiverExpr,
3220  KeyIdents,
3221  /*AtArgumentEpression=*/false);
3222  cutOffParsing();
3223  return ExprError();
3224  }
3225 
3226  // Check for another keyword selector.
3227  selIdent = ParseObjCSelectorPiece(Loc);
3228  if (!selIdent && Tok.isNot(tok::colon))
3229  break;
3230  // We have a selector or a colon, continue parsing.
3231  }
3232  // Parse the, optional, argument list, comma separated.
3233  while (Tok.is(tok::comma)) {
3234  SourceLocation commaLoc = ConsumeToken(); // Eat the ','.
3235  /// Parse the expression after ','
3237  if (Tok.is(tok::colon))
3238  Res = Actions.CorrectDelayedTyposInExpr(Res);
3239  if (Res.isInvalid()) {
3240  if (Tok.is(tok::colon)) {
3241  Diag(commaLoc, diag::note_extra_comma_message_arg) <<
3242  FixItHint::CreateRemoval(commaLoc);
3243  }
3244  // We must manually skip to a ']', otherwise the expression skipper will
3245  // stop at the ']' when it skips to the ';'. We want it to skip beyond
3246  // the enclosing expression.
3247  SkipUntil(tok::r_square, StopAtSemi);
3248  return Res;
3249  }
3250 
3251  // We have a valid expression.
3252  KeyExprs.push_back(Res.get());
3253  }
3254  } else if (!selIdent) {
3255  Diag(Tok, diag::err_expected) << tok::identifier; // missing selector name.
3256 
3257  // We must manually skip to a ']', otherwise the expression skipper will
3258  // stop at the ']' when it skips to the ';'. We want it to skip beyond
3259  // the enclosing expression.
3260  SkipUntil(tok::r_square, StopAtSemi);
3261  return ExprError();
3262  }
3263 
3264  if (Tok.isNot(tok::r_square)) {
3265  Diag(Tok, diag::err_expected)
3266  << (Tok.is(tok::identifier) ? tok::colon : tok::r_square);
3267  // We must manually skip to a ']', otherwise the expression skipper will
3268  // stop at the ']' when it skips to the ';'. We want it to skip beyond
3269  // the enclosing expression.
3270  SkipUntil(tok::r_square, StopAtSemi);
3271  return ExprError();
3272  }
3273 
3274  SourceLocation RBracLoc = ConsumeBracket(); // consume ']'
3275 
3276  unsigned nKeys = KeyIdents.size();
3277  if (nKeys == 0) {
3278  KeyIdents.push_back(selIdent);
3279  KeyLocs.push_back(Loc);
3280  }
3281  Selector Sel = PP.getSelectorTable().getSelector(nKeys, &KeyIdents[0]);
3282 
3283  if (SuperLoc.isValid())
3284  return Actions.ActOnSuperMessage(getCurScope(), SuperLoc, Sel,
3285  LBracLoc, KeyLocs, RBracLoc, KeyExprs);
3286  else if (ReceiverType)
3287  return Actions.ActOnClassMessage(getCurScope(), ReceiverType, Sel,
3288  LBracLoc, KeyLocs, RBracLoc, KeyExprs);
3289  return Actions.ActOnInstanceMessage(getCurScope(), ReceiverExpr, Sel,
3290  LBracLoc, KeyLocs, RBracLoc, KeyExprs);
3291 }
3292 
3293 ExprResult Parser::ParseObjCStringLiteral(SourceLocation AtLoc) {
3294  ExprResult Res(ParseStringLiteralExpression());
3295  if (Res.isInvalid()) return Res;
3296 
3297  // @"foo" @"bar" is a valid concatenated string. Eat any subsequent string
3298  // expressions. At this point, we know that the only valid thing that starts
3299  // with '@' is an @"".
3301  ExprVector AtStrings;
3302  AtLocs.push_back(AtLoc);
3303  AtStrings.push_back(Res.get());
3304 
3305  while (Tok.is(tok::at)) {
3306  AtLocs.push_back(ConsumeToken()); // eat the @.
3307 
3308  // Invalid unless there is a string literal.
3309  if (!isTokenStringLiteral())
3310  return ExprError(Diag(Tok, diag::err_objc_concat_string));
3311 
3312  ExprResult Lit(ParseStringLiteralExpression());
3313  if (Lit.isInvalid())
3314  return Lit;
3315 
3316  AtStrings.push_back(Lit.get());
3317  }
3318 
3319  return Actions.ParseObjCStringLiteral(AtLocs.data(), AtStrings);
3320 }
3321 
3322 /// ParseObjCBooleanLiteral -
3323 /// objc-scalar-literal : '@' boolean-keyword
3324 /// ;
3325 /// boolean-keyword: 'true' | 'false' | '__objc_yes' | '__objc_no'
3326 /// ;
3327 ExprResult Parser::ParseObjCBooleanLiteral(SourceLocation AtLoc,
3328  bool ArgValue) {
3329  SourceLocation EndLoc = ConsumeToken(); // consume the keyword.
3330  return Actions.ActOnObjCBoolLiteral(AtLoc, EndLoc, ArgValue);
3331 }
3332 
3333 /// ParseObjCCharacterLiteral -
3334 /// objc-scalar-literal : '@' character-literal
3335 /// ;
3336 ExprResult Parser::ParseObjCCharacterLiteral(SourceLocation AtLoc) {
3337  ExprResult Lit(Actions.ActOnCharacterConstant(Tok));
3338  if (Lit.isInvalid()) {
3339  return Lit;
3340  }
3341  ConsumeToken(); // Consume the literal token.
3342  return Actions.BuildObjCNumericLiteral(AtLoc, Lit.get());
3343 }
3344 
3345 /// ParseObjCNumericLiteral -
3346 /// objc-scalar-literal : '@' scalar-literal
3347 /// ;
3348 /// scalar-literal : | numeric-constant /* any numeric constant. */
3349 /// ;
3350 ExprResult Parser::ParseObjCNumericLiteral(SourceLocation AtLoc) {
3351  ExprResult Lit(Actions.ActOnNumericConstant(Tok));
3352  if (Lit.isInvalid()) {
3353  return Lit;
3354  }
3355  ConsumeToken(); // Consume the literal token.
3356  return Actions.BuildObjCNumericLiteral(AtLoc, Lit.get());
3357 }
3358 
3359 /// ParseObjCBoxedExpr -
3360 /// objc-box-expression:
3361 /// @( assignment-expression )
3362 ExprResult
3363 Parser::ParseObjCBoxedExpr(SourceLocation AtLoc) {
3364  if (Tok.isNot(tok::l_paren))
3365  return ExprError(Diag(Tok, diag::err_expected_lparen_after) << "@");
3366 
3367  BalancedDelimiterTracker T(*this, tok::l_paren);
3368  T.consumeOpen();
3370  if (T.consumeClose())
3371  return ExprError();
3372 
3373  if (ValueExpr.isInvalid())
3374  return ExprError();
3375 
3376  // Wrap the sub-expression in a parenthesized expression, to distinguish
3377  // a boxed expression from a literal.
3378  SourceLocation LPLoc = T.getOpenLocation(), RPLoc = T.getCloseLocation();
3379  ValueExpr = Actions.ActOnParenExpr(LPLoc, RPLoc, ValueExpr.get());
3380  return Actions.BuildObjCBoxedExpr(SourceRange(AtLoc, RPLoc),
3381  ValueExpr.get());
3382 }
3383 
3384 ExprResult Parser::ParseObjCArrayLiteral(SourceLocation AtLoc) {
3385  ExprVector ElementExprs; // array elements.
3386  ConsumeBracket(); // consume the l_square.
3387 
3388  bool HasInvalidEltExpr = false;
3389  while (Tok.isNot(tok::r_square)) {
3390  // Parse list of array element expressions (all must be id types).
3392  if (Res.isInvalid()) {
3393  // We must manually skip to a ']', otherwise the expression skipper will
3394  // stop at the ']' when it skips to the ';'. We want it to skip beyond
3395  // the enclosing expression.
3396  SkipUntil(tok::r_square, StopAtSemi);
3397  return Res;
3398  }
3399 
3400  Res = Actions.CorrectDelayedTyposInExpr(Res.get());
3401  if (Res.isInvalid())
3402  HasInvalidEltExpr = true;
3403 
3404  // Parse the ellipsis that indicates a pack expansion.
3405  if (Tok.is(tok::ellipsis))
3406  Res = Actions.ActOnPackExpansion(Res.get(), ConsumeToken());
3407  if (Res.isInvalid())
3408  HasInvalidEltExpr = true;
3409 
3410  ElementExprs.push_back(Res.get());
3411 
3412  if (Tok.is(tok::comma))
3413  ConsumeToken(); // Eat the ','.
3414  else if (Tok.isNot(tok::r_square))
3415  return ExprError(Diag(Tok, diag::err_expected_either) << tok::r_square
3416  << tok::comma);
3417  }
3418  SourceLocation EndLoc = ConsumeBracket(); // location of ']'
3419 
3420  if (HasInvalidEltExpr)
3421  return ExprError();
3422 
3423  MultiExprArg Args(ElementExprs);
3424  return Actions.BuildObjCArrayLiteral(SourceRange(AtLoc, EndLoc), Args);
3425 }
3426 
3427 ExprResult Parser::ParseObjCDictionaryLiteral(SourceLocation AtLoc) {
3428  SmallVector<ObjCDictionaryElement, 4> Elements; // dictionary elements.
3429  ConsumeBrace(); // consume the l_square.
3430  bool HasInvalidEltExpr = false;
3431  while (Tok.isNot(tok::r_brace)) {
3432  // Parse the comma separated key : value expressions.
3433  ExprResult KeyExpr;
3434  {
3436  KeyExpr = ParseAssignmentExpression();
3437  if (KeyExpr.isInvalid()) {
3438  // We must manually skip to a '}', otherwise the expression skipper will
3439  // stop at the '}' when it skips to the ';'. We want it to skip beyond
3440  // the enclosing expression.
3441  SkipUntil(tok::r_brace, StopAtSemi);
3442  return KeyExpr;
3443  }
3444  }
3445 
3446  if (ExpectAndConsume(tok::colon)) {
3447  SkipUntil(tok::r_brace, StopAtSemi);
3448  return ExprError();
3449  }
3450 
3452  if (ValueExpr.isInvalid()) {
3453  // We must manually skip to a '}', otherwise the expression skipper will
3454  // stop at the '}' when it skips to the ';'. We want it to skip beyond
3455  // the enclosing expression.
3456  SkipUntil(tok::r_brace, StopAtSemi);
3457  return ValueExpr;
3458  }
3459 
3460  // Check the key and value for possible typos
3461  KeyExpr = Actions.CorrectDelayedTyposInExpr(KeyExpr.get());
3462  ValueExpr = Actions.CorrectDelayedTyposInExpr(ValueExpr.get());
3463  if (KeyExpr.isInvalid() || ValueExpr.isInvalid())
3464  HasInvalidEltExpr = true;
3465 
3466  // Parse the ellipsis that designates this as a pack expansion. Do not
3467  // ActOnPackExpansion here, leave it to template instantiation time where
3468  // we can get better diagnostics.
3469  SourceLocation EllipsisLoc;
3470  if (getLangOpts().CPlusPlus)
3471  TryConsumeToken(tok::ellipsis, EllipsisLoc);
3472 
3473  // We have a valid expression. Collect it in a vector so we can
3474  // build the argument list.
3475  ObjCDictionaryElement Element = {
3476  KeyExpr.get(), ValueExpr.get(), EllipsisLoc, None
3477  };
3478  Elements.push_back(Element);
3479 
3480  if (!TryConsumeToken(tok::comma) && Tok.isNot(tok::r_brace))
3481  return ExprError(Diag(Tok, diag::err_expected_either) << tok::r_brace
3482  << tok::comma);
3483  }
3484  SourceLocation EndLoc = ConsumeBrace();
3485 
3486  if (HasInvalidEltExpr)
3487  return ExprError();
3488 
3489  // Create the ObjCDictionaryLiteral.
3490  return Actions.BuildObjCDictionaryLiteral(SourceRange(AtLoc, EndLoc),
3491  Elements);
3492 }
3493 
3494 /// objc-encode-expression:
3495 /// \@encode ( type-name )
3496 ExprResult
3497 Parser::ParseObjCEncodeExpression(SourceLocation AtLoc) {
3498  assert(Tok.isObjCAtKeyword(tok::objc_encode) && "Not an @encode expression!");
3499 
3500  SourceLocation EncLoc = ConsumeToken();
3501 
3502  if (Tok.isNot(tok::l_paren))
3503  return ExprError(Diag(Tok, diag::err_expected_lparen_after) << "@encode");
3504 
3505  BalancedDelimiterTracker T(*this, tok::l_paren);
3506  T.consumeOpen();
3507 
3508  TypeResult Ty = ParseTypeName();
3509 
3510  T.consumeClose();
3511 
3512  if (Ty.isInvalid())
3513  return ExprError();
3514 
3515  return Actions.ParseObjCEncodeExpression(AtLoc, EncLoc, T.getOpenLocation(),
3516  Ty.get(), T.getCloseLocation());
3517 }
3518 
3519 /// objc-protocol-expression
3520 /// \@protocol ( protocol-name )
3521 ExprResult
3522 Parser::ParseObjCProtocolExpression(SourceLocation AtLoc) {
3523  SourceLocation ProtoLoc = ConsumeToken();
3524 
3525  if (Tok.isNot(tok::l_paren))
3526  return ExprError(Diag(Tok, diag::err_expected_lparen_after) << "@protocol");
3527 
3528  BalancedDelimiterTracker T(*this, tok::l_paren);
3529  T.consumeOpen();
3530 
3531  if (expectIdentifier())
3532  return ExprError();
3533 
3534  IdentifierInfo *protocolId = Tok.getIdentifierInfo();
3535  SourceLocation ProtoIdLoc = ConsumeToken();
3536 
3537  T.consumeClose();
3538 
3539  return Actions.ParseObjCProtocolExpression(protocolId, AtLoc, ProtoLoc,
3540  T.getOpenLocation(), ProtoIdLoc,
3541  T.getCloseLocation());
3542 }
3543 
3544 /// objc-selector-expression
3545 /// @selector '(' '('[opt] objc-keyword-selector ')'[opt] ')'
3546 ExprResult Parser::ParseObjCSelectorExpression(SourceLocation AtLoc) {
3547  SourceLocation SelectorLoc = ConsumeToken();
3548 
3549  if (Tok.isNot(tok::l_paren))
3550  return ExprError(Diag(Tok, diag::err_expected_lparen_after) << "@selector");
3551 
3553  SourceLocation sLoc;
3554 
3555  BalancedDelimiterTracker T(*this, tok::l_paren);
3556  T.consumeOpen();
3557  bool HasOptionalParen = Tok.is(tok::l_paren);
3558  if (HasOptionalParen)
3559  ConsumeParen();
3560 
3561  if (Tok.is(tok::code_completion)) {
3562  Actions.CodeCompleteObjCSelector(getCurScope(), KeyIdents);
3563  cutOffParsing();
3564  return ExprError();
3565  }
3566 
3567  IdentifierInfo *SelIdent = ParseObjCSelectorPiece(sLoc);
3568  if (!SelIdent && // missing selector name.
3569  Tok.isNot(tok::colon) && Tok.isNot(tok::coloncolon))
3570  return ExprError(Diag(Tok, diag::err_expected) << tok::identifier);
3571 
3572  KeyIdents.push_back(SelIdent);
3573 
3574  unsigned nColons = 0;
3575  if (Tok.isNot(tok::r_paren)) {
3576  while (1) {
3577  if (TryConsumeToken(tok::coloncolon)) { // Handle :: in C++.
3578  ++nColons;
3579  KeyIdents.push_back(nullptr);
3580  } else if (ExpectAndConsume(tok::colon)) // Otherwise expect ':'.
3581  return ExprError();
3582  ++nColons;
3583 
3584  if (Tok.is(tok::r_paren))
3585  break;
3586 
3587  if (Tok.is(tok::code_completion)) {
3588  Actions.CodeCompleteObjCSelector(getCurScope(), KeyIdents);
3589  cutOffParsing();
3590  return ExprError();
3591  }
3592 
3593  // Check for another keyword selector.
3594  SourceLocation Loc;
3595  SelIdent = ParseObjCSelectorPiece(Loc);
3596  KeyIdents.push_back(SelIdent);
3597  if (!SelIdent && Tok.isNot(tok::colon) && Tok.isNot(tok::coloncolon))
3598  break;
3599  }
3600  }
3601  if (HasOptionalParen && Tok.is(tok::r_paren))
3602  ConsumeParen(); // ')'
3603  T.consumeClose();
3604  Selector Sel = PP.getSelectorTable().getSelector(nColons, &KeyIdents[0]);
3605  return Actions.ParseObjCSelectorExpression(Sel, AtLoc, SelectorLoc,
3606  T.getOpenLocation(),
3607  T.getCloseLocation(),
3608  !HasOptionalParen);
3609 }
3610 
3611 void Parser::ParseLexedObjCMethodDefs(LexedMethod &LM, bool parseMethod) {
3612  // MCDecl might be null due to error in method or c-function prototype, etc.
3613  Decl *MCDecl = LM.D;
3614  bool skip = MCDecl &&
3615  ((parseMethod && !Actions.isObjCMethodDecl(MCDecl)) ||
3616  (!parseMethod && Actions.isObjCMethodDecl(MCDecl)));
3617  if (skip)
3618  return;
3619 
3620  // Save the current token position.
3621  SourceLocation OrigLoc = Tok.getLocation();
3622 
3623  assert(!LM.Toks.empty() && "ParseLexedObjCMethodDef - Empty body!");
3624  // Store an artificial EOF token to ensure that we don't run off the end of
3625  // the method's body when we come to parse it.
3626  Token Eof;
3627  Eof.startToken();
3628  Eof.setKind(tok::eof);
3629  Eof.setEofData(MCDecl);
3630  Eof.setLocation(OrigLoc);
3631  LM.Toks.push_back(Eof);
3632  // Append the current token at the end of the new token stream so that it
3633  // doesn't get lost.
3634  LM.Toks.push_back(Tok);
3635  PP.EnterTokenStream(LM.Toks, true);
3636 
3637  // Consume the previously pushed token.
3638  ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true);
3639 
3640  assert(Tok.isOneOf(tok::l_brace, tok::kw_try, tok::colon) &&
3641  "Inline objective-c method not starting with '{' or 'try' or ':'");
3642  // Enter a scope for the method or c-function body.
3643  ParseScope BodyScope(this, (parseMethod ? Scope::ObjCMethodScope : 0) |
3646 
3647  // Tell the actions module that we have entered a method or c-function definition
3648  // with the specified Declarator for the method/function.
3649  if (parseMethod)
3650  Actions.ActOnStartOfObjCMethodDef(getCurScope(), MCDecl);
3651  else
3652  Actions.ActOnStartOfFunctionDef(getCurScope(), MCDecl);
3653  if (Tok.is(tok::kw_try))
3654  ParseFunctionTryBlock(MCDecl, BodyScope);
3655  else {
3656  if (Tok.is(tok::colon))
3657  ParseConstructorInitializer(MCDecl);
3658  else
3659  Actions.ActOnDefaultCtorInitializers(MCDecl);
3660  ParseFunctionStatementBody(MCDecl, BodyScope);
3661  }
3662 
3663  if (Tok.getLocation() != OrigLoc) {
3664  // Due to parsing error, we either went over the cached tokens or
3665  // there are still cached tokens left. If it's the latter case skip the
3666  // leftover tokens.
3667  // Since this is an uncommon situation that should be avoided, use the
3668  // expensive isBeforeInTranslationUnit call.
3669  if (PP.getSourceManager().isBeforeInTranslationUnit(Tok.getLocation(),
3670  OrigLoc))
3671  while (Tok.getLocation() != OrigLoc && Tok.isNot(tok::eof))
3672  ConsumeAnyToken();
3673  }
3674  // Clean up the remaining EOF token.
3675  ConsumeAnyToken();
3676 }
AttributePool & getAttributePool() const
Definition: DeclSpec.h:1850
Defines the clang::ASTContext interface.
IdentifierInfo * getNullabilityKeyword(NullabilityKind nullability)
Retrieve the underscored keyword (_Nonnull, _Nullable) that corresponds to the given nullability kind...
Definition: Parser.h:456
Smart pointer class that efficiently represents Objective-C method names.
PtrTy get() const
Definition: Ownership.h:81
ExprResult ParseExpression(TypeCastState isTypeCast=NotTypeCast)
Simple precedence-based parser for binary/ternary operators.
Definition: ParseExpr.cpp:123
A (possibly-)qualified type.
Definition: Type.h:655
This is a scope that corresponds to the parameters within a function prototype.
Definition: Scope.h:81
ObjCDeclQualifier getObjCDeclQualifier() const
Definition: DeclSpec.h:821
Class to handle popping type parameters when leaving the scope.
Definition: ParseObjc.cpp:98
const DeclaratorChunk & getTypeObject(unsigned i) const
Return the specified TypeInfo from this declarator.
Definition: DeclSpec.h:2168
NullabilityKind
Describes the nullability of a particular type.
Definition: Specifiers.h:285
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:941
bool is(tok::TokenKind K) const
is/isNot - Predicates to check if this token is a specific kind, as in "if (Tok.is(tok::l_brace)) {...
Definition: Token.h:95
iterator end()
Definition: DeclGroup.h:106
void setPropertyAttributes(ObjCPropertyAttributeKind PRVal)
Definition: DeclSpec.h:834
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
RAII object used to inform the actions that we&#39;re currently parsing a declaration.
Captures information about "declaration specifiers" specific to Objective-C.
Definition: DeclSpec.h:777
StringRef P
The base class of the type hierarchy.
Definition: Type.h:1428
SourceLocation getCloseLocation() const
This indicates that the scope corresponds to a function, which means that labels are set here...
Definition: Scope.h:47
The parameter is covariant, e.g., X<T> is a subtype of X<U> when the type parameter is covariant and ...
Wrapper for void* pointer.
Definition: Ownership.h:51
Parser - This implements a parser for the C family of languages.
Definition: Parser.h:57
const ParsedAttributes & getAttributes() const
Definition: DeclSpec.h:2398
void setObjCQualifiers(ObjCDeclSpec *quals)
Definition: DeclSpec.h:767
ActionResult< Stmt * > StmtResult
Definition: Ownership.h:268
Information about one declarator, including the parsed type information and the identifier.
Definition: DeclSpec.h:1752
bool isInObjcMethodScope() const
isInObjcMethodScope - Return true if this scope is, or is contained in, an Objective-C method body...
Definition: Scope.h:353
void setBegin(SourceLocation b)
Code completion occurs within an Objective-C implementation or category implementation.
Definition: Sema.h:10203
friend class ObjCDeclContextSwitch
Definition: Parser.h:61
const IdentifierInfo * getSetterName() const
Definition: DeclSpec.h:869
ColonProtectionRAIIObject - This sets the Parser::ColonIsSacred bool and restores it when destroyed...
bool SkipUntil(tok::TokenKind T, SkipUntilFlags Flags=static_cast< SkipUntilFlags >(0))
SkipUntil - Read tokens until we get to the specified token, then consume it (unless StopBeforeMatch ...
Definition: Parser.h:1039
const Token & NextToken()
NextToken - This peeks ahead one token and returns it without consuming it.
Definition: Parser.h:707
bool TryConsumeToken(tok::TokenKind Expected)
Definition: Parser.h:412
The message is a class message, and the identifier is a type name.
Definition: Sema.h:8189
One of these records is kept for each identifier that is lexed.
An element in an Objective-C dictionary literal.
Definition: ExprObjC.h:247
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
The parameter is contravariant, e.g., X<T> is a subtype of X<U> when the type parameter is covariant ...
LLVM_READONLY bool isLetter(unsigned char c)
Return true if this character is an ASCII letter: [a-zA-Z].
Definition: CharInfo.h:112
DeclGroupPtrTy ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType=nullptr)
Definition: SemaDecl.cpp:54
Token - This structure provides full information about a lexed token.
Definition: Token.h:35
RAII class that helps handle the parsing of an open/close delimiter pair, such as braces { ...
Code completion occurs where only a type is permitted.
Definition: Sema.h:10229
bool isInvalidType() const
Definition: DeclSpec.h:2432
Values of this type can be null.
bool isObjCAtKeyword(tok::ObjCKeywordKind objcKey) const
Return true if we have an ObjC keyword identifier.
Definition: Lexer.cpp:58
static Selector constructSetterSelector(IdentifierTable &Idents, SelectorTable &SelTable, const IdentifierInfo *Name)
Return the default setter selector for the given identifier.
ParsedAttributesView ArgAttrs
ArgAttrs - Attribute list for this argument.
Definition: Sema.h:8138
static ParsedType getTypeAnnotation(const Token &Tok)
getTypeAnnotation - Read a parsed type out of an annotation token.
Definition: Parser.h:712
PtrTy get() const
Definition: Ownership.h:174
bool isNot(T Kind) const
Definition: FormatToken.h:326
Whether values of this type can be null is (explicitly) unspecified.
ObjCContainerKind
Definition: Sema.h:7906
unsigned getNumTypeObjects() const
Return the number of types applied to this declarator.
Definition: DeclSpec.h:2164
StmtResult StmtError()
Definition: Ownership.h:284
iterator begin()
Definition: DeclGroup.h:100
Values of this type can never be null.
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:40
SourceLocation ConsumeAnyToken(bool ConsumeCodeCompletionTok=false)
ConsumeAnyToken - Dispatch to the right Consume* method based on the current token type...
Definition: Parser.h:432
IdentifierInfo * getIdentifier() const
Definition: DeclSpec.h:2116
DeclSpec & getMutableDeclSpec()
getMutableDeclSpec - Return a non-const version of the DeclSpec.
Definition: DeclSpec.h:1848
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:277
bool acceptsObjCTypeParams() const
Determines if this is an ObjC interface type that may accept type parameters.
Definition: Type.cpp:1463
bool isOneOf(A K1, B K2) const
Definition: FormatToken.h:319
void setSetterName(IdentifierInfo *name, SourceLocation loc)
Definition: DeclSpec.h:872
const ParsedAttributesView & getAttrs() const
If there are attributes applied to this declaratorchunk, return them.
Definition: DeclSpec.h:1525
SourceLocation NameLoc
Definition: Sema.h:8131
Expr - This represents one expression.
Definition: Expr.h:106
The message is an instance message.
Definition: Sema.h:8186
This file defines the classes used to store parsed information about declaration-specifiers and decla...
ObjCTypeParamListScope(Sema &Actions, Scope *S)
Definition: ParseObjc.cpp:104
Code completion occurs within an Objective-C interface, protocol, or category.
Definition: Sema.h:10200
SourceLocation getLocation() const
Return a source location identifier for the specified offset in the current file. ...
Definition: Token.h:124
This is a compound statement scope.
Definition: Scope.h:130
A class for parsing a field declarator.
static void diagnoseRedundantPropertyNullability(Parser &P, ObjCDeclSpec &DS, NullabilityKind nullability, SourceLocation nullabilityLoc)
Diagnose redundant or conflicting nullability information.
Definition: ParseObjc.cpp:791
DeclaratorContext
Definition: DeclSpec.h:1710
bool isInvalid() const
Definition: Ownership.h:170
SourceLocation getOpenLocation() const
bool isUsable() const
Definition: Ownership.h:171
The result type of a method or function.
Code completion occurs within the list of instance variables in an Objective-C interface, protocol, category, or implementation.
Definition: Sema.h:10206
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:720
ObjCTypeParamVariance
Describes the variance of a given generic parameter.
Definition: DeclObjC.h:553
ObjCKeywordKind
Provides a namespace for Objective-C keywords which start with an &#39;@&#39;.
Definition: TokenKinds.h:41
RAII object that makes &#39;>&#39; behave either as an operator or as the closing angle bracket for a templat...
OpaquePtr< DeclGroupRef > DeclGroupPtrTy
Definition: Parser.h:375
PrettyDeclStackTraceEntry - If a crash occurs in the parser while parsing something related to a decl...
const LangOptions & getLangOpts() const
Definition: Parser.h:359
This is a scope that corresponds to the parameters within a function prototype for a function declara...
Definition: Scope.h:87
NullabilityKind getNullability() const
Definition: DeclSpec.h:839
A class for parsing a DeclSpec.
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclBase.h:409
void addAtStart(ParsedAttr *newAttr)
Definition: ParsedAttr.h:731
ObjCDeclQualifier
ObjCDeclQualifier - Qualifier used on types in method declarations.
Definition: DeclSpec.h:785
void CodeCompleteObjCAtDirective(Scope *S)
Kind
Stop skipping at semicolon.
Definition: Parser.h:1019
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:157
Encodes a location in the source.
bool TryAnnotateTypeOrScopeToken()
TryAnnotateTypeOrScopeToken - If the current token position is on a typename (possibly qualified in C...
Definition: Parser.cpp:1651
bool is(tok::TokenKind Kind) const
Definition: FormatToken.h:310
std::pair< NullabilityKind, bool > DiagNullabilityKind
A nullability kind paired with a bit indicating whether it used a context-sensitive keyword...
Definition: Diagnostic.h:1289
This is a scope that corresponds to the Objective-C @catch statement.
Definition: Scope.h:91
IdentifierInfo * getIdentifierInfo() const
Definition: Token.h:177
ParsedAttr - Represents a syntactic attribute.
Definition: ParsedAttr.h:105
const char * getNameStart() const
Return the beginning of the actual null-terminated string for this identifier.
ObjCPropertyAttributeKind getPropertyAttributes() const
Definition: DeclSpec.h:831
The message is sent to &#39;super&#39;.
Definition: Sema.h:8184
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Definition: TokenKinds.h:25
void remove(ParsedAttr *ToBeRemoved)
Definition: ParsedAttr.h:740
Scope * getCurScope() const
Definition: Parser.h:366
tok::ObjCKeywordKind getObjCKeywordID() const
Return the ObjC keyword kind.
Definition: Lexer.cpp:67
void popObjCTypeParamList(Scope *S, ObjCTypeParamList *typeParamList)
The scope of a struct/union/class definition.
Definition: Scope.h:65
bool isNot(tok::TokenKind K) const
Definition: Token.h:96
ObjCDeclSpec DeclSpec
Definition: Sema.h:8135
Dataflow Directional Tag Classes.
std::pair< IdentifierInfo *, SourceLocation > IdentifierLocPair
A simple pair of identifier info and location.
bool isValid() const
Return true if this is a valid SourceLocation object.
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
Definition: Diagnostic.h:118
void takeAllFrom(AttributePool &pool)
Take the given pool&#39;s allocations and add them to this pool.
Definition: ParsedAttr.h:649
bool isOneOf(tok::TokenKind K1, tok::TokenKind K2) const
Definition: Token.h:97
SkipUntilFlags
Control flags for SkipUntil functions.
Definition: Parser.h:1018
void setObjCDeclQualifier(ObjCDeclQualifier DQVal)
Definition: DeclSpec.h:824
const TargetInfo & getTargetInfo() const
Definition: Parser.h:360
DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Definition: Parser.cpp:73
SourceLocation getNullabilityLoc() const
Definition: DeclSpec.h:846
void setNullability(SourceLocation loc, NullabilityKind kind)
Definition: DeclSpec.h:853
ExprResult ParseAssignmentExpression(TypeCastState isTypeCast=NotTypeCast)
Parse an expr that doesn&#39;t include (top-level) commas.
Definition: ParseExpr.cpp:160
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
Definition: Diagnostic.h:92
This is a scope that can contain a declaration.
Definition: Scope.h:59
bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
Definition: DeclSpec.cpp:749
SourceLocation getIdentifierLoc() const
Definition: DeclSpec.h:2122
X
Add a minimal nested name specifier fixit hint to allow lookup of a tag name from an outer enclosing ...
Definition: SemaDecl.cpp:13820
Context-sensitive version of a keyword attribute.
Definition: ParsedAttr.h:133
Captures information about "declaration specifiers".
Definition: DeclSpec.h:228
void setEnd(SourceLocation e)
SourceLocation ConsumeToken()
ConsumeToken - Consume the current &#39;peek token&#39; and lex the next one.
Definition: Parser.h:404
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
Definition: DeclSpec.h:1841
Stores a list of Objective-C type parameters for a parameterized class or a category/extension thereo...
Definition: DeclObjC.h:656
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string...
Definition: Diagnostic.h:129
AttributePool & getPool() const
Definition: ParsedAttr.h:808
ExprResult ExprError()
Definition: Ownership.h:283
const IdentifierInfo * getGetterName() const
Definition: DeclSpec.h:861
ParamInfo - An array of paraminfo objects is allocated whenever a function declarator is parsed...
Definition: DeclSpec.h:1214
static void addContextSensitiveTypeNullability(Parser &P, Declarator &D, NullabilityKind nullability, SourceLocation nullabilityLoc, bool &addedToDeclSpec)
Add an attribute for a context-sensitive type nullability to the given declarator.
Definition: ParseObjc.cpp:373
A trivial tuple used to represent a source range.
static void takeDeclAttributes(ParsedAttributesView &attrs, ParsedAttributesView &from)
Take all the decl attributes out of the given list and add them to the given attribute set...
Definition: ParseObjc.cpp:1196
void setGetterName(IdentifierInfo *name, SourceLocation loc)
Definition: DeclSpec.h:864
void enter(ObjCTypeParamList *P)
Definition: ParseObjc.cpp:111
bool isObjCAtKeyword(tok::ObjCKeywordKind Kind) const
Definition: FormatToken.h:344
static OpaquePtr getFromOpaquePtr(void *P)
Definition: Ownership.h:92
AttributePool & getAttributePool() const
Definition: DeclSpec.h:723
SourceLocation getBegin() const
ParsedAttributes - A collection of parsed attributes.
Definition: ParsedAttr.h:803
SourceLocation ColonLoc
Location of &#39;:&#39;.
Definition: OpenMPClause.h:102
This scope corresponds to an Objective-C method body.
Definition: Scope.h:95
The parameter is invariant: must match exactly.
TypeResult ParseTypeName(SourceRange *Range=nullptr, DeclaratorContext Context=DeclaratorContext::TypeNameContext, AccessSpecifier AS=AS_none, Decl **OwnedType=nullptr, ParsedAttributes *Attrs=nullptr)
ParseTypeName type-name: [C99 6.7.6] specifier-qualifier-list abstract-declarator[opt].
Definition: ParseDecl.cpp:44
ParsedAttributes & getAttributes()
Definition: DeclSpec.h:750
IdentifierInfo * Name
Definition: Sema.h:8130
void startToken()
Reset all flags to cleared.
Definition: Token.h:169
Stop skipping at specified token, but don&#39;t skip the token itself.
Definition: Parser.h:1021