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