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