xref: /freebsd/contrib/llvm-project/clang/lib/Parse/ParseDecl.cpp (revision a90b9d0159070121c221b966469c3e36d912bf82)
1 //===--- ParseDecl.cpp - Declaration Parsing --------------------*- C++ -*-===//
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 Declaration portions of the Parser interfaces.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "clang/AST/ASTContext.h"
14 #include "clang/AST/DeclTemplate.h"
15 #include "clang/AST/PrettyDeclStackTrace.h"
16 #include "clang/Basic/AddressSpaces.h"
17 #include "clang/Basic/AttributeCommonInfo.h"
18 #include "clang/Basic/Attributes.h"
19 #include "clang/Basic/CharInfo.h"
20 #include "clang/Basic/TargetInfo.h"
21 #include "clang/Basic/TokenKinds.h"
22 #include "clang/Parse/ParseDiagnostic.h"
23 #include "clang/Parse/Parser.h"
24 #include "clang/Parse/RAIIObjectsForParser.h"
25 #include "clang/Sema/EnterExpressionEvaluationContext.h"
26 #include "clang/Sema/Lookup.h"
27 #include "clang/Sema/ParsedTemplate.h"
28 #include "clang/Sema/Scope.h"
29 #include "clang/Sema/SemaDiagnostic.h"
30 #include "llvm/ADT/SmallSet.h"
31 #include "llvm/ADT/SmallString.h"
32 #include "llvm/ADT/StringSwitch.h"
33 #include <optional>
34 
35 using namespace clang;
36 
37 //===----------------------------------------------------------------------===//
38 // C99 6.7: Declarations.
39 //===----------------------------------------------------------------------===//
40 
41 /// ParseTypeName
42 ///       type-name: [C99 6.7.6]
43 ///         specifier-qualifier-list abstract-declarator[opt]
44 ///
45 /// Called type-id in C++.
46 TypeResult Parser::ParseTypeName(SourceRange *Range, DeclaratorContext Context,
47                                  AccessSpecifier AS, Decl **OwnedType,
48                                  ParsedAttributes *Attrs) {
49   DeclSpecContext DSC = getDeclSpecContextFromDeclaratorContext(Context);
50   if (DSC == DeclSpecContext::DSC_normal)
51     DSC = DeclSpecContext::DSC_type_specifier;
52 
53   // Parse the common declaration-specifiers piece.
54   DeclSpec DS(AttrFactory);
55   if (Attrs)
56     DS.addAttributes(*Attrs);
57   ParseSpecifierQualifierList(DS, AS, DSC);
58   if (OwnedType)
59     *OwnedType = DS.isTypeSpecOwned() ? DS.getRepAsDecl() : nullptr;
60 
61   // Move declspec attributes to ParsedAttributes
62   if (Attrs) {
63     llvm::SmallVector<ParsedAttr *, 1> ToBeMoved;
64     for (ParsedAttr &AL : DS.getAttributes()) {
65       if (AL.isDeclspecAttribute())
66         ToBeMoved.push_back(&AL);
67     }
68 
69     for (ParsedAttr *AL : ToBeMoved)
70       Attrs->takeOneFrom(DS.getAttributes(), AL);
71   }
72 
73   // Parse the abstract-declarator, if present.
74   Declarator DeclaratorInfo(DS, ParsedAttributesView::none(), Context);
75   ParseDeclarator(DeclaratorInfo);
76   if (Range)
77     *Range = DeclaratorInfo.getSourceRange();
78 
79   if (DeclaratorInfo.isInvalidType())
80     return true;
81 
82   return Actions.ActOnTypeName(DeclaratorInfo);
83 }
84 
85 /// Normalizes an attribute name by dropping prefixed and suffixed __.
86 static StringRef normalizeAttrName(StringRef Name) {
87   if (Name.size() >= 4 && Name.starts_with("__") && Name.ends_with("__"))
88     return Name.drop_front(2).drop_back(2);
89   return Name;
90 }
91 
92 /// isAttributeLateParsed - Return true if the attribute has arguments that
93 /// require late parsing.
94 static bool isAttributeLateParsed(const IdentifierInfo &II) {
95 #define CLANG_ATTR_LATE_PARSED_LIST
96     return llvm::StringSwitch<bool>(normalizeAttrName(II.getName()))
97 #include "clang/Parse/AttrParserStringSwitches.inc"
98         .Default(false);
99 #undef CLANG_ATTR_LATE_PARSED_LIST
100 }
101 
102 /// Check if the a start and end source location expand to the same macro.
103 static bool FindLocsWithCommonFileID(Preprocessor &PP, SourceLocation StartLoc,
104                                      SourceLocation EndLoc) {
105   if (!StartLoc.isMacroID() || !EndLoc.isMacroID())
106     return false;
107 
108   SourceManager &SM = PP.getSourceManager();
109   if (SM.getFileID(StartLoc) != SM.getFileID(EndLoc))
110     return false;
111 
112   bool AttrStartIsInMacro =
113       Lexer::isAtStartOfMacroExpansion(StartLoc, SM, PP.getLangOpts());
114   bool AttrEndIsInMacro =
115       Lexer::isAtEndOfMacroExpansion(EndLoc, SM, PP.getLangOpts());
116   return AttrStartIsInMacro && AttrEndIsInMacro;
117 }
118 
119 void Parser::ParseAttributes(unsigned WhichAttrKinds, ParsedAttributes &Attrs,
120                              LateParsedAttrList *LateAttrs) {
121   bool MoreToParse;
122   do {
123     // Assume there's nothing left to parse, but if any attributes are in fact
124     // parsed, loop to ensure all specified attribute combinations are parsed.
125     MoreToParse = false;
126     if (WhichAttrKinds & PAKM_CXX11)
127       MoreToParse |= MaybeParseCXX11Attributes(Attrs);
128     if (WhichAttrKinds & PAKM_GNU)
129       MoreToParse |= MaybeParseGNUAttributes(Attrs, LateAttrs);
130     if (WhichAttrKinds & PAKM_Declspec)
131       MoreToParse |= MaybeParseMicrosoftDeclSpecs(Attrs);
132   } while (MoreToParse);
133 }
134 
135 /// ParseGNUAttributes - Parse a non-empty attributes list.
136 ///
137 /// [GNU] attributes:
138 ///         attribute
139 ///         attributes attribute
140 ///
141 /// [GNU]  attribute:
142 ///          '__attribute__' '(' '(' attribute-list ')' ')'
143 ///
144 /// [GNU]  attribute-list:
145 ///          attrib
146 ///          attribute_list ',' attrib
147 ///
148 /// [GNU]  attrib:
149 ///          empty
150 ///          attrib-name
151 ///          attrib-name '(' identifier ')'
152 ///          attrib-name '(' identifier ',' nonempty-expr-list ')'
153 ///          attrib-name '(' argument-expression-list [C99 6.5.2] ')'
154 ///
155 /// [GNU]  attrib-name:
156 ///          identifier
157 ///          typespec
158 ///          typequal
159 ///          storageclass
160 ///
161 /// Whether an attribute takes an 'identifier' is determined by the
162 /// attrib-name. GCC's behavior here is not worth imitating:
163 ///
164 ///  * In C mode, if the attribute argument list starts with an identifier
165 ///    followed by a ',' or an ')', and the identifier doesn't resolve to
166 ///    a type, it is parsed as an identifier. If the attribute actually
167 ///    wanted an expression, it's out of luck (but it turns out that no
168 ///    attributes work that way, because C constant expressions are very
169 ///    limited).
170 ///  * In C++ mode, if the attribute argument list starts with an identifier,
171 ///    and the attribute *wants* an identifier, it is parsed as an identifier.
172 ///    At block scope, any additional tokens between the identifier and the
173 ///    ',' or ')' are ignored, otherwise they produce a parse error.
174 ///
175 /// We follow the C++ model, but don't allow junk after the identifier.
176 void Parser::ParseGNUAttributes(ParsedAttributes &Attrs,
177                                 LateParsedAttrList *LateAttrs, Declarator *D) {
178   assert(Tok.is(tok::kw___attribute) && "Not a GNU attribute list!");
179 
180   SourceLocation StartLoc = Tok.getLocation();
181   SourceLocation EndLoc = StartLoc;
182 
183   while (Tok.is(tok::kw___attribute)) {
184     SourceLocation AttrTokLoc = ConsumeToken();
185     unsigned OldNumAttrs = Attrs.size();
186     unsigned OldNumLateAttrs = LateAttrs ? LateAttrs->size() : 0;
187 
188     if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after,
189                          "attribute")) {
190       SkipUntil(tok::r_paren, StopAtSemi); // skip until ) or ;
191       return;
192     }
193     if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after, "(")) {
194       SkipUntil(tok::r_paren, StopAtSemi); // skip until ) or ;
195       return;
196     }
197     // Parse the attribute-list. e.g. __attribute__(( weak, alias("__f") ))
198     do {
199       // Eat preceeding commas to allow __attribute__((,,,foo))
200       while (TryConsumeToken(tok::comma))
201         ;
202 
203       // Expect an identifier or declaration specifier (const, int, etc.)
204       if (Tok.isAnnotation())
205         break;
206       if (Tok.is(tok::code_completion)) {
207         cutOffParsing();
208         Actions.CodeCompleteAttribute(AttributeCommonInfo::Syntax::AS_GNU);
209         break;
210       }
211       IdentifierInfo *AttrName = Tok.getIdentifierInfo();
212       if (!AttrName)
213         break;
214 
215       SourceLocation AttrNameLoc = ConsumeToken();
216 
217       if (Tok.isNot(tok::l_paren)) {
218         Attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
219                      ParsedAttr::Form::GNU());
220         continue;
221       }
222 
223       // Handle "parameterized" attributes
224       if (!LateAttrs || !isAttributeLateParsed(*AttrName)) {
225         ParseGNUAttributeArgs(AttrName, AttrNameLoc, Attrs, &EndLoc, nullptr,
226                               SourceLocation(), ParsedAttr::Form::GNU(), D);
227         continue;
228       }
229 
230       // Handle attributes with arguments that require late parsing.
231       LateParsedAttribute *LA =
232           new LateParsedAttribute(this, *AttrName, AttrNameLoc);
233       LateAttrs->push_back(LA);
234 
235       // Attributes in a class are parsed at the end of the class, along
236       // with other late-parsed declarations.
237       if (!ClassStack.empty() && !LateAttrs->parseSoon())
238         getCurrentClass().LateParsedDeclarations.push_back(LA);
239 
240       // Be sure ConsumeAndStoreUntil doesn't see the start l_paren, since it
241       // recursively consumes balanced parens.
242       LA->Toks.push_back(Tok);
243       ConsumeParen();
244       // Consume everything up to and including the matching right parens.
245       ConsumeAndStoreUntil(tok::r_paren, LA->Toks, /*StopAtSemi=*/true);
246 
247       Token Eof;
248       Eof.startToken();
249       Eof.setLocation(Tok.getLocation());
250       LA->Toks.push_back(Eof);
251     } while (Tok.is(tok::comma));
252 
253     if (ExpectAndConsume(tok::r_paren))
254       SkipUntil(tok::r_paren, StopAtSemi);
255     SourceLocation Loc = Tok.getLocation();
256     if (ExpectAndConsume(tok::r_paren))
257       SkipUntil(tok::r_paren, StopAtSemi);
258     EndLoc = Loc;
259 
260     // If this was declared in a macro, attach the macro IdentifierInfo to the
261     // parsed attribute.
262     auto &SM = PP.getSourceManager();
263     if (!SM.isWrittenInBuiltinFile(SM.getSpellingLoc(AttrTokLoc)) &&
264         FindLocsWithCommonFileID(PP, AttrTokLoc, Loc)) {
265       CharSourceRange ExpansionRange = SM.getExpansionRange(AttrTokLoc);
266       StringRef FoundName =
267           Lexer::getSourceText(ExpansionRange, SM, PP.getLangOpts());
268       IdentifierInfo *MacroII = PP.getIdentifierInfo(FoundName);
269 
270       for (unsigned i = OldNumAttrs; i < Attrs.size(); ++i)
271         Attrs[i].setMacroIdentifier(MacroII, ExpansionRange.getBegin());
272 
273       if (LateAttrs) {
274         for (unsigned i = OldNumLateAttrs; i < LateAttrs->size(); ++i)
275           (*LateAttrs)[i]->MacroII = MacroII;
276       }
277     }
278   }
279 
280   Attrs.Range = SourceRange(StartLoc, EndLoc);
281 }
282 
283 /// Determine whether the given attribute has an identifier argument.
284 static bool attributeHasIdentifierArg(const IdentifierInfo &II) {
285 #define CLANG_ATTR_IDENTIFIER_ARG_LIST
286   return llvm::StringSwitch<bool>(normalizeAttrName(II.getName()))
287 #include "clang/Parse/AttrParserStringSwitches.inc"
288            .Default(false);
289 #undef CLANG_ATTR_IDENTIFIER_ARG_LIST
290 }
291 
292 /// Determine whether the given attribute has an identifier argument.
293 static ParsedAttributeArgumentsProperties
294 attributeStringLiteralListArg(const IdentifierInfo &II) {
295 #define CLANG_ATTR_STRING_LITERAL_ARG_LIST
296   return llvm::StringSwitch<uint32_t>(normalizeAttrName(II.getName()))
297 #include "clang/Parse/AttrParserStringSwitches.inc"
298       .Default(0);
299 #undef CLANG_ATTR_STRING_LITERAL_ARG_LIST
300 }
301 
302 /// Determine whether the given attribute has a variadic identifier argument.
303 static bool attributeHasVariadicIdentifierArg(const IdentifierInfo &II) {
304 #define CLANG_ATTR_VARIADIC_IDENTIFIER_ARG_LIST
305   return llvm::StringSwitch<bool>(normalizeAttrName(II.getName()))
306 #include "clang/Parse/AttrParserStringSwitches.inc"
307            .Default(false);
308 #undef CLANG_ATTR_VARIADIC_IDENTIFIER_ARG_LIST
309 }
310 
311 /// Determine whether the given attribute treats kw_this as an identifier.
312 static bool attributeTreatsKeywordThisAsIdentifier(const IdentifierInfo &II) {
313 #define CLANG_ATTR_THIS_ISA_IDENTIFIER_ARG_LIST
314   return llvm::StringSwitch<bool>(normalizeAttrName(II.getName()))
315 #include "clang/Parse/AttrParserStringSwitches.inc"
316            .Default(false);
317 #undef CLANG_ATTR_THIS_ISA_IDENTIFIER_ARG_LIST
318 }
319 
320 /// Determine if an attribute accepts parameter packs.
321 static bool attributeAcceptsExprPack(const IdentifierInfo &II) {
322 #define CLANG_ATTR_ACCEPTS_EXPR_PACK
323   return llvm::StringSwitch<bool>(normalizeAttrName(II.getName()))
324 #include "clang/Parse/AttrParserStringSwitches.inc"
325       .Default(false);
326 #undef CLANG_ATTR_ACCEPTS_EXPR_PACK
327 }
328 
329 /// Determine whether the given attribute parses a type argument.
330 static bool attributeIsTypeArgAttr(const IdentifierInfo &II) {
331 #define CLANG_ATTR_TYPE_ARG_LIST
332   return llvm::StringSwitch<bool>(normalizeAttrName(II.getName()))
333 #include "clang/Parse/AttrParserStringSwitches.inc"
334            .Default(false);
335 #undef CLANG_ATTR_TYPE_ARG_LIST
336 }
337 
338 /// Determine whether the given attribute requires parsing its arguments
339 /// in an unevaluated context or not.
340 static bool attributeParsedArgsUnevaluated(const IdentifierInfo &II) {
341 #define CLANG_ATTR_ARG_CONTEXT_LIST
342   return llvm::StringSwitch<bool>(normalizeAttrName(II.getName()))
343 #include "clang/Parse/AttrParserStringSwitches.inc"
344            .Default(false);
345 #undef CLANG_ATTR_ARG_CONTEXT_LIST
346 }
347 
348 IdentifierLoc *Parser::ParseIdentifierLoc() {
349   assert(Tok.is(tok::identifier) && "expected an identifier");
350   IdentifierLoc *IL = IdentifierLoc::create(Actions.Context,
351                                             Tok.getLocation(),
352                                             Tok.getIdentifierInfo());
353   ConsumeToken();
354   return IL;
355 }
356 
357 void Parser::ParseAttributeWithTypeArg(IdentifierInfo &AttrName,
358                                        SourceLocation AttrNameLoc,
359                                        ParsedAttributes &Attrs,
360                                        IdentifierInfo *ScopeName,
361                                        SourceLocation ScopeLoc,
362                                        ParsedAttr::Form Form) {
363   BalancedDelimiterTracker Parens(*this, tok::l_paren);
364   Parens.consumeOpen();
365 
366   TypeResult T;
367   if (Tok.isNot(tok::r_paren))
368     T = ParseTypeName();
369 
370   if (Parens.consumeClose())
371     return;
372 
373   if (T.isInvalid())
374     return;
375 
376   if (T.isUsable())
377     Attrs.addNewTypeAttr(&AttrName,
378                          SourceRange(AttrNameLoc, Parens.getCloseLocation()),
379                          ScopeName, ScopeLoc, T.get(), Form);
380   else
381     Attrs.addNew(&AttrName, SourceRange(AttrNameLoc, Parens.getCloseLocation()),
382                  ScopeName, ScopeLoc, nullptr, 0, Form);
383 }
384 
385 ExprResult
386 Parser::ParseUnevaluatedStringInAttribute(const IdentifierInfo &AttrName) {
387   if (Tok.is(tok::l_paren)) {
388     BalancedDelimiterTracker Paren(*this, tok::l_paren);
389     Paren.consumeOpen();
390     ExprResult Res = ParseUnevaluatedStringInAttribute(AttrName);
391     Paren.consumeClose();
392     return Res;
393   }
394   if (!isTokenStringLiteral()) {
395     Diag(Tok.getLocation(), diag::err_expected_string_literal)
396         << /*in attribute...*/ 4 << AttrName.getName();
397     return ExprError();
398   }
399   return ParseUnevaluatedStringLiteralExpression();
400 }
401 
402 bool Parser::ParseAttributeArgumentList(
403     const IdentifierInfo &AttrName, SmallVectorImpl<Expr *> &Exprs,
404     ParsedAttributeArgumentsProperties ArgsProperties) {
405   bool SawError = false;
406   unsigned Arg = 0;
407   while (true) {
408     ExprResult Expr;
409     if (ArgsProperties.isStringLiteralArg(Arg)) {
410       Expr = ParseUnevaluatedStringInAttribute(AttrName);
411     } else if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
412       Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);
413       Expr = ParseBraceInitializer();
414     } else {
415       Expr = ParseAssignmentExpression();
416     }
417     Expr = Actions.CorrectDelayedTyposInExpr(Expr);
418 
419     if (Tok.is(tok::ellipsis))
420       Expr = Actions.ActOnPackExpansion(Expr.get(), ConsumeToken());
421     else if (Tok.is(tok::code_completion)) {
422       // There's nothing to suggest in here as we parsed a full expression.
423       // Instead fail and propagate the error since caller might have something
424       // the suggest, e.g. signature help in function call. Note that this is
425       // performed before pushing the \p Expr, so that signature help can report
426       // current argument correctly.
427       SawError = true;
428       cutOffParsing();
429       break;
430     }
431 
432     if (Expr.isInvalid()) {
433       SawError = true;
434       break;
435     }
436 
437     Exprs.push_back(Expr.get());
438 
439     if (Tok.isNot(tok::comma))
440       break;
441     // Move to the next argument, remember where the comma was.
442     Token Comma = Tok;
443     ConsumeToken();
444     checkPotentialAngleBracketDelimiter(Comma);
445     Arg++;
446   }
447 
448   if (SawError) {
449     // Ensure typos get diagnosed when errors were encountered while parsing the
450     // expression list.
451     for (auto &E : Exprs) {
452       ExprResult Expr = Actions.CorrectDelayedTyposInExpr(E);
453       if (Expr.isUsable())
454         E = Expr.get();
455     }
456   }
457   return SawError;
458 }
459 
460 unsigned Parser::ParseAttributeArgsCommon(
461     IdentifierInfo *AttrName, SourceLocation AttrNameLoc,
462     ParsedAttributes &Attrs, SourceLocation *EndLoc, IdentifierInfo *ScopeName,
463     SourceLocation ScopeLoc, ParsedAttr::Form Form) {
464   // Ignore the left paren location for now.
465   ConsumeParen();
466 
467   bool ChangeKWThisToIdent = attributeTreatsKeywordThisAsIdentifier(*AttrName);
468   bool AttributeIsTypeArgAttr = attributeIsTypeArgAttr(*AttrName);
469   bool AttributeHasVariadicIdentifierArg =
470       attributeHasVariadicIdentifierArg(*AttrName);
471 
472   // Interpret "kw_this" as an identifier if the attributed requests it.
473   if (ChangeKWThisToIdent && Tok.is(tok::kw_this))
474     Tok.setKind(tok::identifier);
475 
476   ArgsVector ArgExprs;
477   if (Tok.is(tok::identifier)) {
478     // If this attribute wants an 'identifier' argument, make it so.
479     bool IsIdentifierArg = AttributeHasVariadicIdentifierArg ||
480                            attributeHasIdentifierArg(*AttrName);
481     ParsedAttr::Kind AttrKind =
482         ParsedAttr::getParsedKind(AttrName, ScopeName, Form.getSyntax());
483 
484     // If we don't know how to parse this attribute, but this is the only
485     // token in this argument, assume it's meant to be an identifier.
486     if (AttrKind == ParsedAttr::UnknownAttribute ||
487         AttrKind == ParsedAttr::IgnoredAttribute) {
488       const Token &Next = NextToken();
489       IsIdentifierArg = Next.isOneOf(tok::r_paren, tok::comma);
490     }
491 
492     if (IsIdentifierArg)
493       ArgExprs.push_back(ParseIdentifierLoc());
494   }
495 
496   ParsedType TheParsedType;
497   if (!ArgExprs.empty() ? Tok.is(tok::comma) : Tok.isNot(tok::r_paren)) {
498     // Eat the comma.
499     if (!ArgExprs.empty())
500       ConsumeToken();
501 
502     if (AttributeIsTypeArgAttr) {
503       // FIXME: Multiple type arguments are not implemented.
504       TypeResult T = ParseTypeName();
505       if (T.isInvalid()) {
506         SkipUntil(tok::r_paren, StopAtSemi);
507         return 0;
508       }
509       if (T.isUsable())
510         TheParsedType = T.get();
511     } else if (AttributeHasVariadicIdentifierArg) {
512       // Parse variadic identifier arg. This can either consume identifiers or
513       // expressions. Variadic identifier args do not support parameter packs
514       // because those are typically used for attributes with enumeration
515       // arguments, and those enumerations are not something the user could
516       // express via a pack.
517       do {
518         // Interpret "kw_this" as an identifier if the attributed requests it.
519         if (ChangeKWThisToIdent && Tok.is(tok::kw_this))
520           Tok.setKind(tok::identifier);
521 
522         ExprResult ArgExpr;
523         if (Tok.is(tok::identifier)) {
524           ArgExprs.push_back(ParseIdentifierLoc());
525         } else {
526           bool Uneval = attributeParsedArgsUnevaluated(*AttrName);
527           EnterExpressionEvaluationContext Unevaluated(
528               Actions,
529               Uneval ? Sema::ExpressionEvaluationContext::Unevaluated
530                      : Sema::ExpressionEvaluationContext::ConstantEvaluated);
531 
532           ExprResult ArgExpr(
533               Actions.CorrectDelayedTyposInExpr(ParseAssignmentExpression()));
534 
535           if (ArgExpr.isInvalid()) {
536             SkipUntil(tok::r_paren, StopAtSemi);
537             return 0;
538           }
539           ArgExprs.push_back(ArgExpr.get());
540         }
541         // Eat the comma, move to the next argument
542       } while (TryConsumeToken(tok::comma));
543     } else {
544       // General case. Parse all available expressions.
545       bool Uneval = attributeParsedArgsUnevaluated(*AttrName);
546       EnterExpressionEvaluationContext Unevaluated(
547           Actions, Uneval
548                        ? Sema::ExpressionEvaluationContext::Unevaluated
549                        : Sema::ExpressionEvaluationContext::ConstantEvaluated);
550 
551       ExprVector ParsedExprs;
552       ParsedAttributeArgumentsProperties ArgProperties =
553           attributeStringLiteralListArg(*AttrName);
554       if (ParseAttributeArgumentList(*AttrName, ParsedExprs, ArgProperties)) {
555         SkipUntil(tok::r_paren, StopAtSemi);
556         return 0;
557       }
558 
559       // Pack expansion must currently be explicitly supported by an attribute.
560       for (size_t I = 0; I < ParsedExprs.size(); ++I) {
561         if (!isa<PackExpansionExpr>(ParsedExprs[I]))
562           continue;
563 
564         if (!attributeAcceptsExprPack(*AttrName)) {
565           Diag(Tok.getLocation(),
566                diag::err_attribute_argument_parm_pack_not_supported)
567               << AttrName;
568           SkipUntil(tok::r_paren, StopAtSemi);
569           return 0;
570         }
571       }
572 
573       ArgExprs.insert(ArgExprs.end(), ParsedExprs.begin(), ParsedExprs.end());
574     }
575   }
576 
577   SourceLocation RParen = Tok.getLocation();
578   if (!ExpectAndConsume(tok::r_paren)) {
579     SourceLocation AttrLoc = ScopeLoc.isValid() ? ScopeLoc : AttrNameLoc;
580 
581     if (AttributeIsTypeArgAttr && !TheParsedType.get().isNull()) {
582       Attrs.addNewTypeAttr(AttrName, SourceRange(AttrNameLoc, RParen),
583                            ScopeName, ScopeLoc, TheParsedType, Form);
584     } else {
585       Attrs.addNew(AttrName, SourceRange(AttrLoc, RParen), ScopeName, ScopeLoc,
586                    ArgExprs.data(), ArgExprs.size(), Form);
587     }
588   }
589 
590   if (EndLoc)
591     *EndLoc = RParen;
592 
593   return static_cast<unsigned>(ArgExprs.size() + !TheParsedType.get().isNull());
594 }
595 
596 /// Parse the arguments to a parameterized GNU attribute or
597 /// a C++11 attribute in "gnu" namespace.
598 void Parser::ParseGNUAttributeArgs(
599     IdentifierInfo *AttrName, SourceLocation AttrNameLoc,
600     ParsedAttributes &Attrs, SourceLocation *EndLoc, IdentifierInfo *ScopeName,
601     SourceLocation ScopeLoc, ParsedAttr::Form Form, Declarator *D) {
602 
603   assert(Tok.is(tok::l_paren) && "Attribute arg list not starting with '('");
604 
605   ParsedAttr::Kind AttrKind =
606       ParsedAttr::getParsedKind(AttrName, ScopeName, Form.getSyntax());
607 
608   if (AttrKind == ParsedAttr::AT_Availability) {
609     ParseAvailabilityAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc, ScopeName,
610                                ScopeLoc, Form);
611     return;
612   } else if (AttrKind == ParsedAttr::AT_ExternalSourceSymbol) {
613     ParseExternalSourceSymbolAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc,
614                                        ScopeName, ScopeLoc, Form);
615     return;
616   } else if (AttrKind == ParsedAttr::AT_ObjCBridgeRelated) {
617     ParseObjCBridgeRelatedAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc,
618                                     ScopeName, ScopeLoc, Form);
619     return;
620   } else if (AttrKind == ParsedAttr::AT_SwiftNewType) {
621     ParseSwiftNewTypeAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc, ScopeName,
622                                ScopeLoc, Form);
623     return;
624   } else if (AttrKind == ParsedAttr::AT_TypeTagForDatatype) {
625     ParseTypeTagForDatatypeAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc,
626                                      ScopeName, ScopeLoc, Form);
627     return;
628   } else if (attributeIsTypeArgAttr(*AttrName)) {
629     ParseAttributeWithTypeArg(*AttrName, AttrNameLoc, Attrs, ScopeName,
630                               ScopeLoc, Form);
631     return;
632   }
633 
634   // These may refer to the function arguments, but need to be parsed early to
635   // participate in determining whether it's a redeclaration.
636   std::optional<ParseScope> PrototypeScope;
637   if (normalizeAttrName(AttrName->getName()) == "enable_if" &&
638       D && D->isFunctionDeclarator()) {
639     DeclaratorChunk::FunctionTypeInfo FTI = D->getFunctionTypeInfo();
640     PrototypeScope.emplace(this, Scope::FunctionPrototypeScope |
641                                      Scope::FunctionDeclarationScope |
642                                      Scope::DeclScope);
643     for (unsigned i = 0; i != FTI.NumParams; ++i) {
644       ParmVarDecl *Param = cast<ParmVarDecl>(FTI.Params[i].Param);
645       Actions.ActOnReenterCXXMethodParameter(getCurScope(), Param);
646     }
647   }
648 
649   ParseAttributeArgsCommon(AttrName, AttrNameLoc, Attrs, EndLoc, ScopeName,
650                            ScopeLoc, Form);
651 }
652 
653 unsigned Parser::ParseClangAttributeArgs(
654     IdentifierInfo *AttrName, SourceLocation AttrNameLoc,
655     ParsedAttributes &Attrs, SourceLocation *EndLoc, IdentifierInfo *ScopeName,
656     SourceLocation ScopeLoc, ParsedAttr::Form Form) {
657   assert(Tok.is(tok::l_paren) && "Attribute arg list not starting with '('");
658 
659   ParsedAttr::Kind AttrKind =
660       ParsedAttr::getParsedKind(AttrName, ScopeName, Form.getSyntax());
661 
662   switch (AttrKind) {
663   default:
664     return ParseAttributeArgsCommon(AttrName, AttrNameLoc, Attrs, EndLoc,
665                                     ScopeName, ScopeLoc, Form);
666   case ParsedAttr::AT_ExternalSourceSymbol:
667     ParseExternalSourceSymbolAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc,
668                                        ScopeName, ScopeLoc, Form);
669     break;
670   case ParsedAttr::AT_Availability:
671     ParseAvailabilityAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc, ScopeName,
672                                ScopeLoc, Form);
673     break;
674   case ParsedAttr::AT_ObjCBridgeRelated:
675     ParseObjCBridgeRelatedAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc,
676                                     ScopeName, ScopeLoc, Form);
677     break;
678   case ParsedAttr::AT_SwiftNewType:
679     ParseSwiftNewTypeAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc, ScopeName,
680                                ScopeLoc, Form);
681     break;
682   case ParsedAttr::AT_TypeTagForDatatype:
683     ParseTypeTagForDatatypeAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc,
684                                      ScopeName, ScopeLoc, Form);
685     break;
686   }
687   return !Attrs.empty() ? Attrs.begin()->getNumArgs() : 0;
688 }
689 
690 bool Parser::ParseMicrosoftDeclSpecArgs(IdentifierInfo *AttrName,
691                                         SourceLocation AttrNameLoc,
692                                         ParsedAttributes &Attrs) {
693   unsigned ExistingAttrs = Attrs.size();
694 
695   // If the attribute isn't known, we will not attempt to parse any
696   // arguments.
697   if (!hasAttribute(AttributeCommonInfo::Syntax::AS_Declspec, nullptr, AttrName,
698                     getTargetInfo(), getLangOpts())) {
699     // Eat the left paren, then skip to the ending right paren.
700     ConsumeParen();
701     SkipUntil(tok::r_paren);
702     return false;
703   }
704 
705   SourceLocation OpenParenLoc = Tok.getLocation();
706 
707   if (AttrName->getName() == "property") {
708     // The property declspec is more complex in that it can take one or two
709     // assignment expressions as a parameter, but the lhs of the assignment
710     // must be named get or put.
711 
712     BalancedDelimiterTracker T(*this, tok::l_paren);
713     T.expectAndConsume(diag::err_expected_lparen_after,
714                        AttrName->getNameStart(), tok::r_paren);
715 
716     enum AccessorKind {
717       AK_Invalid = -1,
718       AK_Put = 0,
719       AK_Get = 1 // indices into AccessorNames
720     };
721     IdentifierInfo *AccessorNames[] = {nullptr, nullptr};
722     bool HasInvalidAccessor = false;
723 
724     // Parse the accessor specifications.
725     while (true) {
726       // Stop if this doesn't look like an accessor spec.
727       if (!Tok.is(tok::identifier)) {
728         // If the user wrote a completely empty list, use a special diagnostic.
729         if (Tok.is(tok::r_paren) && !HasInvalidAccessor &&
730             AccessorNames[AK_Put] == nullptr &&
731             AccessorNames[AK_Get] == nullptr) {
732           Diag(AttrNameLoc, diag::err_ms_property_no_getter_or_putter);
733           break;
734         }
735 
736         Diag(Tok.getLocation(), diag::err_ms_property_unknown_accessor);
737         break;
738       }
739 
740       AccessorKind Kind;
741       SourceLocation KindLoc = Tok.getLocation();
742       StringRef KindStr = Tok.getIdentifierInfo()->getName();
743       if (KindStr == "get") {
744         Kind = AK_Get;
745       } else if (KindStr == "put") {
746         Kind = AK_Put;
747 
748         // Recover from the common mistake of using 'set' instead of 'put'.
749       } else if (KindStr == "set") {
750         Diag(KindLoc, diag::err_ms_property_has_set_accessor)
751             << FixItHint::CreateReplacement(KindLoc, "put");
752         Kind = AK_Put;
753 
754         // Handle the mistake of forgetting the accessor kind by skipping
755         // this accessor.
756       } else if (NextToken().is(tok::comma) || NextToken().is(tok::r_paren)) {
757         Diag(KindLoc, diag::err_ms_property_missing_accessor_kind);
758         ConsumeToken();
759         HasInvalidAccessor = true;
760         goto next_property_accessor;
761 
762         // Otherwise, complain about the unknown accessor kind.
763       } else {
764         Diag(KindLoc, diag::err_ms_property_unknown_accessor);
765         HasInvalidAccessor = true;
766         Kind = AK_Invalid;
767 
768         // Try to keep parsing unless it doesn't look like an accessor spec.
769         if (!NextToken().is(tok::equal))
770           break;
771       }
772 
773       // Consume the identifier.
774       ConsumeToken();
775 
776       // Consume the '='.
777       if (!TryConsumeToken(tok::equal)) {
778         Diag(Tok.getLocation(), diag::err_ms_property_expected_equal)
779             << KindStr;
780         break;
781       }
782 
783       // Expect the method name.
784       if (!Tok.is(tok::identifier)) {
785         Diag(Tok.getLocation(), diag::err_ms_property_expected_accessor_name);
786         break;
787       }
788 
789       if (Kind == AK_Invalid) {
790         // Just drop invalid accessors.
791       } else if (AccessorNames[Kind] != nullptr) {
792         // Complain about the repeated accessor, ignore it, and keep parsing.
793         Diag(KindLoc, diag::err_ms_property_duplicate_accessor) << KindStr;
794       } else {
795         AccessorNames[Kind] = Tok.getIdentifierInfo();
796       }
797       ConsumeToken();
798 
799     next_property_accessor:
800       // Keep processing accessors until we run out.
801       if (TryConsumeToken(tok::comma))
802         continue;
803 
804       // If we run into the ')', stop without consuming it.
805       if (Tok.is(tok::r_paren))
806         break;
807 
808       Diag(Tok.getLocation(), diag::err_ms_property_expected_comma_or_rparen);
809       break;
810     }
811 
812     // Only add the property attribute if it was well-formed.
813     if (!HasInvalidAccessor)
814       Attrs.addNewPropertyAttr(AttrName, AttrNameLoc, nullptr, SourceLocation(),
815                                AccessorNames[AK_Get], AccessorNames[AK_Put],
816                                ParsedAttr::Form::Declspec());
817     T.skipToEnd();
818     return !HasInvalidAccessor;
819   }
820 
821   unsigned NumArgs =
822       ParseAttributeArgsCommon(AttrName, AttrNameLoc, Attrs, nullptr, nullptr,
823                                SourceLocation(), ParsedAttr::Form::Declspec());
824 
825   // If this attribute's args were parsed, and it was expected to have
826   // arguments but none were provided, emit a diagnostic.
827   if (ExistingAttrs < Attrs.size() && Attrs.back().getMaxArgs() && !NumArgs) {
828     Diag(OpenParenLoc, diag::err_attribute_requires_arguments) << AttrName;
829     return false;
830   }
831   return true;
832 }
833 
834 /// [MS] decl-specifier:
835 ///             __declspec ( extended-decl-modifier-seq )
836 ///
837 /// [MS] extended-decl-modifier-seq:
838 ///             extended-decl-modifier[opt]
839 ///             extended-decl-modifier extended-decl-modifier-seq
840 void Parser::ParseMicrosoftDeclSpecs(ParsedAttributes &Attrs) {
841   assert(getLangOpts().DeclSpecKeyword && "__declspec keyword is not enabled");
842   assert(Tok.is(tok::kw___declspec) && "Not a declspec!");
843 
844   SourceLocation StartLoc = Tok.getLocation();
845   SourceLocation EndLoc = StartLoc;
846 
847   while (Tok.is(tok::kw___declspec)) {
848     ConsumeToken();
849     BalancedDelimiterTracker T(*this, tok::l_paren);
850     if (T.expectAndConsume(diag::err_expected_lparen_after, "__declspec",
851                            tok::r_paren))
852       return;
853 
854     // An empty declspec is perfectly legal and should not warn.  Additionally,
855     // you can specify multiple attributes per declspec.
856     while (Tok.isNot(tok::r_paren)) {
857       // Attribute not present.
858       if (TryConsumeToken(tok::comma))
859         continue;
860 
861       if (Tok.is(tok::code_completion)) {
862         cutOffParsing();
863         Actions.CodeCompleteAttribute(AttributeCommonInfo::AS_Declspec);
864         return;
865       }
866 
867       // We expect either a well-known identifier or a generic string.  Anything
868       // else is a malformed declspec.
869       bool IsString = Tok.getKind() == tok::string_literal;
870       if (!IsString && Tok.getKind() != tok::identifier &&
871           Tok.getKind() != tok::kw_restrict) {
872         Diag(Tok, diag::err_ms_declspec_type);
873         T.skipToEnd();
874         return;
875       }
876 
877       IdentifierInfo *AttrName;
878       SourceLocation AttrNameLoc;
879       if (IsString) {
880         SmallString<8> StrBuffer;
881         bool Invalid = false;
882         StringRef Str = PP.getSpelling(Tok, StrBuffer, &Invalid);
883         if (Invalid) {
884           T.skipToEnd();
885           return;
886         }
887         AttrName = PP.getIdentifierInfo(Str);
888         AttrNameLoc = ConsumeStringToken();
889       } else {
890         AttrName = Tok.getIdentifierInfo();
891         AttrNameLoc = ConsumeToken();
892       }
893 
894       bool AttrHandled = false;
895 
896       // Parse attribute arguments.
897       if (Tok.is(tok::l_paren))
898         AttrHandled = ParseMicrosoftDeclSpecArgs(AttrName, AttrNameLoc, Attrs);
899       else if (AttrName->getName() == "property")
900         // The property attribute must have an argument list.
901         Diag(Tok.getLocation(), diag::err_expected_lparen_after)
902             << AttrName->getName();
903 
904       if (!AttrHandled)
905         Attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
906                      ParsedAttr::Form::Declspec());
907     }
908     T.consumeClose();
909     EndLoc = T.getCloseLocation();
910   }
911 
912   Attrs.Range = SourceRange(StartLoc, EndLoc);
913 }
914 
915 void Parser::ParseMicrosoftTypeAttributes(ParsedAttributes &attrs) {
916   // Treat these like attributes
917   while (true) {
918     auto Kind = Tok.getKind();
919     switch (Kind) {
920     case tok::kw___fastcall:
921     case tok::kw___stdcall:
922     case tok::kw___thiscall:
923     case tok::kw___regcall:
924     case tok::kw___cdecl:
925     case tok::kw___vectorcall:
926     case tok::kw___ptr64:
927     case tok::kw___w64:
928     case tok::kw___ptr32:
929     case tok::kw___sptr:
930     case tok::kw___uptr: {
931       IdentifierInfo *AttrName = Tok.getIdentifierInfo();
932       SourceLocation AttrNameLoc = ConsumeToken();
933       attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
934                    Kind);
935       break;
936     }
937     default:
938       return;
939     }
940   }
941 }
942 
943 void Parser::ParseWebAssemblyFuncrefTypeAttribute(ParsedAttributes &attrs) {
944   assert(Tok.is(tok::kw___funcref));
945   SourceLocation StartLoc = Tok.getLocation();
946   if (!getTargetInfo().getTriple().isWasm()) {
947     ConsumeToken();
948     Diag(StartLoc, diag::err_wasm_funcref_not_wasm);
949     return;
950   }
951 
952   IdentifierInfo *AttrName = Tok.getIdentifierInfo();
953   SourceLocation AttrNameLoc = ConsumeToken();
954   attrs.addNew(AttrName, AttrNameLoc, /*ScopeName=*/nullptr,
955                /*ScopeLoc=*/SourceLocation{}, /*Args=*/nullptr, /*numArgs=*/0,
956                tok::kw___funcref);
957 }
958 
959 void Parser::DiagnoseAndSkipExtendedMicrosoftTypeAttributes() {
960   SourceLocation StartLoc = Tok.getLocation();
961   SourceLocation EndLoc = SkipExtendedMicrosoftTypeAttributes();
962 
963   if (EndLoc.isValid()) {
964     SourceRange Range(StartLoc, EndLoc);
965     Diag(StartLoc, diag::warn_microsoft_qualifiers_ignored) << Range;
966   }
967 }
968 
969 SourceLocation Parser::SkipExtendedMicrosoftTypeAttributes() {
970   SourceLocation EndLoc;
971 
972   while (true) {
973     switch (Tok.getKind()) {
974     case tok::kw_const:
975     case tok::kw_volatile:
976     case tok::kw___fastcall:
977     case tok::kw___stdcall:
978     case tok::kw___thiscall:
979     case tok::kw___cdecl:
980     case tok::kw___vectorcall:
981     case tok::kw___ptr32:
982     case tok::kw___ptr64:
983     case tok::kw___w64:
984     case tok::kw___unaligned:
985     case tok::kw___sptr:
986     case tok::kw___uptr:
987       EndLoc = ConsumeToken();
988       break;
989     default:
990       return EndLoc;
991     }
992   }
993 }
994 
995 void Parser::ParseBorlandTypeAttributes(ParsedAttributes &attrs) {
996   // Treat these like attributes
997   while (Tok.is(tok::kw___pascal)) {
998     IdentifierInfo *AttrName = Tok.getIdentifierInfo();
999     SourceLocation AttrNameLoc = ConsumeToken();
1000     attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
1001                  tok::kw___pascal);
1002   }
1003 }
1004 
1005 void Parser::ParseOpenCLKernelAttributes(ParsedAttributes &attrs) {
1006   // Treat these like attributes
1007   while (Tok.is(tok::kw___kernel)) {
1008     IdentifierInfo *AttrName = Tok.getIdentifierInfo();
1009     SourceLocation AttrNameLoc = ConsumeToken();
1010     attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
1011                  tok::kw___kernel);
1012   }
1013 }
1014 
1015 void Parser::ParseCUDAFunctionAttributes(ParsedAttributes &attrs) {
1016   while (Tok.is(tok::kw___noinline__)) {
1017     IdentifierInfo *AttrName = Tok.getIdentifierInfo();
1018     SourceLocation AttrNameLoc = ConsumeToken();
1019     attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
1020                  tok::kw___noinline__);
1021   }
1022 }
1023 
1024 void Parser::ParseOpenCLQualifiers(ParsedAttributes &Attrs) {
1025   IdentifierInfo *AttrName = Tok.getIdentifierInfo();
1026   SourceLocation AttrNameLoc = Tok.getLocation();
1027   Attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
1028                Tok.getKind());
1029 }
1030 
1031 bool Parser::isHLSLQualifier(const Token &Tok) const {
1032   return Tok.is(tok::kw_groupshared);
1033 }
1034 
1035 void Parser::ParseHLSLQualifiers(ParsedAttributes &Attrs) {
1036   IdentifierInfo *AttrName = Tok.getIdentifierInfo();
1037   auto Kind = Tok.getKind();
1038   SourceLocation AttrNameLoc = ConsumeToken();
1039   Attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0, Kind);
1040 }
1041 
1042 void Parser::ParseNullabilityTypeSpecifiers(ParsedAttributes &attrs) {
1043   // Treat these like attributes, even though they're type specifiers.
1044   while (true) {
1045     auto Kind = Tok.getKind();
1046     switch (Kind) {
1047     case tok::kw__Nonnull:
1048     case tok::kw__Nullable:
1049     case tok::kw__Nullable_result:
1050     case tok::kw__Null_unspecified: {
1051       IdentifierInfo *AttrName = Tok.getIdentifierInfo();
1052       SourceLocation AttrNameLoc = ConsumeToken();
1053       if (!getLangOpts().ObjC)
1054         Diag(AttrNameLoc, diag::ext_nullability)
1055           << AttrName;
1056       attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
1057                    Kind);
1058       break;
1059     }
1060     default:
1061       return;
1062     }
1063   }
1064 }
1065 
1066 static bool VersionNumberSeparator(const char Separator) {
1067   return (Separator == '.' || Separator == '_');
1068 }
1069 
1070 /// Parse a version number.
1071 ///
1072 /// version:
1073 ///   simple-integer
1074 ///   simple-integer '.' simple-integer
1075 ///   simple-integer '_' simple-integer
1076 ///   simple-integer '.' simple-integer '.' simple-integer
1077 ///   simple-integer '_' simple-integer '_' simple-integer
1078 VersionTuple Parser::ParseVersionTuple(SourceRange &Range) {
1079   Range = SourceRange(Tok.getLocation(), Tok.getEndLoc());
1080 
1081   if (!Tok.is(tok::numeric_constant)) {
1082     Diag(Tok, diag::err_expected_version);
1083     SkipUntil(tok::comma, tok::r_paren,
1084               StopAtSemi | StopBeforeMatch | StopAtCodeCompletion);
1085     return VersionTuple();
1086   }
1087 
1088   // Parse the major (and possibly minor and subminor) versions, which
1089   // are stored in the numeric constant. We utilize a quirk of the
1090   // lexer, which is that it handles something like 1.2.3 as a single
1091   // numeric constant, rather than two separate tokens.
1092   SmallString<512> Buffer;
1093   Buffer.resize(Tok.getLength()+1);
1094   const char *ThisTokBegin = &Buffer[0];
1095 
1096   // Get the spelling of the token, which eliminates trigraphs, etc.
1097   bool Invalid = false;
1098   unsigned ActualLength = PP.getSpelling(Tok, ThisTokBegin, &Invalid);
1099   if (Invalid)
1100     return VersionTuple();
1101 
1102   // Parse the major version.
1103   unsigned AfterMajor = 0;
1104   unsigned Major = 0;
1105   while (AfterMajor < ActualLength && isDigit(ThisTokBegin[AfterMajor])) {
1106     Major = Major * 10 + ThisTokBegin[AfterMajor] - '0';
1107     ++AfterMajor;
1108   }
1109 
1110   if (AfterMajor == 0) {
1111     Diag(Tok, diag::err_expected_version);
1112     SkipUntil(tok::comma, tok::r_paren,
1113               StopAtSemi | StopBeforeMatch | StopAtCodeCompletion);
1114     return VersionTuple();
1115   }
1116 
1117   if (AfterMajor == ActualLength) {
1118     ConsumeToken();
1119 
1120     // We only had a single version component.
1121     if (Major == 0) {
1122       Diag(Tok, diag::err_zero_version);
1123       return VersionTuple();
1124     }
1125 
1126     return VersionTuple(Major);
1127   }
1128 
1129   const char AfterMajorSeparator = ThisTokBegin[AfterMajor];
1130   if (!VersionNumberSeparator(AfterMajorSeparator)
1131       || (AfterMajor + 1 == ActualLength)) {
1132     Diag(Tok, diag::err_expected_version);
1133     SkipUntil(tok::comma, tok::r_paren,
1134               StopAtSemi | StopBeforeMatch | StopAtCodeCompletion);
1135     return VersionTuple();
1136   }
1137 
1138   // Parse the minor version.
1139   unsigned AfterMinor = AfterMajor + 1;
1140   unsigned Minor = 0;
1141   while (AfterMinor < ActualLength && isDigit(ThisTokBegin[AfterMinor])) {
1142     Minor = Minor * 10 + ThisTokBegin[AfterMinor] - '0';
1143     ++AfterMinor;
1144   }
1145 
1146   if (AfterMinor == ActualLength) {
1147     ConsumeToken();
1148 
1149     // We had major.minor.
1150     if (Major == 0 && Minor == 0) {
1151       Diag(Tok, diag::err_zero_version);
1152       return VersionTuple();
1153     }
1154 
1155     return VersionTuple(Major, Minor);
1156   }
1157 
1158   const char AfterMinorSeparator = ThisTokBegin[AfterMinor];
1159   // If what follows is not a '.' or '_', we have a problem.
1160   if (!VersionNumberSeparator(AfterMinorSeparator)) {
1161     Diag(Tok, diag::err_expected_version);
1162     SkipUntil(tok::comma, tok::r_paren,
1163               StopAtSemi | StopBeforeMatch | StopAtCodeCompletion);
1164     return VersionTuple();
1165   }
1166 
1167   // Warn if separators, be it '.' or '_', do not match.
1168   if (AfterMajorSeparator != AfterMinorSeparator)
1169     Diag(Tok, diag::warn_expected_consistent_version_separator);
1170 
1171   // Parse the subminor version.
1172   unsigned AfterSubminor = AfterMinor + 1;
1173   unsigned Subminor = 0;
1174   while (AfterSubminor < ActualLength && isDigit(ThisTokBegin[AfterSubminor])) {
1175     Subminor = Subminor * 10 + ThisTokBegin[AfterSubminor] - '0';
1176     ++AfterSubminor;
1177   }
1178 
1179   if (AfterSubminor != ActualLength) {
1180     Diag(Tok, diag::err_expected_version);
1181     SkipUntil(tok::comma, tok::r_paren,
1182               StopAtSemi | StopBeforeMatch | StopAtCodeCompletion);
1183     return VersionTuple();
1184   }
1185   ConsumeToken();
1186   return VersionTuple(Major, Minor, Subminor);
1187 }
1188 
1189 /// Parse the contents of the "availability" attribute.
1190 ///
1191 /// availability-attribute:
1192 ///   'availability' '(' platform ',' opt-strict version-arg-list,
1193 ///                      opt-replacement, opt-message')'
1194 ///
1195 /// platform:
1196 ///   identifier
1197 ///
1198 /// opt-strict:
1199 ///   'strict' ','
1200 ///
1201 /// version-arg-list:
1202 ///   version-arg
1203 ///   version-arg ',' version-arg-list
1204 ///
1205 /// version-arg:
1206 ///   'introduced' '=' version
1207 ///   'deprecated' '=' version
1208 ///   'obsoleted' = version
1209 ///   'unavailable'
1210 /// opt-replacement:
1211 ///   'replacement' '=' <string>
1212 /// opt-message:
1213 ///   'message' '=' <string>
1214 void Parser::ParseAvailabilityAttribute(
1215     IdentifierInfo &Availability, SourceLocation AvailabilityLoc,
1216     ParsedAttributes &attrs, SourceLocation *endLoc, IdentifierInfo *ScopeName,
1217     SourceLocation ScopeLoc, ParsedAttr::Form Form) {
1218   enum { Introduced, Deprecated, Obsoleted, Unknown };
1219   AvailabilityChange Changes[Unknown];
1220   ExprResult MessageExpr, ReplacementExpr;
1221 
1222   // Opening '('.
1223   BalancedDelimiterTracker T(*this, tok::l_paren);
1224   if (T.consumeOpen()) {
1225     Diag(Tok, diag::err_expected) << tok::l_paren;
1226     return;
1227   }
1228 
1229   // Parse the platform name.
1230   if (Tok.isNot(tok::identifier)) {
1231     Diag(Tok, diag::err_availability_expected_platform);
1232     SkipUntil(tok::r_paren, StopAtSemi);
1233     return;
1234   }
1235   IdentifierLoc *Platform = ParseIdentifierLoc();
1236   if (const IdentifierInfo *const Ident = Platform->Ident) {
1237     // Canonicalize platform name from "macosx" to "macos".
1238     if (Ident->getName() == "macosx")
1239       Platform->Ident = PP.getIdentifierInfo("macos");
1240     // Canonicalize platform name from "macosx_app_extension" to
1241     // "macos_app_extension".
1242     else if (Ident->getName() == "macosx_app_extension")
1243       Platform->Ident = PP.getIdentifierInfo("macos_app_extension");
1244     else
1245       Platform->Ident = PP.getIdentifierInfo(
1246           AvailabilityAttr::canonicalizePlatformName(Ident->getName()));
1247   }
1248 
1249   // Parse the ',' following the platform name.
1250   if (ExpectAndConsume(tok::comma)) {
1251     SkipUntil(tok::r_paren, StopAtSemi);
1252     return;
1253   }
1254 
1255   // If we haven't grabbed the pointers for the identifiers
1256   // "introduced", "deprecated", and "obsoleted", do so now.
1257   if (!Ident_introduced) {
1258     Ident_introduced = PP.getIdentifierInfo("introduced");
1259     Ident_deprecated = PP.getIdentifierInfo("deprecated");
1260     Ident_obsoleted = PP.getIdentifierInfo("obsoleted");
1261     Ident_unavailable = PP.getIdentifierInfo("unavailable");
1262     Ident_message = PP.getIdentifierInfo("message");
1263     Ident_strict = PP.getIdentifierInfo("strict");
1264     Ident_replacement = PP.getIdentifierInfo("replacement");
1265   }
1266 
1267   // Parse the optional "strict", the optional "replacement" and the set of
1268   // introductions/deprecations/removals.
1269   SourceLocation UnavailableLoc, StrictLoc;
1270   do {
1271     if (Tok.isNot(tok::identifier)) {
1272       Diag(Tok, diag::err_availability_expected_change);
1273       SkipUntil(tok::r_paren, StopAtSemi);
1274       return;
1275     }
1276     IdentifierInfo *Keyword = Tok.getIdentifierInfo();
1277     SourceLocation KeywordLoc = ConsumeToken();
1278 
1279     if (Keyword == Ident_strict) {
1280       if (StrictLoc.isValid()) {
1281         Diag(KeywordLoc, diag::err_availability_redundant)
1282           << Keyword << SourceRange(StrictLoc);
1283       }
1284       StrictLoc = KeywordLoc;
1285       continue;
1286     }
1287 
1288     if (Keyword == Ident_unavailable) {
1289       if (UnavailableLoc.isValid()) {
1290         Diag(KeywordLoc, diag::err_availability_redundant)
1291           << Keyword << SourceRange(UnavailableLoc);
1292       }
1293       UnavailableLoc = KeywordLoc;
1294       continue;
1295     }
1296 
1297     if (Keyword == Ident_deprecated && Platform->Ident &&
1298         Platform->Ident->isStr("swift")) {
1299       // For swift, we deprecate for all versions.
1300       if (Changes[Deprecated].KeywordLoc.isValid()) {
1301         Diag(KeywordLoc, diag::err_availability_redundant)
1302           << Keyword
1303           << SourceRange(Changes[Deprecated].KeywordLoc);
1304       }
1305 
1306       Changes[Deprecated].KeywordLoc = KeywordLoc;
1307       // Use a fake version here.
1308       Changes[Deprecated].Version = VersionTuple(1);
1309       continue;
1310     }
1311 
1312     if (Tok.isNot(tok::equal)) {
1313       Diag(Tok, diag::err_expected_after) << Keyword << tok::equal;
1314       SkipUntil(tok::r_paren, StopAtSemi);
1315       return;
1316     }
1317     ConsumeToken();
1318     if (Keyword == Ident_message || Keyword == Ident_replacement) {
1319       if (!isTokenStringLiteral()) {
1320         Diag(Tok, diag::err_expected_string_literal)
1321           << /*Source='availability attribute'*/2;
1322         SkipUntil(tok::r_paren, StopAtSemi);
1323         return;
1324       }
1325       if (Keyword == Ident_message) {
1326         MessageExpr = ParseUnevaluatedStringLiteralExpression();
1327         break;
1328       } else {
1329         ReplacementExpr = ParseUnevaluatedStringLiteralExpression();
1330         continue;
1331       }
1332     }
1333 
1334     // Special handling of 'NA' only when applied to introduced or
1335     // deprecated.
1336     if ((Keyword == Ident_introduced || Keyword == Ident_deprecated) &&
1337         Tok.is(tok::identifier)) {
1338       IdentifierInfo *NA = Tok.getIdentifierInfo();
1339       if (NA->getName() == "NA") {
1340         ConsumeToken();
1341         if (Keyword == Ident_introduced)
1342           UnavailableLoc = KeywordLoc;
1343         continue;
1344       }
1345     }
1346 
1347     SourceRange VersionRange;
1348     VersionTuple Version = ParseVersionTuple(VersionRange);
1349 
1350     if (Version.empty()) {
1351       SkipUntil(tok::r_paren, StopAtSemi);
1352       return;
1353     }
1354 
1355     unsigned Index;
1356     if (Keyword == Ident_introduced)
1357       Index = Introduced;
1358     else if (Keyword == Ident_deprecated)
1359       Index = Deprecated;
1360     else if (Keyword == Ident_obsoleted)
1361       Index = Obsoleted;
1362     else
1363       Index = Unknown;
1364 
1365     if (Index < Unknown) {
1366       if (!Changes[Index].KeywordLoc.isInvalid()) {
1367         Diag(KeywordLoc, diag::err_availability_redundant)
1368           << Keyword
1369           << SourceRange(Changes[Index].KeywordLoc,
1370                          Changes[Index].VersionRange.getEnd());
1371       }
1372 
1373       Changes[Index].KeywordLoc = KeywordLoc;
1374       Changes[Index].Version = Version;
1375       Changes[Index].VersionRange = VersionRange;
1376     } else {
1377       Diag(KeywordLoc, diag::err_availability_unknown_change)
1378         << Keyword << VersionRange;
1379     }
1380 
1381   } while (TryConsumeToken(tok::comma));
1382 
1383   // Closing ')'.
1384   if (T.consumeClose())
1385     return;
1386 
1387   if (endLoc)
1388     *endLoc = T.getCloseLocation();
1389 
1390   // The 'unavailable' availability cannot be combined with any other
1391   // availability changes. Make sure that hasn't happened.
1392   if (UnavailableLoc.isValid()) {
1393     bool Complained = false;
1394     for (unsigned Index = Introduced; Index != Unknown; ++Index) {
1395       if (Changes[Index].KeywordLoc.isValid()) {
1396         if (!Complained) {
1397           Diag(UnavailableLoc, diag::warn_availability_and_unavailable)
1398             << SourceRange(Changes[Index].KeywordLoc,
1399                            Changes[Index].VersionRange.getEnd());
1400           Complained = true;
1401         }
1402 
1403         // Clear out the availability.
1404         Changes[Index] = AvailabilityChange();
1405       }
1406     }
1407   }
1408 
1409   // Record this attribute
1410   attrs.addNew(&Availability,
1411                SourceRange(AvailabilityLoc, T.getCloseLocation()), ScopeName,
1412                ScopeLoc, Platform, Changes[Introduced], Changes[Deprecated],
1413                Changes[Obsoleted], UnavailableLoc, MessageExpr.get(), Form,
1414                StrictLoc, ReplacementExpr.get());
1415 }
1416 
1417 /// Parse the contents of the "external_source_symbol" attribute.
1418 ///
1419 /// external-source-symbol-attribute:
1420 ///   'external_source_symbol' '(' keyword-arg-list ')'
1421 ///
1422 /// keyword-arg-list:
1423 ///   keyword-arg
1424 ///   keyword-arg ',' keyword-arg-list
1425 ///
1426 /// keyword-arg:
1427 ///   'language' '=' <string>
1428 ///   'defined_in' '=' <string>
1429 ///   'USR' '=' <string>
1430 ///   'generated_declaration'
1431 void Parser::ParseExternalSourceSymbolAttribute(
1432     IdentifierInfo &ExternalSourceSymbol, SourceLocation Loc,
1433     ParsedAttributes &Attrs, SourceLocation *EndLoc, IdentifierInfo *ScopeName,
1434     SourceLocation ScopeLoc, ParsedAttr::Form Form) {
1435   // Opening '('.
1436   BalancedDelimiterTracker T(*this, tok::l_paren);
1437   if (T.expectAndConsume())
1438     return;
1439 
1440   // Initialize the pointers for the keyword identifiers when required.
1441   if (!Ident_language) {
1442     Ident_language = PP.getIdentifierInfo("language");
1443     Ident_defined_in = PP.getIdentifierInfo("defined_in");
1444     Ident_generated_declaration = PP.getIdentifierInfo("generated_declaration");
1445     Ident_USR = PP.getIdentifierInfo("USR");
1446   }
1447 
1448   ExprResult Language;
1449   bool HasLanguage = false;
1450   ExprResult DefinedInExpr;
1451   bool HasDefinedIn = false;
1452   IdentifierLoc *GeneratedDeclaration = nullptr;
1453   ExprResult USR;
1454   bool HasUSR = false;
1455 
1456   // Parse the language/defined_in/generated_declaration keywords
1457   do {
1458     if (Tok.isNot(tok::identifier)) {
1459       Diag(Tok, diag::err_external_source_symbol_expected_keyword);
1460       SkipUntil(tok::r_paren, StopAtSemi);
1461       return;
1462     }
1463 
1464     SourceLocation KeywordLoc = Tok.getLocation();
1465     IdentifierInfo *Keyword = Tok.getIdentifierInfo();
1466     if (Keyword == Ident_generated_declaration) {
1467       if (GeneratedDeclaration) {
1468         Diag(Tok, diag::err_external_source_symbol_duplicate_clause) << Keyword;
1469         SkipUntil(tok::r_paren, StopAtSemi);
1470         return;
1471       }
1472       GeneratedDeclaration = ParseIdentifierLoc();
1473       continue;
1474     }
1475 
1476     if (Keyword != Ident_language && Keyword != Ident_defined_in &&
1477         Keyword != Ident_USR) {
1478       Diag(Tok, diag::err_external_source_symbol_expected_keyword);
1479       SkipUntil(tok::r_paren, StopAtSemi);
1480       return;
1481     }
1482 
1483     ConsumeToken();
1484     if (ExpectAndConsume(tok::equal, diag::err_expected_after,
1485                          Keyword->getName())) {
1486       SkipUntil(tok::r_paren, StopAtSemi);
1487       return;
1488     }
1489 
1490     bool HadLanguage = HasLanguage, HadDefinedIn = HasDefinedIn,
1491          HadUSR = HasUSR;
1492     if (Keyword == Ident_language)
1493       HasLanguage = true;
1494     else if (Keyword == Ident_USR)
1495       HasUSR = true;
1496     else
1497       HasDefinedIn = true;
1498 
1499     if (!isTokenStringLiteral()) {
1500       Diag(Tok, diag::err_expected_string_literal)
1501           << /*Source='external_source_symbol attribute'*/ 3
1502           << /*language | source container | USR*/ (
1503                  Keyword == Ident_language
1504                      ? 0
1505                      : (Keyword == Ident_defined_in ? 1 : 2));
1506       SkipUntil(tok::comma, tok::r_paren, StopAtSemi | StopBeforeMatch);
1507       continue;
1508     }
1509     if (Keyword == Ident_language) {
1510       if (HadLanguage) {
1511         Diag(KeywordLoc, diag::err_external_source_symbol_duplicate_clause)
1512             << Keyword;
1513         ParseUnevaluatedStringLiteralExpression();
1514         continue;
1515       }
1516       Language = ParseUnevaluatedStringLiteralExpression();
1517     } else if (Keyword == Ident_USR) {
1518       if (HadUSR) {
1519         Diag(KeywordLoc, diag::err_external_source_symbol_duplicate_clause)
1520             << Keyword;
1521         ParseUnevaluatedStringLiteralExpression();
1522         continue;
1523       }
1524       USR = ParseUnevaluatedStringLiteralExpression();
1525     } else {
1526       assert(Keyword == Ident_defined_in && "Invalid clause keyword!");
1527       if (HadDefinedIn) {
1528         Diag(KeywordLoc, diag::err_external_source_symbol_duplicate_clause)
1529             << Keyword;
1530         ParseUnevaluatedStringLiteralExpression();
1531         continue;
1532       }
1533       DefinedInExpr = ParseUnevaluatedStringLiteralExpression();
1534     }
1535   } while (TryConsumeToken(tok::comma));
1536 
1537   // Closing ')'.
1538   if (T.consumeClose())
1539     return;
1540   if (EndLoc)
1541     *EndLoc = T.getCloseLocation();
1542 
1543   ArgsUnion Args[] = {Language.get(), DefinedInExpr.get(), GeneratedDeclaration,
1544                       USR.get()};
1545   Attrs.addNew(&ExternalSourceSymbol, SourceRange(Loc, T.getCloseLocation()),
1546                ScopeName, ScopeLoc, Args, std::size(Args), Form);
1547 }
1548 
1549 /// Parse the contents of the "objc_bridge_related" attribute.
1550 /// objc_bridge_related '(' related_class ',' opt-class_method ',' opt-instance_method ')'
1551 /// related_class:
1552 ///     Identifier
1553 ///
1554 /// opt-class_method:
1555 ///     Identifier: | <empty>
1556 ///
1557 /// opt-instance_method:
1558 ///     Identifier | <empty>
1559 ///
1560 void Parser::ParseObjCBridgeRelatedAttribute(
1561     IdentifierInfo &ObjCBridgeRelated, SourceLocation ObjCBridgeRelatedLoc,
1562     ParsedAttributes &Attrs, SourceLocation *EndLoc, IdentifierInfo *ScopeName,
1563     SourceLocation ScopeLoc, ParsedAttr::Form Form) {
1564   // Opening '('.
1565   BalancedDelimiterTracker T(*this, tok::l_paren);
1566   if (T.consumeOpen()) {
1567     Diag(Tok, diag::err_expected) << tok::l_paren;
1568     return;
1569   }
1570 
1571   // Parse the related class name.
1572   if (Tok.isNot(tok::identifier)) {
1573     Diag(Tok, diag::err_objcbridge_related_expected_related_class);
1574     SkipUntil(tok::r_paren, StopAtSemi);
1575     return;
1576   }
1577   IdentifierLoc *RelatedClass = ParseIdentifierLoc();
1578   if (ExpectAndConsume(tok::comma)) {
1579     SkipUntil(tok::r_paren, StopAtSemi);
1580     return;
1581   }
1582 
1583   // Parse class method name.  It's non-optional in the sense that a trailing
1584   // comma is required, but it can be the empty string, and then we record a
1585   // nullptr.
1586   IdentifierLoc *ClassMethod = nullptr;
1587   if (Tok.is(tok::identifier)) {
1588     ClassMethod = ParseIdentifierLoc();
1589     if (!TryConsumeToken(tok::colon)) {
1590       Diag(Tok, diag::err_objcbridge_related_selector_name);
1591       SkipUntil(tok::r_paren, StopAtSemi);
1592       return;
1593     }
1594   }
1595   if (!TryConsumeToken(tok::comma)) {
1596     if (Tok.is(tok::colon))
1597       Diag(Tok, diag::err_objcbridge_related_selector_name);
1598     else
1599       Diag(Tok, diag::err_expected) << tok::comma;
1600     SkipUntil(tok::r_paren, StopAtSemi);
1601     return;
1602   }
1603 
1604   // Parse instance method name.  Also non-optional but empty string is
1605   // permitted.
1606   IdentifierLoc *InstanceMethod = nullptr;
1607   if (Tok.is(tok::identifier))
1608     InstanceMethod = ParseIdentifierLoc();
1609   else if (Tok.isNot(tok::r_paren)) {
1610     Diag(Tok, diag::err_expected) << tok::r_paren;
1611     SkipUntil(tok::r_paren, StopAtSemi);
1612     return;
1613   }
1614 
1615   // Closing ')'.
1616   if (T.consumeClose())
1617     return;
1618 
1619   if (EndLoc)
1620     *EndLoc = T.getCloseLocation();
1621 
1622   // Record this attribute
1623   Attrs.addNew(&ObjCBridgeRelated,
1624                SourceRange(ObjCBridgeRelatedLoc, T.getCloseLocation()),
1625                ScopeName, ScopeLoc, RelatedClass, ClassMethod, InstanceMethod,
1626                Form);
1627 }
1628 
1629 void Parser::ParseSwiftNewTypeAttribute(
1630     IdentifierInfo &AttrName, SourceLocation AttrNameLoc,
1631     ParsedAttributes &Attrs, SourceLocation *EndLoc, IdentifierInfo *ScopeName,
1632     SourceLocation ScopeLoc, ParsedAttr::Form Form) {
1633   BalancedDelimiterTracker T(*this, tok::l_paren);
1634 
1635   // Opening '('
1636   if (T.consumeOpen()) {
1637     Diag(Tok, diag::err_expected) << tok::l_paren;
1638     return;
1639   }
1640 
1641   if (Tok.is(tok::r_paren)) {
1642     Diag(Tok.getLocation(), diag::err_argument_required_after_attribute);
1643     T.consumeClose();
1644     return;
1645   }
1646   if (Tok.isNot(tok::kw_struct) && Tok.isNot(tok::kw_enum)) {
1647     Diag(Tok, diag::warn_attribute_type_not_supported)
1648         << &AttrName << Tok.getIdentifierInfo();
1649     if (!isTokenSpecial())
1650       ConsumeToken();
1651     T.consumeClose();
1652     return;
1653   }
1654 
1655   auto *SwiftType = IdentifierLoc::create(Actions.Context, Tok.getLocation(),
1656                                           Tok.getIdentifierInfo());
1657   ConsumeToken();
1658 
1659   // Closing ')'
1660   if (T.consumeClose())
1661     return;
1662   if (EndLoc)
1663     *EndLoc = T.getCloseLocation();
1664 
1665   ArgsUnion Args[] = {SwiftType};
1666   Attrs.addNew(&AttrName, SourceRange(AttrNameLoc, T.getCloseLocation()),
1667                ScopeName, ScopeLoc, Args, std::size(Args), Form);
1668 }
1669 
1670 void Parser::ParseTypeTagForDatatypeAttribute(
1671     IdentifierInfo &AttrName, SourceLocation AttrNameLoc,
1672     ParsedAttributes &Attrs, SourceLocation *EndLoc, IdentifierInfo *ScopeName,
1673     SourceLocation ScopeLoc, ParsedAttr::Form Form) {
1674   assert(Tok.is(tok::l_paren) && "Attribute arg list not starting with '('");
1675 
1676   BalancedDelimiterTracker T(*this, tok::l_paren);
1677   T.consumeOpen();
1678 
1679   if (Tok.isNot(tok::identifier)) {
1680     Diag(Tok, diag::err_expected) << tok::identifier;
1681     T.skipToEnd();
1682     return;
1683   }
1684   IdentifierLoc *ArgumentKind = ParseIdentifierLoc();
1685 
1686   if (ExpectAndConsume(tok::comma)) {
1687     T.skipToEnd();
1688     return;
1689   }
1690 
1691   SourceRange MatchingCTypeRange;
1692   TypeResult MatchingCType = ParseTypeName(&MatchingCTypeRange);
1693   if (MatchingCType.isInvalid()) {
1694     T.skipToEnd();
1695     return;
1696   }
1697 
1698   bool LayoutCompatible = false;
1699   bool MustBeNull = false;
1700   while (TryConsumeToken(tok::comma)) {
1701     if (Tok.isNot(tok::identifier)) {
1702       Diag(Tok, diag::err_expected) << tok::identifier;
1703       T.skipToEnd();
1704       return;
1705     }
1706     IdentifierInfo *Flag = Tok.getIdentifierInfo();
1707     if (Flag->isStr("layout_compatible"))
1708       LayoutCompatible = true;
1709     else if (Flag->isStr("must_be_null"))
1710       MustBeNull = true;
1711     else {
1712       Diag(Tok, diag::err_type_safety_unknown_flag) << Flag;
1713       T.skipToEnd();
1714       return;
1715     }
1716     ConsumeToken(); // consume flag
1717   }
1718 
1719   if (!T.consumeClose()) {
1720     Attrs.addNewTypeTagForDatatype(&AttrName, AttrNameLoc, ScopeName, ScopeLoc,
1721                                    ArgumentKind, MatchingCType.get(),
1722                                    LayoutCompatible, MustBeNull, Form);
1723   }
1724 
1725   if (EndLoc)
1726     *EndLoc = T.getCloseLocation();
1727 }
1728 
1729 /// DiagnoseProhibitedCXX11Attribute - We have found the opening square brackets
1730 /// of a C++11 attribute-specifier in a location where an attribute is not
1731 /// permitted. By C++11 [dcl.attr.grammar]p6, this is ill-formed. Diagnose this
1732 /// situation.
1733 ///
1734 /// \return \c true if we skipped an attribute-like chunk of tokens, \c false if
1735 /// this doesn't appear to actually be an attribute-specifier, and the caller
1736 /// should try to parse it.
1737 bool Parser::DiagnoseProhibitedCXX11Attribute() {
1738   assert(Tok.is(tok::l_square) && NextToken().is(tok::l_square));
1739 
1740   switch (isCXX11AttributeSpecifier(/*Disambiguate*/true)) {
1741   case CAK_NotAttributeSpecifier:
1742     // No diagnostic: we're in Obj-C++11 and this is not actually an attribute.
1743     return false;
1744 
1745   case CAK_InvalidAttributeSpecifier:
1746     Diag(Tok.getLocation(), diag::err_l_square_l_square_not_attribute);
1747     return false;
1748 
1749   case CAK_AttributeSpecifier:
1750     // Parse and discard the attributes.
1751     SourceLocation BeginLoc = ConsumeBracket();
1752     ConsumeBracket();
1753     SkipUntil(tok::r_square);
1754     assert(Tok.is(tok::r_square) && "isCXX11AttributeSpecifier lied");
1755     SourceLocation EndLoc = ConsumeBracket();
1756     Diag(BeginLoc, diag::err_attributes_not_allowed)
1757       << SourceRange(BeginLoc, EndLoc);
1758     return true;
1759   }
1760   llvm_unreachable("All cases handled above.");
1761 }
1762 
1763 /// We have found the opening square brackets of a C++11
1764 /// attribute-specifier in a location where an attribute is not permitted, but
1765 /// we know where the attributes ought to be written. Parse them anyway, and
1766 /// provide a fixit moving them to the right place.
1767 void Parser::DiagnoseMisplacedCXX11Attribute(ParsedAttributes &Attrs,
1768                                              SourceLocation CorrectLocation) {
1769   assert((Tok.is(tok::l_square) && NextToken().is(tok::l_square)) ||
1770          Tok.is(tok::kw_alignas) || Tok.isRegularKeywordAttribute());
1771 
1772   // Consume the attributes.
1773   auto Keyword =
1774       Tok.isRegularKeywordAttribute() ? Tok.getIdentifierInfo() : nullptr;
1775   SourceLocation Loc = Tok.getLocation();
1776   ParseCXX11Attributes(Attrs);
1777   CharSourceRange AttrRange(SourceRange(Loc, Attrs.Range.getEnd()), true);
1778   // FIXME: use err_attributes_misplaced
1779   (Keyword ? Diag(Loc, diag::err_keyword_not_allowed) << Keyword
1780            : Diag(Loc, diag::err_attributes_not_allowed))
1781       << FixItHint::CreateInsertionFromRange(CorrectLocation, AttrRange)
1782       << FixItHint::CreateRemoval(AttrRange);
1783 }
1784 
1785 void Parser::DiagnoseProhibitedAttributes(
1786     const ParsedAttributesView &Attrs, const SourceLocation CorrectLocation) {
1787   auto *FirstAttr = Attrs.empty() ? nullptr : &Attrs.front();
1788   if (CorrectLocation.isValid()) {
1789     CharSourceRange AttrRange(Attrs.Range, true);
1790     (FirstAttr && FirstAttr->isRegularKeywordAttribute()
1791          ? Diag(CorrectLocation, diag::err_keyword_misplaced) << FirstAttr
1792          : Diag(CorrectLocation, diag::err_attributes_misplaced))
1793         << FixItHint::CreateInsertionFromRange(CorrectLocation, AttrRange)
1794         << FixItHint::CreateRemoval(AttrRange);
1795   } else {
1796     const SourceRange &Range = Attrs.Range;
1797     (FirstAttr && FirstAttr->isRegularKeywordAttribute()
1798          ? Diag(Range.getBegin(), diag::err_keyword_not_allowed) << FirstAttr
1799          : Diag(Range.getBegin(), diag::err_attributes_not_allowed))
1800         << Range;
1801   }
1802 }
1803 
1804 void Parser::ProhibitCXX11Attributes(ParsedAttributes &Attrs,
1805                                      unsigned AttrDiagID,
1806                                      unsigned KeywordDiagID,
1807                                      bool DiagnoseEmptyAttrs,
1808                                      bool WarnOnUnknownAttrs) {
1809 
1810   if (DiagnoseEmptyAttrs && Attrs.empty() && Attrs.Range.isValid()) {
1811     // An attribute list has been parsed, but it was empty.
1812     // This is the case for [[]].
1813     const auto &LangOpts = getLangOpts();
1814     auto &SM = PP.getSourceManager();
1815     Token FirstLSquare;
1816     Lexer::getRawToken(Attrs.Range.getBegin(), FirstLSquare, SM, LangOpts);
1817 
1818     if (FirstLSquare.is(tok::l_square)) {
1819       std::optional<Token> SecondLSquare =
1820           Lexer::findNextToken(FirstLSquare.getLocation(), SM, LangOpts);
1821 
1822       if (SecondLSquare && SecondLSquare->is(tok::l_square)) {
1823         // The attribute range starts with [[, but is empty. So this must
1824         // be [[]], which we are supposed to diagnose because
1825         // DiagnoseEmptyAttrs is true.
1826         Diag(Attrs.Range.getBegin(), AttrDiagID) << Attrs.Range;
1827         return;
1828       }
1829     }
1830   }
1831 
1832   for (const ParsedAttr &AL : Attrs) {
1833     if (AL.isRegularKeywordAttribute()) {
1834       Diag(AL.getLoc(), KeywordDiagID) << AL;
1835       AL.setInvalid();
1836       continue;
1837     }
1838     if (!AL.isStandardAttributeSyntax())
1839       continue;
1840     if (AL.getKind() == ParsedAttr::UnknownAttribute) {
1841       if (WarnOnUnknownAttrs)
1842         Diag(AL.getLoc(), diag::warn_unknown_attribute_ignored)
1843             << AL << AL.getRange();
1844     } else {
1845       Diag(AL.getLoc(), AttrDiagID) << AL;
1846       AL.setInvalid();
1847     }
1848   }
1849 }
1850 
1851 void Parser::DiagnoseCXX11AttributeExtension(ParsedAttributes &Attrs) {
1852   for (const ParsedAttr &PA : Attrs) {
1853     if (PA.isStandardAttributeSyntax() || PA.isRegularKeywordAttribute())
1854       Diag(PA.getLoc(), diag::ext_cxx11_attr_placement)
1855           << PA << PA.isRegularKeywordAttribute() << PA.getRange();
1856   }
1857 }
1858 
1859 // Usually, `__attribute__((attrib)) class Foo {} var` means that attribute
1860 // applies to var, not the type Foo.
1861 // As an exception to the rule, __declspec(align(...)) before the
1862 // class-key affects the type instead of the variable.
1863 // Also, Microsoft-style [attributes] seem to affect the type instead of the
1864 // variable.
1865 // This function moves attributes that should apply to the type off DS to Attrs.
1866 void Parser::stripTypeAttributesOffDeclSpec(ParsedAttributes &Attrs,
1867                                             DeclSpec &DS,
1868                                             Sema::TagUseKind TUK) {
1869   if (TUK == Sema::TUK_Reference)
1870     return;
1871 
1872   llvm::SmallVector<ParsedAttr *, 1> ToBeMoved;
1873 
1874   for (ParsedAttr &AL : DS.getAttributes()) {
1875     if ((AL.getKind() == ParsedAttr::AT_Aligned &&
1876          AL.isDeclspecAttribute()) ||
1877         AL.isMicrosoftAttribute())
1878       ToBeMoved.push_back(&AL);
1879   }
1880 
1881   for (ParsedAttr *AL : ToBeMoved) {
1882     DS.getAttributes().remove(AL);
1883     Attrs.addAtEnd(AL);
1884   }
1885 }
1886 
1887 /// ParseDeclaration - Parse a full 'declaration', which consists of
1888 /// declaration-specifiers, some number of declarators, and a semicolon.
1889 /// 'Context' should be a DeclaratorContext value.  This returns the
1890 /// location of the semicolon in DeclEnd.
1891 ///
1892 ///       declaration: [C99 6.7]
1893 ///         block-declaration ->
1894 ///           simple-declaration
1895 ///           others                   [FIXME]
1896 /// [C++]   template-declaration
1897 /// [C++]   namespace-definition
1898 /// [C++]   using-directive
1899 /// [C++]   using-declaration
1900 /// [C++11/C11] static_assert-declaration
1901 ///         others... [FIXME]
1902 ///
1903 Parser::DeclGroupPtrTy Parser::ParseDeclaration(DeclaratorContext Context,
1904                                                 SourceLocation &DeclEnd,
1905                                                 ParsedAttributes &DeclAttrs,
1906                                                 ParsedAttributes &DeclSpecAttrs,
1907                                                 SourceLocation *DeclSpecStart) {
1908   ParenBraceBracketBalancer BalancerRAIIObj(*this);
1909   // Must temporarily exit the objective-c container scope for
1910   // parsing c none objective-c decls.
1911   ObjCDeclContextSwitch ObjCDC(*this);
1912 
1913   Decl *SingleDecl = nullptr;
1914   switch (Tok.getKind()) {
1915   case tok::kw_template:
1916   case tok::kw_export:
1917     ProhibitAttributes(DeclAttrs);
1918     ProhibitAttributes(DeclSpecAttrs);
1919     SingleDecl =
1920         ParseDeclarationStartingWithTemplate(Context, DeclEnd, DeclAttrs);
1921     break;
1922   case tok::kw_inline:
1923     // Could be the start of an inline namespace. Allowed as an ext in C++03.
1924     if (getLangOpts().CPlusPlus && NextToken().is(tok::kw_namespace)) {
1925       ProhibitAttributes(DeclAttrs);
1926       ProhibitAttributes(DeclSpecAttrs);
1927       SourceLocation InlineLoc = ConsumeToken();
1928       return ParseNamespace(Context, DeclEnd, InlineLoc);
1929     }
1930     return ParseSimpleDeclaration(Context, DeclEnd, DeclAttrs, DeclSpecAttrs,
1931                                   true, nullptr, DeclSpecStart);
1932 
1933   case tok::kw_cbuffer:
1934   case tok::kw_tbuffer:
1935     SingleDecl = ParseHLSLBuffer(DeclEnd);
1936     break;
1937   case tok::kw_namespace:
1938     ProhibitAttributes(DeclAttrs);
1939     ProhibitAttributes(DeclSpecAttrs);
1940     return ParseNamespace(Context, DeclEnd);
1941   case tok::kw_using: {
1942     ParsedAttributes Attrs(AttrFactory);
1943     takeAndConcatenateAttrs(DeclAttrs, DeclSpecAttrs, Attrs);
1944     return ParseUsingDirectiveOrDeclaration(Context, ParsedTemplateInfo(),
1945                                             DeclEnd, Attrs);
1946   }
1947   case tok::kw_static_assert:
1948   case tok::kw__Static_assert:
1949     ProhibitAttributes(DeclAttrs);
1950     ProhibitAttributes(DeclSpecAttrs);
1951     SingleDecl = ParseStaticAssertDeclaration(DeclEnd);
1952     break;
1953   default:
1954     return ParseSimpleDeclaration(Context, DeclEnd, DeclAttrs, DeclSpecAttrs,
1955                                   true, nullptr, DeclSpecStart);
1956   }
1957 
1958   // This routine returns a DeclGroup, if the thing we parsed only contains a
1959   // single decl, convert it now.
1960   return Actions.ConvertDeclToDeclGroup(SingleDecl);
1961 }
1962 
1963 ///       simple-declaration: [C99 6.7: declaration] [C++ 7p1: dcl.dcl]
1964 ///         declaration-specifiers init-declarator-list[opt] ';'
1965 /// [C++11] attribute-specifier-seq decl-specifier-seq[opt]
1966 ///             init-declarator-list ';'
1967 ///[C90/C++]init-declarator-list ';'                             [TODO]
1968 /// [OMP]   threadprivate-directive
1969 /// [OMP]   allocate-directive                                   [TODO]
1970 ///
1971 ///       for-range-declaration: [C++11 6.5p1: stmt.ranged]
1972 ///         attribute-specifier-seq[opt] type-specifier-seq declarator
1973 ///
1974 /// If RequireSemi is false, this does not check for a ';' at the end of the
1975 /// declaration.  If it is true, it checks for and eats it.
1976 ///
1977 /// If FRI is non-null, we might be parsing a for-range-declaration instead
1978 /// of a simple-declaration. If we find that we are, we also parse the
1979 /// for-range-initializer, and place it here.
1980 ///
1981 /// DeclSpecStart is used when decl-specifiers are parsed before parsing
1982 /// the Declaration. The SourceLocation for this Decl is set to
1983 /// DeclSpecStart if DeclSpecStart is non-null.
1984 Parser::DeclGroupPtrTy Parser::ParseSimpleDeclaration(
1985     DeclaratorContext Context, SourceLocation &DeclEnd,
1986     ParsedAttributes &DeclAttrs, ParsedAttributes &DeclSpecAttrs,
1987     bool RequireSemi, ForRangeInit *FRI, SourceLocation *DeclSpecStart) {
1988   // Need to retain these for diagnostics before we add them to the DeclSepc.
1989   ParsedAttributesView OriginalDeclSpecAttrs;
1990   OriginalDeclSpecAttrs.addAll(DeclSpecAttrs.begin(), DeclSpecAttrs.end());
1991   OriginalDeclSpecAttrs.Range = DeclSpecAttrs.Range;
1992 
1993   // Parse the common declaration-specifiers piece.
1994   ParsingDeclSpec DS(*this);
1995   DS.takeAttributesFrom(DeclSpecAttrs);
1996 
1997   DeclSpecContext DSContext = getDeclSpecContextFromDeclaratorContext(Context);
1998   ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS_none, DSContext);
1999 
2000   // If we had a free-standing type definition with a missing semicolon, we
2001   // may get this far before the problem becomes obvious.
2002   if (DS.hasTagDefinition() &&
2003       DiagnoseMissingSemiAfterTagDefinition(DS, AS_none, DSContext))
2004     return nullptr;
2005 
2006   // C99 6.7.2.3p6: Handle "struct-or-union identifier;", "enum { X };"
2007   // declaration-specifiers init-declarator-list[opt] ';'
2008   if (Tok.is(tok::semi)) {
2009     ProhibitAttributes(DeclAttrs);
2010     DeclEnd = Tok.getLocation();
2011     if (RequireSemi) ConsumeToken();
2012     RecordDecl *AnonRecord = nullptr;
2013     Decl *TheDecl = Actions.ParsedFreeStandingDeclSpec(
2014         getCurScope(), AS_none, DS, ParsedAttributesView::none(), AnonRecord);
2015     Actions.ActOnDefinedDeclarationSpecifier(TheDecl);
2016     DS.complete(TheDecl);
2017     if (AnonRecord) {
2018       Decl* decls[] = {AnonRecord, TheDecl};
2019       return Actions.BuildDeclaratorGroup(decls);
2020     }
2021     return Actions.ConvertDeclToDeclGroup(TheDecl);
2022   }
2023 
2024   if (DS.hasTagDefinition())
2025     Actions.ActOnDefinedDeclarationSpecifier(DS.getRepAsDecl());
2026 
2027   if (DeclSpecStart)
2028     DS.SetRangeStart(*DeclSpecStart);
2029 
2030   return ParseDeclGroup(DS, Context, DeclAttrs, &DeclEnd, FRI);
2031 }
2032 
2033 /// Returns true if this might be the start of a declarator, or a common typo
2034 /// for a declarator.
2035 bool Parser::MightBeDeclarator(DeclaratorContext Context) {
2036   switch (Tok.getKind()) {
2037   case tok::annot_cxxscope:
2038   case tok::annot_template_id:
2039   case tok::caret:
2040   case tok::code_completion:
2041   case tok::coloncolon:
2042   case tok::ellipsis:
2043   case tok::kw___attribute:
2044   case tok::kw_operator:
2045   case tok::l_paren:
2046   case tok::star:
2047     return true;
2048 
2049   case tok::amp:
2050   case tok::ampamp:
2051     return getLangOpts().CPlusPlus;
2052 
2053   case tok::l_square: // Might be an attribute on an unnamed bit-field.
2054     return Context == DeclaratorContext::Member && getLangOpts().CPlusPlus11 &&
2055            NextToken().is(tok::l_square);
2056 
2057   case tok::colon: // Might be a typo for '::' or an unnamed bit-field.
2058     return Context == DeclaratorContext::Member || getLangOpts().CPlusPlus;
2059 
2060   case tok::identifier:
2061     switch (NextToken().getKind()) {
2062     case tok::code_completion:
2063     case tok::coloncolon:
2064     case tok::comma:
2065     case tok::equal:
2066     case tok::equalequal: // Might be a typo for '='.
2067     case tok::kw_alignas:
2068     case tok::kw_asm:
2069     case tok::kw___attribute:
2070     case tok::l_brace:
2071     case tok::l_paren:
2072     case tok::l_square:
2073     case tok::less:
2074     case tok::r_brace:
2075     case tok::r_paren:
2076     case tok::r_square:
2077     case tok::semi:
2078       return true;
2079 
2080     case tok::colon:
2081       // At namespace scope, 'identifier:' is probably a typo for 'identifier::'
2082       // and in block scope it's probably a label. Inside a class definition,
2083       // this is a bit-field.
2084       return Context == DeclaratorContext::Member ||
2085              (getLangOpts().CPlusPlus && Context == DeclaratorContext::File);
2086 
2087     case tok::identifier: // Possible virt-specifier.
2088       return getLangOpts().CPlusPlus11 && isCXX11VirtSpecifier(NextToken());
2089 
2090     default:
2091       return Tok.isRegularKeywordAttribute();
2092     }
2093 
2094   default:
2095     return Tok.isRegularKeywordAttribute();
2096   }
2097 }
2098 
2099 /// Skip until we reach something which seems like a sensible place to pick
2100 /// up parsing after a malformed declaration. This will sometimes stop sooner
2101 /// than SkipUntil(tok::r_brace) would, but will never stop later.
2102 void Parser::SkipMalformedDecl() {
2103   while (true) {
2104     switch (Tok.getKind()) {
2105     case tok::l_brace:
2106       // Skip until matching }, then stop. We've probably skipped over
2107       // a malformed class or function definition or similar.
2108       ConsumeBrace();
2109       SkipUntil(tok::r_brace);
2110       if (Tok.isOneOf(tok::comma, tok::l_brace, tok::kw_try)) {
2111         // This declaration isn't over yet. Keep skipping.
2112         continue;
2113       }
2114       TryConsumeToken(tok::semi);
2115       return;
2116 
2117     case tok::l_square:
2118       ConsumeBracket();
2119       SkipUntil(tok::r_square);
2120       continue;
2121 
2122     case tok::l_paren:
2123       ConsumeParen();
2124       SkipUntil(tok::r_paren);
2125       continue;
2126 
2127     case tok::r_brace:
2128       return;
2129 
2130     case tok::semi:
2131       ConsumeToken();
2132       return;
2133 
2134     case tok::kw_inline:
2135       // 'inline namespace' at the start of a line is almost certainly
2136       // a good place to pick back up parsing, except in an Objective-C
2137       // @interface context.
2138       if (Tok.isAtStartOfLine() && NextToken().is(tok::kw_namespace) &&
2139           (!ParsingInObjCContainer || CurParsedObjCImpl))
2140         return;
2141       break;
2142 
2143     case tok::kw_namespace:
2144       // 'namespace' at the start of a line is almost certainly a good
2145       // place to pick back up parsing, except in an Objective-C
2146       // @interface context.
2147       if (Tok.isAtStartOfLine() &&
2148           (!ParsingInObjCContainer || CurParsedObjCImpl))
2149         return;
2150       break;
2151 
2152     case tok::at:
2153       // @end is very much like } in Objective-C contexts.
2154       if (NextToken().isObjCAtKeyword(tok::objc_end) &&
2155           ParsingInObjCContainer)
2156         return;
2157       break;
2158 
2159     case tok::minus:
2160     case tok::plus:
2161       // - and + probably start new method declarations in Objective-C contexts.
2162       if (Tok.isAtStartOfLine() && ParsingInObjCContainer)
2163         return;
2164       break;
2165 
2166     case tok::eof:
2167     case tok::annot_module_begin:
2168     case tok::annot_module_end:
2169     case tok::annot_module_include:
2170     case tok::annot_repl_input_end:
2171       return;
2172 
2173     default:
2174       break;
2175     }
2176 
2177     ConsumeAnyToken();
2178   }
2179 }
2180 
2181 /// ParseDeclGroup - Having concluded that this is either a function
2182 /// definition or a group of object declarations, actually parse the
2183 /// result.
2184 Parser::DeclGroupPtrTy Parser::ParseDeclGroup(ParsingDeclSpec &DS,
2185                                               DeclaratorContext Context,
2186                                               ParsedAttributes &Attrs,
2187                                               SourceLocation *DeclEnd,
2188                                               ForRangeInit *FRI) {
2189   // Parse the first declarator.
2190   // Consume all of the attributes from `Attrs` by moving them to our own local
2191   // list. This ensures that we will not attempt to interpret them as statement
2192   // attributes higher up the callchain.
2193   ParsedAttributes LocalAttrs(AttrFactory);
2194   LocalAttrs.takeAllFrom(Attrs);
2195   ParsingDeclarator D(*this, DS, LocalAttrs, Context);
2196   ParseDeclarator(D);
2197 
2198   // Bail out if the first declarator didn't seem well-formed.
2199   if (!D.hasName() && !D.mayOmitIdentifier()) {
2200     SkipMalformedDecl();
2201     return nullptr;
2202   }
2203 
2204   if (getLangOpts().HLSL)
2205     MaybeParseHLSLSemantics(D);
2206 
2207   if (Tok.is(tok::kw_requires))
2208     ParseTrailingRequiresClause(D);
2209 
2210   // Save late-parsed attributes for now; they need to be parsed in the
2211   // appropriate function scope after the function Decl has been constructed.
2212   // These will be parsed in ParseFunctionDefinition or ParseLexedAttrList.
2213   LateParsedAttrList LateParsedAttrs(true);
2214   if (D.isFunctionDeclarator()) {
2215     MaybeParseGNUAttributes(D, &LateParsedAttrs);
2216 
2217     // The _Noreturn keyword can't appear here, unlike the GNU noreturn
2218     // attribute. If we find the keyword here, tell the user to put it
2219     // at the start instead.
2220     if (Tok.is(tok::kw__Noreturn)) {
2221       SourceLocation Loc = ConsumeToken();
2222       const char *PrevSpec;
2223       unsigned DiagID;
2224 
2225       // We can offer a fixit if it's valid to mark this function as _Noreturn
2226       // and we don't have any other declarators in this declaration.
2227       bool Fixit = !DS.setFunctionSpecNoreturn(Loc, PrevSpec, DiagID);
2228       MaybeParseGNUAttributes(D, &LateParsedAttrs);
2229       Fixit &= Tok.isOneOf(tok::semi, tok::l_brace, tok::kw_try);
2230 
2231       Diag(Loc, diag::err_c11_noreturn_misplaced)
2232           << (Fixit ? FixItHint::CreateRemoval(Loc) : FixItHint())
2233           << (Fixit ? FixItHint::CreateInsertion(D.getBeginLoc(), "_Noreturn ")
2234                     : FixItHint());
2235     }
2236 
2237     // Check to see if we have a function *definition* which must have a body.
2238     if (Tok.is(tok::equal) && NextToken().is(tok::code_completion)) {
2239       cutOffParsing();
2240       Actions.CodeCompleteAfterFunctionEquals(D);
2241       return nullptr;
2242     }
2243     // We're at the point where the parsing of function declarator is finished.
2244     //
2245     // A common error is that users accidently add a virtual specifier
2246     // (e.g. override) in an out-line method definition.
2247     // We attempt to recover by stripping all these specifiers coming after
2248     // the declarator.
2249     while (auto Specifier = isCXX11VirtSpecifier()) {
2250       Diag(Tok, diag::err_virt_specifier_outside_class)
2251           << VirtSpecifiers::getSpecifierName(Specifier)
2252           << FixItHint::CreateRemoval(Tok.getLocation());
2253       ConsumeToken();
2254     }
2255     // Look at the next token to make sure that this isn't a function
2256     // declaration.  We have to check this because __attribute__ might be the
2257     // start of a function definition in GCC-extended K&R C.
2258     if (!isDeclarationAfterDeclarator()) {
2259 
2260       // Function definitions are only allowed at file scope and in C++ classes.
2261       // The C++ inline method definition case is handled elsewhere, so we only
2262       // need to handle the file scope definition case.
2263       if (Context == DeclaratorContext::File) {
2264         if (isStartOfFunctionDefinition(D)) {
2265           if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef) {
2266             Diag(Tok, diag::err_function_declared_typedef);
2267 
2268             // Recover by treating the 'typedef' as spurious.
2269             DS.ClearStorageClassSpecs();
2270           }
2271 
2272           Decl *TheDecl = ParseFunctionDefinition(D, ParsedTemplateInfo(),
2273                                                   &LateParsedAttrs);
2274           return Actions.ConvertDeclToDeclGroup(TheDecl);
2275         }
2276 
2277         if (isDeclarationSpecifier(ImplicitTypenameContext::No) ||
2278             Tok.is(tok::kw_namespace)) {
2279           // If there is an invalid declaration specifier or a namespace
2280           // definition right after the function prototype, then we must be in a
2281           // missing semicolon case where this isn't actually a body.  Just fall
2282           // through into the code that handles it as a prototype, and let the
2283           // top-level code handle the erroneous declspec where it would
2284           // otherwise expect a comma or semicolon. Note that
2285           // isDeclarationSpecifier already covers 'inline namespace', since
2286           // 'inline' can be a declaration specifier.
2287         } else {
2288           Diag(Tok, diag::err_expected_fn_body);
2289           SkipUntil(tok::semi);
2290           return nullptr;
2291         }
2292       } else {
2293         if (Tok.is(tok::l_brace)) {
2294           Diag(Tok, diag::err_function_definition_not_allowed);
2295           SkipMalformedDecl();
2296           return nullptr;
2297         }
2298       }
2299     }
2300   }
2301 
2302   if (ParseAsmAttributesAfterDeclarator(D))
2303     return nullptr;
2304 
2305   // C++0x [stmt.iter]p1: Check if we have a for-range-declarator. If so, we
2306   // must parse and analyze the for-range-initializer before the declaration is
2307   // analyzed.
2308   //
2309   // Handle the Objective-C for-in loop variable similarly, although we
2310   // don't need to parse the container in advance.
2311   if (FRI && (Tok.is(tok::colon) || isTokIdentifier_in())) {
2312     bool IsForRangeLoop = false;
2313     if (TryConsumeToken(tok::colon, FRI->ColonLoc)) {
2314       IsForRangeLoop = true;
2315       if (getLangOpts().OpenMP)
2316         Actions.startOpenMPCXXRangeFor();
2317       if (Tok.is(tok::l_brace))
2318         FRI->RangeExpr = ParseBraceInitializer();
2319       else
2320         FRI->RangeExpr = ParseExpression();
2321     }
2322 
2323     Decl *ThisDecl = Actions.ActOnDeclarator(getCurScope(), D);
2324     if (IsForRangeLoop) {
2325       Actions.ActOnCXXForRangeDecl(ThisDecl);
2326     } else {
2327       // Obj-C for loop
2328       if (auto *VD = dyn_cast_or_null<VarDecl>(ThisDecl))
2329         VD->setObjCForDecl(true);
2330     }
2331     Actions.FinalizeDeclaration(ThisDecl);
2332     D.complete(ThisDecl);
2333     return Actions.FinalizeDeclaratorGroup(getCurScope(), DS, ThisDecl);
2334   }
2335 
2336   SmallVector<Decl *, 8> DeclsInGroup;
2337   Decl *FirstDecl = ParseDeclarationAfterDeclaratorAndAttributes(
2338       D, ParsedTemplateInfo(), FRI);
2339   if (LateParsedAttrs.size() > 0)
2340     ParseLexedAttributeList(LateParsedAttrs, FirstDecl, true, false);
2341   D.complete(FirstDecl);
2342   if (FirstDecl)
2343     DeclsInGroup.push_back(FirstDecl);
2344 
2345   bool ExpectSemi = Context != DeclaratorContext::ForInit;
2346 
2347   // If we don't have a comma, it is either the end of the list (a ';') or an
2348   // error, bail out.
2349   SourceLocation CommaLoc;
2350   while (TryConsumeToken(tok::comma, CommaLoc)) {
2351     if (Tok.isAtStartOfLine() && ExpectSemi && !MightBeDeclarator(Context)) {
2352       // This comma was followed by a line-break and something which can't be
2353       // the start of a declarator. The comma was probably a typo for a
2354       // semicolon.
2355       Diag(CommaLoc, diag::err_expected_semi_declaration)
2356         << FixItHint::CreateReplacement(CommaLoc, ";");
2357       ExpectSemi = false;
2358       break;
2359     }
2360 
2361     // Parse the next declarator.
2362     D.clear();
2363     D.setCommaLoc(CommaLoc);
2364 
2365     // Accept attributes in an init-declarator.  In the first declarator in a
2366     // declaration, these would be part of the declspec.  In subsequent
2367     // declarators, they become part of the declarator itself, so that they
2368     // don't apply to declarators after *this* one.  Examples:
2369     //    short __attribute__((common)) var;    -> declspec
2370     //    short var __attribute__((common));    -> declarator
2371     //    short x, __attribute__((common)) var;    -> declarator
2372     MaybeParseGNUAttributes(D);
2373 
2374     // MSVC parses but ignores qualifiers after the comma as an extension.
2375     if (getLangOpts().MicrosoftExt)
2376       DiagnoseAndSkipExtendedMicrosoftTypeAttributes();
2377 
2378     ParseDeclarator(D);
2379 
2380     if (getLangOpts().HLSL)
2381       MaybeParseHLSLSemantics(D);
2382 
2383     if (!D.isInvalidType()) {
2384       // C++2a [dcl.decl]p1
2385       //    init-declarator:
2386       //	      declarator initializer[opt]
2387       //        declarator requires-clause
2388       if (Tok.is(tok::kw_requires))
2389         ParseTrailingRequiresClause(D);
2390       Decl *ThisDecl = ParseDeclarationAfterDeclarator(D);
2391       D.complete(ThisDecl);
2392       if (ThisDecl)
2393         DeclsInGroup.push_back(ThisDecl);
2394     }
2395   }
2396 
2397   if (DeclEnd)
2398     *DeclEnd = Tok.getLocation();
2399 
2400   if (ExpectSemi && ExpectAndConsumeSemi(
2401                         Context == DeclaratorContext::File
2402                             ? diag::err_invalid_token_after_toplevel_declarator
2403                             : diag::err_expected_semi_declaration)) {
2404     // Okay, there was no semicolon and one was expected.  If we see a
2405     // declaration specifier, just assume it was missing and continue parsing.
2406     // Otherwise things are very confused and we skip to recover.
2407     if (!isDeclarationSpecifier(ImplicitTypenameContext::No))
2408       SkipMalformedDecl();
2409   }
2410 
2411   return Actions.FinalizeDeclaratorGroup(getCurScope(), DS, DeclsInGroup);
2412 }
2413 
2414 /// Parse an optional simple-asm-expr and attributes, and attach them to a
2415 /// declarator. Returns true on an error.
2416 bool Parser::ParseAsmAttributesAfterDeclarator(Declarator &D) {
2417   // If a simple-asm-expr is present, parse it.
2418   if (Tok.is(tok::kw_asm)) {
2419     SourceLocation Loc;
2420     ExprResult AsmLabel(ParseSimpleAsm(/*ForAsmLabel*/ true, &Loc));
2421     if (AsmLabel.isInvalid()) {
2422       SkipUntil(tok::semi, StopBeforeMatch);
2423       return true;
2424     }
2425 
2426     D.setAsmLabel(AsmLabel.get());
2427     D.SetRangeEnd(Loc);
2428   }
2429 
2430   MaybeParseGNUAttributes(D);
2431   return false;
2432 }
2433 
2434 /// Parse 'declaration' after parsing 'declaration-specifiers
2435 /// declarator'. This method parses the remainder of the declaration
2436 /// (including any attributes or initializer, among other things) and
2437 /// finalizes the declaration.
2438 ///
2439 ///       init-declarator: [C99 6.7]
2440 ///         declarator
2441 ///         declarator '=' initializer
2442 /// [GNU]   declarator simple-asm-expr[opt] attributes[opt]
2443 /// [GNU]   declarator simple-asm-expr[opt] attributes[opt] '=' initializer
2444 /// [C++]   declarator initializer[opt]
2445 ///
2446 /// [C++] initializer:
2447 /// [C++]   '=' initializer-clause
2448 /// [C++]   '(' expression-list ')'
2449 /// [C++0x] '=' 'default'                                                [TODO]
2450 /// [C++0x] '=' 'delete'
2451 /// [C++0x] braced-init-list
2452 ///
2453 /// According to the standard grammar, =default and =delete are function
2454 /// definitions, but that definitely doesn't fit with the parser here.
2455 ///
2456 Decl *Parser::ParseDeclarationAfterDeclarator(
2457     Declarator &D, const ParsedTemplateInfo &TemplateInfo) {
2458   if (ParseAsmAttributesAfterDeclarator(D))
2459     return nullptr;
2460 
2461   return ParseDeclarationAfterDeclaratorAndAttributes(D, TemplateInfo);
2462 }
2463 
2464 Decl *Parser::ParseDeclarationAfterDeclaratorAndAttributes(
2465     Declarator &D, const ParsedTemplateInfo &TemplateInfo, ForRangeInit *FRI) {
2466   // RAII type used to track whether we're inside an initializer.
2467   struct InitializerScopeRAII {
2468     Parser &P;
2469     Declarator &D;
2470     Decl *ThisDecl;
2471 
2472     InitializerScopeRAII(Parser &P, Declarator &D, Decl *ThisDecl)
2473         : P(P), D(D), ThisDecl(ThisDecl) {
2474       if (ThisDecl && P.getLangOpts().CPlusPlus) {
2475         Scope *S = nullptr;
2476         if (D.getCXXScopeSpec().isSet()) {
2477           P.EnterScope(0);
2478           S = P.getCurScope();
2479         }
2480         P.Actions.ActOnCXXEnterDeclInitializer(S, ThisDecl);
2481       }
2482     }
2483     ~InitializerScopeRAII() { pop(); }
2484     void pop() {
2485       if (ThisDecl && P.getLangOpts().CPlusPlus) {
2486         Scope *S = nullptr;
2487         if (D.getCXXScopeSpec().isSet())
2488           S = P.getCurScope();
2489         P.Actions.ActOnCXXExitDeclInitializer(S, ThisDecl);
2490         if (S)
2491           P.ExitScope();
2492       }
2493       ThisDecl = nullptr;
2494     }
2495   };
2496 
2497   enum class InitKind { Uninitialized, Equal, CXXDirect, CXXBraced };
2498   InitKind TheInitKind;
2499   // If a '==' or '+=' is found, suggest a fixit to '='.
2500   if (isTokenEqualOrEqualTypo())
2501     TheInitKind = InitKind::Equal;
2502   else if (Tok.is(tok::l_paren))
2503     TheInitKind = InitKind::CXXDirect;
2504   else if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace) &&
2505            (!CurParsedObjCImpl || !D.isFunctionDeclarator()))
2506     TheInitKind = InitKind::CXXBraced;
2507   else
2508     TheInitKind = InitKind::Uninitialized;
2509   if (TheInitKind != InitKind::Uninitialized)
2510     D.setHasInitializer();
2511 
2512   // Inform Sema that we just parsed this declarator.
2513   Decl *ThisDecl = nullptr;
2514   Decl *OuterDecl = nullptr;
2515   switch (TemplateInfo.Kind) {
2516   case ParsedTemplateInfo::NonTemplate:
2517     ThisDecl = Actions.ActOnDeclarator(getCurScope(), D);
2518     break;
2519 
2520   case ParsedTemplateInfo::Template:
2521   case ParsedTemplateInfo::ExplicitSpecialization: {
2522     ThisDecl = Actions.ActOnTemplateDeclarator(getCurScope(),
2523                                                *TemplateInfo.TemplateParams,
2524                                                D);
2525     if (VarTemplateDecl *VT = dyn_cast_or_null<VarTemplateDecl>(ThisDecl)) {
2526       // Re-direct this decl to refer to the templated decl so that we can
2527       // initialize it.
2528       ThisDecl = VT->getTemplatedDecl();
2529       OuterDecl = VT;
2530     }
2531     break;
2532   }
2533   case ParsedTemplateInfo::ExplicitInstantiation: {
2534     if (Tok.is(tok::semi)) {
2535       DeclResult ThisRes = Actions.ActOnExplicitInstantiation(
2536           getCurScope(), TemplateInfo.ExternLoc, TemplateInfo.TemplateLoc, D);
2537       if (ThisRes.isInvalid()) {
2538         SkipUntil(tok::semi, StopBeforeMatch);
2539         return nullptr;
2540       }
2541       ThisDecl = ThisRes.get();
2542     } else {
2543       // FIXME: This check should be for a variable template instantiation only.
2544 
2545       // Check that this is a valid instantiation
2546       if (D.getName().getKind() != UnqualifiedIdKind::IK_TemplateId) {
2547         // If the declarator-id is not a template-id, issue a diagnostic and
2548         // recover by ignoring the 'template' keyword.
2549         Diag(Tok, diag::err_template_defn_explicit_instantiation)
2550             << 2 << FixItHint::CreateRemoval(TemplateInfo.TemplateLoc);
2551         ThisDecl = Actions.ActOnDeclarator(getCurScope(), D);
2552       } else {
2553         SourceLocation LAngleLoc =
2554             PP.getLocForEndOfToken(TemplateInfo.TemplateLoc);
2555         Diag(D.getIdentifierLoc(),
2556              diag::err_explicit_instantiation_with_definition)
2557             << SourceRange(TemplateInfo.TemplateLoc)
2558             << FixItHint::CreateInsertion(LAngleLoc, "<>");
2559 
2560         // Recover as if it were an explicit specialization.
2561         TemplateParameterLists FakedParamLists;
2562         FakedParamLists.push_back(Actions.ActOnTemplateParameterList(
2563             0, SourceLocation(), TemplateInfo.TemplateLoc, LAngleLoc,
2564             std::nullopt, LAngleLoc, nullptr));
2565 
2566         ThisDecl =
2567             Actions.ActOnTemplateDeclarator(getCurScope(), FakedParamLists, D);
2568       }
2569     }
2570     break;
2571     }
2572   }
2573 
2574   Sema::CUDATargetContextRAII X(Actions, Sema::CTCK_InitGlobalVar, ThisDecl);
2575   switch (TheInitKind) {
2576   // Parse declarator '=' initializer.
2577   case InitKind::Equal: {
2578     SourceLocation EqualLoc = ConsumeToken();
2579 
2580     if (Tok.is(tok::kw_delete)) {
2581       if (D.isFunctionDeclarator())
2582         Diag(ConsumeToken(), diag::err_default_delete_in_multiple_declaration)
2583           << 1 /* delete */;
2584       else
2585         Diag(ConsumeToken(), diag::err_deleted_non_function);
2586     } else if (Tok.is(tok::kw_default)) {
2587       if (D.isFunctionDeclarator())
2588         Diag(ConsumeToken(), diag::err_default_delete_in_multiple_declaration)
2589           << 0 /* default */;
2590       else
2591         Diag(ConsumeToken(), diag::err_default_special_members)
2592             << getLangOpts().CPlusPlus20;
2593     } else {
2594       InitializerScopeRAII InitScope(*this, D, ThisDecl);
2595 
2596       if (Tok.is(tok::code_completion)) {
2597         cutOffParsing();
2598         Actions.CodeCompleteInitializer(getCurScope(), ThisDecl);
2599         Actions.FinalizeDeclaration(ThisDecl);
2600         return nullptr;
2601       }
2602 
2603       PreferredType.enterVariableInit(Tok.getLocation(), ThisDecl);
2604       ExprResult Init = ParseInitializer();
2605 
2606       // If this is the only decl in (possibly) range based for statement,
2607       // our best guess is that the user meant ':' instead of '='.
2608       if (Tok.is(tok::r_paren) && FRI && D.isFirstDeclarator()) {
2609         Diag(EqualLoc, diag::err_single_decl_assign_in_for_range)
2610             << FixItHint::CreateReplacement(EqualLoc, ":");
2611         // We are trying to stop parser from looking for ';' in this for
2612         // statement, therefore preventing spurious errors to be issued.
2613         FRI->ColonLoc = EqualLoc;
2614         Init = ExprError();
2615         FRI->RangeExpr = Init;
2616       }
2617 
2618       InitScope.pop();
2619 
2620       if (Init.isInvalid()) {
2621         SmallVector<tok::TokenKind, 2> StopTokens;
2622         StopTokens.push_back(tok::comma);
2623         if (D.getContext() == DeclaratorContext::ForInit ||
2624             D.getContext() == DeclaratorContext::SelectionInit)
2625           StopTokens.push_back(tok::r_paren);
2626         SkipUntil(StopTokens, StopAtSemi | StopBeforeMatch);
2627         Actions.ActOnInitializerError(ThisDecl);
2628       } else
2629         Actions.AddInitializerToDecl(ThisDecl, Init.get(),
2630                                      /*DirectInit=*/false);
2631     }
2632     break;
2633   }
2634   case InitKind::CXXDirect: {
2635     // Parse C++ direct initializer: '(' expression-list ')'
2636     BalancedDelimiterTracker T(*this, tok::l_paren);
2637     T.consumeOpen();
2638 
2639     ExprVector Exprs;
2640 
2641     InitializerScopeRAII InitScope(*this, D, ThisDecl);
2642 
2643     auto ThisVarDecl = dyn_cast_or_null<VarDecl>(ThisDecl);
2644     auto RunSignatureHelp = [&]() {
2645       QualType PreferredType = Actions.ProduceConstructorSignatureHelp(
2646           ThisVarDecl->getType()->getCanonicalTypeInternal(),
2647           ThisDecl->getLocation(), Exprs, T.getOpenLocation(),
2648           /*Braced=*/false);
2649       CalledSignatureHelp = true;
2650       return PreferredType;
2651     };
2652     auto SetPreferredType = [&] {
2653       PreferredType.enterFunctionArgument(Tok.getLocation(), RunSignatureHelp);
2654     };
2655 
2656     llvm::function_ref<void()> ExpressionStarts;
2657     if (ThisVarDecl) {
2658       // ParseExpressionList can sometimes succeed even when ThisDecl is not
2659       // VarDecl. This is an error and it is reported in a call to
2660       // Actions.ActOnInitializerError(). However, we call
2661       // ProduceConstructorSignatureHelp only on VarDecls.
2662       ExpressionStarts = SetPreferredType;
2663     }
2664 
2665     bool SawError = ParseExpressionList(Exprs, ExpressionStarts);
2666 
2667     InitScope.pop();
2668 
2669     if (SawError) {
2670       if (ThisVarDecl && PP.isCodeCompletionReached() && !CalledSignatureHelp) {
2671         Actions.ProduceConstructorSignatureHelp(
2672             ThisVarDecl->getType()->getCanonicalTypeInternal(),
2673             ThisDecl->getLocation(), Exprs, T.getOpenLocation(),
2674             /*Braced=*/false);
2675         CalledSignatureHelp = true;
2676       }
2677       Actions.ActOnInitializerError(ThisDecl);
2678       SkipUntil(tok::r_paren, StopAtSemi);
2679     } else {
2680       // Match the ')'.
2681       T.consumeClose();
2682 
2683       ExprResult Initializer = Actions.ActOnParenListExpr(T.getOpenLocation(),
2684                                                           T.getCloseLocation(),
2685                                                           Exprs);
2686       Actions.AddInitializerToDecl(ThisDecl, Initializer.get(),
2687                                    /*DirectInit=*/true);
2688     }
2689     break;
2690   }
2691   case InitKind::CXXBraced: {
2692     // Parse C++0x braced-init-list.
2693     Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);
2694 
2695     InitializerScopeRAII InitScope(*this, D, ThisDecl);
2696 
2697     PreferredType.enterVariableInit(Tok.getLocation(), ThisDecl);
2698     ExprResult Init(ParseBraceInitializer());
2699 
2700     InitScope.pop();
2701 
2702     if (Init.isInvalid()) {
2703       Actions.ActOnInitializerError(ThisDecl);
2704     } else
2705       Actions.AddInitializerToDecl(ThisDecl, Init.get(), /*DirectInit=*/true);
2706     break;
2707   }
2708   case InitKind::Uninitialized: {
2709     Actions.ActOnUninitializedDecl(ThisDecl);
2710     break;
2711   }
2712   }
2713 
2714   Actions.FinalizeDeclaration(ThisDecl);
2715   return OuterDecl ? OuterDecl : ThisDecl;
2716 }
2717 
2718 /// ParseSpecifierQualifierList
2719 ///        specifier-qualifier-list:
2720 ///          type-specifier specifier-qualifier-list[opt]
2721 ///          type-qualifier specifier-qualifier-list[opt]
2722 /// [GNU]    attributes     specifier-qualifier-list[opt]
2723 ///
2724 void Parser::ParseSpecifierQualifierList(
2725     DeclSpec &DS, ImplicitTypenameContext AllowImplicitTypename,
2726     AccessSpecifier AS, DeclSpecContext DSC) {
2727   /// specifier-qualifier-list is a subset of declaration-specifiers.  Just
2728   /// parse declaration-specifiers and complain about extra stuff.
2729   /// TODO: diagnose attribute-specifiers and alignment-specifiers.
2730   ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS, DSC, nullptr,
2731                              AllowImplicitTypename);
2732 
2733   // Validate declspec for type-name.
2734   unsigned Specs = DS.getParsedSpecifiers();
2735   if (isTypeSpecifier(DSC) && !DS.hasTypeSpecifier()) {
2736     Diag(Tok, diag::err_expected_type);
2737     DS.SetTypeSpecError();
2738   } else if (Specs == DeclSpec::PQ_None && !DS.hasAttributes()) {
2739     Diag(Tok, diag::err_typename_requires_specqual);
2740     if (!DS.hasTypeSpecifier())
2741       DS.SetTypeSpecError();
2742   }
2743 
2744   // Issue diagnostic and remove storage class if present.
2745   if (Specs & DeclSpec::PQ_StorageClassSpecifier) {
2746     if (DS.getStorageClassSpecLoc().isValid())
2747       Diag(DS.getStorageClassSpecLoc(),diag::err_typename_invalid_storageclass);
2748     else
2749       Diag(DS.getThreadStorageClassSpecLoc(),
2750            diag::err_typename_invalid_storageclass);
2751     DS.ClearStorageClassSpecs();
2752   }
2753 
2754   // Issue diagnostic and remove function specifier if present.
2755   if (Specs & DeclSpec::PQ_FunctionSpecifier) {
2756     if (DS.isInlineSpecified())
2757       Diag(DS.getInlineSpecLoc(), diag::err_typename_invalid_functionspec);
2758     if (DS.isVirtualSpecified())
2759       Diag(DS.getVirtualSpecLoc(), diag::err_typename_invalid_functionspec);
2760     if (DS.hasExplicitSpecifier())
2761       Diag(DS.getExplicitSpecLoc(), diag::err_typename_invalid_functionspec);
2762     if (DS.isNoreturnSpecified())
2763       Diag(DS.getNoreturnSpecLoc(), diag::err_typename_invalid_functionspec);
2764     DS.ClearFunctionSpecs();
2765   }
2766 
2767   // Issue diagnostic and remove constexpr specifier if present.
2768   if (DS.hasConstexprSpecifier() && DSC != DeclSpecContext::DSC_condition) {
2769     Diag(DS.getConstexprSpecLoc(), diag::err_typename_invalid_constexpr)
2770         << static_cast<int>(DS.getConstexprSpecifier());
2771     DS.ClearConstexprSpec();
2772   }
2773 }
2774 
2775 /// isValidAfterIdentifierInDeclaratorAfterDeclSpec - Return true if the
2776 /// specified token is valid after the identifier in a declarator which
2777 /// immediately follows the declspec.  For example, these things are valid:
2778 ///
2779 ///      int x   [             4];         // direct-declarator
2780 ///      int x   (             int y);     // direct-declarator
2781 ///  int(int x   )                         // direct-declarator
2782 ///      int x   ;                         // simple-declaration
2783 ///      int x   =             17;         // init-declarator-list
2784 ///      int x   ,             y;          // init-declarator-list
2785 ///      int x   __asm__       ("foo");    // init-declarator-list
2786 ///      int x   :             4;          // struct-declarator
2787 ///      int x   {             5};         // C++'0x unified initializers
2788 ///
2789 /// This is not, because 'x' does not immediately follow the declspec (though
2790 /// ')' happens to be valid anyway).
2791 ///    int (x)
2792 ///
2793 static bool isValidAfterIdentifierInDeclarator(const Token &T) {
2794   return T.isOneOf(tok::l_square, tok::l_paren, tok::r_paren, tok::semi,
2795                    tok::comma, tok::equal, tok::kw_asm, tok::l_brace,
2796                    tok::colon);
2797 }
2798 
2799 /// ParseImplicitInt - This method is called when we have an non-typename
2800 /// identifier in a declspec (which normally terminates the decl spec) when
2801 /// the declspec has no type specifier.  In this case, the declspec is either
2802 /// malformed or is "implicit int" (in K&R and C89).
2803 ///
2804 /// This method handles diagnosing this prettily and returns false if the
2805 /// declspec is done being processed.  If it recovers and thinks there may be
2806 /// other pieces of declspec after it, it returns true.
2807 ///
2808 bool Parser::ParseImplicitInt(DeclSpec &DS, CXXScopeSpec *SS,
2809                               const ParsedTemplateInfo &TemplateInfo,
2810                               AccessSpecifier AS, DeclSpecContext DSC,
2811                               ParsedAttributes &Attrs) {
2812   assert(Tok.is(tok::identifier) && "should have identifier");
2813 
2814   SourceLocation Loc = Tok.getLocation();
2815   // If we see an identifier that is not a type name, we normally would
2816   // parse it as the identifier being declared.  However, when a typename
2817   // is typo'd or the definition is not included, this will incorrectly
2818   // parse the typename as the identifier name and fall over misparsing
2819   // later parts of the diagnostic.
2820   //
2821   // As such, we try to do some look-ahead in cases where this would
2822   // otherwise be an "implicit-int" case to see if this is invalid.  For
2823   // example: "static foo_t x = 4;"  In this case, if we parsed foo_t as
2824   // an identifier with implicit int, we'd get a parse error because the
2825   // next token is obviously invalid for a type.  Parse these as a case
2826   // with an invalid type specifier.
2827   assert(!DS.hasTypeSpecifier() && "Type specifier checked above");
2828 
2829   // Since we know that this either implicit int (which is rare) or an
2830   // error, do lookahead to try to do better recovery. This never applies
2831   // within a type specifier. Outside of C++, we allow this even if the
2832   // language doesn't "officially" support implicit int -- we support
2833   // implicit int as an extension in some language modes.
2834   if (!isTypeSpecifier(DSC) && getLangOpts().isImplicitIntAllowed() &&
2835       isValidAfterIdentifierInDeclarator(NextToken())) {
2836     // If this token is valid for implicit int, e.g. "static x = 4", then
2837     // we just avoid eating the identifier, so it will be parsed as the
2838     // identifier in the declarator.
2839     return false;
2840   }
2841 
2842   // Early exit as Sema has a dedicated missing_actual_pipe_type diagnostic
2843   // for incomplete declarations such as `pipe p`.
2844   if (getLangOpts().OpenCLCPlusPlus && DS.isTypeSpecPipe())
2845     return false;
2846 
2847   if (getLangOpts().CPlusPlus &&
2848       DS.getStorageClassSpec() == DeclSpec::SCS_auto) {
2849     // Don't require a type specifier if we have the 'auto' storage class
2850     // specifier in C++98 -- we'll promote it to a type specifier.
2851     if (SS)
2852       AnnotateScopeToken(*SS, /*IsNewAnnotation*/false);
2853     return false;
2854   }
2855 
2856   if (getLangOpts().CPlusPlus && (!SS || SS->isEmpty()) &&
2857       getLangOpts().MSVCCompat) {
2858     // Lookup of an unqualified type name has failed in MSVC compatibility mode.
2859     // Give Sema a chance to recover if we are in a template with dependent base
2860     // classes.
2861     if (ParsedType T = Actions.ActOnMSVCUnknownTypeName(
2862             *Tok.getIdentifierInfo(), Tok.getLocation(),
2863             DSC == DeclSpecContext::DSC_template_type_arg)) {
2864       const char *PrevSpec;
2865       unsigned DiagID;
2866       DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, DiagID, T,
2867                          Actions.getASTContext().getPrintingPolicy());
2868       DS.SetRangeEnd(Tok.getLocation());
2869       ConsumeToken();
2870       return false;
2871     }
2872   }
2873 
2874   // Otherwise, if we don't consume this token, we are going to emit an
2875   // error anyway.  Try to recover from various common problems.  Check
2876   // to see if this was a reference to a tag name without a tag specified.
2877   // This is a common problem in C (saying 'foo' instead of 'struct foo').
2878   //
2879   // C++ doesn't need this, and isTagName doesn't take SS.
2880   if (SS == nullptr) {
2881     const char *TagName = nullptr, *FixitTagName = nullptr;
2882     tok::TokenKind TagKind = tok::unknown;
2883 
2884     switch (Actions.isTagName(*Tok.getIdentifierInfo(), getCurScope())) {
2885       default: break;
2886       case DeclSpec::TST_enum:
2887         TagName="enum"  ; FixitTagName = "enum "  ; TagKind=tok::kw_enum ;break;
2888       case DeclSpec::TST_union:
2889         TagName="union" ; FixitTagName = "union " ;TagKind=tok::kw_union ;break;
2890       case DeclSpec::TST_struct:
2891         TagName="struct"; FixitTagName = "struct ";TagKind=tok::kw_struct;break;
2892       case DeclSpec::TST_interface:
2893         TagName="__interface"; FixitTagName = "__interface ";
2894         TagKind=tok::kw___interface;break;
2895       case DeclSpec::TST_class:
2896         TagName="class" ; FixitTagName = "class " ;TagKind=tok::kw_class ;break;
2897     }
2898 
2899     if (TagName) {
2900       IdentifierInfo *TokenName = Tok.getIdentifierInfo();
2901       LookupResult R(Actions, TokenName, SourceLocation(),
2902                      Sema::LookupOrdinaryName);
2903 
2904       Diag(Loc, diag::err_use_of_tag_name_without_tag)
2905         << TokenName << TagName << getLangOpts().CPlusPlus
2906         << FixItHint::CreateInsertion(Tok.getLocation(), FixitTagName);
2907 
2908       if (Actions.LookupParsedName(R, getCurScope(), SS)) {
2909         for (LookupResult::iterator I = R.begin(), IEnd = R.end();
2910              I != IEnd; ++I)
2911           Diag((*I)->getLocation(), diag::note_decl_hiding_tag_type)
2912             << TokenName << TagName;
2913       }
2914 
2915       // Parse this as a tag as if the missing tag were present.
2916       if (TagKind == tok::kw_enum)
2917         ParseEnumSpecifier(Loc, DS, TemplateInfo, AS,
2918                            DeclSpecContext::DSC_normal);
2919       else
2920         ParseClassSpecifier(TagKind, Loc, DS, TemplateInfo, AS,
2921                             /*EnteringContext*/ false,
2922                             DeclSpecContext::DSC_normal, Attrs);
2923       return true;
2924     }
2925   }
2926 
2927   // Determine whether this identifier could plausibly be the name of something
2928   // being declared (with a missing type).
2929   if (!isTypeSpecifier(DSC) && (!SS || DSC == DeclSpecContext::DSC_top_level ||
2930                                 DSC == DeclSpecContext::DSC_class)) {
2931     // Look ahead to the next token to try to figure out what this declaration
2932     // was supposed to be.
2933     switch (NextToken().getKind()) {
2934     case tok::l_paren: {
2935       // static x(4); // 'x' is not a type
2936       // x(int n);    // 'x' is not a type
2937       // x (*p)[];    // 'x' is a type
2938       //
2939       // Since we're in an error case, we can afford to perform a tentative
2940       // parse to determine which case we're in.
2941       TentativeParsingAction PA(*this);
2942       ConsumeToken();
2943       TPResult TPR = TryParseDeclarator(/*mayBeAbstract*/false);
2944       PA.Revert();
2945 
2946       if (TPR != TPResult::False) {
2947         // The identifier is followed by a parenthesized declarator.
2948         // It's supposed to be a type.
2949         break;
2950       }
2951 
2952       // If we're in a context where we could be declaring a constructor,
2953       // check whether this is a constructor declaration with a bogus name.
2954       if (DSC == DeclSpecContext::DSC_class ||
2955           (DSC == DeclSpecContext::DSC_top_level && SS)) {
2956         IdentifierInfo *II = Tok.getIdentifierInfo();
2957         if (Actions.isCurrentClassNameTypo(II, SS)) {
2958           Diag(Loc, diag::err_constructor_bad_name)
2959             << Tok.getIdentifierInfo() << II
2960             << FixItHint::CreateReplacement(Tok.getLocation(), II->getName());
2961           Tok.setIdentifierInfo(II);
2962         }
2963       }
2964       // Fall through.
2965       [[fallthrough]];
2966     }
2967     case tok::comma:
2968     case tok::equal:
2969     case tok::kw_asm:
2970     case tok::l_brace:
2971     case tok::l_square:
2972     case tok::semi:
2973       // This looks like a variable or function declaration. The type is
2974       // probably missing. We're done parsing decl-specifiers.
2975       // But only if we are not in a function prototype scope.
2976       if (getCurScope()->isFunctionPrototypeScope())
2977         break;
2978       if (SS)
2979         AnnotateScopeToken(*SS, /*IsNewAnnotation*/false);
2980       return false;
2981 
2982     default:
2983       // This is probably supposed to be a type. This includes cases like:
2984       //   int f(itn);
2985       //   struct S { unsigned : 4; };
2986       break;
2987     }
2988   }
2989 
2990   // This is almost certainly an invalid type name. Let Sema emit a diagnostic
2991   // and attempt to recover.
2992   ParsedType T;
2993   IdentifierInfo *II = Tok.getIdentifierInfo();
2994   bool IsTemplateName = getLangOpts().CPlusPlus && NextToken().is(tok::less);
2995   Actions.DiagnoseUnknownTypeName(II, Loc, getCurScope(), SS, T,
2996                                   IsTemplateName);
2997   if (T) {
2998     // The action has suggested that the type T could be used. Set that as
2999     // the type in the declaration specifiers, consume the would-be type
3000     // name token, and we're done.
3001     const char *PrevSpec;
3002     unsigned DiagID;
3003     DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, DiagID, T,
3004                        Actions.getASTContext().getPrintingPolicy());
3005     DS.SetRangeEnd(Tok.getLocation());
3006     ConsumeToken();
3007     // There may be other declaration specifiers after this.
3008     return true;
3009   } else if (II != Tok.getIdentifierInfo()) {
3010     // If no type was suggested, the correction is to a keyword
3011     Tok.setKind(II->getTokenID());
3012     // There may be other declaration specifiers after this.
3013     return true;
3014   }
3015 
3016   // Otherwise, the action had no suggestion for us.  Mark this as an error.
3017   DS.SetTypeSpecError();
3018   DS.SetRangeEnd(Tok.getLocation());
3019   ConsumeToken();
3020 
3021   // Eat any following template arguments.
3022   if (IsTemplateName) {
3023     SourceLocation LAngle, RAngle;
3024     TemplateArgList Args;
3025     ParseTemplateIdAfterTemplateName(true, LAngle, Args, RAngle);
3026   }
3027 
3028   // TODO: Could inject an invalid typedef decl in an enclosing scope to
3029   // avoid rippling error messages on subsequent uses of the same type,
3030   // could be useful if #include was forgotten.
3031   return true;
3032 }
3033 
3034 /// Determine the declaration specifier context from the declarator
3035 /// context.
3036 ///
3037 /// \param Context the declarator context, which is one of the
3038 /// DeclaratorContext enumerator values.
3039 Parser::DeclSpecContext
3040 Parser::getDeclSpecContextFromDeclaratorContext(DeclaratorContext Context) {
3041   switch (Context) {
3042   case DeclaratorContext::Member:
3043     return DeclSpecContext::DSC_class;
3044   case DeclaratorContext::File:
3045     return DeclSpecContext::DSC_top_level;
3046   case DeclaratorContext::TemplateParam:
3047     return DeclSpecContext::DSC_template_param;
3048   case DeclaratorContext::TemplateArg:
3049     return DeclSpecContext::DSC_template_arg;
3050   case DeclaratorContext::TemplateTypeArg:
3051     return DeclSpecContext::DSC_template_type_arg;
3052   case DeclaratorContext::TrailingReturn:
3053   case DeclaratorContext::TrailingReturnVar:
3054     return DeclSpecContext::DSC_trailing;
3055   case DeclaratorContext::AliasDecl:
3056   case DeclaratorContext::AliasTemplate:
3057     return DeclSpecContext::DSC_alias_declaration;
3058   case DeclaratorContext::Association:
3059     return DeclSpecContext::DSC_association;
3060   case DeclaratorContext::TypeName:
3061     return DeclSpecContext::DSC_type_specifier;
3062   case DeclaratorContext::Condition:
3063     return DeclSpecContext::DSC_condition;
3064   case DeclaratorContext::ConversionId:
3065     return DeclSpecContext::DSC_conv_operator;
3066   case DeclaratorContext::CXXNew:
3067     return DeclSpecContext::DSC_new;
3068   case DeclaratorContext::Prototype:
3069   case DeclaratorContext::ObjCResult:
3070   case DeclaratorContext::ObjCParameter:
3071   case DeclaratorContext::KNRTypeList:
3072   case DeclaratorContext::FunctionalCast:
3073   case DeclaratorContext::Block:
3074   case DeclaratorContext::ForInit:
3075   case DeclaratorContext::SelectionInit:
3076   case DeclaratorContext::CXXCatch:
3077   case DeclaratorContext::ObjCCatch:
3078   case DeclaratorContext::BlockLiteral:
3079   case DeclaratorContext::LambdaExpr:
3080   case DeclaratorContext::LambdaExprParameter:
3081   case DeclaratorContext::RequiresExpr:
3082     return DeclSpecContext::DSC_normal;
3083   }
3084 
3085   llvm_unreachable("Missing DeclaratorContext case");
3086 }
3087 
3088 /// ParseAlignArgument - Parse the argument to an alignment-specifier.
3089 ///
3090 /// [C11]   type-id
3091 /// [C11]   constant-expression
3092 /// [C++0x] type-id ...[opt]
3093 /// [C++0x] assignment-expression ...[opt]
3094 ExprResult Parser::ParseAlignArgument(StringRef KWName, SourceLocation Start,
3095                                       SourceLocation &EllipsisLoc, bool &IsType,
3096                                       ParsedType &TypeResult) {
3097   ExprResult ER;
3098   if (isTypeIdInParens()) {
3099     SourceLocation TypeLoc = Tok.getLocation();
3100     ParsedType Ty = ParseTypeName().get();
3101     SourceRange TypeRange(Start, Tok.getLocation());
3102     if (Actions.ActOnAlignasTypeArgument(KWName, Ty, TypeLoc, TypeRange))
3103       return ExprError();
3104     TypeResult = Ty;
3105     IsType = true;
3106   } else {
3107     ER = ParseConstantExpression();
3108     IsType = false;
3109   }
3110 
3111   if (getLangOpts().CPlusPlus11)
3112     TryConsumeToken(tok::ellipsis, EllipsisLoc);
3113 
3114   return ER;
3115 }
3116 
3117 /// ParseAlignmentSpecifier - Parse an alignment-specifier, and add the
3118 /// attribute to Attrs.
3119 ///
3120 /// alignment-specifier:
3121 /// [C11]   '_Alignas' '(' type-id ')'
3122 /// [C11]   '_Alignas' '(' constant-expression ')'
3123 /// [C++11] 'alignas' '(' type-id ...[opt] ')'
3124 /// [C++11] 'alignas' '(' assignment-expression ...[opt] ')'
3125 void Parser::ParseAlignmentSpecifier(ParsedAttributes &Attrs,
3126                                      SourceLocation *EndLoc) {
3127   assert(Tok.isOneOf(tok::kw_alignas, tok::kw__Alignas) &&
3128          "Not an alignment-specifier!");
3129   Token KWTok = Tok;
3130   IdentifierInfo *KWName = KWTok.getIdentifierInfo();
3131   auto Kind = KWTok.getKind();
3132   SourceLocation KWLoc = ConsumeToken();
3133 
3134   BalancedDelimiterTracker T(*this, tok::l_paren);
3135   if (T.expectAndConsume())
3136     return;
3137 
3138   bool IsType;
3139   ParsedType TypeResult;
3140   SourceLocation EllipsisLoc;
3141   ExprResult ArgExpr =
3142       ParseAlignArgument(PP.getSpelling(KWTok), T.getOpenLocation(),
3143                          EllipsisLoc, IsType, TypeResult);
3144   if (ArgExpr.isInvalid()) {
3145     T.skipToEnd();
3146     return;
3147   }
3148 
3149   T.consumeClose();
3150   if (EndLoc)
3151     *EndLoc = T.getCloseLocation();
3152 
3153   if (IsType) {
3154     Attrs.addNewTypeAttr(KWName, KWLoc, nullptr, KWLoc, TypeResult, Kind,
3155                          EllipsisLoc);
3156   } else {
3157     ArgsVector ArgExprs;
3158     ArgExprs.push_back(ArgExpr.get());
3159     Attrs.addNew(KWName, KWLoc, nullptr, KWLoc, ArgExprs.data(), 1, Kind,
3160                  EllipsisLoc);
3161   }
3162 }
3163 
3164 ExprResult Parser::ParseExtIntegerArgument() {
3165   assert(Tok.isOneOf(tok::kw__ExtInt, tok::kw__BitInt) &&
3166          "Not an extended int type");
3167   ConsumeToken();
3168 
3169   BalancedDelimiterTracker T(*this, tok::l_paren);
3170   if (T.expectAndConsume())
3171     return ExprError();
3172 
3173   ExprResult ER = ParseConstantExpression();
3174   if (ER.isInvalid()) {
3175     T.skipToEnd();
3176     return ExprError();
3177   }
3178 
3179   if(T.consumeClose())
3180     return ExprError();
3181   return ER;
3182 }
3183 
3184 /// Determine whether we're looking at something that might be a declarator
3185 /// in a simple-declaration. If it can't possibly be a declarator, maybe
3186 /// diagnose a missing semicolon after a prior tag definition in the decl
3187 /// specifier.
3188 ///
3189 /// \return \c true if an error occurred and this can't be any kind of
3190 /// declaration.
3191 bool
3192 Parser::DiagnoseMissingSemiAfterTagDefinition(DeclSpec &DS, AccessSpecifier AS,
3193                                               DeclSpecContext DSContext,
3194                                               LateParsedAttrList *LateAttrs) {
3195   assert(DS.hasTagDefinition() && "shouldn't call this");
3196 
3197   bool EnteringContext = (DSContext == DeclSpecContext::DSC_class ||
3198                           DSContext == DeclSpecContext::DSC_top_level);
3199 
3200   if (getLangOpts().CPlusPlus &&
3201       Tok.isOneOf(tok::identifier, tok::coloncolon, tok::kw_decltype,
3202                   tok::annot_template_id) &&
3203       TryAnnotateCXXScopeToken(EnteringContext)) {
3204     SkipMalformedDecl();
3205     return true;
3206   }
3207 
3208   bool HasScope = Tok.is(tok::annot_cxxscope);
3209   // Make a copy in case GetLookAheadToken invalidates the result of NextToken.
3210   Token AfterScope = HasScope ? NextToken() : Tok;
3211 
3212   // Determine whether the following tokens could possibly be a
3213   // declarator.
3214   bool MightBeDeclarator = true;
3215   if (Tok.isOneOf(tok::kw_typename, tok::annot_typename)) {
3216     // A declarator-id can't start with 'typename'.
3217     MightBeDeclarator = false;
3218   } else if (AfterScope.is(tok::annot_template_id)) {
3219     // If we have a type expressed as a template-id, this cannot be a
3220     // declarator-id (such a type cannot be redeclared in a simple-declaration).
3221     TemplateIdAnnotation *Annot =
3222         static_cast<TemplateIdAnnotation *>(AfterScope.getAnnotationValue());
3223     if (Annot->Kind == TNK_Type_template)
3224       MightBeDeclarator = false;
3225   } else if (AfterScope.is(tok::identifier)) {
3226     const Token &Next = HasScope ? GetLookAheadToken(2) : NextToken();
3227 
3228     // These tokens cannot come after the declarator-id in a
3229     // simple-declaration, and are likely to come after a type-specifier.
3230     if (Next.isOneOf(tok::star, tok::amp, tok::ampamp, tok::identifier,
3231                      tok::annot_cxxscope, tok::coloncolon)) {
3232       // Missing a semicolon.
3233       MightBeDeclarator = false;
3234     } else if (HasScope) {
3235       // If the declarator-id has a scope specifier, it must redeclare a
3236       // previously-declared entity. If that's a type (and this is not a
3237       // typedef), that's an error.
3238       CXXScopeSpec SS;
3239       Actions.RestoreNestedNameSpecifierAnnotation(
3240           Tok.getAnnotationValue(), Tok.getAnnotationRange(), SS);
3241       IdentifierInfo *Name = AfterScope.getIdentifierInfo();
3242       Sema::NameClassification Classification = Actions.ClassifyName(
3243           getCurScope(), SS, Name, AfterScope.getLocation(), Next,
3244           /*CCC=*/nullptr);
3245       switch (Classification.getKind()) {
3246       case Sema::NC_Error:
3247         SkipMalformedDecl();
3248         return true;
3249 
3250       case Sema::NC_Keyword:
3251         llvm_unreachable("typo correction is not possible here");
3252 
3253       case Sema::NC_Type:
3254       case Sema::NC_TypeTemplate:
3255       case Sema::NC_UndeclaredNonType:
3256       case Sema::NC_UndeclaredTemplate:
3257         // Not a previously-declared non-type entity.
3258         MightBeDeclarator = false;
3259         break;
3260 
3261       case Sema::NC_Unknown:
3262       case Sema::NC_NonType:
3263       case Sema::NC_DependentNonType:
3264       case Sema::NC_OverloadSet:
3265       case Sema::NC_VarTemplate:
3266       case Sema::NC_FunctionTemplate:
3267       case Sema::NC_Concept:
3268         // Might be a redeclaration of a prior entity.
3269         break;
3270       }
3271     }
3272   }
3273 
3274   if (MightBeDeclarator)
3275     return false;
3276 
3277   const PrintingPolicy &PPol = Actions.getASTContext().getPrintingPolicy();
3278   Diag(PP.getLocForEndOfToken(DS.getRepAsDecl()->getEndLoc()),
3279        diag::err_expected_after)
3280       << DeclSpec::getSpecifierName(DS.getTypeSpecType(), PPol) << tok::semi;
3281 
3282   // Try to recover from the typo, by dropping the tag definition and parsing
3283   // the problematic tokens as a type.
3284   //
3285   // FIXME: Split the DeclSpec into pieces for the standalone
3286   // declaration and pieces for the following declaration, instead
3287   // of assuming that all the other pieces attach to new declaration,
3288   // and call ParsedFreeStandingDeclSpec as appropriate.
3289   DS.ClearTypeSpecType();
3290   ParsedTemplateInfo NotATemplate;
3291   ParseDeclarationSpecifiers(DS, NotATemplate, AS, DSContext, LateAttrs);
3292   return false;
3293 }
3294 
3295 /// ParseDeclarationSpecifiers
3296 ///       declaration-specifiers: [C99 6.7]
3297 ///         storage-class-specifier declaration-specifiers[opt]
3298 ///         type-specifier declaration-specifiers[opt]
3299 /// [C99]   function-specifier declaration-specifiers[opt]
3300 /// [C11]   alignment-specifier declaration-specifiers[opt]
3301 /// [GNU]   attributes declaration-specifiers[opt]
3302 /// [Clang] '__module_private__' declaration-specifiers[opt]
3303 /// [ObjC1] '__kindof' declaration-specifiers[opt]
3304 ///
3305 ///       storage-class-specifier: [C99 6.7.1]
3306 ///         'typedef'
3307 ///         'extern'
3308 ///         'static'
3309 ///         'auto'
3310 ///         'register'
3311 /// [C++]   'mutable'
3312 /// [C++11] 'thread_local'
3313 /// [C11]   '_Thread_local'
3314 /// [GNU]   '__thread'
3315 ///       function-specifier: [C99 6.7.4]
3316 /// [C99]   'inline'
3317 /// [C++]   'virtual'
3318 /// [C++]   'explicit'
3319 /// [OpenCL] '__kernel'
3320 ///       'friend': [C++ dcl.friend]
3321 ///       'constexpr': [C++0x dcl.constexpr]
3322 void Parser::ParseDeclarationSpecifiers(
3323     DeclSpec &DS, const ParsedTemplateInfo &TemplateInfo, AccessSpecifier AS,
3324     DeclSpecContext DSContext, LateParsedAttrList *LateAttrs,
3325     ImplicitTypenameContext AllowImplicitTypename) {
3326   if (DS.getSourceRange().isInvalid()) {
3327     // Start the range at the current token but make the end of the range
3328     // invalid.  This will make the entire range invalid unless we successfully
3329     // consume a token.
3330     DS.SetRangeStart(Tok.getLocation());
3331     DS.SetRangeEnd(SourceLocation());
3332   }
3333 
3334   // If we are in a operator context, convert it back into a type specifier
3335   // context for better error handling later on.
3336   if (DSContext == DeclSpecContext::DSC_conv_operator) {
3337     // No implicit typename here.
3338     AllowImplicitTypename = ImplicitTypenameContext::No;
3339     DSContext = DeclSpecContext::DSC_type_specifier;
3340   }
3341 
3342   bool EnteringContext = (DSContext == DeclSpecContext::DSC_class ||
3343                           DSContext == DeclSpecContext::DSC_top_level);
3344   bool AttrsLastTime = false;
3345   ParsedAttributes attrs(AttrFactory);
3346   // We use Sema's policy to get bool macros right.
3347   PrintingPolicy Policy = Actions.getPrintingPolicy();
3348   while (true) {
3349     bool isInvalid = false;
3350     bool isStorageClass = false;
3351     const char *PrevSpec = nullptr;
3352     unsigned DiagID = 0;
3353 
3354     // This value needs to be set to the location of the last token if the last
3355     // token of the specifier is already consumed.
3356     SourceLocation ConsumedEnd;
3357 
3358     // HACK: MSVC doesn't consider _Atomic to be a keyword and its STL
3359     // implementation for VS2013 uses _Atomic as an identifier for one of the
3360     // classes in <atomic>.
3361     //
3362     // A typedef declaration containing _Atomic<...> is among the places where
3363     // the class is used.  If we are currently parsing such a declaration, treat
3364     // the token as an identifier.
3365     if (getLangOpts().MSVCCompat && Tok.is(tok::kw__Atomic) &&
3366         DS.getStorageClassSpec() == clang::DeclSpec::SCS_typedef &&
3367         !DS.hasTypeSpecifier() && GetLookAheadToken(1).is(tok::less))
3368       Tok.setKind(tok::identifier);
3369 
3370     SourceLocation Loc = Tok.getLocation();
3371 
3372     // Helper for image types in OpenCL.
3373     auto handleOpenCLImageKW = [&] (StringRef Ext, TypeSpecifierType ImageTypeSpec) {
3374       // Check if the image type is supported and otherwise turn the keyword into an identifier
3375       // because image types from extensions are not reserved identifiers.
3376       if (!StringRef(Ext).empty() && !getActions().getOpenCLOptions().isSupported(Ext, getLangOpts())) {
3377         Tok.getIdentifierInfo()->revertTokenIDToIdentifier();
3378         Tok.setKind(tok::identifier);
3379         return false;
3380       }
3381       isInvalid = DS.SetTypeSpecType(ImageTypeSpec, Loc, PrevSpec, DiagID, Policy);
3382       return true;
3383     };
3384 
3385     // Turn off usual access checking for template specializations and
3386     // instantiations.
3387     bool IsTemplateSpecOrInst =
3388         (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation ||
3389          TemplateInfo.Kind == ParsedTemplateInfo::ExplicitSpecialization);
3390 
3391     switch (Tok.getKind()) {
3392     default:
3393       if (Tok.isRegularKeywordAttribute())
3394         goto Attribute;
3395 
3396     DoneWithDeclSpec:
3397       if (!AttrsLastTime)
3398         ProhibitAttributes(attrs);
3399       else {
3400         // Reject C++11 / C23 attributes that aren't type attributes.
3401         for (const ParsedAttr &PA : attrs) {
3402           if (!PA.isCXX11Attribute() && !PA.isC23Attribute() &&
3403               !PA.isRegularKeywordAttribute())
3404             continue;
3405           if (PA.getKind() == ParsedAttr::UnknownAttribute)
3406             // We will warn about the unknown attribute elsewhere (in
3407             // SemaDeclAttr.cpp)
3408             continue;
3409           // GCC ignores this attribute when placed on the DeclSpec in [[]]
3410           // syntax, so we do the same.
3411           if (PA.getKind() == ParsedAttr::AT_VectorSize) {
3412             Diag(PA.getLoc(), diag::warn_attribute_ignored) << PA;
3413             PA.setInvalid();
3414             continue;
3415           }
3416           // We reject AT_LifetimeBound and AT_AnyX86NoCfCheck, even though they
3417           // are type attributes, because we historically haven't allowed these
3418           // to be used as type attributes in C++11 / C23 syntax.
3419           if (PA.isTypeAttr() && PA.getKind() != ParsedAttr::AT_LifetimeBound &&
3420               PA.getKind() != ParsedAttr::AT_AnyX86NoCfCheck)
3421             continue;
3422           Diag(PA.getLoc(), diag::err_attribute_not_type_attr)
3423               << PA << PA.isRegularKeywordAttribute();
3424           PA.setInvalid();
3425         }
3426 
3427         DS.takeAttributesFrom(attrs);
3428       }
3429 
3430       // If this is not a declaration specifier token, we're done reading decl
3431       // specifiers.  First verify that DeclSpec's are consistent.
3432       DS.Finish(Actions, Policy);
3433       return;
3434 
3435     case tok::l_square:
3436     case tok::kw_alignas:
3437       if (!isAllowedCXX11AttributeSpecifier())
3438         goto DoneWithDeclSpec;
3439 
3440     Attribute:
3441       ProhibitAttributes(attrs);
3442       // FIXME: It would be good to recover by accepting the attributes,
3443       //        but attempting to do that now would cause serious
3444       //        madness in terms of diagnostics.
3445       attrs.clear();
3446       attrs.Range = SourceRange();
3447 
3448       ParseCXX11Attributes(attrs);
3449       AttrsLastTime = true;
3450       continue;
3451 
3452     case tok::code_completion: {
3453       Sema::ParserCompletionContext CCC = Sema::PCC_Namespace;
3454       if (DS.hasTypeSpecifier()) {
3455         bool AllowNonIdentifiers
3456           = (getCurScope()->getFlags() & (Scope::ControlScope |
3457                                           Scope::BlockScope |
3458                                           Scope::TemplateParamScope |
3459                                           Scope::FunctionPrototypeScope |
3460                                           Scope::AtCatchScope)) == 0;
3461         bool AllowNestedNameSpecifiers
3462           = DSContext == DeclSpecContext::DSC_top_level ||
3463             (DSContext == DeclSpecContext::DSC_class && DS.isFriendSpecified());
3464 
3465         cutOffParsing();
3466         Actions.CodeCompleteDeclSpec(getCurScope(), DS,
3467                                      AllowNonIdentifiers,
3468                                      AllowNestedNameSpecifiers);
3469         return;
3470       }
3471 
3472       // Class context can appear inside a function/block, so prioritise that.
3473       if (TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate)
3474         CCC = DSContext == DeclSpecContext::DSC_class ? Sema::PCC_MemberTemplate
3475                                                       : Sema::PCC_Template;
3476       else if (DSContext == DeclSpecContext::DSC_class)
3477         CCC = Sema::PCC_Class;
3478       else if (getCurScope()->getFnParent() || getCurScope()->getBlockParent())
3479         CCC = Sema::PCC_LocalDeclarationSpecifiers;
3480       else if (CurParsedObjCImpl)
3481         CCC = Sema::PCC_ObjCImplementation;
3482 
3483       cutOffParsing();
3484       Actions.CodeCompleteOrdinaryName(getCurScope(), CCC);
3485       return;
3486     }
3487 
3488     case tok::coloncolon: // ::foo::bar
3489       // C++ scope specifier.  Annotate and loop, or bail out on error.
3490       if (getLangOpts().CPlusPlus &&
3491           TryAnnotateCXXScopeToken(EnteringContext)) {
3492         if (!DS.hasTypeSpecifier())
3493           DS.SetTypeSpecError();
3494         goto DoneWithDeclSpec;
3495       }
3496       if (Tok.is(tok::coloncolon)) // ::new or ::delete
3497         goto DoneWithDeclSpec;
3498       continue;
3499 
3500     case tok::annot_cxxscope: {
3501       if (DS.hasTypeSpecifier() || DS.isTypeAltiVecVector())
3502         goto DoneWithDeclSpec;
3503 
3504       CXXScopeSpec SS;
3505       if (TemplateInfo.TemplateParams)
3506         SS.setTemplateParamLists(*TemplateInfo.TemplateParams);
3507       Actions.RestoreNestedNameSpecifierAnnotation(Tok.getAnnotationValue(),
3508                                                    Tok.getAnnotationRange(),
3509                                                    SS);
3510 
3511       // We are looking for a qualified typename.
3512       Token Next = NextToken();
3513 
3514       TemplateIdAnnotation *TemplateId = Next.is(tok::annot_template_id)
3515                                              ? takeTemplateIdAnnotation(Next)
3516                                              : nullptr;
3517       if (TemplateId && TemplateId->hasInvalidName()) {
3518         // We found something like 'T::U<Args> x', but U is not a template.
3519         // Assume it was supposed to be a type.
3520         DS.SetTypeSpecError();
3521         ConsumeAnnotationToken();
3522         break;
3523       }
3524 
3525       if (TemplateId && TemplateId->Kind == TNK_Type_template) {
3526         // We have a qualified template-id, e.g., N::A<int>
3527 
3528         // If this would be a valid constructor declaration with template
3529         // arguments, we will reject the attempt to form an invalid type-id
3530         // referring to the injected-class-name when we annotate the token,
3531         // per C++ [class.qual]p2.
3532         //
3533         // To improve diagnostics for this case, parse the declaration as a
3534         // constructor (and reject the extra template arguments later).
3535         if ((DSContext == DeclSpecContext::DSC_top_level ||
3536              DSContext == DeclSpecContext::DSC_class) &&
3537             TemplateId->Name &&
3538             Actions.isCurrentClassName(*TemplateId->Name, getCurScope(), &SS) &&
3539             isConstructorDeclarator(/*Unqualified=*/false,
3540                                     /*DeductionGuide=*/false,
3541                                     DS.isFriendSpecified())) {
3542           // The user meant this to be an out-of-line constructor
3543           // definition, but template arguments are not allowed
3544           // there.  Just allow this as a constructor; we'll
3545           // complain about it later.
3546           goto DoneWithDeclSpec;
3547         }
3548 
3549         DS.getTypeSpecScope() = SS;
3550         ConsumeAnnotationToken(); // The C++ scope.
3551         assert(Tok.is(tok::annot_template_id) &&
3552                "ParseOptionalCXXScopeSpecifier not working");
3553         AnnotateTemplateIdTokenAsType(SS, AllowImplicitTypename);
3554         continue;
3555       }
3556 
3557       if (TemplateId && TemplateId->Kind == TNK_Concept_template) {
3558         DS.getTypeSpecScope() = SS;
3559         // This is probably a qualified placeholder-specifier, e.g., ::C<int>
3560         // auto ... Consume the scope annotation and continue to consume the
3561         // template-id as a placeholder-specifier. Let the next iteration
3562         // diagnose a missing auto.
3563         ConsumeAnnotationToken();
3564         continue;
3565       }
3566 
3567       if (Next.is(tok::annot_typename)) {
3568         DS.getTypeSpecScope() = SS;
3569         ConsumeAnnotationToken(); // The C++ scope.
3570         TypeResult T = getTypeAnnotation(Tok);
3571         isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename,
3572                                        Tok.getAnnotationEndLoc(),
3573                                        PrevSpec, DiagID, T, Policy);
3574         if (isInvalid)
3575           break;
3576         DS.SetRangeEnd(Tok.getAnnotationEndLoc());
3577         ConsumeAnnotationToken(); // The typename
3578       }
3579 
3580       if (AllowImplicitTypename == ImplicitTypenameContext::Yes &&
3581           Next.is(tok::annot_template_id) &&
3582           static_cast<TemplateIdAnnotation *>(Next.getAnnotationValue())
3583                   ->Kind == TNK_Dependent_template_name) {
3584         DS.getTypeSpecScope() = SS;
3585         ConsumeAnnotationToken(); // The C++ scope.
3586         AnnotateTemplateIdTokenAsType(SS, AllowImplicitTypename);
3587         continue;
3588       }
3589 
3590       if (Next.isNot(tok::identifier))
3591         goto DoneWithDeclSpec;
3592 
3593       // Check whether this is a constructor declaration. If we're in a
3594       // context where the identifier could be a class name, and it has the
3595       // shape of a constructor declaration, process it as one.
3596       if ((DSContext == DeclSpecContext::DSC_top_level ||
3597            DSContext == DeclSpecContext::DSC_class) &&
3598           Actions.isCurrentClassName(*Next.getIdentifierInfo(), getCurScope(),
3599                                      &SS) &&
3600           isConstructorDeclarator(/*Unqualified=*/false,
3601                                   /*DeductionGuide=*/false,
3602                                   DS.isFriendSpecified(),
3603                                   &TemplateInfo))
3604         goto DoneWithDeclSpec;
3605 
3606       // C++20 [temp.spec] 13.9/6.
3607       // This disables the access checking rules for function template explicit
3608       // instantiation and explicit specialization:
3609       // - `return type`.
3610       SuppressAccessChecks SAC(*this, IsTemplateSpecOrInst);
3611 
3612       ParsedType TypeRep = Actions.getTypeName(
3613           *Next.getIdentifierInfo(), Next.getLocation(), getCurScope(), &SS,
3614           false, false, nullptr,
3615           /*IsCtorOrDtorName=*/false,
3616           /*WantNontrivialTypeSourceInfo=*/true,
3617           isClassTemplateDeductionContext(DSContext), AllowImplicitTypename);
3618 
3619       if (IsTemplateSpecOrInst)
3620         SAC.done();
3621 
3622       // If the referenced identifier is not a type, then this declspec is
3623       // erroneous: We already checked about that it has no type specifier, and
3624       // C++ doesn't have implicit int.  Diagnose it as a typo w.r.t. to the
3625       // typename.
3626       if (!TypeRep) {
3627         if (TryAnnotateTypeConstraint())
3628           goto DoneWithDeclSpec;
3629         if (Tok.isNot(tok::annot_cxxscope) ||
3630             NextToken().isNot(tok::identifier))
3631           continue;
3632         // Eat the scope spec so the identifier is current.
3633         ConsumeAnnotationToken();
3634         ParsedAttributes Attrs(AttrFactory);
3635         if (ParseImplicitInt(DS, &SS, TemplateInfo, AS, DSContext, Attrs)) {
3636           if (!Attrs.empty()) {
3637             AttrsLastTime = true;
3638             attrs.takeAllFrom(Attrs);
3639           }
3640           continue;
3641         }
3642         goto DoneWithDeclSpec;
3643       }
3644 
3645       DS.getTypeSpecScope() = SS;
3646       ConsumeAnnotationToken(); // The C++ scope.
3647 
3648       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
3649                                      DiagID, TypeRep, Policy);
3650       if (isInvalid)
3651         break;
3652 
3653       DS.SetRangeEnd(Tok.getLocation());
3654       ConsumeToken(); // The typename.
3655 
3656       continue;
3657     }
3658 
3659     case tok::annot_typename: {
3660       // If we've previously seen a tag definition, we were almost surely
3661       // missing a semicolon after it.
3662       if (DS.hasTypeSpecifier() && DS.hasTagDefinition())
3663         goto DoneWithDeclSpec;
3664 
3665       TypeResult T = getTypeAnnotation(Tok);
3666       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
3667                                      DiagID, T, Policy);
3668       if (isInvalid)
3669         break;
3670 
3671       DS.SetRangeEnd(Tok.getAnnotationEndLoc());
3672       ConsumeAnnotationToken(); // The typename
3673 
3674       continue;
3675     }
3676 
3677     case tok::kw___is_signed:
3678       // GNU libstdc++ 4.4 uses __is_signed as an identifier, but Clang
3679       // typically treats it as a trait. If we see __is_signed as it appears
3680       // in libstdc++, e.g.,
3681       //
3682       //   static const bool __is_signed;
3683       //
3684       // then treat __is_signed as an identifier rather than as a keyword.
3685       if (DS.getTypeSpecType() == TST_bool &&
3686           DS.getTypeQualifiers() == DeclSpec::TQ_const &&
3687           DS.getStorageClassSpec() == DeclSpec::SCS_static)
3688         TryKeywordIdentFallback(true);
3689 
3690       // We're done with the declaration-specifiers.
3691       goto DoneWithDeclSpec;
3692 
3693       // typedef-name
3694     case tok::kw___super:
3695     case tok::kw_decltype:
3696     case tok::identifier:
3697     ParseIdentifier: {
3698       // This identifier can only be a typedef name if we haven't already seen
3699       // a type-specifier.  Without this check we misparse:
3700       //  typedef int X; struct Y { short X; };  as 'short int'.
3701       if (DS.hasTypeSpecifier())
3702         goto DoneWithDeclSpec;
3703 
3704       // If the token is an identifier named "__declspec" and Microsoft
3705       // extensions are not enabled, it is likely that there will be cascading
3706       // parse errors if this really is a __declspec attribute. Attempt to
3707       // recognize that scenario and recover gracefully.
3708       if (!getLangOpts().DeclSpecKeyword && Tok.is(tok::identifier) &&
3709           Tok.getIdentifierInfo()->getName().equals("__declspec")) {
3710         Diag(Loc, diag::err_ms_attributes_not_enabled);
3711 
3712         // The next token should be an open paren. If it is, eat the entire
3713         // attribute declaration and continue.
3714         if (NextToken().is(tok::l_paren)) {
3715           // Consume the __declspec identifier.
3716           ConsumeToken();
3717 
3718           // Eat the parens and everything between them.
3719           BalancedDelimiterTracker T(*this, tok::l_paren);
3720           if (T.consumeOpen()) {
3721             assert(false && "Not a left paren?");
3722             return;
3723           }
3724           T.skipToEnd();
3725           continue;
3726         }
3727       }
3728 
3729       // In C++, check to see if this is a scope specifier like foo::bar::, if
3730       // so handle it as such.  This is important for ctor parsing.
3731       if (getLangOpts().CPlusPlus) {
3732         // C++20 [temp.spec] 13.9/6.
3733         // This disables the access checking rules for function template
3734         // explicit instantiation and explicit specialization:
3735         // - `return type`.
3736         SuppressAccessChecks SAC(*this, IsTemplateSpecOrInst);
3737 
3738         const bool Success = TryAnnotateCXXScopeToken(EnteringContext);
3739 
3740         if (IsTemplateSpecOrInst)
3741           SAC.done();
3742 
3743         if (Success) {
3744           if (IsTemplateSpecOrInst)
3745             SAC.redelay();
3746           DS.SetTypeSpecError();
3747           goto DoneWithDeclSpec;
3748         }
3749 
3750         if (!Tok.is(tok::identifier))
3751           continue;
3752       }
3753 
3754       // Check for need to substitute AltiVec keyword tokens.
3755       if (TryAltiVecToken(DS, Loc, PrevSpec, DiagID, isInvalid))
3756         break;
3757 
3758       // [AltiVec] 2.2: [If the 'vector' specifier is used] The syntax does not
3759       //                allow the use of a typedef name as a type specifier.
3760       if (DS.isTypeAltiVecVector())
3761         goto DoneWithDeclSpec;
3762 
3763       if (DSContext == DeclSpecContext::DSC_objc_method_result &&
3764           isObjCInstancetype()) {
3765         ParsedType TypeRep = Actions.ActOnObjCInstanceType(Loc);
3766         assert(TypeRep);
3767         isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
3768                                        DiagID, TypeRep, Policy);
3769         if (isInvalid)
3770           break;
3771 
3772         DS.SetRangeEnd(Loc);
3773         ConsumeToken();
3774         continue;
3775       }
3776 
3777       // If we're in a context where the identifier could be a class name,
3778       // check whether this is a constructor declaration.
3779       if (getLangOpts().CPlusPlus && DSContext == DeclSpecContext::DSC_class &&
3780           Actions.isCurrentClassName(*Tok.getIdentifierInfo(), getCurScope()) &&
3781           isConstructorDeclarator(/*Unqualified=*/true,
3782                                   /*DeductionGuide=*/false,
3783                                   DS.isFriendSpecified()))
3784         goto DoneWithDeclSpec;
3785 
3786       ParsedType TypeRep = Actions.getTypeName(
3787           *Tok.getIdentifierInfo(), Tok.getLocation(), getCurScope(), nullptr,
3788           false, false, nullptr, false, false,
3789           isClassTemplateDeductionContext(DSContext));
3790 
3791       // If this is not a typedef name, don't parse it as part of the declspec,
3792       // it must be an implicit int or an error.
3793       if (!TypeRep) {
3794         if (TryAnnotateTypeConstraint())
3795           goto DoneWithDeclSpec;
3796         if (Tok.isNot(tok::identifier))
3797           continue;
3798         ParsedAttributes Attrs(AttrFactory);
3799         if (ParseImplicitInt(DS, nullptr, TemplateInfo, AS, DSContext, Attrs)) {
3800           if (!Attrs.empty()) {
3801             AttrsLastTime = true;
3802             attrs.takeAllFrom(Attrs);
3803           }
3804           continue;
3805         }
3806         goto DoneWithDeclSpec;
3807       }
3808 
3809       // Likewise, if this is a context where the identifier could be a template
3810       // name, check whether this is a deduction guide declaration.
3811       CXXScopeSpec SS;
3812       if (getLangOpts().CPlusPlus17 &&
3813           (DSContext == DeclSpecContext::DSC_class ||
3814            DSContext == DeclSpecContext::DSC_top_level) &&
3815           Actions.isDeductionGuideName(getCurScope(), *Tok.getIdentifierInfo(),
3816                                        Tok.getLocation(), SS) &&
3817           isConstructorDeclarator(/*Unqualified*/ true,
3818                                   /*DeductionGuide*/ true))
3819         goto DoneWithDeclSpec;
3820 
3821       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
3822                                      DiagID, TypeRep, Policy);
3823       if (isInvalid)
3824         break;
3825 
3826       DS.SetRangeEnd(Tok.getLocation());
3827       ConsumeToken(); // The identifier
3828 
3829       // Objective-C supports type arguments and protocol references
3830       // following an Objective-C object or object pointer
3831       // type. Handle either one of them.
3832       if (Tok.is(tok::less) && getLangOpts().ObjC) {
3833         SourceLocation NewEndLoc;
3834         TypeResult NewTypeRep = parseObjCTypeArgsAndProtocolQualifiers(
3835                                   Loc, TypeRep, /*consumeLastToken=*/true,
3836                                   NewEndLoc);
3837         if (NewTypeRep.isUsable()) {
3838           DS.UpdateTypeRep(NewTypeRep.get());
3839           DS.SetRangeEnd(NewEndLoc);
3840         }
3841       }
3842 
3843       // Need to support trailing type qualifiers (e.g. "id<p> const").
3844       // If a type specifier follows, it will be diagnosed elsewhere.
3845       continue;
3846     }
3847 
3848       // type-name or placeholder-specifier
3849     case tok::annot_template_id: {
3850       TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
3851 
3852       if (TemplateId->hasInvalidName()) {
3853         DS.SetTypeSpecError();
3854         break;
3855       }
3856 
3857       if (TemplateId->Kind == TNK_Concept_template) {
3858         // If we've already diagnosed that this type-constraint has invalid
3859         // arguments, drop it and just form 'auto' or 'decltype(auto)'.
3860         if (TemplateId->hasInvalidArgs())
3861           TemplateId = nullptr;
3862 
3863         // Any of the following tokens are likely the start of the user
3864         // forgetting 'auto' or 'decltype(auto)', so diagnose.
3865         // Note: if updating this list, please make sure we update
3866         // isCXXDeclarationSpecifier's check for IsPlaceholderSpecifier to have
3867         // a matching list.
3868         if (NextToken().isOneOf(tok::identifier, tok::kw_const,
3869                                 tok::kw_volatile, tok::kw_restrict, tok::amp,
3870                                 tok::ampamp)) {
3871           Diag(Loc, diag::err_placeholder_expected_auto_or_decltype_auto)
3872               << FixItHint::CreateInsertion(NextToken().getLocation(), "auto");
3873           // Attempt to continue as if 'auto' was placed here.
3874           isInvalid = DS.SetTypeSpecType(TST_auto, Loc, PrevSpec, DiagID,
3875                                          TemplateId, Policy);
3876           break;
3877         }
3878         if (!NextToken().isOneOf(tok::kw_auto, tok::kw_decltype))
3879             goto DoneWithDeclSpec;
3880 
3881         if (TemplateId && !isInvalid && Actions.CheckTypeConstraint(TemplateId))
3882             TemplateId = nullptr;
3883 
3884         ConsumeAnnotationToken();
3885         SourceLocation AutoLoc = Tok.getLocation();
3886         if (TryConsumeToken(tok::kw_decltype)) {
3887           BalancedDelimiterTracker Tracker(*this, tok::l_paren);
3888           if (Tracker.consumeOpen()) {
3889             // Something like `void foo(Iterator decltype i)`
3890             Diag(Tok, diag::err_expected) << tok::l_paren;
3891           } else {
3892             if (!TryConsumeToken(tok::kw_auto)) {
3893               // Something like `void foo(Iterator decltype(int) i)`
3894               Tracker.skipToEnd();
3895               Diag(Tok, diag::err_placeholder_expected_auto_or_decltype_auto)
3896                 << FixItHint::CreateReplacement(SourceRange(AutoLoc,
3897                                                             Tok.getLocation()),
3898                                                 "auto");
3899             } else {
3900               Tracker.consumeClose();
3901             }
3902           }
3903           ConsumedEnd = Tok.getLocation();
3904           DS.setTypeArgumentRange(Tracker.getRange());
3905           // Even if something went wrong above, continue as if we've seen
3906           // `decltype(auto)`.
3907           isInvalid = DS.SetTypeSpecType(TST_decltype_auto, Loc, PrevSpec,
3908                                          DiagID, TemplateId, Policy);
3909         } else {
3910           isInvalid = DS.SetTypeSpecType(TST_auto, AutoLoc, PrevSpec, DiagID,
3911                                          TemplateId, Policy);
3912         }
3913         break;
3914       }
3915 
3916       if (TemplateId->Kind != TNK_Type_template &&
3917           TemplateId->Kind != TNK_Undeclared_template) {
3918         // This template-id does not refer to a type name, so we're
3919         // done with the type-specifiers.
3920         goto DoneWithDeclSpec;
3921       }
3922 
3923       // If we're in a context where the template-id could be a
3924       // constructor name or specialization, check whether this is a
3925       // constructor declaration.
3926       if (getLangOpts().CPlusPlus && DSContext == DeclSpecContext::DSC_class &&
3927           Actions.isCurrentClassName(*TemplateId->Name, getCurScope()) &&
3928           isConstructorDeclarator(/*Unqualified=*/true,
3929                                   /*DeductionGuide=*/false,
3930                                   DS.isFriendSpecified()))
3931         goto DoneWithDeclSpec;
3932 
3933       // Turn the template-id annotation token into a type annotation
3934       // token, then try again to parse it as a type-specifier.
3935       CXXScopeSpec SS;
3936       AnnotateTemplateIdTokenAsType(SS, AllowImplicitTypename);
3937       continue;
3938     }
3939 
3940     // Attributes support.
3941     case tok::kw___attribute:
3942     case tok::kw___declspec:
3943       ParseAttributes(PAKM_GNU | PAKM_Declspec, DS.getAttributes(), LateAttrs);
3944       continue;
3945 
3946     // Microsoft single token adornments.
3947     case tok::kw___forceinline: {
3948       isInvalid = DS.setFunctionSpecForceInline(Loc, PrevSpec, DiagID);
3949       IdentifierInfo *AttrName = Tok.getIdentifierInfo();
3950       SourceLocation AttrNameLoc = Tok.getLocation();
3951       DS.getAttributes().addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc,
3952                                 nullptr, 0, tok::kw___forceinline);
3953       break;
3954     }
3955 
3956     case tok::kw___unaligned:
3957       isInvalid = DS.SetTypeQual(DeclSpec::TQ_unaligned, Loc, PrevSpec, DiagID,
3958                                  getLangOpts());
3959       break;
3960 
3961     case tok::kw___sptr:
3962     case tok::kw___uptr:
3963     case tok::kw___ptr64:
3964     case tok::kw___ptr32:
3965     case tok::kw___w64:
3966     case tok::kw___cdecl:
3967     case tok::kw___stdcall:
3968     case tok::kw___fastcall:
3969     case tok::kw___thiscall:
3970     case tok::kw___regcall:
3971     case tok::kw___vectorcall:
3972       ParseMicrosoftTypeAttributes(DS.getAttributes());
3973       continue;
3974 
3975     case tok::kw___funcref:
3976       ParseWebAssemblyFuncrefTypeAttribute(DS.getAttributes());
3977       continue;
3978 
3979     // Borland single token adornments.
3980     case tok::kw___pascal:
3981       ParseBorlandTypeAttributes(DS.getAttributes());
3982       continue;
3983 
3984     // OpenCL single token adornments.
3985     case tok::kw___kernel:
3986       ParseOpenCLKernelAttributes(DS.getAttributes());
3987       continue;
3988 
3989     // CUDA/HIP single token adornments.
3990     case tok::kw___noinline__:
3991       ParseCUDAFunctionAttributes(DS.getAttributes());
3992       continue;
3993 
3994     // Nullability type specifiers.
3995     case tok::kw__Nonnull:
3996     case tok::kw__Nullable:
3997     case tok::kw__Nullable_result:
3998     case tok::kw__Null_unspecified:
3999       ParseNullabilityTypeSpecifiers(DS.getAttributes());
4000       continue;
4001 
4002     // Objective-C 'kindof' types.
4003     case tok::kw___kindof:
4004       DS.getAttributes().addNew(Tok.getIdentifierInfo(), Loc, nullptr, Loc,
4005                                 nullptr, 0, tok::kw___kindof);
4006       (void)ConsumeToken();
4007       continue;
4008 
4009     // storage-class-specifier
4010     case tok::kw_typedef:
4011       isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_typedef, Loc,
4012                                          PrevSpec, DiagID, Policy);
4013       isStorageClass = true;
4014       break;
4015     case tok::kw_extern:
4016       if (DS.getThreadStorageClassSpec() == DeclSpec::TSCS___thread)
4017         Diag(Tok, diag::ext_thread_before) << "extern";
4018       isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_extern, Loc,
4019                                          PrevSpec, DiagID, Policy);
4020       isStorageClass = true;
4021       break;
4022     case tok::kw___private_extern__:
4023       isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_private_extern,
4024                                          Loc, PrevSpec, DiagID, Policy);
4025       isStorageClass = true;
4026       break;
4027     case tok::kw_static:
4028       if (DS.getThreadStorageClassSpec() == DeclSpec::TSCS___thread)
4029         Diag(Tok, diag::ext_thread_before) << "static";
4030       isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_static, Loc,
4031                                          PrevSpec, DiagID, Policy);
4032       isStorageClass = true;
4033       break;
4034     case tok::kw_auto:
4035       if (getLangOpts().CPlusPlus11 || getLangOpts().C23) {
4036         if (isKnownToBeTypeSpecifier(GetLookAheadToken(1))) {
4037           isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_auto, Loc,
4038                                              PrevSpec, DiagID, Policy);
4039           if (!isInvalid && !getLangOpts().C23)
4040             Diag(Tok, diag::ext_auto_storage_class)
4041               << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc());
4042         } else
4043           isInvalid = DS.SetTypeSpecType(DeclSpec::TST_auto, Loc, PrevSpec,
4044                                          DiagID, Policy);
4045       } else
4046         isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_auto, Loc,
4047                                            PrevSpec, DiagID, Policy);
4048       isStorageClass = true;
4049       break;
4050     case tok::kw___auto_type:
4051       Diag(Tok, diag::ext_auto_type);
4052       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_auto_type, Loc, PrevSpec,
4053                                      DiagID, Policy);
4054       break;
4055     case tok::kw_register:
4056       isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_register, Loc,
4057                                          PrevSpec, DiagID, Policy);
4058       isStorageClass = true;
4059       break;
4060     case tok::kw_mutable:
4061       isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_mutable, Loc,
4062                                          PrevSpec, DiagID, Policy);
4063       isStorageClass = true;
4064       break;
4065     case tok::kw___thread:
4066       isInvalid = DS.SetStorageClassSpecThread(DeclSpec::TSCS___thread, Loc,
4067                                                PrevSpec, DiagID);
4068       isStorageClass = true;
4069       break;
4070     case tok::kw_thread_local:
4071       if (getLangOpts().C23)
4072         Diag(Tok, diag::warn_c23_compat_keyword) << Tok.getName();
4073       // We map thread_local to _Thread_local in C23 mode so it retains the C
4074       // semantics rather than getting the C++ semantics.
4075       // FIXME: diagnostics will show _Thread_local when the user wrote
4076       // thread_local in source in C23 mode; we need some general way to
4077       // identify which way the user spelled the keyword in source.
4078       isInvalid = DS.SetStorageClassSpecThread(
4079           getLangOpts().C23 ? DeclSpec::TSCS__Thread_local
4080                             : DeclSpec::TSCS_thread_local,
4081           Loc, PrevSpec, DiagID);
4082       isStorageClass = true;
4083       break;
4084     case tok::kw__Thread_local:
4085       if (!getLangOpts().C11)
4086         Diag(Tok, diag::ext_c11_feature) << Tok.getName();
4087       isInvalid = DS.SetStorageClassSpecThread(DeclSpec::TSCS__Thread_local,
4088                                                Loc, PrevSpec, DiagID);
4089       isStorageClass = true;
4090       break;
4091 
4092     // function-specifier
4093     case tok::kw_inline:
4094       isInvalid = DS.setFunctionSpecInline(Loc, PrevSpec, DiagID);
4095       break;
4096     case tok::kw_virtual:
4097       // C++ for OpenCL does not allow virtual function qualifier, to avoid
4098       // function pointers restricted in OpenCL v2.0 s6.9.a.
4099       if (getLangOpts().OpenCLCPlusPlus &&
4100           !getActions().getOpenCLOptions().isAvailableOption(
4101               "__cl_clang_function_pointers", getLangOpts())) {
4102         DiagID = diag::err_openclcxx_virtual_function;
4103         PrevSpec = Tok.getIdentifierInfo()->getNameStart();
4104         isInvalid = true;
4105       } else {
4106         isInvalid = DS.setFunctionSpecVirtual(Loc, PrevSpec, DiagID);
4107       }
4108       break;
4109     case tok::kw_explicit: {
4110       SourceLocation ExplicitLoc = Loc;
4111       SourceLocation CloseParenLoc;
4112       ExplicitSpecifier ExplicitSpec(nullptr, ExplicitSpecKind::ResolvedTrue);
4113       ConsumedEnd = ExplicitLoc;
4114       ConsumeToken(); // kw_explicit
4115       if (Tok.is(tok::l_paren)) {
4116         if (getLangOpts().CPlusPlus20 || isExplicitBool() == TPResult::True) {
4117           Diag(Tok.getLocation(), getLangOpts().CPlusPlus20
4118                                       ? diag::warn_cxx17_compat_explicit_bool
4119                                       : diag::ext_explicit_bool);
4120 
4121           ExprResult ExplicitExpr(static_cast<Expr *>(nullptr));
4122           BalancedDelimiterTracker Tracker(*this, tok::l_paren);
4123           Tracker.consumeOpen();
4124 
4125           EnterExpressionEvaluationContext ConstantEvaluated(
4126               Actions, Sema::ExpressionEvaluationContext::ConstantEvaluated);
4127 
4128           ExplicitExpr = ParseConstantExpressionInExprEvalContext();
4129           ConsumedEnd = Tok.getLocation();
4130           if (ExplicitExpr.isUsable()) {
4131             CloseParenLoc = Tok.getLocation();
4132             Tracker.consumeClose();
4133             ExplicitSpec =
4134                 Actions.ActOnExplicitBoolSpecifier(ExplicitExpr.get());
4135           } else
4136             Tracker.skipToEnd();
4137         } else {
4138           Diag(Tok.getLocation(), diag::warn_cxx20_compat_explicit_bool);
4139         }
4140       }
4141       isInvalid = DS.setFunctionSpecExplicit(ExplicitLoc, PrevSpec, DiagID,
4142                                              ExplicitSpec, CloseParenLoc);
4143       break;
4144     }
4145     case tok::kw__Noreturn:
4146       if (!getLangOpts().C11)
4147         Diag(Tok, diag::ext_c11_feature) << Tok.getName();
4148       isInvalid = DS.setFunctionSpecNoreturn(Loc, PrevSpec, DiagID);
4149       break;
4150 
4151     // alignment-specifier
4152     case tok::kw__Alignas:
4153       if (!getLangOpts().C11)
4154         Diag(Tok, diag::ext_c11_feature) << Tok.getName();
4155       ParseAlignmentSpecifier(DS.getAttributes());
4156       continue;
4157 
4158     // friend
4159     case tok::kw_friend:
4160       if (DSContext == DeclSpecContext::DSC_class)
4161         isInvalid = DS.SetFriendSpec(Loc, PrevSpec, DiagID);
4162       else {
4163         PrevSpec = ""; // not actually used by the diagnostic
4164         DiagID = diag::err_friend_invalid_in_context;
4165         isInvalid = true;
4166       }
4167       break;
4168 
4169     // Modules
4170     case tok::kw___module_private__:
4171       isInvalid = DS.setModulePrivateSpec(Loc, PrevSpec, DiagID);
4172       break;
4173 
4174     // constexpr, consteval, constinit specifiers
4175     case tok::kw_constexpr:
4176       isInvalid = DS.SetConstexprSpec(ConstexprSpecKind::Constexpr, Loc,
4177                                       PrevSpec, DiagID);
4178       break;
4179     case tok::kw_consteval:
4180       isInvalid = DS.SetConstexprSpec(ConstexprSpecKind::Consteval, Loc,
4181                                       PrevSpec, DiagID);
4182       break;
4183     case tok::kw_constinit:
4184       isInvalid = DS.SetConstexprSpec(ConstexprSpecKind::Constinit, Loc,
4185                                       PrevSpec, DiagID);
4186       break;
4187 
4188     // type-specifier
4189     case tok::kw_short:
4190       isInvalid = DS.SetTypeSpecWidth(TypeSpecifierWidth::Short, Loc, PrevSpec,
4191                                       DiagID, Policy);
4192       break;
4193     case tok::kw_long:
4194       if (DS.getTypeSpecWidth() != TypeSpecifierWidth::Long)
4195         isInvalid = DS.SetTypeSpecWidth(TypeSpecifierWidth::Long, Loc, PrevSpec,
4196                                         DiagID, Policy);
4197       else
4198         isInvalid = DS.SetTypeSpecWidth(TypeSpecifierWidth::LongLong, Loc,
4199                                         PrevSpec, DiagID, Policy);
4200       break;
4201     case tok::kw___int64:
4202       isInvalid = DS.SetTypeSpecWidth(TypeSpecifierWidth::LongLong, Loc,
4203                                       PrevSpec, DiagID, Policy);
4204       break;
4205     case tok::kw_signed:
4206       isInvalid =
4207           DS.SetTypeSpecSign(TypeSpecifierSign::Signed, Loc, PrevSpec, DiagID);
4208       break;
4209     case tok::kw_unsigned:
4210       isInvalid = DS.SetTypeSpecSign(TypeSpecifierSign::Unsigned, Loc, PrevSpec,
4211                                      DiagID);
4212       break;
4213     case tok::kw__Complex:
4214       if (!getLangOpts().C99)
4215         Diag(Tok, diag::ext_c99_feature) << Tok.getName();
4216       isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_complex, Loc, PrevSpec,
4217                                         DiagID);
4218       break;
4219     case tok::kw__Imaginary:
4220       if (!getLangOpts().C99)
4221         Diag(Tok, diag::ext_c99_feature) << Tok.getName();
4222       isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_imaginary, Loc, PrevSpec,
4223                                         DiagID);
4224       break;
4225     case tok::kw_void:
4226       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec,
4227                                      DiagID, Policy);
4228       break;
4229     case tok::kw_char:
4230       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec,
4231                                      DiagID, Policy);
4232       break;
4233     case tok::kw_int:
4234       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec,
4235                                      DiagID, Policy);
4236       break;
4237     case tok::kw__ExtInt:
4238     case tok::kw__BitInt: {
4239       DiagnoseBitIntUse(Tok);
4240       ExprResult ER = ParseExtIntegerArgument();
4241       if (ER.isInvalid())
4242         continue;
4243       isInvalid = DS.SetBitIntType(Loc, ER.get(), PrevSpec, DiagID, Policy);
4244       ConsumedEnd = PrevTokLocation;
4245       break;
4246     }
4247     case tok::kw___int128:
4248       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_int128, Loc, PrevSpec,
4249                                      DiagID, Policy);
4250       break;
4251     case tok::kw_half:
4252       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_half, Loc, PrevSpec,
4253                                      DiagID, Policy);
4254       break;
4255     case tok::kw___bf16:
4256       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_BFloat16, Loc, PrevSpec,
4257                                      DiagID, Policy);
4258       break;
4259     case tok::kw_float:
4260       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec,
4261                                      DiagID, Policy);
4262       break;
4263     case tok::kw_double:
4264       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec,
4265                                      DiagID, Policy);
4266       break;
4267     case tok::kw__Float16:
4268       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float16, Loc, PrevSpec,
4269                                      DiagID, Policy);
4270       break;
4271     case tok::kw__Accum:
4272       assert(getLangOpts().FixedPoint &&
4273              "This keyword is only used when fixed point types are enabled "
4274              "with `-ffixed-point`");
4275       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_accum, Loc, PrevSpec, DiagID,
4276                                      Policy);
4277       break;
4278     case tok::kw__Fract:
4279       assert(getLangOpts().FixedPoint &&
4280              "This keyword is only used when fixed point types are enabled "
4281              "with `-ffixed-point`");
4282       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_fract, Loc, PrevSpec, DiagID,
4283                                      Policy);
4284       break;
4285     case tok::kw__Sat:
4286       assert(getLangOpts().FixedPoint &&
4287              "This keyword is only used when fixed point types are enabled "
4288              "with `-ffixed-point`");
4289       isInvalid = DS.SetTypeSpecSat(Loc, PrevSpec, DiagID);
4290       break;
4291     case tok::kw___float128:
4292       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float128, Loc, PrevSpec,
4293                                      DiagID, Policy);
4294       break;
4295     case tok::kw___ibm128:
4296       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_ibm128, Loc, PrevSpec,
4297                                      DiagID, Policy);
4298       break;
4299     case tok::kw_wchar_t:
4300       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec,
4301                                      DiagID, Policy);
4302       break;
4303     case tok::kw_char8_t:
4304       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char8, Loc, PrevSpec,
4305                                      DiagID, Policy);
4306       break;
4307     case tok::kw_char16_t:
4308       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec,
4309                                      DiagID, Policy);
4310       break;
4311     case tok::kw_char32_t:
4312       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char32, Loc, PrevSpec,
4313                                      DiagID, Policy);
4314       break;
4315     case tok::kw_bool:
4316       if (getLangOpts().C23)
4317         Diag(Tok, diag::warn_c23_compat_keyword) << Tok.getName();
4318       [[fallthrough]];
4319     case tok::kw__Bool:
4320       if (Tok.is(tok::kw__Bool) && !getLangOpts().C99)
4321         Diag(Tok, diag::ext_c99_feature) << Tok.getName();
4322 
4323       if (Tok.is(tok::kw_bool) &&
4324           DS.getTypeSpecType() != DeclSpec::TST_unspecified &&
4325           DS.getStorageClassSpec() == DeclSpec::SCS_typedef) {
4326         PrevSpec = ""; // Not used by the diagnostic.
4327         DiagID = diag::err_bool_redeclaration;
4328         // For better error recovery.
4329         Tok.setKind(tok::identifier);
4330         isInvalid = true;
4331       } else {
4332         isInvalid = DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec,
4333                                        DiagID, Policy);
4334       }
4335       break;
4336     case tok::kw__Decimal32:
4337       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal32, Loc, PrevSpec,
4338                                      DiagID, Policy);
4339       break;
4340     case tok::kw__Decimal64:
4341       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal64, Loc, PrevSpec,
4342                                      DiagID, Policy);
4343       break;
4344     case tok::kw__Decimal128:
4345       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal128, Loc, PrevSpec,
4346                                      DiagID, Policy);
4347       break;
4348     case tok::kw___vector:
4349       isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID, Policy);
4350       break;
4351     case tok::kw___pixel:
4352       isInvalid = DS.SetTypeAltiVecPixel(true, Loc, PrevSpec, DiagID, Policy);
4353       break;
4354     case tok::kw___bool:
4355       isInvalid = DS.SetTypeAltiVecBool(true, Loc, PrevSpec, DiagID, Policy);
4356       break;
4357     case tok::kw_pipe:
4358       if (!getLangOpts().OpenCL ||
4359           getLangOpts().getOpenCLCompatibleVersion() < 200) {
4360         // OpenCL 2.0 and later define this keyword. OpenCL 1.2 and earlier
4361         // should support the "pipe" word as identifier.
4362         Tok.getIdentifierInfo()->revertTokenIDToIdentifier();
4363         Tok.setKind(tok::identifier);
4364         goto DoneWithDeclSpec;
4365       } else if (!getLangOpts().OpenCLPipes) {
4366         DiagID = diag::err_opencl_unknown_type_specifier;
4367         PrevSpec = Tok.getIdentifierInfo()->getNameStart();
4368         isInvalid = true;
4369       } else
4370         isInvalid = DS.SetTypePipe(true, Loc, PrevSpec, DiagID, Policy);
4371       break;
4372 // We only need to enumerate each image type once.
4373 #define IMAGE_READ_WRITE_TYPE(Type, Id, Ext)
4374 #define IMAGE_WRITE_TYPE(Type, Id, Ext)
4375 #define IMAGE_READ_TYPE(ImgType, Id, Ext) \
4376     case tok::kw_##ImgType##_t: \
4377       if (!handleOpenCLImageKW(Ext, DeclSpec::TST_##ImgType##_t)) \
4378         goto DoneWithDeclSpec; \
4379       break;
4380 #include "clang/Basic/OpenCLImageTypes.def"
4381     case tok::kw___unknown_anytype:
4382       isInvalid = DS.SetTypeSpecType(TST_unknown_anytype, Loc,
4383                                      PrevSpec, DiagID, Policy);
4384       break;
4385 
4386     // class-specifier:
4387     case tok::kw_class:
4388     case tok::kw_struct:
4389     case tok::kw___interface:
4390     case tok::kw_union: {
4391       tok::TokenKind Kind = Tok.getKind();
4392       ConsumeToken();
4393 
4394       // These are attributes following class specifiers.
4395       // To produce better diagnostic, we parse them when
4396       // parsing class specifier.
4397       ParsedAttributes Attributes(AttrFactory);
4398       ParseClassSpecifier(Kind, Loc, DS, TemplateInfo, AS,
4399                           EnteringContext, DSContext, Attributes);
4400 
4401       // If there are attributes following class specifier,
4402       // take them over and handle them here.
4403       if (!Attributes.empty()) {
4404         AttrsLastTime = true;
4405         attrs.takeAllFrom(Attributes);
4406       }
4407       continue;
4408     }
4409 
4410     // enum-specifier:
4411     case tok::kw_enum:
4412       ConsumeToken();
4413       ParseEnumSpecifier(Loc, DS, TemplateInfo, AS, DSContext);
4414       continue;
4415 
4416     // cv-qualifier:
4417     case tok::kw_const:
4418       isInvalid = DS.SetTypeQual(DeclSpec::TQ_const, Loc, PrevSpec, DiagID,
4419                                  getLangOpts());
4420       break;
4421     case tok::kw_volatile:
4422       isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec, DiagID,
4423                                  getLangOpts());
4424       break;
4425     case tok::kw_restrict:
4426       isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec, DiagID,
4427                                  getLangOpts());
4428       break;
4429 
4430     // C++ typename-specifier:
4431     case tok::kw_typename:
4432       if (TryAnnotateTypeOrScopeToken()) {
4433         DS.SetTypeSpecError();
4434         goto DoneWithDeclSpec;
4435       }
4436       if (!Tok.is(tok::kw_typename))
4437         continue;
4438       break;
4439 
4440     // C23/GNU typeof support.
4441     case tok::kw_typeof:
4442     case tok::kw_typeof_unqual:
4443       ParseTypeofSpecifier(DS);
4444       continue;
4445 
4446     case tok::annot_decltype:
4447       ParseDecltypeSpecifier(DS);
4448       continue;
4449 
4450     case tok::annot_pragma_pack:
4451       HandlePragmaPack();
4452       continue;
4453 
4454     case tok::annot_pragma_ms_pragma:
4455       HandlePragmaMSPragma();
4456       continue;
4457 
4458     case tok::annot_pragma_ms_vtordisp:
4459       HandlePragmaMSVtorDisp();
4460       continue;
4461 
4462     case tok::annot_pragma_ms_pointers_to_members:
4463       HandlePragmaMSPointersToMembers();
4464       continue;
4465 
4466 #define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) case tok::kw___##Trait:
4467 #include "clang/Basic/TransformTypeTraits.def"
4468       // HACK: libstdc++ already uses '__remove_cv' as an alias template so we
4469       // work around this by expecting all transform type traits to be suffixed
4470       // with '('. They're an identifier otherwise.
4471       if (!MaybeParseTypeTransformTypeSpecifier(DS))
4472         goto ParseIdentifier;
4473       continue;
4474 
4475     case tok::kw__Atomic:
4476       // C11 6.7.2.4/4:
4477       //   If the _Atomic keyword is immediately followed by a left parenthesis,
4478       //   it is interpreted as a type specifier (with a type name), not as a
4479       //   type qualifier.
4480       if (!getLangOpts().C11)
4481         Diag(Tok, diag::ext_c11_feature) << Tok.getName();
4482 
4483       if (NextToken().is(tok::l_paren)) {
4484         ParseAtomicSpecifier(DS);
4485         continue;
4486       }
4487       isInvalid = DS.SetTypeQual(DeclSpec::TQ_atomic, Loc, PrevSpec, DiagID,
4488                                  getLangOpts());
4489       break;
4490 
4491     // OpenCL address space qualifiers:
4492     case tok::kw___generic:
4493       // generic address space is introduced only in OpenCL v2.0
4494       // see OpenCL C Spec v2.0 s6.5.5
4495       // OpenCL v3.0 introduces __opencl_c_generic_address_space
4496       // feature macro to indicate if generic address space is supported
4497       if (!Actions.getLangOpts().OpenCLGenericAddressSpace) {
4498         DiagID = diag::err_opencl_unknown_type_specifier;
4499         PrevSpec = Tok.getIdentifierInfo()->getNameStart();
4500         isInvalid = true;
4501         break;
4502       }
4503       [[fallthrough]];
4504     case tok::kw_private:
4505       // It's fine (but redundant) to check this for __generic on the
4506       // fallthrough path; we only form the __generic token in OpenCL mode.
4507       if (!getLangOpts().OpenCL)
4508         goto DoneWithDeclSpec;
4509       [[fallthrough]];
4510     case tok::kw___private:
4511     case tok::kw___global:
4512     case tok::kw___local:
4513     case tok::kw___constant:
4514     // OpenCL access qualifiers:
4515     case tok::kw___read_only:
4516     case tok::kw___write_only:
4517     case tok::kw___read_write:
4518       ParseOpenCLQualifiers(DS.getAttributes());
4519       break;
4520 
4521     case tok::kw_groupshared:
4522     case tok::kw_in:
4523     case tok::kw_inout:
4524     case tok::kw_out:
4525       // NOTE: ParseHLSLQualifiers will consume the qualifier token.
4526       ParseHLSLQualifiers(DS.getAttributes());
4527       continue;
4528 
4529     case tok::less:
4530       // GCC ObjC supports types like "<SomeProtocol>" as a synonym for
4531       // "id<SomeProtocol>".  This is hopelessly old fashioned and dangerous,
4532       // but we support it.
4533       if (DS.hasTypeSpecifier() || !getLangOpts().ObjC)
4534         goto DoneWithDeclSpec;
4535 
4536       SourceLocation StartLoc = Tok.getLocation();
4537       SourceLocation EndLoc;
4538       TypeResult Type = parseObjCProtocolQualifierType(EndLoc);
4539       if (Type.isUsable()) {
4540         if (DS.SetTypeSpecType(DeclSpec::TST_typename, StartLoc, StartLoc,
4541                                PrevSpec, DiagID, Type.get(),
4542                                Actions.getASTContext().getPrintingPolicy()))
4543           Diag(StartLoc, DiagID) << PrevSpec;
4544 
4545         DS.SetRangeEnd(EndLoc);
4546       } else {
4547         DS.SetTypeSpecError();
4548       }
4549 
4550       // Need to support trailing type qualifiers (e.g. "id<p> const").
4551       // If a type specifier follows, it will be diagnosed elsewhere.
4552       continue;
4553     }
4554 
4555     DS.SetRangeEnd(ConsumedEnd.isValid() ? ConsumedEnd : Tok.getLocation());
4556 
4557     // If the specifier wasn't legal, issue a diagnostic.
4558     if (isInvalid) {
4559       assert(PrevSpec && "Method did not return previous specifier!");
4560       assert(DiagID);
4561 
4562       if (DiagID == diag::ext_duplicate_declspec ||
4563           DiagID == diag::ext_warn_duplicate_declspec ||
4564           DiagID == diag::err_duplicate_declspec)
4565         Diag(Loc, DiagID) << PrevSpec
4566                           << FixItHint::CreateRemoval(
4567                                  SourceRange(Loc, DS.getEndLoc()));
4568       else if (DiagID == diag::err_opencl_unknown_type_specifier) {
4569         Diag(Loc, DiagID) << getLangOpts().getOpenCLVersionString() << PrevSpec
4570                           << isStorageClass;
4571       } else
4572         Diag(Loc, DiagID) << PrevSpec;
4573     }
4574 
4575     if (DiagID != diag::err_bool_redeclaration && ConsumedEnd.isInvalid())
4576       // After an error the next token can be an annotation token.
4577       ConsumeAnyToken();
4578 
4579     AttrsLastTime = false;
4580   }
4581 }
4582 
4583 /// ParseStructDeclaration - Parse a struct declaration without the terminating
4584 /// semicolon.
4585 ///
4586 /// Note that a struct declaration refers to a declaration in a struct,
4587 /// not to the declaration of a struct.
4588 ///
4589 ///       struct-declaration:
4590 /// [C23]   attributes-specifier-seq[opt]
4591 ///           specifier-qualifier-list struct-declarator-list
4592 /// [GNU]   __extension__ struct-declaration
4593 /// [GNU]   specifier-qualifier-list
4594 ///       struct-declarator-list:
4595 ///         struct-declarator
4596 ///         struct-declarator-list ',' struct-declarator
4597 /// [GNU]   struct-declarator-list ',' attributes[opt] struct-declarator
4598 ///       struct-declarator:
4599 ///         declarator
4600 /// [GNU]   declarator attributes[opt]
4601 ///         declarator[opt] ':' constant-expression
4602 /// [GNU]   declarator[opt] ':' constant-expression attributes[opt]
4603 ///
4604 void Parser::ParseStructDeclaration(
4605     ParsingDeclSpec &DS,
4606     llvm::function_ref<void(ParsingFieldDeclarator &)> FieldsCallback) {
4607 
4608   if (Tok.is(tok::kw___extension__)) {
4609     // __extension__ silences extension warnings in the subexpression.
4610     ExtensionRAIIObject O(Diags);  // Use RAII to do this.
4611     ConsumeToken();
4612     return ParseStructDeclaration(DS, FieldsCallback);
4613   }
4614 
4615   // Parse leading attributes.
4616   ParsedAttributes Attrs(AttrFactory);
4617   MaybeParseCXX11Attributes(Attrs);
4618 
4619   // Parse the common specifier-qualifiers-list piece.
4620   ParseSpecifierQualifierList(DS);
4621 
4622   // If there are no declarators, this is a free-standing declaration
4623   // specifier. Let the actions module cope with it.
4624   if (Tok.is(tok::semi)) {
4625     // C23 6.7.2.1p9 : "The optional attribute specifier sequence in a
4626     // member declaration appertains to each of the members declared by the
4627     // member declarator list; it shall not appear if the optional member
4628     // declarator list is omitted."
4629     ProhibitAttributes(Attrs);
4630     RecordDecl *AnonRecord = nullptr;
4631     Decl *TheDecl = Actions.ParsedFreeStandingDeclSpec(
4632         getCurScope(), AS_none, DS, ParsedAttributesView::none(), AnonRecord);
4633     assert(!AnonRecord && "Did not expect anonymous struct or union here");
4634     DS.complete(TheDecl);
4635     return;
4636   }
4637 
4638   // Read struct-declarators until we find the semicolon.
4639   bool FirstDeclarator = true;
4640   SourceLocation CommaLoc;
4641   while (true) {
4642     ParsingFieldDeclarator DeclaratorInfo(*this, DS, Attrs);
4643     DeclaratorInfo.D.setCommaLoc(CommaLoc);
4644 
4645     // Attributes are only allowed here on successive declarators.
4646     if (!FirstDeclarator) {
4647       // However, this does not apply for [[]] attributes (which could show up
4648       // before or after the __attribute__ attributes).
4649       DiagnoseAndSkipCXX11Attributes();
4650       MaybeParseGNUAttributes(DeclaratorInfo.D);
4651       DiagnoseAndSkipCXX11Attributes();
4652     }
4653 
4654     /// struct-declarator: declarator
4655     /// struct-declarator: declarator[opt] ':' constant-expression
4656     if (Tok.isNot(tok::colon)) {
4657       // Don't parse FOO:BAR as if it were a typo for FOO::BAR.
4658       ColonProtectionRAIIObject X(*this);
4659       ParseDeclarator(DeclaratorInfo.D);
4660     } else
4661       DeclaratorInfo.D.SetIdentifier(nullptr, Tok.getLocation());
4662 
4663     if (TryConsumeToken(tok::colon)) {
4664       ExprResult Res(ParseConstantExpression());
4665       if (Res.isInvalid())
4666         SkipUntil(tok::semi, StopBeforeMatch);
4667       else
4668         DeclaratorInfo.BitfieldSize = Res.get();
4669     }
4670 
4671     // If attributes exist after the declarator, parse them.
4672     MaybeParseGNUAttributes(DeclaratorInfo.D);
4673 
4674     // We're done with this declarator;  invoke the callback.
4675     FieldsCallback(DeclaratorInfo);
4676 
4677     // If we don't have a comma, it is either the end of the list (a ';')
4678     // or an error, bail out.
4679     if (!TryConsumeToken(tok::comma, CommaLoc))
4680       return;
4681 
4682     FirstDeclarator = false;
4683   }
4684 }
4685 
4686 /// ParseStructUnionBody
4687 ///       struct-contents:
4688 ///         struct-declaration-list
4689 /// [EXT]   empty
4690 /// [GNU]   "struct-declaration-list" without terminating ';'
4691 ///       struct-declaration-list:
4692 ///         struct-declaration
4693 ///         struct-declaration-list struct-declaration
4694 /// [OBC]   '@' 'defs' '(' class-name ')'
4695 ///
4696 void Parser::ParseStructUnionBody(SourceLocation RecordLoc,
4697                                   DeclSpec::TST TagType, RecordDecl *TagDecl) {
4698   PrettyDeclStackTraceEntry CrashInfo(Actions.Context, TagDecl, RecordLoc,
4699                                       "parsing struct/union body");
4700   assert(!getLangOpts().CPlusPlus && "C++ declarations not supported");
4701 
4702   BalancedDelimiterTracker T(*this, tok::l_brace);
4703   if (T.consumeOpen())
4704     return;
4705 
4706   ParseScope StructScope(this, Scope::ClassScope|Scope::DeclScope);
4707   Actions.ActOnTagStartDefinition(getCurScope(), TagDecl);
4708 
4709   // While we still have something to read, read the declarations in the struct.
4710   while (!tryParseMisplacedModuleImport() && Tok.isNot(tok::r_brace) &&
4711          Tok.isNot(tok::eof)) {
4712     // Each iteration of this loop reads one struct-declaration.
4713 
4714     // Check for extraneous top-level semicolon.
4715     if (Tok.is(tok::semi)) {
4716       ConsumeExtraSemi(InsideStruct, TagType);
4717       continue;
4718     }
4719 
4720     // Parse _Static_assert declaration.
4721     if (Tok.isOneOf(tok::kw__Static_assert, tok::kw_static_assert)) {
4722       SourceLocation DeclEnd;
4723       ParseStaticAssertDeclaration(DeclEnd);
4724       continue;
4725     }
4726 
4727     if (Tok.is(tok::annot_pragma_pack)) {
4728       HandlePragmaPack();
4729       continue;
4730     }
4731 
4732     if (Tok.is(tok::annot_pragma_align)) {
4733       HandlePragmaAlign();
4734       continue;
4735     }
4736 
4737     if (Tok.isOneOf(tok::annot_pragma_openmp, tok::annot_attr_openmp)) {
4738       // Result can be ignored, because it must be always empty.
4739       AccessSpecifier AS = AS_none;
4740       ParsedAttributes Attrs(AttrFactory);
4741       (void)ParseOpenMPDeclarativeDirectiveWithExtDecl(AS, Attrs);
4742       continue;
4743     }
4744 
4745     if (Tok.is(tok::annot_pragma_openacc)) {
4746       ParseOpenACCDirectiveDecl();
4747       continue;
4748     }
4749 
4750     if (tok::isPragmaAnnotation(Tok.getKind())) {
4751       Diag(Tok.getLocation(), diag::err_pragma_misplaced_in_decl)
4752           << DeclSpec::getSpecifierName(
4753                  TagType, Actions.getASTContext().getPrintingPolicy());
4754       ConsumeAnnotationToken();
4755       continue;
4756     }
4757 
4758     if (!Tok.is(tok::at)) {
4759       auto CFieldCallback = [&](ParsingFieldDeclarator &FD) {
4760         // Install the declarator into the current TagDecl.
4761         Decl *Field =
4762             Actions.ActOnField(getCurScope(), TagDecl,
4763                                FD.D.getDeclSpec().getSourceRange().getBegin(),
4764                                FD.D, FD.BitfieldSize);
4765         FD.complete(Field);
4766       };
4767 
4768       // Parse all the comma separated declarators.
4769       ParsingDeclSpec DS(*this);
4770       ParseStructDeclaration(DS, CFieldCallback);
4771     } else { // Handle @defs
4772       ConsumeToken();
4773       if (!Tok.isObjCAtKeyword(tok::objc_defs)) {
4774         Diag(Tok, diag::err_unexpected_at);
4775         SkipUntil(tok::semi);
4776         continue;
4777       }
4778       ConsumeToken();
4779       ExpectAndConsume(tok::l_paren);
4780       if (!Tok.is(tok::identifier)) {
4781         Diag(Tok, diag::err_expected) << tok::identifier;
4782         SkipUntil(tok::semi);
4783         continue;
4784       }
4785       SmallVector<Decl *, 16> Fields;
4786       Actions.ActOnDefs(getCurScope(), TagDecl, Tok.getLocation(),
4787                         Tok.getIdentifierInfo(), Fields);
4788       ConsumeToken();
4789       ExpectAndConsume(tok::r_paren);
4790     }
4791 
4792     if (TryConsumeToken(tok::semi))
4793       continue;
4794 
4795     if (Tok.is(tok::r_brace)) {
4796       ExpectAndConsume(tok::semi, diag::ext_expected_semi_decl_list);
4797       break;
4798     }
4799 
4800     ExpectAndConsume(tok::semi, diag::err_expected_semi_decl_list);
4801     // Skip to end of block or statement to avoid ext-warning on extra ';'.
4802     SkipUntil(tok::r_brace, StopAtSemi | StopBeforeMatch);
4803     // If we stopped at a ';', eat it.
4804     TryConsumeToken(tok::semi);
4805   }
4806 
4807   T.consumeClose();
4808 
4809   ParsedAttributes attrs(AttrFactory);
4810   // If attributes exist after struct contents, parse them.
4811   MaybeParseGNUAttributes(attrs);
4812 
4813   SmallVector<Decl *, 32> FieldDecls(TagDecl->fields());
4814 
4815   Actions.ActOnFields(getCurScope(), RecordLoc, TagDecl, FieldDecls,
4816                       T.getOpenLocation(), T.getCloseLocation(), attrs);
4817   StructScope.Exit();
4818   Actions.ActOnTagFinishDefinition(getCurScope(), TagDecl, T.getRange());
4819 }
4820 
4821 /// ParseEnumSpecifier
4822 ///       enum-specifier: [C99 6.7.2.2]
4823 ///         'enum' identifier[opt] '{' enumerator-list '}'
4824 ///[C99/C++]'enum' identifier[opt] '{' enumerator-list ',' '}'
4825 /// [GNU]   'enum' attributes[opt] identifier[opt] '{' enumerator-list ',' [opt]
4826 ///                                                 '}' attributes[opt]
4827 /// [MS]    'enum' __declspec[opt] identifier[opt] '{' enumerator-list ',' [opt]
4828 ///                                                 '}'
4829 ///         'enum' identifier
4830 /// [GNU]   'enum' attributes[opt] identifier
4831 ///
4832 /// [C++11] enum-head '{' enumerator-list[opt] '}'
4833 /// [C++11] enum-head '{' enumerator-list ','  '}'
4834 ///
4835 ///       enum-head: [C++11]
4836 ///         enum-key attribute-specifier-seq[opt] identifier[opt] enum-base[opt]
4837 ///         enum-key attribute-specifier-seq[opt] nested-name-specifier
4838 ///             identifier enum-base[opt]
4839 ///
4840 ///       enum-key: [C++11]
4841 ///         'enum'
4842 ///         'enum' 'class'
4843 ///         'enum' 'struct'
4844 ///
4845 ///       enum-base: [C++11]
4846 ///         ':' type-specifier-seq
4847 ///
4848 /// [C++] elaborated-type-specifier:
4849 /// [C++]   'enum' nested-name-specifier[opt] identifier
4850 ///
4851 void Parser::ParseEnumSpecifier(SourceLocation StartLoc, DeclSpec &DS,
4852                                 const ParsedTemplateInfo &TemplateInfo,
4853                                 AccessSpecifier AS, DeclSpecContext DSC) {
4854   // Parse the tag portion of this.
4855   if (Tok.is(tok::code_completion)) {
4856     // Code completion for an enum name.
4857     cutOffParsing();
4858     Actions.CodeCompleteTag(getCurScope(), DeclSpec::TST_enum);
4859     DS.SetTypeSpecError(); // Needed by ActOnUsingDeclaration.
4860     return;
4861   }
4862 
4863   // If attributes exist after tag, parse them.
4864   ParsedAttributes attrs(AttrFactory);
4865   MaybeParseAttributes(PAKM_GNU | PAKM_Declspec | PAKM_CXX11, attrs);
4866 
4867   SourceLocation ScopedEnumKWLoc;
4868   bool IsScopedUsingClassTag = false;
4869 
4870   // In C++11, recognize 'enum class' and 'enum struct'.
4871   if (Tok.isOneOf(tok::kw_class, tok::kw_struct) && getLangOpts().CPlusPlus) {
4872     Diag(Tok, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_scoped_enum
4873                                         : diag::ext_scoped_enum);
4874     IsScopedUsingClassTag = Tok.is(tok::kw_class);
4875     ScopedEnumKWLoc = ConsumeToken();
4876 
4877     // Attributes are not allowed between these keywords.  Diagnose,
4878     // but then just treat them like they appeared in the right place.
4879     ProhibitAttributes(attrs);
4880 
4881     // They are allowed afterwards, though.
4882     MaybeParseAttributes(PAKM_GNU | PAKM_Declspec | PAKM_CXX11, attrs);
4883   }
4884 
4885   // C++11 [temp.explicit]p12:
4886   //   The usual access controls do not apply to names used to specify
4887   //   explicit instantiations.
4888   // We extend this to also cover explicit specializations.  Note that
4889   // we don't suppress if this turns out to be an elaborated type
4890   // specifier.
4891   bool shouldDelayDiagsInTag =
4892     (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation ||
4893      TemplateInfo.Kind == ParsedTemplateInfo::ExplicitSpecialization);
4894   SuppressAccessChecks diagsFromTag(*this, shouldDelayDiagsInTag);
4895 
4896   // Determine whether this declaration is permitted to have an enum-base.
4897   AllowDefiningTypeSpec AllowEnumSpecifier =
4898       isDefiningTypeSpecifierContext(DSC, getLangOpts().CPlusPlus);
4899   bool CanBeOpaqueEnumDeclaration =
4900       DS.isEmpty() && isOpaqueEnumDeclarationContext(DSC);
4901   bool CanHaveEnumBase = (getLangOpts().CPlusPlus11 || getLangOpts().ObjC ||
4902                           getLangOpts().MicrosoftExt) &&
4903                          (AllowEnumSpecifier == AllowDefiningTypeSpec::Yes ||
4904                           CanBeOpaqueEnumDeclaration);
4905 
4906   CXXScopeSpec &SS = DS.getTypeSpecScope();
4907   if (getLangOpts().CPlusPlus) {
4908     // "enum foo : bar;" is not a potential typo for "enum foo::bar;".
4909     ColonProtectionRAIIObject X(*this);
4910 
4911     CXXScopeSpec Spec;
4912     if (ParseOptionalCXXScopeSpecifier(Spec, /*ObjectType=*/nullptr,
4913                                        /*ObjectHasErrors=*/false,
4914                                        /*EnteringContext=*/true))
4915       return;
4916 
4917     if (Spec.isSet() && Tok.isNot(tok::identifier)) {
4918       Diag(Tok, diag::err_expected) << tok::identifier;
4919       DS.SetTypeSpecError();
4920       if (Tok.isNot(tok::l_brace)) {
4921         // Has no name and is not a definition.
4922         // Skip the rest of this declarator, up until the comma or semicolon.
4923         SkipUntil(tok::comma, StopAtSemi);
4924         return;
4925       }
4926     }
4927 
4928     SS = Spec;
4929   }
4930 
4931   // Must have either 'enum name' or 'enum {...}' or (rarely) 'enum : T { ... }'.
4932   if (Tok.isNot(tok::identifier) && Tok.isNot(tok::l_brace) &&
4933       Tok.isNot(tok::colon)) {
4934     Diag(Tok, diag::err_expected_either) << tok::identifier << tok::l_brace;
4935 
4936     DS.SetTypeSpecError();
4937     // Skip the rest of this declarator, up until the comma or semicolon.
4938     SkipUntil(tok::comma, StopAtSemi);
4939     return;
4940   }
4941 
4942   // If an identifier is present, consume and remember it.
4943   IdentifierInfo *Name = nullptr;
4944   SourceLocation NameLoc;
4945   if (Tok.is(tok::identifier)) {
4946     Name = Tok.getIdentifierInfo();
4947     NameLoc = ConsumeToken();
4948   }
4949 
4950   if (!Name && ScopedEnumKWLoc.isValid()) {
4951     // C++0x 7.2p2: The optional identifier shall not be omitted in the
4952     // declaration of a scoped enumeration.
4953     Diag(Tok, diag::err_scoped_enum_missing_identifier);
4954     ScopedEnumKWLoc = SourceLocation();
4955     IsScopedUsingClassTag = false;
4956   }
4957 
4958   // Okay, end the suppression area.  We'll decide whether to emit the
4959   // diagnostics in a second.
4960   if (shouldDelayDiagsInTag)
4961     diagsFromTag.done();
4962 
4963   TypeResult BaseType;
4964   SourceRange BaseRange;
4965 
4966   bool CanBeBitfield =
4967       getCurScope()->isClassScope() && ScopedEnumKWLoc.isInvalid() && Name;
4968 
4969   // Parse the fixed underlying type.
4970   if (Tok.is(tok::colon)) {
4971     // This might be an enum-base or part of some unrelated enclosing context.
4972     //
4973     // 'enum E : base' is permitted in two circumstances:
4974     //
4975     // 1) As a defining-type-specifier, when followed by '{'.
4976     // 2) As the sole constituent of a complete declaration -- when DS is empty
4977     //    and the next token is ';'.
4978     //
4979     // The restriction to defining-type-specifiers is important to allow parsing
4980     //   a ? new enum E : int{}
4981     //   _Generic(a, enum E : int{})
4982     // properly.
4983     //
4984     // One additional consideration applies:
4985     //
4986     // C++ [dcl.enum]p1:
4987     //   A ':' following "enum nested-name-specifier[opt] identifier" within
4988     //   the decl-specifier-seq of a member-declaration is parsed as part of
4989     //   an enum-base.
4990     //
4991     // Other language modes supporting enumerations with fixed underlying types
4992     // do not have clear rules on this, so we disambiguate to determine whether
4993     // the tokens form a bit-field width or an enum-base.
4994 
4995     if (CanBeBitfield && !isEnumBase(CanBeOpaqueEnumDeclaration)) {
4996       // Outside C++11, do not interpret the tokens as an enum-base if they do
4997       // not make sense as one. In C++11, it's an error if this happens.
4998       if (getLangOpts().CPlusPlus11)
4999         Diag(Tok.getLocation(), diag::err_anonymous_enum_bitfield);
5000     } else if (CanHaveEnumBase || !ColonIsSacred) {
5001       SourceLocation ColonLoc = ConsumeToken();
5002 
5003       // Parse a type-specifier-seq as a type. We can't just ParseTypeName here,
5004       // because under -fms-extensions,
5005       //   enum E : int *p;
5006       // declares 'enum E : int; E *p;' not 'enum E : int*; E p;'.
5007       DeclSpec DS(AttrFactory);
5008       // enum-base is not assumed to be a type and therefore requires the
5009       // typename keyword [p0634r3].
5010       ParseSpecifierQualifierList(DS, ImplicitTypenameContext::No, AS,
5011                                   DeclSpecContext::DSC_type_specifier);
5012       Declarator DeclaratorInfo(DS, ParsedAttributesView::none(),
5013                                 DeclaratorContext::TypeName);
5014       BaseType = Actions.ActOnTypeName(DeclaratorInfo);
5015 
5016       BaseRange = SourceRange(ColonLoc, DeclaratorInfo.getSourceRange().getEnd());
5017 
5018       if (!getLangOpts().ObjC && !getLangOpts().C23) {
5019         if (getLangOpts().CPlusPlus11)
5020           Diag(ColonLoc, diag::warn_cxx98_compat_enum_fixed_underlying_type)
5021               << BaseRange;
5022         else if (getLangOpts().CPlusPlus)
5023           Diag(ColonLoc, diag::ext_cxx11_enum_fixed_underlying_type)
5024               << BaseRange;
5025         else if (getLangOpts().MicrosoftExt)
5026           Diag(ColonLoc, diag::ext_ms_c_enum_fixed_underlying_type)
5027               << BaseRange;
5028         else
5029           Diag(ColonLoc, diag::ext_clang_c_enum_fixed_underlying_type)
5030               << BaseRange;
5031       }
5032     }
5033   }
5034 
5035   // There are four options here.  If we have 'friend enum foo;' then this is a
5036   // friend declaration, and cannot have an accompanying definition. If we have
5037   // 'enum foo;', then this is a forward declaration.  If we have
5038   // 'enum foo {...' then this is a definition. Otherwise we have something
5039   // like 'enum foo xyz', a reference.
5040   //
5041   // This is needed to handle stuff like this right (C99 6.7.2.3p11):
5042   // enum foo {..};  void bar() { enum foo; }    <- new foo in bar.
5043   // enum foo {..};  void bar() { enum foo x; }  <- use of old foo.
5044   //
5045   Sema::TagUseKind TUK;
5046   if (AllowEnumSpecifier == AllowDefiningTypeSpec::No)
5047     TUK = Sema::TUK_Reference;
5048   else if (Tok.is(tok::l_brace)) {
5049     if (DS.isFriendSpecified()) {
5050       Diag(Tok.getLocation(), diag::err_friend_decl_defines_type)
5051         << SourceRange(DS.getFriendSpecLoc());
5052       ConsumeBrace();
5053       SkipUntil(tok::r_brace, StopAtSemi);
5054       // Discard any other definition-only pieces.
5055       attrs.clear();
5056       ScopedEnumKWLoc = SourceLocation();
5057       IsScopedUsingClassTag = false;
5058       BaseType = TypeResult();
5059       TUK = Sema::TUK_Friend;
5060     } else {
5061       TUK = Sema::TUK_Definition;
5062     }
5063   } else if (!isTypeSpecifier(DSC) &&
5064              (Tok.is(tok::semi) ||
5065               (Tok.isAtStartOfLine() &&
5066                !isValidAfterTypeSpecifier(CanBeBitfield)))) {
5067     // An opaque-enum-declaration is required to be standalone (no preceding or
5068     // following tokens in the declaration). Sema enforces this separately by
5069     // diagnosing anything else in the DeclSpec.
5070     TUK = DS.isFriendSpecified() ? Sema::TUK_Friend : Sema::TUK_Declaration;
5071     if (Tok.isNot(tok::semi)) {
5072       // A semicolon was missing after this declaration. Diagnose and recover.
5073       ExpectAndConsume(tok::semi, diag::err_expected_after, "enum");
5074       PP.EnterToken(Tok, /*IsReinject=*/true);
5075       Tok.setKind(tok::semi);
5076     }
5077   } else {
5078     TUK = Sema::TUK_Reference;
5079   }
5080 
5081   bool IsElaboratedTypeSpecifier =
5082       TUK == Sema::TUK_Reference || TUK == Sema::TUK_Friend;
5083 
5084   // If this is an elaborated type specifier nested in a larger declaration,
5085   // and we delayed diagnostics before, just merge them into the current pool.
5086   if (TUK == Sema::TUK_Reference && shouldDelayDiagsInTag) {
5087     diagsFromTag.redelay();
5088   }
5089 
5090   MultiTemplateParamsArg TParams;
5091   if (TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate &&
5092       TUK != Sema::TUK_Reference) {
5093     if (!getLangOpts().CPlusPlus11 || !SS.isSet()) {
5094       // Skip the rest of this declarator, up until the comma or semicolon.
5095       Diag(Tok, diag::err_enum_template);
5096       SkipUntil(tok::comma, StopAtSemi);
5097       return;
5098     }
5099 
5100     if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation) {
5101       // Enumerations can't be explicitly instantiated.
5102       DS.SetTypeSpecError();
5103       Diag(StartLoc, diag::err_explicit_instantiation_enum);
5104       return;
5105     }
5106 
5107     assert(TemplateInfo.TemplateParams && "no template parameters");
5108     TParams = MultiTemplateParamsArg(TemplateInfo.TemplateParams->data(),
5109                                      TemplateInfo.TemplateParams->size());
5110     SS.setTemplateParamLists(TParams);
5111   }
5112 
5113   if (!Name && TUK != Sema::TUK_Definition) {
5114     Diag(Tok, diag::err_enumerator_unnamed_no_def);
5115 
5116     DS.SetTypeSpecError();
5117     // Skip the rest of this declarator, up until the comma or semicolon.
5118     SkipUntil(tok::comma, StopAtSemi);
5119     return;
5120   }
5121 
5122   // An elaborated-type-specifier has a much more constrained grammar:
5123   //
5124   //   'enum' nested-name-specifier[opt] identifier
5125   //
5126   // If we parsed any other bits, reject them now.
5127   //
5128   // MSVC and (for now at least) Objective-C permit a full enum-specifier
5129   // or opaque-enum-declaration anywhere.
5130   if (IsElaboratedTypeSpecifier && !getLangOpts().MicrosoftExt &&
5131       !getLangOpts().ObjC) {
5132     ProhibitCXX11Attributes(attrs, diag::err_attributes_not_allowed,
5133                             diag::err_keyword_not_allowed,
5134                             /*DiagnoseEmptyAttrs=*/true);
5135     if (BaseType.isUsable())
5136       Diag(BaseRange.getBegin(), diag::ext_enum_base_in_type_specifier)
5137           << (AllowEnumSpecifier == AllowDefiningTypeSpec::Yes) << BaseRange;
5138     else if (ScopedEnumKWLoc.isValid())
5139       Diag(ScopedEnumKWLoc, diag::ext_elaborated_enum_class)
5140         << FixItHint::CreateRemoval(ScopedEnumKWLoc) << IsScopedUsingClassTag;
5141   }
5142 
5143   stripTypeAttributesOffDeclSpec(attrs, DS, TUK);
5144 
5145   Sema::SkipBodyInfo SkipBody;
5146   if (!Name && TUK == Sema::TUK_Definition && Tok.is(tok::l_brace) &&
5147       NextToken().is(tok::identifier))
5148     SkipBody = Actions.shouldSkipAnonEnumBody(getCurScope(),
5149                                               NextToken().getIdentifierInfo(),
5150                                               NextToken().getLocation());
5151 
5152   bool Owned = false;
5153   bool IsDependent = false;
5154   const char *PrevSpec = nullptr;
5155   unsigned DiagID;
5156   Decl *TagDecl =
5157       Actions.ActOnTag(getCurScope(), DeclSpec::TST_enum, TUK, StartLoc, SS,
5158                     Name, NameLoc, attrs, AS, DS.getModulePrivateSpecLoc(),
5159                     TParams, Owned, IsDependent, ScopedEnumKWLoc,
5160                     IsScopedUsingClassTag,
5161                     BaseType, DSC == DeclSpecContext::DSC_type_specifier,
5162                     DSC == DeclSpecContext::DSC_template_param ||
5163                         DSC == DeclSpecContext::DSC_template_type_arg,
5164                     OffsetOfState, &SkipBody).get();
5165 
5166   if (SkipBody.ShouldSkip) {
5167     assert(TUK == Sema::TUK_Definition && "can only skip a definition");
5168 
5169     BalancedDelimiterTracker T(*this, tok::l_brace);
5170     T.consumeOpen();
5171     T.skipToEnd();
5172 
5173     if (DS.SetTypeSpecType(DeclSpec::TST_enum, StartLoc,
5174                            NameLoc.isValid() ? NameLoc : StartLoc,
5175                            PrevSpec, DiagID, TagDecl, Owned,
5176                            Actions.getASTContext().getPrintingPolicy()))
5177       Diag(StartLoc, DiagID) << PrevSpec;
5178     return;
5179   }
5180 
5181   if (IsDependent) {
5182     // This enum has a dependent nested-name-specifier. Handle it as a
5183     // dependent tag.
5184     if (!Name) {
5185       DS.SetTypeSpecError();
5186       Diag(Tok, diag::err_expected_type_name_after_typename);
5187       return;
5188     }
5189 
5190     TypeResult Type = Actions.ActOnDependentTag(
5191         getCurScope(), DeclSpec::TST_enum, TUK, SS, Name, StartLoc, NameLoc);
5192     if (Type.isInvalid()) {
5193       DS.SetTypeSpecError();
5194       return;
5195     }
5196 
5197     if (DS.SetTypeSpecType(DeclSpec::TST_typename, StartLoc,
5198                            NameLoc.isValid() ? NameLoc : StartLoc,
5199                            PrevSpec, DiagID, Type.get(),
5200                            Actions.getASTContext().getPrintingPolicy()))
5201       Diag(StartLoc, DiagID) << PrevSpec;
5202 
5203     return;
5204   }
5205 
5206   if (!TagDecl) {
5207     // The action failed to produce an enumeration tag. If this is a
5208     // definition, consume the entire definition.
5209     if (Tok.is(tok::l_brace) && TUK != Sema::TUK_Reference) {
5210       ConsumeBrace();
5211       SkipUntil(tok::r_brace, StopAtSemi);
5212     }
5213 
5214     DS.SetTypeSpecError();
5215     return;
5216   }
5217 
5218   if (Tok.is(tok::l_brace) && TUK == Sema::TUK_Definition) {
5219     Decl *D = SkipBody.CheckSameAsPrevious ? SkipBody.New : TagDecl;
5220     ParseEnumBody(StartLoc, D);
5221     if (SkipBody.CheckSameAsPrevious &&
5222         !Actions.ActOnDuplicateDefinition(TagDecl, SkipBody)) {
5223       DS.SetTypeSpecError();
5224       return;
5225     }
5226   }
5227 
5228   if (DS.SetTypeSpecType(DeclSpec::TST_enum, StartLoc,
5229                          NameLoc.isValid() ? NameLoc : StartLoc,
5230                          PrevSpec, DiagID, TagDecl, Owned,
5231                          Actions.getASTContext().getPrintingPolicy()))
5232     Diag(StartLoc, DiagID) << PrevSpec;
5233 }
5234 
5235 /// ParseEnumBody - Parse a {} enclosed enumerator-list.
5236 ///       enumerator-list:
5237 ///         enumerator
5238 ///         enumerator-list ',' enumerator
5239 ///       enumerator:
5240 ///         enumeration-constant attributes[opt]
5241 ///         enumeration-constant attributes[opt] '=' constant-expression
5242 ///       enumeration-constant:
5243 ///         identifier
5244 ///
5245 void Parser::ParseEnumBody(SourceLocation StartLoc, Decl *EnumDecl) {
5246   // Enter the scope of the enum body and start the definition.
5247   ParseScope EnumScope(this, Scope::DeclScope | Scope::EnumScope);
5248   Actions.ActOnTagStartDefinition(getCurScope(), EnumDecl);
5249 
5250   BalancedDelimiterTracker T(*this, tok::l_brace);
5251   T.consumeOpen();
5252 
5253   // C does not allow an empty enumerator-list, C++ does [dcl.enum].
5254   if (Tok.is(tok::r_brace) && !getLangOpts().CPlusPlus)
5255     Diag(Tok, diag::err_empty_enum);
5256 
5257   SmallVector<Decl *, 32> EnumConstantDecls;
5258   SmallVector<SuppressAccessChecks, 32> EnumAvailabilityDiags;
5259 
5260   Decl *LastEnumConstDecl = nullptr;
5261 
5262   // Parse the enumerator-list.
5263   while (Tok.isNot(tok::r_brace)) {
5264     // Parse enumerator. If failed, try skipping till the start of the next
5265     // enumerator definition.
5266     if (Tok.isNot(tok::identifier)) {
5267       Diag(Tok.getLocation(), diag::err_expected) << tok::identifier;
5268       if (SkipUntil(tok::comma, tok::r_brace, StopBeforeMatch) &&
5269           TryConsumeToken(tok::comma))
5270         continue;
5271       break;
5272     }
5273     IdentifierInfo *Ident = Tok.getIdentifierInfo();
5274     SourceLocation IdentLoc = ConsumeToken();
5275 
5276     // If attributes exist after the enumerator, parse them.
5277     ParsedAttributes attrs(AttrFactory);
5278     MaybeParseGNUAttributes(attrs);
5279     if (isAllowedCXX11AttributeSpecifier()) {
5280       if (getLangOpts().CPlusPlus)
5281         Diag(Tok.getLocation(), getLangOpts().CPlusPlus17
5282                                     ? diag::warn_cxx14_compat_ns_enum_attribute
5283                                     : diag::ext_ns_enum_attribute)
5284             << 1 /*enumerator*/;
5285       ParseCXX11Attributes(attrs);
5286     }
5287 
5288     SourceLocation EqualLoc;
5289     ExprResult AssignedVal;
5290     EnumAvailabilityDiags.emplace_back(*this);
5291 
5292     EnterExpressionEvaluationContext ConstantEvaluated(
5293         Actions, Sema::ExpressionEvaluationContext::ConstantEvaluated);
5294     if (TryConsumeToken(tok::equal, EqualLoc)) {
5295       AssignedVal = ParseConstantExpressionInExprEvalContext();
5296       if (AssignedVal.isInvalid())
5297         SkipUntil(tok::comma, tok::r_brace, StopBeforeMatch);
5298     }
5299 
5300     // Install the enumerator constant into EnumDecl.
5301     Decl *EnumConstDecl = Actions.ActOnEnumConstant(
5302         getCurScope(), EnumDecl, LastEnumConstDecl, IdentLoc, Ident, attrs,
5303         EqualLoc, AssignedVal.get());
5304     EnumAvailabilityDiags.back().done();
5305 
5306     EnumConstantDecls.push_back(EnumConstDecl);
5307     LastEnumConstDecl = EnumConstDecl;
5308 
5309     if (Tok.is(tok::identifier)) {
5310       // We're missing a comma between enumerators.
5311       SourceLocation Loc = getEndOfPreviousToken();
5312       Diag(Loc, diag::err_enumerator_list_missing_comma)
5313         << FixItHint::CreateInsertion(Loc, ", ");
5314       continue;
5315     }
5316 
5317     // Emumerator definition must be finished, only comma or r_brace are
5318     // allowed here.
5319     SourceLocation CommaLoc;
5320     if (Tok.isNot(tok::r_brace) && !TryConsumeToken(tok::comma, CommaLoc)) {
5321       if (EqualLoc.isValid())
5322         Diag(Tok.getLocation(), diag::err_expected_either) << tok::r_brace
5323                                                            << tok::comma;
5324       else
5325         Diag(Tok.getLocation(), diag::err_expected_end_of_enumerator);
5326       if (SkipUntil(tok::comma, tok::r_brace, StopBeforeMatch)) {
5327         if (TryConsumeToken(tok::comma, CommaLoc))
5328           continue;
5329       } else {
5330         break;
5331       }
5332     }
5333 
5334     // If comma is followed by r_brace, emit appropriate warning.
5335     if (Tok.is(tok::r_brace) && CommaLoc.isValid()) {
5336       if (!getLangOpts().C99 && !getLangOpts().CPlusPlus11)
5337         Diag(CommaLoc, getLangOpts().CPlusPlus ?
5338                diag::ext_enumerator_list_comma_cxx :
5339                diag::ext_enumerator_list_comma_c)
5340           << FixItHint::CreateRemoval(CommaLoc);
5341       else if (getLangOpts().CPlusPlus11)
5342         Diag(CommaLoc, diag::warn_cxx98_compat_enumerator_list_comma)
5343           << FixItHint::CreateRemoval(CommaLoc);
5344       break;
5345     }
5346   }
5347 
5348   // Eat the }.
5349   T.consumeClose();
5350 
5351   // If attributes exist after the identifier list, parse them.
5352   ParsedAttributes attrs(AttrFactory);
5353   MaybeParseGNUAttributes(attrs);
5354 
5355   Actions.ActOnEnumBody(StartLoc, T.getRange(), EnumDecl, EnumConstantDecls,
5356                         getCurScope(), attrs);
5357 
5358   // Now handle enum constant availability diagnostics.
5359   assert(EnumConstantDecls.size() == EnumAvailabilityDiags.size());
5360   for (size_t i = 0, e = EnumConstantDecls.size(); i != e; ++i) {
5361     ParsingDeclRAIIObject PD(*this, ParsingDeclRAIIObject::NoParent);
5362     EnumAvailabilityDiags[i].redelay();
5363     PD.complete(EnumConstantDecls[i]);
5364   }
5365 
5366   EnumScope.Exit();
5367   Actions.ActOnTagFinishDefinition(getCurScope(), EnumDecl, T.getRange());
5368 
5369   // The next token must be valid after an enum definition. If not, a ';'
5370   // was probably forgotten.
5371   bool CanBeBitfield = getCurScope()->isClassScope();
5372   if (!isValidAfterTypeSpecifier(CanBeBitfield)) {
5373     ExpectAndConsume(tok::semi, diag::err_expected_after, "enum");
5374     // Push this token back into the preprocessor and change our current token
5375     // to ';' so that the rest of the code recovers as though there were an
5376     // ';' after the definition.
5377     PP.EnterToken(Tok, /*IsReinject=*/true);
5378     Tok.setKind(tok::semi);
5379   }
5380 }
5381 
5382 /// isKnownToBeTypeSpecifier - Return true if we know that the specified token
5383 /// is definitely a type-specifier.  Return false if it isn't part of a type
5384 /// specifier or if we're not sure.
5385 bool Parser::isKnownToBeTypeSpecifier(const Token &Tok) const {
5386   switch (Tok.getKind()) {
5387   default: return false;
5388     // type-specifiers
5389   case tok::kw_short:
5390   case tok::kw_long:
5391   case tok::kw___int64:
5392   case tok::kw___int128:
5393   case tok::kw_signed:
5394   case tok::kw_unsigned:
5395   case tok::kw__Complex:
5396   case tok::kw__Imaginary:
5397   case tok::kw_void:
5398   case tok::kw_char:
5399   case tok::kw_wchar_t:
5400   case tok::kw_char8_t:
5401   case tok::kw_char16_t:
5402   case tok::kw_char32_t:
5403   case tok::kw_int:
5404   case tok::kw__ExtInt:
5405   case tok::kw__BitInt:
5406   case tok::kw___bf16:
5407   case tok::kw_half:
5408   case tok::kw_float:
5409   case tok::kw_double:
5410   case tok::kw__Accum:
5411   case tok::kw__Fract:
5412   case tok::kw__Float16:
5413   case tok::kw___float128:
5414   case tok::kw___ibm128:
5415   case tok::kw_bool:
5416   case tok::kw__Bool:
5417   case tok::kw__Decimal32:
5418   case tok::kw__Decimal64:
5419   case tok::kw__Decimal128:
5420   case tok::kw___vector:
5421 #define GENERIC_IMAGE_TYPE(ImgType, Id) case tok::kw_##ImgType##_t:
5422 #include "clang/Basic/OpenCLImageTypes.def"
5423 
5424     // struct-or-union-specifier (C99) or class-specifier (C++)
5425   case tok::kw_class:
5426   case tok::kw_struct:
5427   case tok::kw___interface:
5428   case tok::kw_union:
5429     // enum-specifier
5430   case tok::kw_enum:
5431 
5432     // typedef-name
5433   case tok::annot_typename:
5434     return true;
5435   }
5436 }
5437 
5438 /// isTypeSpecifierQualifier - Return true if the current token could be the
5439 /// start of a specifier-qualifier-list.
5440 bool Parser::isTypeSpecifierQualifier() {
5441   switch (Tok.getKind()) {
5442   default: return false;
5443 
5444   case tok::identifier:   // foo::bar
5445     if (TryAltiVecVectorToken())
5446       return true;
5447     [[fallthrough]];
5448   case tok::kw_typename:  // typename T::type
5449     // Annotate typenames and C++ scope specifiers.  If we get one, just
5450     // recurse to handle whatever we get.
5451     if (TryAnnotateTypeOrScopeToken())
5452       return true;
5453     if (Tok.is(tok::identifier))
5454       return false;
5455     return isTypeSpecifierQualifier();
5456 
5457   case tok::coloncolon:   // ::foo::bar
5458     if (NextToken().is(tok::kw_new) ||    // ::new
5459         NextToken().is(tok::kw_delete))   // ::delete
5460       return false;
5461 
5462     if (TryAnnotateTypeOrScopeToken())
5463       return true;
5464     return isTypeSpecifierQualifier();
5465 
5466     // GNU attributes support.
5467   case tok::kw___attribute:
5468     // C23/GNU typeof support.
5469   case tok::kw_typeof:
5470   case tok::kw_typeof_unqual:
5471 
5472     // type-specifiers
5473   case tok::kw_short:
5474   case tok::kw_long:
5475   case tok::kw___int64:
5476   case tok::kw___int128:
5477   case tok::kw_signed:
5478   case tok::kw_unsigned:
5479   case tok::kw__Complex:
5480   case tok::kw__Imaginary:
5481   case tok::kw_void:
5482   case tok::kw_char:
5483   case tok::kw_wchar_t:
5484   case tok::kw_char8_t:
5485   case tok::kw_char16_t:
5486   case tok::kw_char32_t:
5487   case tok::kw_int:
5488   case tok::kw__ExtInt:
5489   case tok::kw__BitInt:
5490   case tok::kw_half:
5491   case tok::kw___bf16:
5492   case tok::kw_float:
5493   case tok::kw_double:
5494   case tok::kw__Accum:
5495   case tok::kw__Fract:
5496   case tok::kw__Float16:
5497   case tok::kw___float128:
5498   case tok::kw___ibm128:
5499   case tok::kw_bool:
5500   case tok::kw__Bool:
5501   case tok::kw__Decimal32:
5502   case tok::kw__Decimal64:
5503   case tok::kw__Decimal128:
5504   case tok::kw___vector:
5505 #define GENERIC_IMAGE_TYPE(ImgType, Id) case tok::kw_##ImgType##_t:
5506 #include "clang/Basic/OpenCLImageTypes.def"
5507 
5508     // struct-or-union-specifier (C99) or class-specifier (C++)
5509   case tok::kw_class:
5510   case tok::kw_struct:
5511   case tok::kw___interface:
5512   case tok::kw_union:
5513     // enum-specifier
5514   case tok::kw_enum:
5515 
5516     // type-qualifier
5517   case tok::kw_const:
5518   case tok::kw_volatile:
5519   case tok::kw_restrict:
5520   case tok::kw__Sat:
5521 
5522     // Debugger support.
5523   case tok::kw___unknown_anytype:
5524 
5525     // typedef-name
5526   case tok::annot_typename:
5527     return true;
5528 
5529     // GNU ObjC bizarre protocol extension: <proto1,proto2> with implicit 'id'.
5530   case tok::less:
5531     return getLangOpts().ObjC;
5532 
5533   case tok::kw___cdecl:
5534   case tok::kw___stdcall:
5535   case tok::kw___fastcall:
5536   case tok::kw___thiscall:
5537   case tok::kw___regcall:
5538   case tok::kw___vectorcall:
5539   case tok::kw___w64:
5540   case tok::kw___ptr64:
5541   case tok::kw___ptr32:
5542   case tok::kw___pascal:
5543   case tok::kw___unaligned:
5544 
5545   case tok::kw__Nonnull:
5546   case tok::kw__Nullable:
5547   case tok::kw__Nullable_result:
5548   case tok::kw__Null_unspecified:
5549 
5550   case tok::kw___kindof:
5551 
5552   case tok::kw___private:
5553   case tok::kw___local:
5554   case tok::kw___global:
5555   case tok::kw___constant:
5556   case tok::kw___generic:
5557   case tok::kw___read_only:
5558   case tok::kw___read_write:
5559   case tok::kw___write_only:
5560   case tok::kw___funcref:
5561     return true;
5562 
5563   case tok::kw_private:
5564     return getLangOpts().OpenCL;
5565 
5566   // C11 _Atomic
5567   case tok::kw__Atomic:
5568     return true;
5569 
5570   // HLSL type qualifiers
5571   case tok::kw_groupshared:
5572   case tok::kw_in:
5573   case tok::kw_inout:
5574   case tok::kw_out:
5575     return getLangOpts().HLSL;
5576   }
5577 }
5578 
5579 Parser::DeclGroupPtrTy Parser::ParseTopLevelStmtDecl() {
5580   assert(PP.isIncrementalProcessingEnabled() && "Not in incremental mode");
5581 
5582   // Parse a top-level-stmt.
5583   Parser::StmtVector Stmts;
5584   ParsedStmtContext SubStmtCtx = ParsedStmtContext();
5585   Actions.PushFunctionScope();
5586   StmtResult R = ParseStatementOrDeclaration(Stmts, SubStmtCtx);
5587   Actions.PopFunctionScopeInfo();
5588   if (!R.isUsable())
5589     return nullptr;
5590 
5591   SmallVector<Decl *, 2> DeclsInGroup;
5592   DeclsInGroup.push_back(Actions.ActOnTopLevelStmtDecl(R.get()));
5593 
5594   if (Tok.is(tok::annot_repl_input_end) &&
5595       Tok.getAnnotationValue() != nullptr) {
5596     ConsumeAnnotationToken();
5597     cast<TopLevelStmtDecl>(DeclsInGroup.back())->setSemiMissing();
5598   }
5599 
5600   // Currently happens for things like  -fms-extensions and use `__if_exists`.
5601   for (Stmt *S : Stmts)
5602     DeclsInGroup.push_back(Actions.ActOnTopLevelStmtDecl(S));
5603 
5604   return Actions.BuildDeclaratorGroup(DeclsInGroup);
5605 }
5606 
5607 /// isDeclarationSpecifier() - Return true if the current token is part of a
5608 /// declaration specifier.
5609 ///
5610 /// \param AllowImplicitTypename whether this is a context where T::type [T
5611 /// dependent] can appear.
5612 /// \param DisambiguatingWithExpression True to indicate that the purpose of
5613 /// this check is to disambiguate between an expression and a declaration.
5614 bool Parser::isDeclarationSpecifier(
5615     ImplicitTypenameContext AllowImplicitTypename,
5616     bool DisambiguatingWithExpression) {
5617   switch (Tok.getKind()) {
5618   default: return false;
5619 
5620   // OpenCL 2.0 and later define this keyword.
5621   case tok::kw_pipe:
5622     return getLangOpts().OpenCL &&
5623            getLangOpts().getOpenCLCompatibleVersion() >= 200;
5624 
5625   case tok::identifier:   // foo::bar
5626     // Unfortunate hack to support "Class.factoryMethod" notation.
5627     if (getLangOpts().ObjC && NextToken().is(tok::period))
5628       return false;
5629     if (TryAltiVecVectorToken())
5630       return true;
5631     [[fallthrough]];
5632   case tok::kw_decltype: // decltype(T())::type
5633   case tok::kw_typename: // typename T::type
5634     // Annotate typenames and C++ scope specifiers.  If we get one, just
5635     // recurse to handle whatever we get.
5636     if (TryAnnotateTypeOrScopeToken(AllowImplicitTypename))
5637       return true;
5638     if (TryAnnotateTypeConstraint())
5639       return true;
5640     if (Tok.is(tok::identifier))
5641       return false;
5642 
5643     // If we're in Objective-C and we have an Objective-C class type followed
5644     // by an identifier and then either ':' or ']', in a place where an
5645     // expression is permitted, then this is probably a class message send
5646     // missing the initial '['. In this case, we won't consider this to be
5647     // the start of a declaration.
5648     if (DisambiguatingWithExpression &&
5649         isStartOfObjCClassMessageMissingOpenBracket())
5650       return false;
5651 
5652     return isDeclarationSpecifier(AllowImplicitTypename);
5653 
5654   case tok::coloncolon:   // ::foo::bar
5655     if (!getLangOpts().CPlusPlus)
5656       return false;
5657     if (NextToken().is(tok::kw_new) ||    // ::new
5658         NextToken().is(tok::kw_delete))   // ::delete
5659       return false;
5660 
5661     // Annotate typenames and C++ scope specifiers.  If we get one, just
5662     // recurse to handle whatever we get.
5663     if (TryAnnotateTypeOrScopeToken())
5664       return true;
5665     return isDeclarationSpecifier(ImplicitTypenameContext::No);
5666 
5667     // storage-class-specifier
5668   case tok::kw_typedef:
5669   case tok::kw_extern:
5670   case tok::kw___private_extern__:
5671   case tok::kw_static:
5672   case tok::kw_auto:
5673   case tok::kw___auto_type:
5674   case tok::kw_register:
5675   case tok::kw___thread:
5676   case tok::kw_thread_local:
5677   case tok::kw__Thread_local:
5678 
5679     // Modules
5680   case tok::kw___module_private__:
5681 
5682     // Debugger support
5683   case tok::kw___unknown_anytype:
5684 
5685     // type-specifiers
5686   case tok::kw_short:
5687   case tok::kw_long:
5688   case tok::kw___int64:
5689   case tok::kw___int128:
5690   case tok::kw_signed:
5691   case tok::kw_unsigned:
5692   case tok::kw__Complex:
5693   case tok::kw__Imaginary:
5694   case tok::kw_void:
5695   case tok::kw_char:
5696   case tok::kw_wchar_t:
5697   case tok::kw_char8_t:
5698   case tok::kw_char16_t:
5699   case tok::kw_char32_t:
5700 
5701   case tok::kw_int:
5702   case tok::kw__ExtInt:
5703   case tok::kw__BitInt:
5704   case tok::kw_half:
5705   case tok::kw___bf16:
5706   case tok::kw_float:
5707   case tok::kw_double:
5708   case tok::kw__Accum:
5709   case tok::kw__Fract:
5710   case tok::kw__Float16:
5711   case tok::kw___float128:
5712   case tok::kw___ibm128:
5713   case tok::kw_bool:
5714   case tok::kw__Bool:
5715   case tok::kw__Decimal32:
5716   case tok::kw__Decimal64:
5717   case tok::kw__Decimal128:
5718   case tok::kw___vector:
5719 
5720     // struct-or-union-specifier (C99) or class-specifier (C++)
5721   case tok::kw_class:
5722   case tok::kw_struct:
5723   case tok::kw_union:
5724   case tok::kw___interface:
5725     // enum-specifier
5726   case tok::kw_enum:
5727 
5728     // type-qualifier
5729   case tok::kw_const:
5730   case tok::kw_volatile:
5731   case tok::kw_restrict:
5732   case tok::kw__Sat:
5733 
5734     // function-specifier
5735   case tok::kw_inline:
5736   case tok::kw_virtual:
5737   case tok::kw_explicit:
5738   case tok::kw__Noreturn:
5739 
5740     // alignment-specifier
5741   case tok::kw__Alignas:
5742 
5743     // friend keyword.
5744   case tok::kw_friend:
5745 
5746     // static_assert-declaration
5747   case tok::kw_static_assert:
5748   case tok::kw__Static_assert:
5749 
5750     // C23/GNU typeof support.
5751   case tok::kw_typeof:
5752   case tok::kw_typeof_unqual:
5753 
5754     // GNU attributes.
5755   case tok::kw___attribute:
5756 
5757     // C++11 decltype and constexpr.
5758   case tok::annot_decltype:
5759   case tok::kw_constexpr:
5760 
5761     // C++20 consteval and constinit.
5762   case tok::kw_consteval:
5763   case tok::kw_constinit:
5764 
5765     // C11 _Atomic
5766   case tok::kw__Atomic:
5767     return true;
5768 
5769     // GNU ObjC bizarre protocol extension: <proto1,proto2> with implicit 'id'.
5770   case tok::less:
5771     return getLangOpts().ObjC;
5772 
5773     // typedef-name
5774   case tok::annot_typename:
5775     return !DisambiguatingWithExpression ||
5776            !isStartOfObjCClassMessageMissingOpenBracket();
5777 
5778     // placeholder-type-specifier
5779   case tok::annot_template_id: {
5780     TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
5781     if (TemplateId->hasInvalidName())
5782       return true;
5783     // FIXME: What about type templates that have only been annotated as
5784     // annot_template_id, not as annot_typename?
5785     return isTypeConstraintAnnotation() &&
5786            (NextToken().is(tok::kw_auto) || NextToken().is(tok::kw_decltype));
5787   }
5788 
5789   case tok::annot_cxxscope: {
5790     TemplateIdAnnotation *TemplateId =
5791         NextToken().is(tok::annot_template_id)
5792             ? takeTemplateIdAnnotation(NextToken())
5793             : nullptr;
5794     if (TemplateId && TemplateId->hasInvalidName())
5795       return true;
5796     // FIXME: What about type templates that have only been annotated as
5797     // annot_template_id, not as annot_typename?
5798     if (NextToken().is(tok::identifier) && TryAnnotateTypeConstraint())
5799       return true;
5800     return isTypeConstraintAnnotation() &&
5801         GetLookAheadToken(2).isOneOf(tok::kw_auto, tok::kw_decltype);
5802   }
5803 
5804   case tok::kw___declspec:
5805   case tok::kw___cdecl:
5806   case tok::kw___stdcall:
5807   case tok::kw___fastcall:
5808   case tok::kw___thiscall:
5809   case tok::kw___regcall:
5810   case tok::kw___vectorcall:
5811   case tok::kw___w64:
5812   case tok::kw___sptr:
5813   case tok::kw___uptr:
5814   case tok::kw___ptr64:
5815   case tok::kw___ptr32:
5816   case tok::kw___forceinline:
5817   case tok::kw___pascal:
5818   case tok::kw___unaligned:
5819 
5820   case tok::kw__Nonnull:
5821   case tok::kw__Nullable:
5822   case tok::kw__Nullable_result:
5823   case tok::kw__Null_unspecified:
5824 
5825   case tok::kw___kindof:
5826 
5827   case tok::kw___private:
5828   case tok::kw___local:
5829   case tok::kw___global:
5830   case tok::kw___constant:
5831   case tok::kw___generic:
5832   case tok::kw___read_only:
5833   case tok::kw___read_write:
5834   case tok::kw___write_only:
5835 #define GENERIC_IMAGE_TYPE(ImgType, Id) case tok::kw_##ImgType##_t:
5836 #include "clang/Basic/OpenCLImageTypes.def"
5837 
5838   case tok::kw___funcref:
5839   case tok::kw_groupshared:
5840     return true;
5841 
5842   case tok::kw_private:
5843     return getLangOpts().OpenCL;
5844   }
5845 }
5846 
5847 bool Parser::isConstructorDeclarator(bool IsUnqualified, bool DeductionGuide,
5848                                      DeclSpec::FriendSpecified IsFriend,
5849                                      const ParsedTemplateInfo *TemplateInfo) {
5850   RevertingTentativeParsingAction TPA(*this);
5851   // Parse the C++ scope specifier.
5852   CXXScopeSpec SS;
5853   if (TemplateInfo && TemplateInfo->TemplateParams)
5854     SS.setTemplateParamLists(*TemplateInfo->TemplateParams);
5855 
5856   if (ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/nullptr,
5857                                      /*ObjectHasErrors=*/false,
5858                                      /*EnteringContext=*/true)) {
5859     return false;
5860   }
5861 
5862   // Parse the constructor name.
5863   if (Tok.is(tok::identifier)) {
5864     // We already know that we have a constructor name; just consume
5865     // the token.
5866     ConsumeToken();
5867   } else if (Tok.is(tok::annot_template_id)) {
5868     ConsumeAnnotationToken();
5869   } else {
5870     return false;
5871   }
5872 
5873   // There may be attributes here, appertaining to the constructor name or type
5874   // we just stepped past.
5875   SkipCXX11Attributes();
5876 
5877   // Current class name must be followed by a left parenthesis.
5878   if (Tok.isNot(tok::l_paren)) {
5879     return false;
5880   }
5881   ConsumeParen();
5882 
5883   // A right parenthesis, or ellipsis followed by a right parenthesis signals
5884   // that we have a constructor.
5885   if (Tok.is(tok::r_paren) ||
5886       (Tok.is(tok::ellipsis) && NextToken().is(tok::r_paren))) {
5887     return true;
5888   }
5889 
5890   // A C++11 attribute here signals that we have a constructor, and is an
5891   // attribute on the first constructor parameter.
5892   if (getLangOpts().CPlusPlus11 &&
5893       isCXX11AttributeSpecifier(/*Disambiguate*/ false,
5894                                 /*OuterMightBeMessageSend*/ true)) {
5895     return true;
5896   }
5897 
5898   // If we need to, enter the specified scope.
5899   DeclaratorScopeObj DeclScopeObj(*this, SS);
5900   if (SS.isSet() && Actions.ShouldEnterDeclaratorScope(getCurScope(), SS))
5901     DeclScopeObj.EnterDeclaratorScope();
5902 
5903   // Optionally skip Microsoft attributes.
5904   ParsedAttributes Attrs(AttrFactory);
5905   MaybeParseMicrosoftAttributes(Attrs);
5906 
5907   // Check whether the next token(s) are part of a declaration
5908   // specifier, in which case we have the start of a parameter and,
5909   // therefore, we know that this is a constructor.
5910   // Due to an ambiguity with implicit typename, the above is not enough.
5911   // Additionally, check to see if we are a friend.
5912   // If we parsed a scope specifier as well as friend,
5913   // we might be parsing a friend constructor.
5914   bool IsConstructor = false;
5915   ImplicitTypenameContext ITC = IsFriend && !SS.isSet()
5916                                     ? ImplicitTypenameContext::No
5917                                     : ImplicitTypenameContext::Yes;
5918   // Constructors cannot have this parameters, but we support that scenario here
5919   // to improve diagnostic.
5920   if (Tok.is(tok::kw_this)) {
5921     ConsumeToken();
5922     return isDeclarationSpecifier(ITC);
5923   }
5924 
5925   if (isDeclarationSpecifier(ITC))
5926     IsConstructor = true;
5927   else if (Tok.is(tok::identifier) ||
5928            (Tok.is(tok::annot_cxxscope) && NextToken().is(tok::identifier))) {
5929     // We've seen "C ( X" or "C ( X::Y", but "X" / "X::Y" is not a type.
5930     // This might be a parenthesized member name, but is more likely to
5931     // be a constructor declaration with an invalid argument type. Keep
5932     // looking.
5933     if (Tok.is(tok::annot_cxxscope))
5934       ConsumeAnnotationToken();
5935     ConsumeToken();
5936 
5937     // If this is not a constructor, we must be parsing a declarator,
5938     // which must have one of the following syntactic forms (see the
5939     // grammar extract at the start of ParseDirectDeclarator):
5940     switch (Tok.getKind()) {
5941     case tok::l_paren:
5942       // C(X   (   int));
5943     case tok::l_square:
5944       // C(X   [   5]);
5945       // C(X   [   [attribute]]);
5946     case tok::coloncolon:
5947       // C(X   ::   Y);
5948       // C(X   ::   *p);
5949       // Assume this isn't a constructor, rather than assuming it's a
5950       // constructor with an unnamed parameter of an ill-formed type.
5951       break;
5952 
5953     case tok::r_paren:
5954       // C(X   )
5955 
5956       // Skip past the right-paren and any following attributes to get to
5957       // the function body or trailing-return-type.
5958       ConsumeParen();
5959       SkipCXX11Attributes();
5960 
5961       if (DeductionGuide) {
5962         // C(X) -> ... is a deduction guide.
5963         IsConstructor = Tok.is(tok::arrow);
5964         break;
5965       }
5966       if (Tok.is(tok::colon) || Tok.is(tok::kw_try)) {
5967         // Assume these were meant to be constructors:
5968         //   C(X)   :    (the name of a bit-field cannot be parenthesized).
5969         //   C(X)   try  (this is otherwise ill-formed).
5970         IsConstructor = true;
5971       }
5972       if (Tok.is(tok::semi) || Tok.is(tok::l_brace)) {
5973         // If we have a constructor name within the class definition,
5974         // assume these were meant to be constructors:
5975         //   C(X)   {
5976         //   C(X)   ;
5977         // ... because otherwise we would be declaring a non-static data
5978         // member that is ill-formed because it's of the same type as its
5979         // surrounding class.
5980         //
5981         // FIXME: We can actually do this whether or not the name is qualified,
5982         // because if it is qualified in this context it must be being used as
5983         // a constructor name.
5984         // currently, so we're somewhat conservative here.
5985         IsConstructor = IsUnqualified;
5986       }
5987       break;
5988 
5989     default:
5990       IsConstructor = true;
5991       break;
5992     }
5993   }
5994   return IsConstructor;
5995 }
5996 
5997 /// ParseTypeQualifierListOpt
5998 ///          type-qualifier-list: [C99 6.7.5]
5999 ///            type-qualifier
6000 /// [vendor]   attributes
6001 ///              [ only if AttrReqs & AR_VendorAttributesParsed ]
6002 ///            type-qualifier-list type-qualifier
6003 /// [vendor]   type-qualifier-list attributes
6004 ///              [ only if AttrReqs & AR_VendorAttributesParsed ]
6005 /// [C++0x]    attribute-specifier[opt] is allowed before cv-qualifier-seq
6006 ///              [ only if AttReqs & AR_CXX11AttributesParsed ]
6007 /// Note: vendor can be GNU, MS, etc and can be explicitly controlled via
6008 /// AttrRequirements bitmask values.
6009 void Parser::ParseTypeQualifierListOpt(
6010     DeclSpec &DS, unsigned AttrReqs, bool AtomicAllowed,
6011     bool IdentifierRequired,
6012     std::optional<llvm::function_ref<void()>> CodeCompletionHandler) {
6013   if ((AttrReqs & AR_CXX11AttributesParsed) &&
6014       isAllowedCXX11AttributeSpecifier()) {
6015     ParsedAttributes Attrs(AttrFactory);
6016     ParseCXX11Attributes(Attrs);
6017     DS.takeAttributesFrom(Attrs);
6018   }
6019 
6020   SourceLocation EndLoc;
6021 
6022   while (true) {
6023     bool isInvalid = false;
6024     const char *PrevSpec = nullptr;
6025     unsigned DiagID = 0;
6026     SourceLocation Loc = Tok.getLocation();
6027 
6028     switch (Tok.getKind()) {
6029     case tok::code_completion:
6030       cutOffParsing();
6031       if (CodeCompletionHandler)
6032         (*CodeCompletionHandler)();
6033       else
6034         Actions.CodeCompleteTypeQualifiers(DS);
6035       return;
6036 
6037     case tok::kw_const:
6038       isInvalid = DS.SetTypeQual(DeclSpec::TQ_const   , Loc, PrevSpec, DiagID,
6039                                  getLangOpts());
6040       break;
6041     case tok::kw_volatile:
6042       isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec, DiagID,
6043                                  getLangOpts());
6044       break;
6045     case tok::kw_restrict:
6046       isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec, DiagID,
6047                                  getLangOpts());
6048       break;
6049     case tok::kw__Atomic:
6050       if (!AtomicAllowed)
6051         goto DoneWithTypeQuals;
6052       if (!getLangOpts().C11)
6053         Diag(Tok, diag::ext_c11_feature) << Tok.getName();
6054       isInvalid = DS.SetTypeQual(DeclSpec::TQ_atomic, Loc, PrevSpec, DiagID,
6055                                  getLangOpts());
6056       break;
6057 
6058     // OpenCL qualifiers:
6059     case tok::kw_private:
6060       if (!getLangOpts().OpenCL)
6061         goto DoneWithTypeQuals;
6062       [[fallthrough]];
6063     case tok::kw___private:
6064     case tok::kw___global:
6065     case tok::kw___local:
6066     case tok::kw___constant:
6067     case tok::kw___generic:
6068     case tok::kw___read_only:
6069     case tok::kw___write_only:
6070     case tok::kw___read_write:
6071       ParseOpenCLQualifiers(DS.getAttributes());
6072       break;
6073 
6074     case tok::kw_groupshared:
6075     case tok::kw_in:
6076     case tok::kw_inout:
6077     case tok::kw_out:
6078       // NOTE: ParseHLSLQualifiers will consume the qualifier token.
6079       ParseHLSLQualifiers(DS.getAttributes());
6080       continue;
6081 
6082     case tok::kw___unaligned:
6083       isInvalid = DS.SetTypeQual(DeclSpec::TQ_unaligned, Loc, PrevSpec, DiagID,
6084                                  getLangOpts());
6085       break;
6086     case tok::kw___uptr:
6087       // GNU libc headers in C mode use '__uptr' as an identifier which conflicts
6088       // with the MS modifier keyword.
6089       if ((AttrReqs & AR_DeclspecAttributesParsed) && !getLangOpts().CPlusPlus &&
6090           IdentifierRequired && DS.isEmpty() && NextToken().is(tok::semi)) {
6091         if (TryKeywordIdentFallback(false))
6092           continue;
6093       }
6094       [[fallthrough]];
6095     case tok::kw___sptr:
6096     case tok::kw___w64:
6097     case tok::kw___ptr64:
6098     case tok::kw___ptr32:
6099     case tok::kw___cdecl:
6100     case tok::kw___stdcall:
6101     case tok::kw___fastcall:
6102     case tok::kw___thiscall:
6103     case tok::kw___regcall:
6104     case tok::kw___vectorcall:
6105       if (AttrReqs & AR_DeclspecAttributesParsed) {
6106         ParseMicrosoftTypeAttributes(DS.getAttributes());
6107         continue;
6108       }
6109       goto DoneWithTypeQuals;
6110 
6111     case tok::kw___funcref:
6112       ParseWebAssemblyFuncrefTypeAttribute(DS.getAttributes());
6113       continue;
6114       goto DoneWithTypeQuals;
6115 
6116     case tok::kw___pascal:
6117       if (AttrReqs & AR_VendorAttributesParsed) {
6118         ParseBorlandTypeAttributes(DS.getAttributes());
6119         continue;
6120       }
6121       goto DoneWithTypeQuals;
6122 
6123     // Nullability type specifiers.
6124     case tok::kw__Nonnull:
6125     case tok::kw__Nullable:
6126     case tok::kw__Nullable_result:
6127     case tok::kw__Null_unspecified:
6128       ParseNullabilityTypeSpecifiers(DS.getAttributes());
6129       continue;
6130 
6131     // Objective-C 'kindof' types.
6132     case tok::kw___kindof:
6133       DS.getAttributes().addNew(Tok.getIdentifierInfo(), Loc, nullptr, Loc,
6134                                 nullptr, 0, tok::kw___kindof);
6135       (void)ConsumeToken();
6136       continue;
6137 
6138     case tok::kw___attribute:
6139       if (AttrReqs & AR_GNUAttributesParsedAndRejected)
6140         // When GNU attributes are expressly forbidden, diagnose their usage.
6141         Diag(Tok, diag::err_attributes_not_allowed);
6142 
6143       // Parse the attributes even if they are rejected to ensure that error
6144       // recovery is graceful.
6145       if (AttrReqs & AR_GNUAttributesParsed ||
6146           AttrReqs & AR_GNUAttributesParsedAndRejected) {
6147         ParseGNUAttributes(DS.getAttributes());
6148         continue; // do *not* consume the next token!
6149       }
6150       // otherwise, FALL THROUGH!
6151       [[fallthrough]];
6152     default:
6153       DoneWithTypeQuals:
6154       // If this is not a type-qualifier token, we're done reading type
6155       // qualifiers.  First verify that DeclSpec's are consistent.
6156       DS.Finish(Actions, Actions.getASTContext().getPrintingPolicy());
6157       if (EndLoc.isValid())
6158         DS.SetRangeEnd(EndLoc);
6159       return;
6160     }
6161 
6162     // If the specifier combination wasn't legal, issue a diagnostic.
6163     if (isInvalid) {
6164       assert(PrevSpec && "Method did not return previous specifier!");
6165       Diag(Tok, DiagID) << PrevSpec;
6166     }
6167     EndLoc = ConsumeToken();
6168   }
6169 }
6170 
6171 /// ParseDeclarator - Parse and verify a newly-initialized declarator.
6172 void Parser::ParseDeclarator(Declarator &D) {
6173   /// This implements the 'declarator' production in the C grammar, then checks
6174   /// for well-formedness and issues diagnostics.
6175   Actions.runWithSufficientStackSpace(D.getBeginLoc(), [&] {
6176     ParseDeclaratorInternal(D, &Parser::ParseDirectDeclarator);
6177   });
6178 }
6179 
6180 static bool isPtrOperatorToken(tok::TokenKind Kind, const LangOptions &Lang,
6181                                DeclaratorContext TheContext) {
6182   if (Kind == tok::star || Kind == tok::caret)
6183     return true;
6184 
6185   // OpenCL 2.0 and later define this keyword.
6186   if (Kind == tok::kw_pipe && Lang.OpenCL &&
6187       Lang.getOpenCLCompatibleVersion() >= 200)
6188     return true;
6189 
6190   if (!Lang.CPlusPlus)
6191     return false;
6192 
6193   if (Kind == tok::amp)
6194     return true;
6195 
6196   // We parse rvalue refs in C++03, because otherwise the errors are scary.
6197   // But we must not parse them in conversion-type-ids and new-type-ids, since
6198   // those can be legitimately followed by a && operator.
6199   // (The same thing can in theory happen after a trailing-return-type, but
6200   // since those are a C++11 feature, there is no rejects-valid issue there.)
6201   if (Kind == tok::ampamp)
6202     return Lang.CPlusPlus11 || (TheContext != DeclaratorContext::ConversionId &&
6203                                 TheContext != DeclaratorContext::CXXNew);
6204 
6205   return false;
6206 }
6207 
6208 // Indicates whether the given declarator is a pipe declarator.
6209 static bool isPipeDeclarator(const Declarator &D) {
6210   const unsigned NumTypes = D.getNumTypeObjects();
6211 
6212   for (unsigned Idx = 0; Idx != NumTypes; ++Idx)
6213     if (DeclaratorChunk::Pipe == D.getTypeObject(Idx).Kind)
6214       return true;
6215 
6216   return false;
6217 }
6218 
6219 /// ParseDeclaratorInternal - Parse a C or C++ declarator. The direct-declarator
6220 /// is parsed by the function passed to it. Pass null, and the direct-declarator
6221 /// isn't parsed at all, making this function effectively parse the C++
6222 /// ptr-operator production.
6223 ///
6224 /// If the grammar of this construct is extended, matching changes must also be
6225 /// made to TryParseDeclarator and MightBeDeclarator, and possibly to
6226 /// isConstructorDeclarator.
6227 ///
6228 ///       declarator: [C99 6.7.5] [C++ 8p4, dcl.decl]
6229 /// [C]     pointer[opt] direct-declarator
6230 /// [C++]   direct-declarator
6231 /// [C++]   ptr-operator declarator
6232 ///
6233 ///       pointer: [C99 6.7.5]
6234 ///         '*' type-qualifier-list[opt]
6235 ///         '*' type-qualifier-list[opt] pointer
6236 ///
6237 ///       ptr-operator:
6238 ///         '*' cv-qualifier-seq[opt]
6239 ///         '&'
6240 /// [C++0x] '&&'
6241 /// [GNU]   '&' restrict[opt] attributes[opt]
6242 /// [GNU?]  '&&' restrict[opt] attributes[opt]
6243 ///         '::'[opt] nested-name-specifier '*' cv-qualifier-seq[opt]
6244 void Parser::ParseDeclaratorInternal(Declarator &D,
6245                                      DirectDeclParseFunction DirectDeclParser) {
6246   if (Diags.hasAllExtensionsSilenced())
6247     D.setExtension();
6248 
6249   // C++ member pointers start with a '::' or a nested-name.
6250   // Member pointers get special handling, since there's no place for the
6251   // scope spec in the generic path below.
6252   if (getLangOpts().CPlusPlus &&
6253       (Tok.is(tok::coloncolon) || Tok.is(tok::kw_decltype) ||
6254        (Tok.is(tok::identifier) &&
6255         (NextToken().is(tok::coloncolon) || NextToken().is(tok::less))) ||
6256        Tok.is(tok::annot_cxxscope))) {
6257     bool EnteringContext = D.getContext() == DeclaratorContext::File ||
6258                            D.getContext() == DeclaratorContext::Member;
6259     CXXScopeSpec SS;
6260     SS.setTemplateParamLists(D.getTemplateParameterLists());
6261     ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/nullptr,
6262                                    /*ObjectHasErrors=*/false, EnteringContext);
6263 
6264     if (SS.isNotEmpty()) {
6265       if (Tok.isNot(tok::star)) {
6266         // The scope spec really belongs to the direct-declarator.
6267         if (D.mayHaveIdentifier())
6268           D.getCXXScopeSpec() = SS;
6269         else
6270           AnnotateScopeToken(SS, true);
6271 
6272         if (DirectDeclParser)
6273           (this->*DirectDeclParser)(D);
6274         return;
6275       }
6276 
6277       if (SS.isValid()) {
6278         checkCompoundToken(SS.getEndLoc(), tok::coloncolon,
6279                            CompoundToken::MemberPtr);
6280       }
6281 
6282       SourceLocation StarLoc = ConsumeToken();
6283       D.SetRangeEnd(StarLoc);
6284       DeclSpec DS(AttrFactory);
6285       ParseTypeQualifierListOpt(DS);
6286       D.ExtendWithDeclSpec(DS);
6287 
6288       // Recurse to parse whatever is left.
6289       Actions.runWithSufficientStackSpace(D.getBeginLoc(), [&] {
6290         ParseDeclaratorInternal(D, DirectDeclParser);
6291       });
6292 
6293       // Sema will have to catch (syntactically invalid) pointers into global
6294       // scope. It has to catch pointers into namespace scope anyway.
6295       D.AddTypeInfo(DeclaratorChunk::getMemberPointer(
6296                         SS, DS.getTypeQualifiers(), StarLoc, DS.getEndLoc()),
6297                     std::move(DS.getAttributes()),
6298                     /* Don't replace range end. */ SourceLocation());
6299       return;
6300     }
6301   }
6302 
6303   tok::TokenKind Kind = Tok.getKind();
6304 
6305   if (D.getDeclSpec().isTypeSpecPipe() && !isPipeDeclarator(D)) {
6306     DeclSpec DS(AttrFactory);
6307     ParseTypeQualifierListOpt(DS);
6308 
6309     D.AddTypeInfo(
6310         DeclaratorChunk::getPipe(DS.getTypeQualifiers(), DS.getPipeLoc()),
6311         std::move(DS.getAttributes()), SourceLocation());
6312   }
6313 
6314   // Not a pointer, C++ reference, or block.
6315   if (!isPtrOperatorToken(Kind, getLangOpts(), D.getContext())) {
6316     if (DirectDeclParser)
6317       (this->*DirectDeclParser)(D);
6318     return;
6319   }
6320 
6321   // Otherwise, '*' -> pointer, '^' -> block, '&' -> lvalue reference,
6322   // '&&' -> rvalue reference
6323   SourceLocation Loc = ConsumeToken();  // Eat the *, ^, & or &&.
6324   D.SetRangeEnd(Loc);
6325 
6326   if (Kind == tok::star || Kind == tok::caret) {
6327     // Is a pointer.
6328     DeclSpec DS(AttrFactory);
6329 
6330     // GNU attributes are not allowed here in a new-type-id, but Declspec and
6331     // C++11 attributes are allowed.
6332     unsigned Reqs = AR_CXX11AttributesParsed | AR_DeclspecAttributesParsed |
6333                     ((D.getContext() != DeclaratorContext::CXXNew)
6334                          ? AR_GNUAttributesParsed
6335                          : AR_GNUAttributesParsedAndRejected);
6336     ParseTypeQualifierListOpt(DS, Reqs, true, !D.mayOmitIdentifier());
6337     D.ExtendWithDeclSpec(DS);
6338 
6339     // Recursively parse the declarator.
6340     Actions.runWithSufficientStackSpace(
6341         D.getBeginLoc(), [&] { ParseDeclaratorInternal(D, DirectDeclParser); });
6342     if (Kind == tok::star)
6343       // Remember that we parsed a pointer type, and remember the type-quals.
6344       D.AddTypeInfo(DeclaratorChunk::getPointer(
6345                         DS.getTypeQualifiers(), Loc, DS.getConstSpecLoc(),
6346                         DS.getVolatileSpecLoc(), DS.getRestrictSpecLoc(),
6347                         DS.getAtomicSpecLoc(), DS.getUnalignedSpecLoc()),
6348                     std::move(DS.getAttributes()), SourceLocation());
6349     else
6350       // Remember that we parsed a Block type, and remember the type-quals.
6351       D.AddTypeInfo(
6352           DeclaratorChunk::getBlockPointer(DS.getTypeQualifiers(), Loc),
6353           std::move(DS.getAttributes()), SourceLocation());
6354   } else {
6355     // Is a reference
6356     DeclSpec DS(AttrFactory);
6357 
6358     // Complain about rvalue references in C++03, but then go on and build
6359     // the declarator.
6360     if (Kind == tok::ampamp)
6361       Diag(Loc, getLangOpts().CPlusPlus11 ?
6362            diag::warn_cxx98_compat_rvalue_reference :
6363            diag::ext_rvalue_reference);
6364 
6365     // GNU-style and C++11 attributes are allowed here, as is restrict.
6366     ParseTypeQualifierListOpt(DS);
6367     D.ExtendWithDeclSpec(DS);
6368 
6369     // C++ 8.3.2p1: cv-qualified references are ill-formed except when the
6370     // cv-qualifiers are introduced through the use of a typedef or of a
6371     // template type argument, in which case the cv-qualifiers are ignored.
6372     if (DS.getTypeQualifiers() != DeclSpec::TQ_unspecified) {
6373       if (DS.getTypeQualifiers() & DeclSpec::TQ_const)
6374         Diag(DS.getConstSpecLoc(),
6375              diag::err_invalid_reference_qualifier_application) << "const";
6376       if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile)
6377         Diag(DS.getVolatileSpecLoc(),
6378              diag::err_invalid_reference_qualifier_application) << "volatile";
6379       // 'restrict' is permitted as an extension.
6380       if (DS.getTypeQualifiers() & DeclSpec::TQ_atomic)
6381         Diag(DS.getAtomicSpecLoc(),
6382              diag::err_invalid_reference_qualifier_application) << "_Atomic";
6383     }
6384 
6385     // Recursively parse the declarator.
6386     Actions.runWithSufficientStackSpace(
6387         D.getBeginLoc(), [&] { ParseDeclaratorInternal(D, DirectDeclParser); });
6388 
6389     if (D.getNumTypeObjects() > 0) {
6390       // C++ [dcl.ref]p4: There shall be no references to references.
6391       DeclaratorChunk& InnerChunk = D.getTypeObject(D.getNumTypeObjects() - 1);
6392       if (InnerChunk.Kind == DeclaratorChunk::Reference) {
6393         if (const IdentifierInfo *II = D.getIdentifier())
6394           Diag(InnerChunk.Loc, diag::err_illegal_decl_reference_to_reference)
6395            << II;
6396         else
6397           Diag(InnerChunk.Loc, diag::err_illegal_decl_reference_to_reference)
6398             << "type name";
6399 
6400         // Once we've complained about the reference-to-reference, we
6401         // can go ahead and build the (technically ill-formed)
6402         // declarator: reference collapsing will take care of it.
6403       }
6404     }
6405 
6406     // Remember that we parsed a reference type.
6407     D.AddTypeInfo(DeclaratorChunk::getReference(DS.getTypeQualifiers(), Loc,
6408                                                 Kind == tok::amp),
6409                   std::move(DS.getAttributes()), SourceLocation());
6410   }
6411 }
6412 
6413 // When correcting from misplaced brackets before the identifier, the location
6414 // is saved inside the declarator so that other diagnostic messages can use
6415 // them.  This extracts and returns that location, or returns the provided
6416 // location if a stored location does not exist.
6417 static SourceLocation getMissingDeclaratorIdLoc(Declarator &D,
6418                                                 SourceLocation Loc) {
6419   if (D.getName().StartLocation.isInvalid() &&
6420       D.getName().EndLocation.isValid())
6421     return D.getName().EndLocation;
6422 
6423   return Loc;
6424 }
6425 
6426 /// ParseDirectDeclarator
6427 ///       direct-declarator: [C99 6.7.5]
6428 /// [C99]   identifier
6429 ///         '(' declarator ')'
6430 /// [GNU]   '(' attributes declarator ')'
6431 /// [C90]   direct-declarator '[' constant-expression[opt] ']'
6432 /// [C99]   direct-declarator '[' type-qual-list[opt] assignment-expr[opt] ']'
6433 /// [C99]   direct-declarator '[' 'static' type-qual-list[opt] assign-expr ']'
6434 /// [C99]   direct-declarator '[' type-qual-list 'static' assignment-expr ']'
6435 /// [C99]   direct-declarator '[' type-qual-list[opt] '*' ']'
6436 /// [C++11] direct-declarator '[' constant-expression[opt] ']'
6437 ///                    attribute-specifier-seq[opt]
6438 ///         direct-declarator '(' parameter-type-list ')'
6439 ///         direct-declarator '(' identifier-list[opt] ')'
6440 /// [GNU]   direct-declarator '(' parameter-forward-declarations
6441 ///                    parameter-type-list[opt] ')'
6442 /// [C++]   direct-declarator '(' parameter-declaration-clause ')'
6443 ///                    cv-qualifier-seq[opt] exception-specification[opt]
6444 /// [C++11] direct-declarator '(' parameter-declaration-clause ')'
6445 ///                    attribute-specifier-seq[opt] cv-qualifier-seq[opt]
6446 ///                    ref-qualifier[opt] exception-specification[opt]
6447 /// [C++]   declarator-id
6448 /// [C++11] declarator-id attribute-specifier-seq[opt]
6449 ///
6450 ///       declarator-id: [C++ 8]
6451 ///         '...'[opt] id-expression
6452 ///         '::'[opt] nested-name-specifier[opt] type-name
6453 ///
6454 ///       id-expression: [C++ 5.1]
6455 ///         unqualified-id
6456 ///         qualified-id
6457 ///
6458 ///       unqualified-id: [C++ 5.1]
6459 ///         identifier
6460 ///         operator-function-id
6461 ///         conversion-function-id
6462 ///          '~' class-name
6463 ///         template-id
6464 ///
6465 /// C++17 adds the following, which we also handle here:
6466 ///
6467 ///       simple-declaration:
6468 ///         <decl-spec> '[' identifier-list ']' brace-or-equal-initializer ';'
6469 ///
6470 /// Note, any additional constructs added here may need corresponding changes
6471 /// in isConstructorDeclarator.
6472 void Parser::ParseDirectDeclarator(Declarator &D) {
6473   DeclaratorScopeObj DeclScopeObj(*this, D.getCXXScopeSpec());
6474 
6475   if (getLangOpts().CPlusPlus && D.mayHaveIdentifier()) {
6476     // This might be a C++17 structured binding.
6477     if (Tok.is(tok::l_square) && !D.mayOmitIdentifier() &&
6478         D.getCXXScopeSpec().isEmpty())
6479       return ParseDecompositionDeclarator(D);
6480 
6481     // Don't parse FOO:BAR as if it were a typo for FOO::BAR inside a class, in
6482     // this context it is a bitfield. Also in range-based for statement colon
6483     // may delimit for-range-declaration.
6484     ColonProtectionRAIIObject X(
6485         *this, D.getContext() == DeclaratorContext::Member ||
6486                    (D.getContext() == DeclaratorContext::ForInit &&
6487                     getLangOpts().CPlusPlus11));
6488 
6489     // ParseDeclaratorInternal might already have parsed the scope.
6490     if (D.getCXXScopeSpec().isEmpty()) {
6491       bool EnteringContext = D.getContext() == DeclaratorContext::File ||
6492                              D.getContext() == DeclaratorContext::Member;
6493       ParseOptionalCXXScopeSpecifier(
6494           D.getCXXScopeSpec(), /*ObjectType=*/nullptr,
6495           /*ObjectHasErrors=*/false, EnteringContext);
6496     }
6497 
6498     if (D.getCXXScopeSpec().isValid()) {
6499       if (Actions.ShouldEnterDeclaratorScope(getCurScope(),
6500                                              D.getCXXScopeSpec()))
6501         // Change the declaration context for name lookup, until this function
6502         // is exited (and the declarator has been parsed).
6503         DeclScopeObj.EnterDeclaratorScope();
6504       else if (getObjCDeclContext()) {
6505         // Ensure that we don't interpret the next token as an identifier when
6506         // dealing with declarations in an Objective-C container.
6507         D.SetIdentifier(nullptr, Tok.getLocation());
6508         D.setInvalidType(true);
6509         ConsumeToken();
6510         goto PastIdentifier;
6511       }
6512     }
6513 
6514     // C++0x [dcl.fct]p14:
6515     //   There is a syntactic ambiguity when an ellipsis occurs at the end of a
6516     //   parameter-declaration-clause without a preceding comma. In this case,
6517     //   the ellipsis is parsed as part of the abstract-declarator if the type
6518     //   of the parameter either names a template parameter pack that has not
6519     //   been expanded or contains auto; otherwise, it is parsed as part of the
6520     //   parameter-declaration-clause.
6521     if (Tok.is(tok::ellipsis) && D.getCXXScopeSpec().isEmpty() &&
6522         !((D.getContext() == DeclaratorContext::Prototype ||
6523            D.getContext() == DeclaratorContext::LambdaExprParameter ||
6524            D.getContext() == DeclaratorContext::BlockLiteral) &&
6525           NextToken().is(tok::r_paren) && !D.hasGroupingParens() &&
6526           !Actions.containsUnexpandedParameterPacks(D) &&
6527           D.getDeclSpec().getTypeSpecType() != TST_auto)) {
6528       SourceLocation EllipsisLoc = ConsumeToken();
6529       if (isPtrOperatorToken(Tok.getKind(), getLangOpts(), D.getContext())) {
6530         // The ellipsis was put in the wrong place. Recover, and explain to
6531         // the user what they should have done.
6532         ParseDeclarator(D);
6533         if (EllipsisLoc.isValid())
6534           DiagnoseMisplacedEllipsisInDeclarator(EllipsisLoc, D);
6535         return;
6536       } else
6537         D.setEllipsisLoc(EllipsisLoc);
6538 
6539       // The ellipsis can't be followed by a parenthesized declarator. We
6540       // check for that in ParseParenDeclarator, after we have disambiguated
6541       // the l_paren token.
6542     }
6543 
6544     if (Tok.isOneOf(tok::identifier, tok::kw_operator, tok::annot_template_id,
6545                     tok::tilde)) {
6546       // We found something that indicates the start of an unqualified-id.
6547       // Parse that unqualified-id.
6548       bool AllowConstructorName;
6549       bool AllowDeductionGuide;
6550       if (D.getDeclSpec().hasTypeSpecifier()) {
6551         AllowConstructorName = false;
6552         AllowDeductionGuide = false;
6553       } else if (D.getCXXScopeSpec().isSet()) {
6554         AllowConstructorName = (D.getContext() == DeclaratorContext::File ||
6555                                 D.getContext() == DeclaratorContext::Member);
6556         AllowDeductionGuide = false;
6557       } else {
6558         AllowConstructorName = (D.getContext() == DeclaratorContext::Member);
6559         AllowDeductionGuide = (D.getContext() == DeclaratorContext::File ||
6560                                D.getContext() == DeclaratorContext::Member);
6561       }
6562 
6563       bool HadScope = D.getCXXScopeSpec().isValid();
6564       if (ParseUnqualifiedId(D.getCXXScopeSpec(),
6565                              /*ObjectType=*/nullptr,
6566                              /*ObjectHadErrors=*/false,
6567                              /*EnteringContext=*/true,
6568                              /*AllowDestructorName=*/true, AllowConstructorName,
6569                              AllowDeductionGuide, nullptr, D.getName()) ||
6570           // Once we're past the identifier, if the scope was bad, mark the
6571           // whole declarator bad.
6572           D.getCXXScopeSpec().isInvalid()) {
6573         D.SetIdentifier(nullptr, Tok.getLocation());
6574         D.setInvalidType(true);
6575       } else {
6576         // ParseUnqualifiedId might have parsed a scope specifier during error
6577         // recovery. If it did so, enter that scope.
6578         if (!HadScope && D.getCXXScopeSpec().isValid() &&
6579             Actions.ShouldEnterDeclaratorScope(getCurScope(),
6580                                                D.getCXXScopeSpec()))
6581           DeclScopeObj.EnterDeclaratorScope();
6582 
6583         // Parsed the unqualified-id; update range information and move along.
6584         if (D.getSourceRange().getBegin().isInvalid())
6585           D.SetRangeBegin(D.getName().getSourceRange().getBegin());
6586         D.SetRangeEnd(D.getName().getSourceRange().getEnd());
6587       }
6588       goto PastIdentifier;
6589     }
6590 
6591     if (D.getCXXScopeSpec().isNotEmpty()) {
6592       // We have a scope specifier but no following unqualified-id.
6593       Diag(PP.getLocForEndOfToken(D.getCXXScopeSpec().getEndLoc()),
6594            diag::err_expected_unqualified_id)
6595           << /*C++*/1;
6596       D.SetIdentifier(nullptr, Tok.getLocation());
6597       goto PastIdentifier;
6598     }
6599   } else if (Tok.is(tok::identifier) && D.mayHaveIdentifier()) {
6600     assert(!getLangOpts().CPlusPlus &&
6601            "There's a C++-specific check for tok::identifier above");
6602     assert(Tok.getIdentifierInfo() && "Not an identifier?");
6603     D.SetIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
6604     D.SetRangeEnd(Tok.getLocation());
6605     ConsumeToken();
6606     goto PastIdentifier;
6607   } else if (Tok.is(tok::identifier) && !D.mayHaveIdentifier()) {
6608     // We're not allowed an identifier here, but we got one. Try to figure out
6609     // if the user was trying to attach a name to the type, or whether the name
6610     // is some unrelated trailing syntax.
6611     bool DiagnoseIdentifier = false;
6612     if (D.hasGroupingParens())
6613       // An identifier within parens is unlikely to be intended to be anything
6614       // other than a name being "declared".
6615       DiagnoseIdentifier = true;
6616     else if (D.getContext() == DeclaratorContext::TemplateArg)
6617       // T<int N> is an accidental identifier; T<int N indicates a missing '>'.
6618       DiagnoseIdentifier =
6619           NextToken().isOneOf(tok::comma, tok::greater, tok::greatergreater);
6620     else if (D.getContext() == DeclaratorContext::AliasDecl ||
6621              D.getContext() == DeclaratorContext::AliasTemplate)
6622       // The most likely error is that the ';' was forgotten.
6623       DiagnoseIdentifier = NextToken().isOneOf(tok::comma, tok::semi);
6624     else if ((D.getContext() == DeclaratorContext::TrailingReturn ||
6625               D.getContext() == DeclaratorContext::TrailingReturnVar) &&
6626              !isCXX11VirtSpecifier(Tok))
6627       DiagnoseIdentifier = NextToken().isOneOf(
6628           tok::comma, tok::semi, tok::equal, tok::l_brace, tok::kw_try);
6629     if (DiagnoseIdentifier) {
6630       Diag(Tok.getLocation(), diag::err_unexpected_unqualified_id)
6631         << FixItHint::CreateRemoval(Tok.getLocation());
6632       D.SetIdentifier(nullptr, Tok.getLocation());
6633       ConsumeToken();
6634       goto PastIdentifier;
6635     }
6636   }
6637 
6638   if (Tok.is(tok::l_paren)) {
6639     // If this might be an abstract-declarator followed by a direct-initializer,
6640     // check whether this is a valid declarator chunk. If it can't be, assume
6641     // that it's an initializer instead.
6642     if (D.mayOmitIdentifier() && D.mayBeFollowedByCXXDirectInit()) {
6643       RevertingTentativeParsingAction PA(*this);
6644       if (TryParseDeclarator(true, D.mayHaveIdentifier(), true,
6645                              D.getDeclSpec().getTypeSpecType() == TST_auto) ==
6646           TPResult::False) {
6647         D.SetIdentifier(nullptr, Tok.getLocation());
6648         goto PastIdentifier;
6649       }
6650     }
6651 
6652     // direct-declarator: '(' declarator ')'
6653     // direct-declarator: '(' attributes declarator ')'
6654     // Example: 'char (*X)'   or 'int (*XX)(void)'
6655     ParseParenDeclarator(D);
6656 
6657     // If the declarator was parenthesized, we entered the declarator
6658     // scope when parsing the parenthesized declarator, then exited
6659     // the scope already. Re-enter the scope, if we need to.
6660     if (D.getCXXScopeSpec().isSet()) {
6661       // If there was an error parsing parenthesized declarator, declarator
6662       // scope may have been entered before. Don't do it again.
6663       if (!D.isInvalidType() &&
6664           Actions.ShouldEnterDeclaratorScope(getCurScope(),
6665                                              D.getCXXScopeSpec()))
6666         // Change the declaration context for name lookup, until this function
6667         // is exited (and the declarator has been parsed).
6668         DeclScopeObj.EnterDeclaratorScope();
6669     }
6670   } else if (D.mayOmitIdentifier()) {
6671     // This could be something simple like "int" (in which case the declarator
6672     // portion is empty), if an abstract-declarator is allowed.
6673     D.SetIdentifier(nullptr, Tok.getLocation());
6674 
6675     // The grammar for abstract-pack-declarator does not allow grouping parens.
6676     // FIXME: Revisit this once core issue 1488 is resolved.
6677     if (D.hasEllipsis() && D.hasGroupingParens())
6678       Diag(PP.getLocForEndOfToken(D.getEllipsisLoc()),
6679            diag::ext_abstract_pack_declarator_parens);
6680   } else {
6681     if (Tok.getKind() == tok::annot_pragma_parser_crash)
6682       LLVM_BUILTIN_TRAP;
6683     if (Tok.is(tok::l_square))
6684       return ParseMisplacedBracketDeclarator(D);
6685     if (D.getContext() == DeclaratorContext::Member) {
6686       // Objective-C++: Detect C++ keywords and try to prevent further errors by
6687       // treating these keyword as valid member names.
6688       if (getLangOpts().ObjC && getLangOpts().CPlusPlus &&
6689           !Tok.isAnnotation() && Tok.getIdentifierInfo() &&
6690           Tok.getIdentifierInfo()->isCPlusPlusKeyword(getLangOpts())) {
6691         Diag(getMissingDeclaratorIdLoc(D, Tok.getLocation()),
6692              diag::err_expected_member_name_or_semi_objcxx_keyword)
6693             << Tok.getIdentifierInfo()
6694             << (D.getDeclSpec().isEmpty() ? SourceRange()
6695                                           : D.getDeclSpec().getSourceRange());
6696         D.SetIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
6697         D.SetRangeEnd(Tok.getLocation());
6698         ConsumeToken();
6699         goto PastIdentifier;
6700       }
6701       Diag(getMissingDeclaratorIdLoc(D, Tok.getLocation()),
6702            diag::err_expected_member_name_or_semi)
6703           << (D.getDeclSpec().isEmpty() ? SourceRange()
6704                                         : D.getDeclSpec().getSourceRange());
6705     } else {
6706       if (Tok.getKind() == tok::TokenKind::kw_while) {
6707         Diag(Tok, diag::err_while_loop_outside_of_a_function);
6708       } else if (getLangOpts().CPlusPlus) {
6709         if (Tok.isOneOf(tok::period, tok::arrow))
6710           Diag(Tok, diag::err_invalid_operator_on_type) << Tok.is(tok::arrow);
6711         else {
6712           SourceLocation Loc = D.getCXXScopeSpec().getEndLoc();
6713           if (Tok.isAtStartOfLine() && Loc.isValid())
6714             Diag(PP.getLocForEndOfToken(Loc), diag::err_expected_unqualified_id)
6715                 << getLangOpts().CPlusPlus;
6716           else
6717             Diag(getMissingDeclaratorIdLoc(D, Tok.getLocation()),
6718                  diag::err_expected_unqualified_id)
6719                 << getLangOpts().CPlusPlus;
6720         }
6721       } else {
6722         Diag(getMissingDeclaratorIdLoc(D, Tok.getLocation()),
6723              diag::err_expected_either)
6724             << tok::identifier << tok::l_paren;
6725       }
6726     }
6727     D.SetIdentifier(nullptr, Tok.getLocation());
6728     D.setInvalidType(true);
6729   }
6730 
6731  PastIdentifier:
6732   assert(D.isPastIdentifier() &&
6733          "Haven't past the location of the identifier yet?");
6734 
6735   // Don't parse attributes unless we have parsed an unparenthesized name.
6736   if (D.hasName() && !D.getNumTypeObjects())
6737     MaybeParseCXX11Attributes(D);
6738 
6739   while (true) {
6740     if (Tok.is(tok::l_paren)) {
6741       bool IsFunctionDeclaration = D.isFunctionDeclaratorAFunctionDeclaration();
6742       // Enter function-declaration scope, limiting any declarators to the
6743       // function prototype scope, including parameter declarators.
6744       ParseScope PrototypeScope(this,
6745                                 Scope::FunctionPrototypeScope|Scope::DeclScope|
6746                                 (IsFunctionDeclaration
6747                                    ? Scope::FunctionDeclarationScope : 0));
6748 
6749       // The paren may be part of a C++ direct initializer, eg. "int x(1);".
6750       // In such a case, check if we actually have a function declarator; if it
6751       // is not, the declarator has been fully parsed.
6752       bool IsAmbiguous = false;
6753       if (getLangOpts().CPlusPlus && D.mayBeFollowedByCXXDirectInit()) {
6754         // C++2a [temp.res]p5
6755         // A qualified-id is assumed to name a type if
6756         //   - [...]
6757         //   - it is a decl-specifier of the decl-specifier-seq of a
6758         //     - [...]
6759         //     - parameter-declaration in a member-declaration [...]
6760         //     - parameter-declaration in a declarator of a function or function
6761         //       template declaration whose declarator-id is qualified [...]
6762         auto AllowImplicitTypename = ImplicitTypenameContext::No;
6763         if (D.getCXXScopeSpec().isSet())
6764           AllowImplicitTypename =
6765               (ImplicitTypenameContext)Actions.isDeclaratorFunctionLike(D);
6766         else if (D.getContext() == DeclaratorContext::Member) {
6767           AllowImplicitTypename = ImplicitTypenameContext::Yes;
6768         }
6769 
6770         // The name of the declarator, if any, is tentatively declared within
6771         // a possible direct initializer.
6772         TentativelyDeclaredIdentifiers.push_back(D.getIdentifier());
6773         bool IsFunctionDecl =
6774             isCXXFunctionDeclarator(&IsAmbiguous, AllowImplicitTypename);
6775         TentativelyDeclaredIdentifiers.pop_back();
6776         if (!IsFunctionDecl)
6777           break;
6778       }
6779       ParsedAttributes attrs(AttrFactory);
6780       BalancedDelimiterTracker T(*this, tok::l_paren);
6781       T.consumeOpen();
6782       if (IsFunctionDeclaration)
6783         Actions.ActOnStartFunctionDeclarationDeclarator(D,
6784                                                         TemplateParameterDepth);
6785       ParseFunctionDeclarator(D, attrs, T, IsAmbiguous);
6786       if (IsFunctionDeclaration)
6787         Actions.ActOnFinishFunctionDeclarationDeclarator(D);
6788       PrototypeScope.Exit();
6789     } else if (Tok.is(tok::l_square)) {
6790       ParseBracketDeclarator(D);
6791     } else if (Tok.isRegularKeywordAttribute()) {
6792       // For consistency with attribute parsing.
6793       Diag(Tok, diag::err_keyword_not_allowed) << Tok.getIdentifierInfo();
6794       bool TakesArgs = doesKeywordAttributeTakeArgs(Tok.getKind());
6795       ConsumeToken();
6796       if (TakesArgs) {
6797         BalancedDelimiterTracker T(*this, tok::l_paren);
6798         if (!T.consumeOpen())
6799           T.skipToEnd();
6800       }
6801     } else if (Tok.is(tok::kw_requires) && D.hasGroupingParens()) {
6802       // This declarator is declaring a function, but the requires clause is
6803       // in the wrong place:
6804       //   void (f() requires true);
6805       // instead of
6806       //   void f() requires true;
6807       // or
6808       //   void (f()) requires true;
6809       Diag(Tok, diag::err_requires_clause_inside_parens);
6810       ConsumeToken();
6811       ExprResult TrailingRequiresClause = Actions.CorrectDelayedTyposInExpr(
6812          ParseConstraintLogicalOrExpression(/*IsTrailingRequiresClause=*/true));
6813       if (TrailingRequiresClause.isUsable() && D.isFunctionDeclarator() &&
6814           !D.hasTrailingRequiresClause())
6815         // We're already ill-formed if we got here but we'll accept it anyway.
6816         D.setTrailingRequiresClause(TrailingRequiresClause.get());
6817     } else {
6818       break;
6819     }
6820   }
6821 }
6822 
6823 void Parser::ParseDecompositionDeclarator(Declarator &D) {
6824   assert(Tok.is(tok::l_square));
6825 
6826   // If this doesn't look like a structured binding, maybe it's a misplaced
6827   // array declarator.
6828   // FIXME: Consume the l_square first so we don't need extra lookahead for
6829   // this.
6830   if (!(NextToken().is(tok::identifier) &&
6831         GetLookAheadToken(2).isOneOf(tok::comma, tok::r_square)) &&
6832       !(NextToken().is(tok::r_square) &&
6833         GetLookAheadToken(2).isOneOf(tok::equal, tok::l_brace)))
6834     return ParseMisplacedBracketDeclarator(D);
6835 
6836   BalancedDelimiterTracker T(*this, tok::l_square);
6837   T.consumeOpen();
6838 
6839   SmallVector<DecompositionDeclarator::Binding, 32> Bindings;
6840   while (Tok.isNot(tok::r_square)) {
6841     if (!Bindings.empty()) {
6842       if (Tok.is(tok::comma))
6843         ConsumeToken();
6844       else {
6845         if (Tok.is(tok::identifier)) {
6846           SourceLocation EndLoc = getEndOfPreviousToken();
6847           Diag(EndLoc, diag::err_expected)
6848               << tok::comma << FixItHint::CreateInsertion(EndLoc, ",");
6849         } else {
6850           Diag(Tok, diag::err_expected_comma_or_rsquare);
6851         }
6852 
6853         SkipUntil(tok::r_square, tok::comma, tok::identifier,
6854                   StopAtSemi | StopBeforeMatch);
6855         if (Tok.is(tok::comma))
6856           ConsumeToken();
6857         else if (Tok.isNot(tok::identifier))
6858           break;
6859       }
6860     }
6861 
6862     if (Tok.isNot(tok::identifier)) {
6863       Diag(Tok, diag::err_expected) << tok::identifier;
6864       break;
6865     }
6866 
6867     Bindings.push_back({Tok.getIdentifierInfo(), Tok.getLocation()});
6868     ConsumeToken();
6869   }
6870 
6871   if (Tok.isNot(tok::r_square))
6872     // We've already diagnosed a problem here.
6873     T.skipToEnd();
6874   else {
6875     // C++17 does not allow the identifier-list in a structured binding
6876     // to be empty.
6877     if (Bindings.empty())
6878       Diag(Tok.getLocation(), diag::ext_decomp_decl_empty);
6879 
6880     T.consumeClose();
6881   }
6882 
6883   return D.setDecompositionBindings(T.getOpenLocation(), Bindings,
6884                                     T.getCloseLocation());
6885 }
6886 
6887 /// ParseParenDeclarator - We parsed the declarator D up to a paren.  This is
6888 /// only called before the identifier, so these are most likely just grouping
6889 /// parens for precedence.  If we find that these are actually function
6890 /// parameter parens in an abstract-declarator, we call ParseFunctionDeclarator.
6891 ///
6892 ///       direct-declarator:
6893 ///         '(' declarator ')'
6894 /// [GNU]   '(' attributes declarator ')'
6895 ///         direct-declarator '(' parameter-type-list ')'
6896 ///         direct-declarator '(' identifier-list[opt] ')'
6897 /// [GNU]   direct-declarator '(' parameter-forward-declarations
6898 ///                    parameter-type-list[opt] ')'
6899 ///
6900 void Parser::ParseParenDeclarator(Declarator &D) {
6901   BalancedDelimiterTracker T(*this, tok::l_paren);
6902   T.consumeOpen();
6903 
6904   assert(!D.isPastIdentifier() && "Should be called before passing identifier");
6905 
6906   // Eat any attributes before we look at whether this is a grouping or function
6907   // declarator paren.  If this is a grouping paren, the attribute applies to
6908   // the type being built up, for example:
6909   //     int (__attribute__(()) *x)(long y)
6910   // If this ends up not being a grouping paren, the attribute applies to the
6911   // first argument, for example:
6912   //     int (__attribute__(()) int x)
6913   // In either case, we need to eat any attributes to be able to determine what
6914   // sort of paren this is.
6915   //
6916   ParsedAttributes attrs(AttrFactory);
6917   bool RequiresArg = false;
6918   if (Tok.is(tok::kw___attribute)) {
6919     ParseGNUAttributes(attrs);
6920 
6921     // We require that the argument list (if this is a non-grouping paren) be
6922     // present even if the attribute list was empty.
6923     RequiresArg = true;
6924   }
6925 
6926   // Eat any Microsoft extensions.
6927   ParseMicrosoftTypeAttributes(attrs);
6928 
6929   // Eat any Borland extensions.
6930   if  (Tok.is(tok::kw___pascal))
6931     ParseBorlandTypeAttributes(attrs);
6932 
6933   // If we haven't past the identifier yet (or where the identifier would be
6934   // stored, if this is an abstract declarator), then this is probably just
6935   // grouping parens. However, if this could be an abstract-declarator, then
6936   // this could also be the start of function arguments (consider 'void()').
6937   bool isGrouping;
6938 
6939   if (!D.mayOmitIdentifier()) {
6940     // If this can't be an abstract-declarator, this *must* be a grouping
6941     // paren, because we haven't seen the identifier yet.
6942     isGrouping = true;
6943   } else if (Tok.is(tok::r_paren) || // 'int()' is a function.
6944              (getLangOpts().CPlusPlus && Tok.is(tok::ellipsis) &&
6945               NextToken().is(tok::r_paren)) || // C++ int(...)
6946              isDeclarationSpecifier(
6947                  ImplicitTypenameContext::No) || // 'int(int)' is a function.
6948              isCXX11AttributeSpecifier()) { // 'int([[]]int)' is a function.
6949     // This handles C99 6.7.5.3p11: in "typedef int X; void foo(X)", X is
6950     // considered to be a type, not a K&R identifier-list.
6951     isGrouping = false;
6952   } else {
6953     // Otherwise, this is a grouping paren, e.g. 'int (*X)' or 'int(X)'.
6954     isGrouping = true;
6955   }
6956 
6957   // If this is a grouping paren, handle:
6958   // direct-declarator: '(' declarator ')'
6959   // direct-declarator: '(' attributes declarator ')'
6960   if (isGrouping) {
6961     SourceLocation EllipsisLoc = D.getEllipsisLoc();
6962     D.setEllipsisLoc(SourceLocation());
6963 
6964     bool hadGroupingParens = D.hasGroupingParens();
6965     D.setGroupingParens(true);
6966     ParseDeclaratorInternal(D, &Parser::ParseDirectDeclarator);
6967     // Match the ')'.
6968     T.consumeClose();
6969     D.AddTypeInfo(
6970         DeclaratorChunk::getParen(T.getOpenLocation(), T.getCloseLocation()),
6971         std::move(attrs), T.getCloseLocation());
6972 
6973     D.setGroupingParens(hadGroupingParens);
6974 
6975     // An ellipsis cannot be placed outside parentheses.
6976     if (EllipsisLoc.isValid())
6977       DiagnoseMisplacedEllipsisInDeclarator(EllipsisLoc, D);
6978 
6979     return;
6980   }
6981 
6982   // Okay, if this wasn't a grouping paren, it must be the start of a function
6983   // argument list.  Recognize that this declarator will never have an
6984   // identifier (and remember where it would have been), then call into
6985   // ParseFunctionDeclarator to handle of argument list.
6986   D.SetIdentifier(nullptr, Tok.getLocation());
6987 
6988   // Enter function-declaration scope, limiting any declarators to the
6989   // function prototype scope, including parameter declarators.
6990   ParseScope PrototypeScope(this,
6991                             Scope::FunctionPrototypeScope | Scope::DeclScope |
6992                             (D.isFunctionDeclaratorAFunctionDeclaration()
6993                                ? Scope::FunctionDeclarationScope : 0));
6994   ParseFunctionDeclarator(D, attrs, T, false, RequiresArg);
6995   PrototypeScope.Exit();
6996 }
6997 
6998 void Parser::InitCXXThisScopeForDeclaratorIfRelevant(
6999     const Declarator &D, const DeclSpec &DS,
7000     std::optional<Sema::CXXThisScopeRAII> &ThisScope) {
7001   // C++11 [expr.prim.general]p3:
7002   //   If a declaration declares a member function or member function
7003   //   template of a class X, the expression this is a prvalue of type
7004   //   "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq
7005   //   and the end of the function-definition, member-declarator, or
7006   //   declarator.
7007   // FIXME: currently, "static" case isn't handled correctly.
7008   bool IsCXX11MemberFunction =
7009       getLangOpts().CPlusPlus11 &&
7010       D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef &&
7011       (D.getContext() == DeclaratorContext::Member
7012            ? !D.getDeclSpec().isFriendSpecified()
7013            : D.getContext() == DeclaratorContext::File &&
7014                  D.getCXXScopeSpec().isValid() &&
7015                  Actions.CurContext->isRecord());
7016   if (!IsCXX11MemberFunction)
7017     return;
7018 
7019   Qualifiers Q = Qualifiers::fromCVRUMask(DS.getTypeQualifiers());
7020   if (D.getDeclSpec().hasConstexprSpecifier() && !getLangOpts().CPlusPlus14)
7021     Q.addConst();
7022   // FIXME: Collect C++ address spaces.
7023   // If there are multiple different address spaces, the source is invalid.
7024   // Carry on using the first addr space for the qualifiers of 'this'.
7025   // The diagnostic will be given later while creating the function
7026   // prototype for the method.
7027   if (getLangOpts().OpenCLCPlusPlus) {
7028     for (ParsedAttr &attr : DS.getAttributes()) {
7029       LangAS ASIdx = attr.asOpenCLLangAS();
7030       if (ASIdx != LangAS::Default) {
7031         Q.addAddressSpace(ASIdx);
7032         break;
7033       }
7034     }
7035   }
7036   ThisScope.emplace(Actions, dyn_cast<CXXRecordDecl>(Actions.CurContext), Q,
7037                     IsCXX11MemberFunction);
7038 }
7039 
7040 /// ParseFunctionDeclarator - We are after the identifier and have parsed the
7041 /// declarator D up to a paren, which indicates that we are parsing function
7042 /// arguments.
7043 ///
7044 /// If FirstArgAttrs is non-null, then the caller parsed those attributes
7045 /// immediately after the open paren - they will be applied to the DeclSpec
7046 /// of the first parameter.
7047 ///
7048 /// If RequiresArg is true, then the first argument of the function is required
7049 /// to be present and required to not be an identifier list.
7050 ///
7051 /// For C++, after the parameter-list, it also parses the cv-qualifier-seq[opt],
7052 /// (C++11) ref-qualifier[opt], exception-specification[opt],
7053 /// (C++11) attribute-specifier-seq[opt], (C++11) trailing-return-type[opt] and
7054 /// (C++2a) the trailing requires-clause.
7055 ///
7056 /// [C++11] exception-specification:
7057 ///           dynamic-exception-specification
7058 ///           noexcept-specification
7059 ///
7060 void Parser::ParseFunctionDeclarator(Declarator &D,
7061                                      ParsedAttributes &FirstArgAttrs,
7062                                      BalancedDelimiterTracker &Tracker,
7063                                      bool IsAmbiguous,
7064                                      bool RequiresArg) {
7065   assert(getCurScope()->isFunctionPrototypeScope() &&
7066          "Should call from a Function scope");
7067   // lparen is already consumed!
7068   assert(D.isPastIdentifier() && "Should not call before identifier!");
7069 
7070   // This should be true when the function has typed arguments.
7071   // Otherwise, it is treated as a K&R-style function.
7072   bool HasProto = false;
7073   // Build up an array of information about the parsed arguments.
7074   SmallVector<DeclaratorChunk::ParamInfo, 16> ParamInfo;
7075   // Remember where we see an ellipsis, if any.
7076   SourceLocation EllipsisLoc;
7077 
7078   DeclSpec DS(AttrFactory);
7079   bool RefQualifierIsLValueRef = true;
7080   SourceLocation RefQualifierLoc;
7081   ExceptionSpecificationType ESpecType = EST_None;
7082   SourceRange ESpecRange;
7083   SmallVector<ParsedType, 2> DynamicExceptions;
7084   SmallVector<SourceRange, 2> DynamicExceptionRanges;
7085   ExprResult NoexceptExpr;
7086   CachedTokens *ExceptionSpecTokens = nullptr;
7087   ParsedAttributes FnAttrs(AttrFactory);
7088   TypeResult TrailingReturnType;
7089   SourceLocation TrailingReturnTypeLoc;
7090 
7091   /* LocalEndLoc is the end location for the local FunctionTypeLoc.
7092      EndLoc is the end location for the function declarator.
7093      They differ for trailing return types. */
7094   SourceLocation StartLoc, LocalEndLoc, EndLoc;
7095   SourceLocation LParenLoc, RParenLoc;
7096   LParenLoc = Tracker.getOpenLocation();
7097   StartLoc = LParenLoc;
7098 
7099   if (isFunctionDeclaratorIdentifierList()) {
7100     if (RequiresArg)
7101       Diag(Tok, diag::err_argument_required_after_attribute);
7102 
7103     ParseFunctionDeclaratorIdentifierList(D, ParamInfo);
7104 
7105     Tracker.consumeClose();
7106     RParenLoc = Tracker.getCloseLocation();
7107     LocalEndLoc = RParenLoc;
7108     EndLoc = RParenLoc;
7109 
7110     // If there are attributes following the identifier list, parse them and
7111     // prohibit them.
7112     MaybeParseCXX11Attributes(FnAttrs);
7113     ProhibitAttributes(FnAttrs);
7114   } else {
7115     if (Tok.isNot(tok::r_paren))
7116       ParseParameterDeclarationClause(D, FirstArgAttrs, ParamInfo, EllipsisLoc);
7117     else if (RequiresArg)
7118       Diag(Tok, diag::err_argument_required_after_attribute);
7119 
7120     // OpenCL disallows functions without a prototype, but it doesn't enforce
7121     // strict prototypes as in C23 because it allows a function definition to
7122     // have an identifier list. See OpenCL 3.0 6.11/g for more details.
7123     HasProto = ParamInfo.size() || getLangOpts().requiresStrictPrototypes() ||
7124                getLangOpts().OpenCL;
7125 
7126     // If we have the closing ')', eat it.
7127     Tracker.consumeClose();
7128     RParenLoc = Tracker.getCloseLocation();
7129     LocalEndLoc = RParenLoc;
7130     EndLoc = RParenLoc;
7131 
7132     if (getLangOpts().CPlusPlus) {
7133       // FIXME: Accept these components in any order, and produce fixits to
7134       // correct the order if the user gets it wrong. Ideally we should deal
7135       // with the pure-specifier in the same way.
7136 
7137       // Parse cv-qualifier-seq[opt].
7138       ParseTypeQualifierListOpt(DS, AR_NoAttributesParsed,
7139                                 /*AtomicAllowed*/ false,
7140                                 /*IdentifierRequired=*/false,
7141                                 llvm::function_ref<void()>([&]() {
7142                                   Actions.CodeCompleteFunctionQualifiers(DS, D);
7143                                 }));
7144       if (!DS.getSourceRange().getEnd().isInvalid()) {
7145         EndLoc = DS.getSourceRange().getEnd();
7146       }
7147 
7148       // Parse ref-qualifier[opt].
7149       if (ParseRefQualifier(RefQualifierIsLValueRef, RefQualifierLoc))
7150         EndLoc = RefQualifierLoc;
7151 
7152       std::optional<Sema::CXXThisScopeRAII> ThisScope;
7153       InitCXXThisScopeForDeclaratorIfRelevant(D, DS, ThisScope);
7154 
7155       // Parse exception-specification[opt].
7156       // FIXME: Per [class.mem]p6, all exception-specifications at class scope
7157       // should be delayed, including those for non-members (eg, friend
7158       // declarations). But only applying this to member declarations is
7159       // consistent with what other implementations do.
7160       bool Delayed = D.isFirstDeclarationOfMember() &&
7161                      D.isFunctionDeclaratorAFunctionDeclaration();
7162       if (Delayed && Actions.isLibstdcxxEagerExceptionSpecHack(D) &&
7163           GetLookAheadToken(0).is(tok::kw_noexcept) &&
7164           GetLookAheadToken(1).is(tok::l_paren) &&
7165           GetLookAheadToken(2).is(tok::kw_noexcept) &&
7166           GetLookAheadToken(3).is(tok::l_paren) &&
7167           GetLookAheadToken(4).is(tok::identifier) &&
7168           GetLookAheadToken(4).getIdentifierInfo()->isStr("swap")) {
7169         // HACK: We've got an exception-specification
7170         //   noexcept(noexcept(swap(...)))
7171         // or
7172         //   noexcept(noexcept(swap(...)) && noexcept(swap(...)))
7173         // on a 'swap' member function. This is a libstdc++ bug; the lookup
7174         // for 'swap' will only find the function we're currently declaring,
7175         // whereas it expects to find a non-member swap through ADL. Turn off
7176         // delayed parsing to give it a chance to find what it expects.
7177         Delayed = false;
7178       }
7179       ESpecType = tryParseExceptionSpecification(Delayed,
7180                                                  ESpecRange,
7181                                                  DynamicExceptions,
7182                                                  DynamicExceptionRanges,
7183                                                  NoexceptExpr,
7184                                                  ExceptionSpecTokens);
7185       if (ESpecType != EST_None)
7186         EndLoc = ESpecRange.getEnd();
7187 
7188       // Parse attribute-specifier-seq[opt]. Per DR 979 and DR 1297, this goes
7189       // after the exception-specification.
7190       MaybeParseCXX11Attributes(FnAttrs);
7191 
7192       // Parse trailing-return-type[opt].
7193       LocalEndLoc = EndLoc;
7194       if (getLangOpts().CPlusPlus11 && Tok.is(tok::arrow)) {
7195         Diag(Tok, diag::warn_cxx98_compat_trailing_return_type);
7196         if (D.getDeclSpec().getTypeSpecType() == TST_auto)
7197           StartLoc = D.getDeclSpec().getTypeSpecTypeLoc();
7198         LocalEndLoc = Tok.getLocation();
7199         SourceRange Range;
7200         TrailingReturnType =
7201             ParseTrailingReturnType(Range, D.mayBeFollowedByCXXDirectInit());
7202         TrailingReturnTypeLoc = Range.getBegin();
7203         EndLoc = Range.getEnd();
7204       }
7205     } else {
7206       MaybeParseCXX11Attributes(FnAttrs);
7207     }
7208   }
7209 
7210   // Collect non-parameter declarations from the prototype if this is a function
7211   // declaration. They will be moved into the scope of the function. Only do
7212   // this in C and not C++, where the decls will continue to live in the
7213   // surrounding context.
7214   SmallVector<NamedDecl *, 0> DeclsInPrototype;
7215   if (getCurScope()->isFunctionDeclarationScope() && !getLangOpts().CPlusPlus) {
7216     for (Decl *D : getCurScope()->decls()) {
7217       NamedDecl *ND = dyn_cast<NamedDecl>(D);
7218       if (!ND || isa<ParmVarDecl>(ND))
7219         continue;
7220       DeclsInPrototype.push_back(ND);
7221     }
7222     // Sort DeclsInPrototype based on raw encoding of the source location.
7223     // Scope::decls() is iterating over a SmallPtrSet so sort the Decls before
7224     // moving to DeclContext. This provides a stable ordering for traversing
7225     // Decls in DeclContext, which is important for tasks like ASTWriter for
7226     // deterministic output.
7227     llvm::sort(DeclsInPrototype, [](Decl *D1, Decl *D2) {
7228       return D1->getLocation().getRawEncoding() <
7229              D2->getLocation().getRawEncoding();
7230     });
7231   }
7232 
7233   // Remember that we parsed a function type, and remember the attributes.
7234   D.AddTypeInfo(DeclaratorChunk::getFunction(
7235                     HasProto, IsAmbiguous, LParenLoc, ParamInfo.data(),
7236                     ParamInfo.size(), EllipsisLoc, RParenLoc,
7237                     RefQualifierIsLValueRef, RefQualifierLoc,
7238                     /*MutableLoc=*/SourceLocation(),
7239                     ESpecType, ESpecRange, DynamicExceptions.data(),
7240                     DynamicExceptionRanges.data(), DynamicExceptions.size(),
7241                     NoexceptExpr.isUsable() ? NoexceptExpr.get() : nullptr,
7242                     ExceptionSpecTokens, DeclsInPrototype, StartLoc,
7243                     LocalEndLoc, D, TrailingReturnType, TrailingReturnTypeLoc,
7244                     &DS),
7245                 std::move(FnAttrs), EndLoc);
7246 }
7247 
7248 /// ParseRefQualifier - Parses a member function ref-qualifier. Returns
7249 /// true if a ref-qualifier is found.
7250 bool Parser::ParseRefQualifier(bool &RefQualifierIsLValueRef,
7251                                SourceLocation &RefQualifierLoc) {
7252   if (Tok.isOneOf(tok::amp, tok::ampamp)) {
7253     Diag(Tok, getLangOpts().CPlusPlus11 ?
7254          diag::warn_cxx98_compat_ref_qualifier :
7255          diag::ext_ref_qualifier);
7256 
7257     RefQualifierIsLValueRef = Tok.is(tok::amp);
7258     RefQualifierLoc = ConsumeToken();
7259     return true;
7260   }
7261   return false;
7262 }
7263 
7264 /// isFunctionDeclaratorIdentifierList - This parameter list may have an
7265 /// identifier list form for a K&R-style function:  void foo(a,b,c)
7266 ///
7267 /// Note that identifier-lists are only allowed for normal declarators, not for
7268 /// abstract-declarators.
7269 bool Parser::isFunctionDeclaratorIdentifierList() {
7270   return !getLangOpts().requiresStrictPrototypes()
7271          && Tok.is(tok::identifier)
7272          && !TryAltiVecVectorToken()
7273          // K&R identifier lists can't have typedefs as identifiers, per C99
7274          // 6.7.5.3p11.
7275          && (TryAnnotateTypeOrScopeToken() || !Tok.is(tok::annot_typename))
7276          // Identifier lists follow a really simple grammar: the identifiers can
7277          // be followed *only* by a ", identifier" or ")".  However, K&R
7278          // identifier lists are really rare in the brave new modern world, and
7279          // it is very common for someone to typo a type in a non-K&R style
7280          // list.  If we are presented with something like: "void foo(intptr x,
7281          // float y)", we don't want to start parsing the function declarator as
7282          // though it is a K&R style declarator just because intptr is an
7283          // invalid type.
7284          //
7285          // To handle this, we check to see if the token after the first
7286          // identifier is a "," or ")".  Only then do we parse it as an
7287          // identifier list.
7288          && (!Tok.is(tok::eof) &&
7289              (NextToken().is(tok::comma) || NextToken().is(tok::r_paren)));
7290 }
7291 
7292 /// ParseFunctionDeclaratorIdentifierList - While parsing a function declarator
7293 /// we found a K&R-style identifier list instead of a typed parameter list.
7294 ///
7295 /// After returning, ParamInfo will hold the parsed parameters.
7296 ///
7297 ///       identifier-list: [C99 6.7.5]
7298 ///         identifier
7299 ///         identifier-list ',' identifier
7300 ///
7301 void Parser::ParseFunctionDeclaratorIdentifierList(
7302        Declarator &D,
7303        SmallVectorImpl<DeclaratorChunk::ParamInfo> &ParamInfo) {
7304   // We should never reach this point in C23 or C++.
7305   assert(!getLangOpts().requiresStrictPrototypes() &&
7306          "Cannot parse an identifier list in C23 or C++");
7307 
7308   // If there was no identifier specified for the declarator, either we are in
7309   // an abstract-declarator, or we are in a parameter declarator which was found
7310   // to be abstract.  In abstract-declarators, identifier lists are not valid:
7311   // diagnose this.
7312   if (!D.getIdentifier())
7313     Diag(Tok, diag::ext_ident_list_in_param);
7314 
7315   // Maintain an efficient lookup of params we have seen so far.
7316   llvm::SmallSet<const IdentifierInfo*, 16> ParamsSoFar;
7317 
7318   do {
7319     // If this isn't an identifier, report the error and skip until ')'.
7320     if (Tok.isNot(tok::identifier)) {
7321       Diag(Tok, diag::err_expected) << tok::identifier;
7322       SkipUntil(tok::r_paren, StopAtSemi | StopBeforeMatch);
7323       // Forget we parsed anything.
7324       ParamInfo.clear();
7325       return;
7326     }
7327 
7328     IdentifierInfo *ParmII = Tok.getIdentifierInfo();
7329 
7330     // Reject 'typedef int y; int test(x, y)', but continue parsing.
7331     if (Actions.getTypeName(*ParmII, Tok.getLocation(), getCurScope()))
7332       Diag(Tok, diag::err_unexpected_typedef_ident) << ParmII;
7333 
7334     // Verify that the argument identifier has not already been mentioned.
7335     if (!ParamsSoFar.insert(ParmII).second) {
7336       Diag(Tok, diag::err_param_redefinition) << ParmII;
7337     } else {
7338       // Remember this identifier in ParamInfo.
7339       ParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII,
7340                                                      Tok.getLocation(),
7341                                                      nullptr));
7342     }
7343 
7344     // Eat the identifier.
7345     ConsumeToken();
7346     // The list continues if we see a comma.
7347   } while (TryConsumeToken(tok::comma));
7348 }
7349 
7350 /// ParseParameterDeclarationClause - Parse a (possibly empty) parameter-list
7351 /// after the opening parenthesis. This function will not parse a K&R-style
7352 /// identifier list.
7353 ///
7354 /// DeclContext is the context of the declarator being parsed.  If FirstArgAttrs
7355 /// is non-null, then the caller parsed those attributes immediately after the
7356 /// open paren - they will be applied to the DeclSpec of the first parameter.
7357 ///
7358 /// After returning, ParamInfo will hold the parsed parameters. EllipsisLoc will
7359 /// be the location of the ellipsis, if any was parsed.
7360 ///
7361 ///       parameter-type-list: [C99 6.7.5]
7362 ///         parameter-list
7363 ///         parameter-list ',' '...'
7364 /// [C++]   parameter-list '...'
7365 ///
7366 ///       parameter-list: [C99 6.7.5]
7367 ///         parameter-declaration
7368 ///         parameter-list ',' parameter-declaration
7369 ///
7370 ///       parameter-declaration: [C99 6.7.5]
7371 ///         declaration-specifiers declarator
7372 /// [C++]   declaration-specifiers declarator '=' assignment-expression
7373 /// [C++11]                                       initializer-clause
7374 /// [GNU]   declaration-specifiers declarator attributes
7375 ///         declaration-specifiers abstract-declarator[opt]
7376 /// [C++]   declaration-specifiers abstract-declarator[opt]
7377 ///           '=' assignment-expression
7378 /// [GNU]   declaration-specifiers abstract-declarator[opt] attributes
7379 /// [C++11] attribute-specifier-seq parameter-declaration
7380 /// [C++2b] attribute-specifier-seq 'this' parameter-declaration
7381 ///
7382 void Parser::ParseParameterDeclarationClause(
7383     DeclaratorContext DeclaratorCtx, ParsedAttributes &FirstArgAttrs,
7384     SmallVectorImpl<DeclaratorChunk::ParamInfo> &ParamInfo,
7385     SourceLocation &EllipsisLoc, bool IsACXXFunctionDeclaration) {
7386 
7387   // Avoid exceeding the maximum function scope depth.
7388   // See https://bugs.llvm.org/show_bug.cgi?id=19607
7389   // Note Sema::ActOnParamDeclarator calls ParmVarDecl::setScopeInfo with
7390   // getFunctionPrototypeDepth() - 1.
7391   if (getCurScope()->getFunctionPrototypeDepth() - 1 >
7392       ParmVarDecl::getMaxFunctionScopeDepth()) {
7393     Diag(Tok.getLocation(), diag::err_function_scope_depth_exceeded)
7394         << ParmVarDecl::getMaxFunctionScopeDepth();
7395     cutOffParsing();
7396     return;
7397   }
7398 
7399   // C++2a [temp.res]p5
7400   // A qualified-id is assumed to name a type if
7401   //   - [...]
7402   //   - it is a decl-specifier of the decl-specifier-seq of a
7403   //     - [...]
7404   //     - parameter-declaration in a member-declaration [...]
7405   //     - parameter-declaration in a declarator of a function or function
7406   //       template declaration whose declarator-id is qualified [...]
7407   //     - parameter-declaration in a lambda-declarator [...]
7408   auto AllowImplicitTypename = ImplicitTypenameContext::No;
7409   if (DeclaratorCtx == DeclaratorContext::Member ||
7410       DeclaratorCtx == DeclaratorContext::LambdaExpr ||
7411       DeclaratorCtx == DeclaratorContext::RequiresExpr ||
7412       IsACXXFunctionDeclaration) {
7413     AllowImplicitTypename = ImplicitTypenameContext::Yes;
7414   }
7415 
7416   do {
7417     // FIXME: Issue a diagnostic if we parsed an attribute-specifier-seq
7418     // before deciding this was a parameter-declaration-clause.
7419     if (TryConsumeToken(tok::ellipsis, EllipsisLoc))
7420       break;
7421 
7422     // Parse the declaration-specifiers.
7423     // Just use the ParsingDeclaration "scope" of the declarator.
7424     DeclSpec DS(AttrFactory);
7425 
7426     ParsedAttributes ArgDeclAttrs(AttrFactory);
7427     ParsedAttributes ArgDeclSpecAttrs(AttrFactory);
7428 
7429     if (FirstArgAttrs.Range.isValid()) {
7430       // If the caller parsed attributes for the first argument, add them now.
7431       // Take them so that we only apply the attributes to the first parameter.
7432       // We have already started parsing the decl-specifier sequence, so don't
7433       // parse any parameter-declaration pieces that precede it.
7434       ArgDeclSpecAttrs.takeAllFrom(FirstArgAttrs);
7435     } else {
7436       // Parse any C++11 attributes.
7437       MaybeParseCXX11Attributes(ArgDeclAttrs);
7438 
7439       // Skip any Microsoft attributes before a param.
7440       MaybeParseMicrosoftAttributes(ArgDeclSpecAttrs);
7441     }
7442 
7443     SourceLocation DSStart = Tok.getLocation();
7444 
7445     // Parse a C++23 Explicit Object Parameter
7446     // We do that in all language modes to produce a better diagnostic.
7447     SourceLocation ThisLoc;
7448     if (getLangOpts().CPlusPlus && Tok.is(tok::kw_this))
7449       ThisLoc = ConsumeToken();
7450 
7451     ParseDeclarationSpecifiers(DS, /*TemplateInfo=*/ParsedTemplateInfo(),
7452                                AS_none, DeclSpecContext::DSC_normal,
7453                                /*LateAttrs=*/nullptr, AllowImplicitTypename);
7454 
7455     DS.takeAttributesFrom(ArgDeclSpecAttrs);
7456 
7457     // Parse the declarator.  This is "PrototypeContext" or
7458     // "LambdaExprParameterContext", because we must accept either
7459     // 'declarator' or 'abstract-declarator' here.
7460     Declarator ParmDeclarator(DS, ArgDeclAttrs,
7461                               DeclaratorCtx == DeclaratorContext::RequiresExpr
7462                                   ? DeclaratorContext::RequiresExpr
7463                               : DeclaratorCtx == DeclaratorContext::LambdaExpr
7464                                   ? DeclaratorContext::LambdaExprParameter
7465                                   : DeclaratorContext::Prototype);
7466     ParseDeclarator(ParmDeclarator);
7467 
7468     if (ThisLoc.isValid())
7469       ParmDeclarator.SetRangeBegin(ThisLoc);
7470 
7471     // Parse GNU attributes, if present.
7472     MaybeParseGNUAttributes(ParmDeclarator);
7473     if (getLangOpts().HLSL)
7474       MaybeParseHLSLSemantics(DS.getAttributes());
7475 
7476     if (Tok.is(tok::kw_requires)) {
7477       // User tried to define a requires clause in a parameter declaration,
7478       // which is surely not a function declaration.
7479       // void f(int (*g)(int, int) requires true);
7480       Diag(Tok,
7481            diag::err_requires_clause_on_declarator_not_declaring_a_function);
7482       ConsumeToken();
7483       Actions.CorrectDelayedTyposInExpr(
7484          ParseConstraintLogicalOrExpression(/*IsTrailingRequiresClause=*/true));
7485     }
7486 
7487     // Remember this parsed parameter in ParamInfo.
7488     IdentifierInfo *ParmII = ParmDeclarator.getIdentifier();
7489 
7490     // DefArgToks is used when the parsing of default arguments needs
7491     // to be delayed.
7492     std::unique_ptr<CachedTokens> DefArgToks;
7493 
7494     // If no parameter was specified, verify that *something* was specified,
7495     // otherwise we have a missing type and identifier.
7496     if (DS.isEmpty() && ParmDeclarator.getIdentifier() == nullptr &&
7497         ParmDeclarator.getNumTypeObjects() == 0) {
7498       // Completely missing, emit error.
7499       Diag(DSStart, diag::err_missing_param);
7500     } else {
7501       // Otherwise, we have something.  Add it and let semantic analysis try
7502       // to grok it and add the result to the ParamInfo we are building.
7503 
7504       // Last chance to recover from a misplaced ellipsis in an attempted
7505       // parameter pack declaration.
7506       if (Tok.is(tok::ellipsis) &&
7507           (NextToken().isNot(tok::r_paren) ||
7508            (!ParmDeclarator.getEllipsisLoc().isValid() &&
7509             !Actions.isUnexpandedParameterPackPermitted())) &&
7510           Actions.containsUnexpandedParameterPacks(ParmDeclarator))
7511         DiagnoseMisplacedEllipsisInDeclarator(ConsumeToken(), ParmDeclarator);
7512 
7513       // Now we are at the point where declarator parsing is finished.
7514       //
7515       // Try to catch keywords in place of the identifier in a declarator, and
7516       // in particular the common case where:
7517       //   1 identifier comes at the end of the declarator
7518       //   2 if the identifier is dropped, the declarator is valid but anonymous
7519       //     (no identifier)
7520       //   3 declarator parsing succeeds, and then we have a trailing keyword,
7521       //     which is never valid in a param list (e.g. missing a ',')
7522       // And we can't handle this in ParseDeclarator because in general keywords
7523       // may be allowed to follow the declarator. (And in some cases there'd be
7524       // better recovery like inserting punctuation). ParseDeclarator is just
7525       // treating this as an anonymous parameter, and fortunately at this point
7526       // we've already almost done that.
7527       //
7528       // We care about case 1) where the declarator type should be known, and
7529       // the identifier should be null.
7530       if (!ParmDeclarator.isInvalidType() && !ParmDeclarator.hasName() &&
7531           Tok.isNot(tok::raw_identifier) && !Tok.isAnnotation() &&
7532           Tok.getIdentifierInfo() &&
7533           Tok.getIdentifierInfo()->isKeyword(getLangOpts())) {
7534         Diag(Tok, diag::err_keyword_as_parameter) << PP.getSpelling(Tok);
7535         // Consume the keyword.
7536         ConsumeToken();
7537       }
7538       // Inform the actions module about the parameter declarator, so it gets
7539       // added to the current scope.
7540       Decl *Param =
7541           Actions.ActOnParamDeclarator(getCurScope(), ParmDeclarator, ThisLoc);
7542       // Parse the default argument, if any. We parse the default
7543       // arguments in all dialects; the semantic analysis in
7544       // ActOnParamDefaultArgument will reject the default argument in
7545       // C.
7546       if (Tok.is(tok::equal)) {
7547         SourceLocation EqualLoc = Tok.getLocation();
7548 
7549         // Parse the default argument
7550         if (DeclaratorCtx == DeclaratorContext::Member) {
7551           // If we're inside a class definition, cache the tokens
7552           // corresponding to the default argument. We'll actually parse
7553           // them when we see the end of the class definition.
7554           DefArgToks.reset(new CachedTokens);
7555 
7556           SourceLocation ArgStartLoc = NextToken().getLocation();
7557           ConsumeAndStoreInitializer(*DefArgToks, CIK_DefaultArgument);
7558           Actions.ActOnParamUnparsedDefaultArgument(Param, EqualLoc,
7559                                                     ArgStartLoc);
7560         } else {
7561           // Consume the '='.
7562           ConsumeToken();
7563 
7564           // The argument isn't actually potentially evaluated unless it is
7565           // used.
7566           EnterExpressionEvaluationContext Eval(
7567               Actions,
7568               Sema::ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed,
7569               Param);
7570 
7571           ExprResult DefArgResult;
7572           if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
7573             Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);
7574             DefArgResult = ParseBraceInitializer();
7575           } else {
7576             if (Tok.is(tok::l_paren) && NextToken().is(tok::l_brace)) {
7577               Diag(Tok, diag::err_stmt_expr_in_default_arg) << 0;
7578               Actions.ActOnParamDefaultArgumentError(Param, EqualLoc,
7579                                                      /*DefaultArg=*/nullptr);
7580               // Skip the statement expression and continue parsing
7581               SkipUntil(tok::comma, StopBeforeMatch);
7582               continue;
7583             }
7584             DefArgResult = ParseAssignmentExpression();
7585           }
7586           DefArgResult = Actions.CorrectDelayedTyposInExpr(DefArgResult);
7587           if (DefArgResult.isInvalid()) {
7588             Actions.ActOnParamDefaultArgumentError(Param, EqualLoc,
7589                                                    /*DefaultArg=*/nullptr);
7590             SkipUntil(tok::comma, tok::r_paren, StopAtSemi | StopBeforeMatch);
7591           } else {
7592             // Inform the actions module about the default argument
7593             Actions.ActOnParamDefaultArgument(Param, EqualLoc,
7594                                               DefArgResult.get());
7595           }
7596         }
7597       }
7598 
7599       ParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII,
7600                                           ParmDeclarator.getIdentifierLoc(),
7601                                           Param, std::move(DefArgToks)));
7602     }
7603 
7604     if (TryConsumeToken(tok::ellipsis, EllipsisLoc)) {
7605       if (!getLangOpts().CPlusPlus) {
7606         // We have ellipsis without a preceding ',', which is ill-formed
7607         // in C. Complain and provide the fix.
7608         Diag(EllipsisLoc, diag::err_missing_comma_before_ellipsis)
7609             << FixItHint::CreateInsertion(EllipsisLoc, ", ");
7610       } else if (ParmDeclarator.getEllipsisLoc().isValid() ||
7611                  Actions.containsUnexpandedParameterPacks(ParmDeclarator)) {
7612         // It looks like this was supposed to be a parameter pack. Warn and
7613         // point out where the ellipsis should have gone.
7614         SourceLocation ParmEllipsis = ParmDeclarator.getEllipsisLoc();
7615         Diag(EllipsisLoc, diag::warn_misplaced_ellipsis_vararg)
7616           << ParmEllipsis.isValid() << ParmEllipsis;
7617         if (ParmEllipsis.isValid()) {
7618           Diag(ParmEllipsis,
7619                diag::note_misplaced_ellipsis_vararg_existing_ellipsis);
7620         } else {
7621           Diag(ParmDeclarator.getIdentifierLoc(),
7622                diag::note_misplaced_ellipsis_vararg_add_ellipsis)
7623             << FixItHint::CreateInsertion(ParmDeclarator.getIdentifierLoc(),
7624                                           "...")
7625             << !ParmDeclarator.hasName();
7626         }
7627         Diag(EllipsisLoc, diag::note_misplaced_ellipsis_vararg_add_comma)
7628           << FixItHint::CreateInsertion(EllipsisLoc, ", ");
7629       }
7630 
7631       // We can't have any more parameters after an ellipsis.
7632       break;
7633     }
7634 
7635     // If the next token is a comma, consume it and keep reading arguments.
7636   } while (TryConsumeToken(tok::comma));
7637 }
7638 
7639 /// [C90]   direct-declarator '[' constant-expression[opt] ']'
7640 /// [C99]   direct-declarator '[' type-qual-list[opt] assignment-expr[opt] ']'
7641 /// [C99]   direct-declarator '[' 'static' type-qual-list[opt] assign-expr ']'
7642 /// [C99]   direct-declarator '[' type-qual-list 'static' assignment-expr ']'
7643 /// [C99]   direct-declarator '[' type-qual-list[opt] '*' ']'
7644 /// [C++11] direct-declarator '[' constant-expression[opt] ']'
7645 ///                           attribute-specifier-seq[opt]
7646 void Parser::ParseBracketDeclarator(Declarator &D) {
7647   if (CheckProhibitedCXX11Attribute())
7648     return;
7649 
7650   BalancedDelimiterTracker T(*this, tok::l_square);
7651   T.consumeOpen();
7652 
7653   // C array syntax has many features, but by-far the most common is [] and [4].
7654   // This code does a fast path to handle some of the most obvious cases.
7655   if (Tok.getKind() == tok::r_square) {
7656     T.consumeClose();
7657     ParsedAttributes attrs(AttrFactory);
7658     MaybeParseCXX11Attributes(attrs);
7659 
7660     // Remember that we parsed the empty array type.
7661     D.AddTypeInfo(DeclaratorChunk::getArray(0, false, false, nullptr,
7662                                             T.getOpenLocation(),
7663                                             T.getCloseLocation()),
7664                   std::move(attrs), T.getCloseLocation());
7665     return;
7666   } else if (Tok.getKind() == tok::numeric_constant &&
7667              GetLookAheadToken(1).is(tok::r_square)) {
7668     // [4] is very common.  Parse the numeric constant expression.
7669     ExprResult ExprRes(Actions.ActOnNumericConstant(Tok, getCurScope()));
7670     ConsumeToken();
7671 
7672     T.consumeClose();
7673     ParsedAttributes attrs(AttrFactory);
7674     MaybeParseCXX11Attributes(attrs);
7675 
7676     // Remember that we parsed a array type, and remember its features.
7677     D.AddTypeInfo(DeclaratorChunk::getArray(0, false, false, ExprRes.get(),
7678                                             T.getOpenLocation(),
7679                                             T.getCloseLocation()),
7680                   std::move(attrs), T.getCloseLocation());
7681     return;
7682   } else if (Tok.getKind() == tok::code_completion) {
7683     cutOffParsing();
7684     Actions.CodeCompleteBracketDeclarator(getCurScope());
7685     return;
7686   }
7687 
7688   // If valid, this location is the position where we read the 'static' keyword.
7689   SourceLocation StaticLoc;
7690   TryConsumeToken(tok::kw_static, StaticLoc);
7691 
7692   // If there is a type-qualifier-list, read it now.
7693   // Type qualifiers in an array subscript are a C99 feature.
7694   DeclSpec DS(AttrFactory);
7695   ParseTypeQualifierListOpt(DS, AR_CXX11AttributesParsed);
7696 
7697   // If we haven't already read 'static', check to see if there is one after the
7698   // type-qualifier-list.
7699   if (!StaticLoc.isValid())
7700     TryConsumeToken(tok::kw_static, StaticLoc);
7701 
7702   // Handle "direct-declarator [ type-qual-list[opt] * ]".
7703   bool isStar = false;
7704   ExprResult NumElements;
7705 
7706   // Handle the case where we have '[*]' as the array size.  However, a leading
7707   // star could be the start of an expression, for example 'X[*p + 4]'.  Verify
7708   // the token after the star is a ']'.  Since stars in arrays are
7709   // infrequent, use of lookahead is not costly here.
7710   if (Tok.is(tok::star) && GetLookAheadToken(1).is(tok::r_square)) {
7711     ConsumeToken();  // Eat the '*'.
7712 
7713     if (StaticLoc.isValid()) {
7714       Diag(StaticLoc, diag::err_unspecified_vla_size_with_static);
7715       StaticLoc = SourceLocation();  // Drop the static.
7716     }
7717     isStar = true;
7718   } else if (Tok.isNot(tok::r_square)) {
7719     // Note, in C89, this production uses the constant-expr production instead
7720     // of assignment-expr.  The only difference is that assignment-expr allows
7721     // things like '=' and '*='.  Sema rejects these in C89 mode because they
7722     // are not i-c-e's, so we don't need to distinguish between the two here.
7723 
7724     // Parse the constant-expression or assignment-expression now (depending
7725     // on dialect).
7726     if (getLangOpts().CPlusPlus) {
7727       NumElements = ParseArrayBoundExpression();
7728     } else {
7729       EnterExpressionEvaluationContext Unevaluated(
7730           Actions, Sema::ExpressionEvaluationContext::ConstantEvaluated);
7731       NumElements =
7732           Actions.CorrectDelayedTyposInExpr(ParseAssignmentExpression());
7733     }
7734   } else {
7735     if (StaticLoc.isValid()) {
7736       Diag(StaticLoc, diag::err_unspecified_size_with_static);
7737       StaticLoc = SourceLocation();  // Drop the static.
7738     }
7739   }
7740 
7741   // If there was an error parsing the assignment-expression, recover.
7742   if (NumElements.isInvalid()) {
7743     D.setInvalidType(true);
7744     // If the expression was invalid, skip it.
7745     SkipUntil(tok::r_square, StopAtSemi);
7746     return;
7747   }
7748 
7749   T.consumeClose();
7750 
7751   MaybeParseCXX11Attributes(DS.getAttributes());
7752 
7753   // Remember that we parsed a array type, and remember its features.
7754   D.AddTypeInfo(
7755       DeclaratorChunk::getArray(DS.getTypeQualifiers(), StaticLoc.isValid(),
7756                                 isStar, NumElements.get(), T.getOpenLocation(),
7757                                 T.getCloseLocation()),
7758       std::move(DS.getAttributes()), T.getCloseLocation());
7759 }
7760 
7761 /// Diagnose brackets before an identifier.
7762 void Parser::ParseMisplacedBracketDeclarator(Declarator &D) {
7763   assert(Tok.is(tok::l_square) && "Missing opening bracket");
7764   assert(!D.mayOmitIdentifier() && "Declarator cannot omit identifier");
7765 
7766   SourceLocation StartBracketLoc = Tok.getLocation();
7767   Declarator TempDeclarator(D.getDeclSpec(), ParsedAttributesView::none(),
7768                             D.getContext());
7769 
7770   while (Tok.is(tok::l_square)) {
7771     ParseBracketDeclarator(TempDeclarator);
7772   }
7773 
7774   // Stuff the location of the start of the brackets into the Declarator.
7775   // The diagnostics from ParseDirectDeclarator will make more sense if
7776   // they use this location instead.
7777   if (Tok.is(tok::semi))
7778     D.getName().EndLocation = StartBracketLoc;
7779 
7780   SourceLocation SuggestParenLoc = Tok.getLocation();
7781 
7782   // Now that the brackets are removed, try parsing the declarator again.
7783   ParseDeclaratorInternal(D, &Parser::ParseDirectDeclarator);
7784 
7785   // Something went wrong parsing the brackets, in which case,
7786   // ParseBracketDeclarator has emitted an error, and we don't need to emit
7787   // one here.
7788   if (TempDeclarator.getNumTypeObjects() == 0)
7789     return;
7790 
7791   // Determine if parens will need to be suggested in the diagnostic.
7792   bool NeedParens = false;
7793   if (D.getNumTypeObjects() != 0) {
7794     switch (D.getTypeObject(D.getNumTypeObjects() - 1).Kind) {
7795     case DeclaratorChunk::Pointer:
7796     case DeclaratorChunk::Reference:
7797     case DeclaratorChunk::BlockPointer:
7798     case DeclaratorChunk::MemberPointer:
7799     case DeclaratorChunk::Pipe:
7800       NeedParens = true;
7801       break;
7802     case DeclaratorChunk::Array:
7803     case DeclaratorChunk::Function:
7804     case DeclaratorChunk::Paren:
7805       break;
7806     }
7807   }
7808 
7809   if (NeedParens) {
7810     // Create a DeclaratorChunk for the inserted parens.
7811     SourceLocation EndLoc = PP.getLocForEndOfToken(D.getEndLoc());
7812     D.AddTypeInfo(DeclaratorChunk::getParen(SuggestParenLoc, EndLoc),
7813                   SourceLocation());
7814   }
7815 
7816   // Adding back the bracket info to the end of the Declarator.
7817   for (unsigned i = 0, e = TempDeclarator.getNumTypeObjects(); i < e; ++i) {
7818     const DeclaratorChunk &Chunk = TempDeclarator.getTypeObject(i);
7819     D.AddTypeInfo(Chunk, SourceLocation());
7820   }
7821 
7822   // The missing identifier would have been diagnosed in ParseDirectDeclarator.
7823   // If parentheses are required, always suggest them.
7824   if (!D.getIdentifier() && !NeedParens)
7825     return;
7826 
7827   SourceLocation EndBracketLoc = TempDeclarator.getEndLoc();
7828 
7829   // Generate the move bracket error message.
7830   SourceRange BracketRange(StartBracketLoc, EndBracketLoc);
7831   SourceLocation EndLoc = PP.getLocForEndOfToken(D.getEndLoc());
7832 
7833   if (NeedParens) {
7834     Diag(EndLoc, diag::err_brackets_go_after_unqualified_id)
7835         << getLangOpts().CPlusPlus
7836         << FixItHint::CreateInsertion(SuggestParenLoc, "(")
7837         << FixItHint::CreateInsertion(EndLoc, ")")
7838         << FixItHint::CreateInsertionFromRange(
7839                EndLoc, CharSourceRange(BracketRange, true))
7840         << FixItHint::CreateRemoval(BracketRange);
7841   } else {
7842     Diag(EndLoc, diag::err_brackets_go_after_unqualified_id)
7843         << getLangOpts().CPlusPlus
7844         << FixItHint::CreateInsertionFromRange(
7845                EndLoc, CharSourceRange(BracketRange, true))
7846         << FixItHint::CreateRemoval(BracketRange);
7847   }
7848 }
7849 
7850 /// [GNU]   typeof-specifier:
7851 ///           typeof ( expressions )
7852 ///           typeof ( type-name )
7853 /// [GNU/C++] typeof unary-expression
7854 /// [C23]   typeof-specifier:
7855 ///           typeof '(' typeof-specifier-argument ')'
7856 ///           typeof_unqual '(' typeof-specifier-argument ')'
7857 ///
7858 ///         typeof-specifier-argument:
7859 ///           expression
7860 ///           type-name
7861 ///
7862 void Parser::ParseTypeofSpecifier(DeclSpec &DS) {
7863   assert(Tok.isOneOf(tok::kw_typeof, tok::kw_typeof_unqual) &&
7864          "Not a typeof specifier");
7865 
7866   bool IsUnqual = Tok.is(tok::kw_typeof_unqual);
7867   const IdentifierInfo *II = Tok.getIdentifierInfo();
7868   if (getLangOpts().C23 && !II->getName().starts_with("__"))
7869     Diag(Tok.getLocation(), diag::warn_c23_compat_keyword) << Tok.getName();
7870 
7871   Token OpTok = Tok;
7872   SourceLocation StartLoc = ConsumeToken();
7873   bool HasParens = Tok.is(tok::l_paren);
7874 
7875   EnterExpressionEvaluationContext Unevaluated(
7876       Actions, Sema::ExpressionEvaluationContext::Unevaluated,
7877       Sema::ReuseLambdaContextDecl);
7878 
7879   bool isCastExpr;
7880   ParsedType CastTy;
7881   SourceRange CastRange;
7882   ExprResult Operand = Actions.CorrectDelayedTyposInExpr(
7883       ParseExprAfterUnaryExprOrTypeTrait(OpTok, isCastExpr, CastTy, CastRange));
7884   if (HasParens)
7885     DS.setTypeArgumentRange(CastRange);
7886 
7887   if (CastRange.getEnd().isInvalid())
7888     // FIXME: Not accurate, the range gets one token more than it should.
7889     DS.SetRangeEnd(Tok.getLocation());
7890   else
7891     DS.SetRangeEnd(CastRange.getEnd());
7892 
7893   if (isCastExpr) {
7894     if (!CastTy) {
7895       DS.SetTypeSpecError();
7896       return;
7897     }
7898 
7899     const char *PrevSpec = nullptr;
7900     unsigned DiagID;
7901     // Check for duplicate type specifiers (e.g. "int typeof(int)").
7902     if (DS.SetTypeSpecType(IsUnqual ? DeclSpec::TST_typeof_unqualType
7903                                     : DeclSpec::TST_typeofType,
7904                            StartLoc, PrevSpec,
7905                            DiagID, CastTy,
7906                            Actions.getASTContext().getPrintingPolicy()))
7907       Diag(StartLoc, DiagID) << PrevSpec;
7908     return;
7909   }
7910 
7911   // If we get here, the operand to the typeof was an expression.
7912   if (Operand.isInvalid()) {
7913     DS.SetTypeSpecError();
7914     return;
7915   }
7916 
7917   // We might need to transform the operand if it is potentially evaluated.
7918   Operand = Actions.HandleExprEvaluationContextForTypeof(Operand.get());
7919   if (Operand.isInvalid()) {
7920     DS.SetTypeSpecError();
7921     return;
7922   }
7923 
7924   const char *PrevSpec = nullptr;
7925   unsigned DiagID;
7926   // Check for duplicate type specifiers (e.g. "int typeof(int)").
7927   if (DS.SetTypeSpecType(IsUnqual ? DeclSpec::TST_typeof_unqualExpr
7928                                   : DeclSpec::TST_typeofExpr,
7929                          StartLoc, PrevSpec,
7930                          DiagID, Operand.get(),
7931                          Actions.getASTContext().getPrintingPolicy()))
7932     Diag(StartLoc, DiagID) << PrevSpec;
7933 }
7934 
7935 /// [C11]   atomic-specifier:
7936 ///           _Atomic ( type-name )
7937 ///
7938 void Parser::ParseAtomicSpecifier(DeclSpec &DS) {
7939   assert(Tok.is(tok::kw__Atomic) && NextToken().is(tok::l_paren) &&
7940          "Not an atomic specifier");
7941 
7942   SourceLocation StartLoc = ConsumeToken();
7943   BalancedDelimiterTracker T(*this, tok::l_paren);
7944   if (T.consumeOpen())
7945     return;
7946 
7947   TypeResult Result = ParseTypeName();
7948   if (Result.isInvalid()) {
7949     SkipUntil(tok::r_paren, StopAtSemi);
7950     return;
7951   }
7952 
7953   // Match the ')'
7954   T.consumeClose();
7955 
7956   if (T.getCloseLocation().isInvalid())
7957     return;
7958 
7959   DS.setTypeArgumentRange(T.getRange());
7960   DS.SetRangeEnd(T.getCloseLocation());
7961 
7962   const char *PrevSpec = nullptr;
7963   unsigned DiagID;
7964   if (DS.SetTypeSpecType(DeclSpec::TST_atomic, StartLoc, PrevSpec,
7965                          DiagID, Result.get(),
7966                          Actions.getASTContext().getPrintingPolicy()))
7967     Diag(StartLoc, DiagID) << PrevSpec;
7968 }
7969 
7970 /// TryAltiVecVectorTokenOutOfLine - Out of line body that should only be called
7971 /// from TryAltiVecVectorToken.
7972 bool Parser::TryAltiVecVectorTokenOutOfLine() {
7973   Token Next = NextToken();
7974   switch (Next.getKind()) {
7975   default: return false;
7976   case tok::kw_short:
7977   case tok::kw_long:
7978   case tok::kw_signed:
7979   case tok::kw_unsigned:
7980   case tok::kw_void:
7981   case tok::kw_char:
7982   case tok::kw_int:
7983   case tok::kw_float:
7984   case tok::kw_double:
7985   case tok::kw_bool:
7986   case tok::kw__Bool:
7987   case tok::kw___bool:
7988   case tok::kw___pixel:
7989     Tok.setKind(tok::kw___vector);
7990     return true;
7991   case tok::identifier:
7992     if (Next.getIdentifierInfo() == Ident_pixel) {
7993       Tok.setKind(tok::kw___vector);
7994       return true;
7995     }
7996     if (Next.getIdentifierInfo() == Ident_bool ||
7997         Next.getIdentifierInfo() == Ident_Bool) {
7998       Tok.setKind(tok::kw___vector);
7999       return true;
8000     }
8001     return false;
8002   }
8003 }
8004 
8005 bool Parser::TryAltiVecTokenOutOfLine(DeclSpec &DS, SourceLocation Loc,
8006                                       const char *&PrevSpec, unsigned &DiagID,
8007                                       bool &isInvalid) {
8008   const PrintingPolicy &Policy = Actions.getASTContext().getPrintingPolicy();
8009   if (Tok.getIdentifierInfo() == Ident_vector) {
8010     Token Next = NextToken();
8011     switch (Next.getKind()) {
8012     case tok::kw_short:
8013     case tok::kw_long:
8014     case tok::kw_signed:
8015     case tok::kw_unsigned:
8016     case tok::kw_void:
8017     case tok::kw_char:
8018     case tok::kw_int:
8019     case tok::kw_float:
8020     case tok::kw_double:
8021     case tok::kw_bool:
8022     case tok::kw__Bool:
8023     case tok::kw___bool:
8024     case tok::kw___pixel:
8025       isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID, Policy);
8026       return true;
8027     case tok::identifier:
8028       if (Next.getIdentifierInfo() == Ident_pixel) {
8029         isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID,Policy);
8030         return true;
8031       }
8032       if (Next.getIdentifierInfo() == Ident_bool ||
8033           Next.getIdentifierInfo() == Ident_Bool) {
8034         isInvalid =
8035             DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID, Policy);
8036         return true;
8037       }
8038       break;
8039     default:
8040       break;
8041     }
8042   } else if ((Tok.getIdentifierInfo() == Ident_pixel) &&
8043              DS.isTypeAltiVecVector()) {
8044     isInvalid = DS.SetTypeAltiVecPixel(true, Loc, PrevSpec, DiagID, Policy);
8045     return true;
8046   } else if ((Tok.getIdentifierInfo() == Ident_bool) &&
8047              DS.isTypeAltiVecVector()) {
8048     isInvalid = DS.SetTypeAltiVecBool(true, Loc, PrevSpec, DiagID, Policy);
8049     return true;
8050   }
8051   return false;
8052 }
8053 
8054 TypeResult Parser::ParseTypeFromString(StringRef TypeStr, StringRef Context,
8055                                        SourceLocation IncludeLoc) {
8056   // Consume (unexpanded) tokens up to the end-of-directive.
8057   SmallVector<Token, 4> Tokens;
8058   {
8059     // Create a new buffer from which we will parse the type.
8060     auto &SourceMgr = PP.getSourceManager();
8061     FileID FID = SourceMgr.createFileID(
8062         llvm::MemoryBuffer::getMemBufferCopy(TypeStr, Context), SrcMgr::C_User,
8063         0, 0, IncludeLoc);
8064 
8065     // Form a new lexer that references the buffer.
8066     Lexer L(FID, SourceMgr.getBufferOrFake(FID), PP);
8067     L.setParsingPreprocessorDirective(true);
8068 
8069     // Lex the tokens from that buffer.
8070     Token Tok;
8071     do {
8072       L.Lex(Tok);
8073       Tokens.push_back(Tok);
8074     } while (Tok.isNot(tok::eod));
8075   }
8076 
8077   // Replace the "eod" token with an "eof" token identifying the end of
8078   // the provided string.
8079   Token &EndToken = Tokens.back();
8080   EndToken.startToken();
8081   EndToken.setKind(tok::eof);
8082   EndToken.setLocation(Tok.getLocation());
8083   EndToken.setEofData(TypeStr.data());
8084 
8085   // Add the current token back.
8086   Tokens.push_back(Tok);
8087 
8088   // Enter the tokens into the token stream.
8089   PP.EnterTokenStream(Tokens, /*DisableMacroExpansion=*/false,
8090                       /*IsReinject=*/false);
8091 
8092   // Consume the current token so that we'll start parsing the tokens we
8093   // added to the stream.
8094   ConsumeAnyToken();
8095 
8096   // Enter a new scope.
8097   ParseScope LocalScope(this, 0);
8098 
8099   // Parse the type.
8100   TypeResult Result = ParseTypeName(nullptr);
8101 
8102   // Check if we parsed the whole thing.
8103   if (Result.isUsable() &&
8104       (Tok.isNot(tok::eof) || Tok.getEofData() != TypeStr.data())) {
8105     Diag(Tok.getLocation(), diag::err_type_unparsed);
8106   }
8107 
8108   // There could be leftover tokens (e.g. because of an error).
8109   // Skip through until we reach the 'end of directive' token.
8110   while (Tok.isNot(tok::eof))
8111     ConsumeAnyToken();
8112 
8113   // Consume the end token.
8114   if (Tok.is(tok::eof) && Tok.getEofData() == TypeStr.data())
8115     ConsumeAnyToken();
8116   return Result;
8117 }
8118 
8119 void Parser::DiagnoseBitIntUse(const Token &Tok) {
8120   // If the token is for _ExtInt, diagnose it as being deprecated. Otherwise,
8121   // the token is about _BitInt and gets (potentially) diagnosed as use of an
8122   // extension.
8123   assert(Tok.isOneOf(tok::kw__ExtInt, tok::kw__BitInt) &&
8124          "expected either an _ExtInt or _BitInt token!");
8125 
8126   SourceLocation Loc = Tok.getLocation();
8127   if (Tok.is(tok::kw__ExtInt)) {
8128     Diag(Loc, diag::warn_ext_int_deprecated)
8129         << FixItHint::CreateReplacement(Loc, "_BitInt");
8130   } else {
8131     // In C23 mode, diagnose that the use is not compatible with pre-C23 modes.
8132     // Otherwise, diagnose that the use is a Clang extension.
8133     if (getLangOpts().C23)
8134       Diag(Loc, diag::warn_c23_compat_keyword) << Tok.getName();
8135     else
8136       Diag(Loc, diag::ext_bit_int) << getLangOpts().CPlusPlus;
8137   }
8138 }
8139