xref: /freebsd/contrib/llvm-project/clang/lib/Parse/ParseObjc.cpp (revision 7877fdebeeb35fad1cbbafce22598b1bdf97c786)
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 
25 using namespace clang;
26 
27 /// Skips attributes after an Objective-C @ directive. Emits a diagnostic.
28 void Parser::MaybeSkipAttributes(tok::ObjCKeywordKind Kind) {
29   ParsedAttributes attrs(AttrFactory);
30   if (Tok.is(tok::kw___attribute)) {
31     if (Kind == tok::objc_interface || Kind == tok::objc_protocol)
32       Diag(Tok, diag::err_objc_postfix_attribute_hint)
33           << (Kind == tok::objc_protocol);
34     else
35       Diag(Tok, diag::err_objc_postfix_attribute);
36     ParseGNUAttributes(attrs);
37   }
38 }
39 
40 /// ParseObjCAtDirectives - Handle parts of the external-declaration production:
41 ///       external-declaration: [C99 6.9]
42 /// [OBJC]  objc-class-definition
43 /// [OBJC]  objc-class-declaration
44 /// [OBJC]  objc-alias-declaration
45 /// [OBJC]  objc-protocol-definition
46 /// [OBJC]  objc-method-definition
47 /// [OBJC]  '@' 'end'
48 Parser::DeclGroupPtrTy
49 Parser::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.
98 class Parser::ObjCTypeParamListScope {
99   Sema &Actions;
100   Scope *S;
101   ObjCTypeParamList *Params;
102 
103 public:
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 ///
130 Parser::DeclGroupPtrTy
131 Parser::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 
166 void Parser::CheckNestedObjCContexts(SourceLocation AtLoc)
167 {
168   Sema::ObjCContainerKind ock = Actions.getObjCContainerKind();
169   if (ock == Sema::OCK_None)
170     return;
171 
172   Decl *Decl = Actions.getObjCDeclContext();
173   if (CurParsedObjCImpl) {
174     CurParsedObjCImpl->finish(AtLoc);
175   } else {
176     Actions.ActOnAtEnd(getCurScope(), AtLoc);
177   }
178   Diag(AtLoc, diag::err_objc_missing_end)
179       << FixItHint::CreateInsertion(AtLoc, "@end\n");
180   if (Decl)
181     Diag(Decl->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 ///
213 Decl *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.
372 static 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 '>'.
421 ObjCTypeParamList *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.
570 ObjCTypeParamList *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 ///
593 void 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.
800 static 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 ///
843 void 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 ///
986 Decl *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 ///
1007 IdentifierInfo *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 ///
1115 bool 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 ///
1142 void 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.
1208 static 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.
1220 static 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 ///
1237 ParsedType 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 ///
1331 Decl *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 ///
1521 bool Parser::
1522 ParseObjCProtocolReferences(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 
1564 TypeResult 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 ///
1592 void 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 
1771 void 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 
1824 TypeResult 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 
1866 void 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 ///
1904 void 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.
2017 Parser::DeclGroupPtrTy
2018 Parser::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 )
2099 Parser::DeclGroupPtrTy
2100 Parser::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 
2228 Parser::DeclGroupPtrTy
2229 Parser::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 
2241 Parser::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 
2255 void 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 ///
2282 Decl *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 ///
2310 Decl *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 ///
2364 Decl *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 ///
2424 StmtResult 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 ///
2442 StmtResult
2443 Parser::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 ///
2502 StmtResult 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 ///
2621 StmtResult
2622 Parser::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.
2643 void 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 ///
2687 Decl *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 
2729 StmtResult 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 
2770 ExprResult 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
2897 bool 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.
2970 bool 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 
2977 bool 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 ///
3015 ExprResult 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 ///
3149 ExprResult
3150 Parser::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 
3316 ExprResult 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 ///                        ;
3350 ExprResult 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 ///                        ;
3359 ExprResult 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 ///                    ;
3373 ExprResult 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 )
3385 ExprResult
3386 Parser::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 
3407 ExprResult 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 
3450 ExprResult 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 )
3519 ExprResult
3520 Parser::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 )
3544 ExprResult
3545 Parser::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] ')'
3569 ExprResult 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 
3634 void 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