1	//===--- Parser.h - C Language Parser ---------------------------*- 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 defines the Parser interface.
10	//
11	//===----------------------------------------------------------------------===//
12
13	#ifndef LLVM_CLANG_PARSE_PARSER_H
14	#define LLVM_CLANG_PARSE_PARSER_H
15
16	#include "clang/Basic/OpenACCKinds.h"
17	#include "clang/Basic/OperatorPrecedence.h"
18	#include "clang/Lex/CodeCompletionHandler.h"
19	#include "clang/Lex/Preprocessor.h"
20	#include "clang/Sema/Sema.h"
21	#include "clang/Sema/SemaCodeCompletion.h"
22	#include "clang/Sema/SemaObjC.h"
23	#include "clang/Sema/SemaOpenMP.h"
24	#include "llvm/ADT/STLForwardCompat.h"
25	#include "llvm/ADT/SmallVector.h"
26	#include "llvm/Frontend/OpenMP/OMPContext.h"
27	#include "llvm/Support/SaveAndRestore.h"
28	#include <optional>
29	#include <stack>
30
31	namespace clang {
32	class PragmaHandler;
33	class Scope;
34	class BalancedDelimiterTracker;
35	class CorrectionCandidateCallback;
36	class DeclGroupRef;
37	class DiagnosticBuilder;
38	struct LoopHint;
39	class Parser;
40	class ParsingDeclRAIIObject;
41	class ParsingDeclSpec;
42	class ParsingDeclarator;
43	class ParsingFieldDeclarator;
44	class ColonProtectionRAIIObject;
45	class InMessageExpressionRAIIObject;
46	class PoisonSEHIdentifiersRAIIObject;
47	class OMPClause;
48	class OpenACCClause;
49	class ObjCTypeParamList;
50	struct OMPTraitProperty;
51	struct OMPTraitSelector;
52	struct OMPTraitSet;
53	class OMPTraitInfo;
54
55	enum class AnnotatedNameKind {
56	/// Annotation has failed and emitted an error.
57	Error,
58	/// The identifier is a tentatively-declared name.
59	TentativeDecl,
60	/// The identifier is a template name. FIXME: Add an annotation for that.
61	TemplateName,
62	/// The identifier can't be resolved.
63	Unresolved,
64	/// Annotation was successful.
65	Success
66	};
67
68	/// The kind of extra semi diagnostic to emit.
69	enum class ExtraSemiKind {
70	OutsideFunction = 0,
71	InsideStruct = 1,
72	InstanceVariableList = 2,
73	AfterMemberFunctionDefinition = 3
74	};
75
76	/// The kind of template we are parsing.
77	enum class ParsedTemplateKind {
78	/// We are not parsing a template at all.
79	NonTemplate = 0,
80	/// We are parsing a template declaration.
81	Template,
82	/// We are parsing an explicit specialization.
83	ExplicitSpecialization,
84	/// We are parsing an explicit instantiation.
85	ExplicitInstantiation
86	};
87
88	enum class CachedInitKind { DefaultArgument, DefaultInitializer };
89
90	// Definitions for Objective-c context sensitive keywords recognition.
91	enum class ObjCTypeQual {
92	in = 0,
93	out,
94	inout,
95	oneway,
96	bycopy,
97	byref,
98	nonnull,
99	nullable,
100	null_unspecified,
101	NumQuals
102	};
103
104	/// TypeCastState - State whether an expression is or may be a type cast.
105	enum class TypeCastState { NotTypeCast = 0, MaybeTypeCast, IsTypeCast };
106
107	/// Control what ParseCastExpression will parse.
108	enum class CastParseKind { AnyCastExpr = 0, UnaryExprOnly, PrimaryExprOnly };
109
110	/// ParenParseOption - Control what ParseParenExpression will parse.
111	enum class ParenParseOption {
112	SimpleExpr, // Only parse '(' expression ')'
113	FoldExpr, // Also allow fold-expression <anything>
114	CompoundStmt, // Also allow '(' compound-statement ')'
115	CompoundLiteral, // Also allow '(' type-name ')' '{' ... '}'
116	CastExpr // Also allow '(' type-name ')' <anything>
117	};
118
119	/// Describes the behavior that should be taken for an __if_exists
120	/// block.
121	enum class IfExistsBehavior {
122	/// Parse the block; this code is always used.
123	Parse,
124	/// Skip the block entirely; this code is never used.
125	Skip,
126	/// Parse the block as a dependent block, which may be used in
127	/// some template instantiations but not others.
128	Dependent
129	};
130
131	/// Specifies the context in which type-id/expression
132	/// disambiguation will occur.
133	enum class TentativeCXXTypeIdContext {
134	InParens,
135	Unambiguous,
136	AsTemplateArgument,
137	InTrailingReturnType,
138	AsGenericSelectionArgument,
139	};
140
141	/// The kind of attribute specifier we have found.
142	enum class CXX11AttributeKind {
143	/// This is not an attribute specifier.
144	NotAttributeSpecifier,
145	/// This should be treated as an attribute-specifier.
146	AttributeSpecifier,
147	/// The next tokens are '[[', but this is not an attribute-specifier. This
148	/// is ill-formed by C++11 [dcl.attr.grammar]p6.
149	InvalidAttributeSpecifier
150	};
151
152	/// Parser - This implements a parser for the C family of languages. After
153	/// parsing units of the grammar, productions are invoked to handle whatever has
154	/// been read.
155	///
156	/// \nosubgrouping
157	class Parser : public CodeCompletionHandler {
158	// Table of Contents
159	// -----------------
160	// 1. Parsing (Parser.cpp)
161	// 2. C++ Class Inline Methods (ParseCXXInlineMethods.cpp)
162	// 3. Declarations (ParseDecl.cpp)
163	// 4. C++ Declarations (ParseDeclCXX.cpp)
164	// 5. Expressions (ParseExpr.cpp)
165	// 6. C++ Expressions (ParseExprCXX.cpp)
166	// 7. HLSL Constructs (ParseHLSL.cpp)
167	// 8. Initializers (ParseInit.cpp)
168	// 9. Objective-C Constructs (ParseObjc.cpp)
169	// 10. OpenACC Constructs (ParseOpenACC.cpp)
170	// 11. OpenMP Constructs (ParseOpenMP.cpp)
171	// 12. Pragmas (ParsePragma.cpp)
172	// 13. Statements (ParseStmt.cpp)
173	// 14. `inline asm` Statement (ParseStmtAsm.cpp)
174	// 15. C++ Templates (ParseTemplate.cpp)
175	// 16. Tentative Parsing (ParseTentative.cpp)
176
177	/// \name Parsing
178	/// Implementations are in Parser.cpp
179	///@{
180
181	public:
182	friend class ColonProtectionRAIIObject;
183	friend class PoisonSEHIdentifiersRAIIObject;
184	friend class ParenBraceBracketBalancer;
185	friend class BalancedDelimiterTracker;
186
187	Parser(Preprocessor &PP, Sema &Actions, bool SkipFunctionBodies);
188	~Parser() override;
189
190	const LangOptions &getLangOpts() const { return PP.getLangOpts(); }
191	const TargetInfo &getTargetInfo() const { return PP.getTargetInfo(); }
192	Preprocessor &getPreprocessor() const { return PP; }
193	Sema &getActions() const { return Actions; }
194	AttributeFactory &getAttrFactory() { return AttrFactory; }
195
196	const Token &getCurToken() const { return Tok; }
197	Scope *getCurScope() const { return Actions.getCurScope(); }
198
199	void incrementMSManglingNumber() const {
200	return Actions.incrementMSManglingNumber();
201	}
202
203	// Type forwarding. All of these are statically 'void*', but they may all be
204	// different actual classes based on the actions in place.
205	typedef OpaquePtr<DeclGroupRef> DeclGroupPtrTy;
206	typedef OpaquePtr<TemplateName> TemplateTy;
207
208	/// Initialize - Warm up the parser.
209	///
210	void Initialize();
211
212	/// Parse the first top-level declaration in a translation unit.
213	///
214	/// \verbatim
215	/// translation-unit:
216	/// [C] external-declaration
217	/// [C] translation-unit external-declaration
218	/// [C++] top-level-declaration-seq[opt]
219	/// [C++20] global-module-fragment[opt] module-declaration
220	/// top-level-declaration-seq[opt] private-module-fragment[opt]
221	/// \endverbatim
222	///
223	/// Note that in C, it is an error if there is no first declaration.
224	bool ParseFirstTopLevelDecl(DeclGroupPtrTy &Result,
225	Sema::ModuleImportState &ImportState);
226
227	/// ParseTopLevelDecl - Parse one top-level declaration, return whatever the
228	/// action tells us to. This returns true if the EOF was encountered.
229	///
230	/// \verbatim
231	/// top-level-declaration:
232	/// declaration
233	/// [C++20] module-import-declaration
234	/// \endverbatim
235	bool ParseTopLevelDecl(DeclGroupPtrTy &Result,
236	Sema::ModuleImportState &ImportState);
237	bool ParseTopLevelDecl() {
238	DeclGroupPtrTy Result;
239	Sema::ModuleImportState IS = Sema::ModuleImportState::NotACXX20Module;
240	return ParseTopLevelDecl(Result, ImportState&: IS);
241	}
242
243	/// ConsumeToken - Consume the current 'peek token' and lex the next one.
244	/// This does not work with special tokens: string literals, code completion,
245	/// annotation tokens and balanced tokens must be handled using the specific
246	/// consume methods.
247	/// Returns the location of the consumed token.
248	SourceLocation ConsumeToken() {
249	assert(!isTokenSpecial() &&
250	"Should consume special tokens with Consume*Token");
251	PrevTokLocation = Tok.getLocation();
252	PP.Lex(Result&: Tok);
253	return PrevTokLocation;
254	}
255
256	bool TryConsumeToken(tok::TokenKind Expected) {
257	if (Tok.isNot(K: Expected))
258	return false;
259	assert(!isTokenSpecial() &&
260	"Should consume special tokens with Consume*Token");
261	PrevTokLocation = Tok.getLocation();
262	PP.Lex(Result&: Tok);
263	return true;
264	}
265
266	bool TryConsumeToken(tok::TokenKind Expected, SourceLocation &Loc) {
267	if (!TryConsumeToken(Expected))
268	return false;
269	Loc = PrevTokLocation;
270	return true;
271	}
272
273	/// ConsumeAnyToken - Dispatch to the right Consume* method based on the
274	/// current token type. This should only be used in cases where the type of
275	/// the token really isn't known, e.g. in error recovery.
276	SourceLocation ConsumeAnyToken(bool ConsumeCodeCompletionTok = false) {
277	if (isTokenParen())
278	return ConsumeParen();
279	if (isTokenBracket())
280	return ConsumeBracket();
281	if (isTokenBrace())
282	return ConsumeBrace();
283	if (isTokenStringLiteral())
284	return ConsumeStringToken();
285	if (Tok.is(K: tok::code_completion))
286	return ConsumeCodeCompletionTok ? ConsumeCodeCompletionToken()
287	: handleUnexpectedCodeCompletionToken();
288	if (Tok.isAnnotation())
289	return ConsumeAnnotationToken();
290	return ConsumeToken();
291	}
292
293	SourceLocation getEndOfPreviousToken() const;
294
295	/// GetLookAheadToken - This peeks ahead N tokens and returns that token
296	/// without consuming any tokens. LookAhead(0) returns 'Tok', LookAhead(1)
297	/// returns the token after Tok, etc.
298	///
299	/// Note that this differs from the Preprocessor's LookAhead method, because
300	/// the Parser always has one token lexed that the preprocessor doesn't.
301	///
302	const Token &GetLookAheadToken(unsigned N) {
303	if (N == 0 || Tok.is(K: tok::eof))
304	return Tok;
305	return PP.LookAhead(N: N - 1);
306	}
307
308	/// NextToken - This peeks ahead one token and returns it without
309	/// consuming it.
310	const Token &NextToken() { return PP.LookAhead(N: 0); }
311
312	/// getTypeAnnotation - Read a parsed type out of an annotation token.
313	static TypeResult getTypeAnnotation(const Token &Tok) {
314	if (!Tok.getAnnotationValue())
315	return TypeError();
316	return ParsedType::getFromOpaquePtr(P: Tok.getAnnotationValue());
317	}
318
319	/// TryAnnotateTypeOrScopeToken - If the current token position is on a
320	/// typename (possibly qualified in C++) or a C++ scope specifier not followed
321	/// by a typename, TryAnnotateTypeOrScopeToken will replace one or more tokens
322	/// with a single annotation token representing the typename or C++ scope
323	/// respectively.
324	/// This simplifies handling of C++ scope specifiers and allows efficient
325	/// backtracking without the need to re-parse and resolve nested-names and
326	/// typenames.
327	/// It will mainly be called when we expect to treat identifiers as typenames
328	/// (if they are typenames). For example, in C we do not expect identifiers
329	/// inside expressions to be treated as typenames so it will not be called
330	/// for expressions in C.
331	/// The benefit for C/ObjC is that a typename will be annotated and
332	/// Actions.getTypeName will not be needed to be called again (e.g.
333	/// getTypeName will not be called twice, once to check whether we have a
334	/// declaration specifier, and another one to get the actual type inside
335	/// ParseDeclarationSpecifiers).
336	///
337	/// This returns true if an error occurred.
338	///
339	/// Note that this routine emits an error if you call it with ::new or
340	/// ::delete as the current tokens, so only call it in contexts where these
341	/// are invalid.
342	bool
343	TryAnnotateTypeOrScopeToken(ImplicitTypenameContext AllowImplicitTypename =
344	ImplicitTypenameContext::No);
345
346	/// Try to annotate a type or scope token, having already parsed an
347	/// optional scope specifier. \p IsNewScope should be \c true unless the scope
348	/// specifier was extracted from an existing tok::annot_cxxscope annotation.
349	bool TryAnnotateTypeOrScopeTokenAfterScopeSpec(
350	CXXScopeSpec &SS, bool IsNewScope,
351	ImplicitTypenameContext AllowImplicitTypename);
352
353	/// TryAnnotateScopeToken - Like TryAnnotateTypeOrScopeToken but only
354	/// annotates C++ scope specifiers and template-ids. This returns
355	/// true if there was an error that could not be recovered from.
356	///
357	/// Note that this routine emits an error if you call it with ::new or
358	/// ::delete as the current tokens, so only call it in contexts where these
359	/// are invalid.
360	bool TryAnnotateCXXScopeToken(bool EnteringContext = false);
361
362	bool MightBeCXXScopeToken() {
363	return getLangOpts().CPlusPlus &&
364	(Tok.is(K: tok::identifier) || Tok.is(K: tok::coloncolon) ||
365	(Tok.is(K: tok::annot_template_id) &&
366	NextToken().is(K: tok::coloncolon)) ||
367	Tok.is(K: tok::kw_decltype) || Tok.is(K: tok::kw___super));
368	}
369	bool TryAnnotateOptionalCXXScopeToken(bool EnteringContext = false) {
370	return MightBeCXXScopeToken() && TryAnnotateCXXScopeToken(EnteringContext);
371	}
372
373	//===--------------------------------------------------------------------===//
374	// Scope manipulation
375
376	/// ParseScope - Introduces a new scope for parsing. The kind of
377	/// scope is determined by ScopeFlags. Objects of this type should
378	/// be created on the stack to coincide with the position where the
379	/// parser enters the new scope, and this object's constructor will
380	/// create that new scope. Similarly, once the object is destroyed
381	/// the parser will exit the scope.
382	class ParseScope {
383	Parser *Self;
384	ParseScope(const ParseScope &) = delete;
385	void operator=(const ParseScope &) = delete;
386
387	public:
388	// ParseScope - Construct a new object to manage a scope in the
389	// parser Self where the new Scope is created with the flags
390	// ScopeFlags, but only when we aren't about to enter a compound statement.
391	ParseScope(Parser *Self, unsigned ScopeFlags, bool EnteredScope = true,
392	bool BeforeCompoundStmt = false)
393	: Self(Self) {
394	if (EnteredScope && !BeforeCompoundStmt)
395	Self->EnterScope(ScopeFlags);
396	else {
397	if (BeforeCompoundStmt)
398	Self->incrementMSManglingNumber();
399
400	this->Self = nullptr;
401	}
402	}
403
404	// Exit - Exit the scope associated with this object now, rather
405	// than waiting until the object is destroyed.
406	void Exit() {
407	if (Self) {
408	Self->ExitScope();
409	Self = nullptr;
410	}
411	}
412
413	~ParseScope() { Exit(); }
414	};
415
416	/// Introduces zero or more scopes for parsing. The scopes will all be exited
417	/// when the object is destroyed.
418	class MultiParseScope {
419	Parser &Self;
420	unsigned NumScopes = 0;
421
422	MultiParseScope(const MultiParseScope &) = delete;
423
424	public:
425	MultiParseScope(Parser &Self) : Self(Self) {}
426	void Enter(unsigned ScopeFlags) {
427	Self.EnterScope(ScopeFlags);
428	++NumScopes;
429	}
430	void Exit() {
431	while (NumScopes) {
432	Self.ExitScope();
433	--NumScopes;
434	}
435	}
436	~MultiParseScope() { Exit(); }
437	};
438
439	/// EnterScope - Start a new scope.
440	void EnterScope(unsigned ScopeFlags);
441
442	/// ExitScope - Pop a scope off the scope stack.
443	void ExitScope();
444
445	//===--------------------------------------------------------------------===//
446	// Diagnostic Emission and Error recovery.
447
448	DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID);
449	DiagnosticBuilder Diag(const Token &Tok, unsigned DiagID);
450	DiagnosticBuilder Diag(unsigned DiagID) { return Diag(Tok, DiagID); }
451
452	DiagnosticBuilder DiagCompat(SourceLocation Loc, unsigned CompatDiagId);
453	DiagnosticBuilder DiagCompat(const Token &Tok, unsigned CompatDiagId);
454	DiagnosticBuilder DiagCompat(unsigned CompatDiagId) {
455	return DiagCompat(Tok, CompatDiagId);
456	}
457
458	/// Control flags for SkipUntil functions.
459	enum SkipUntilFlags {
460	StopAtSemi = 1 << 0, ///< Stop skipping at semicolon
461	/// Stop skipping at specified token, but don't skip the token itself
462	StopBeforeMatch = 1 << 1,
463	StopAtCodeCompletion = 1 << 2 ///< Stop at code completion
464	};
465
466	friend constexpr SkipUntilFlags operator|(SkipUntilFlags L,
467	SkipUntilFlags R) {
468	return static_cast<SkipUntilFlags>(static_cast<unsigned>(L) |
469	static_cast<unsigned>(R));
470	}
471
472	/// SkipUntil - Read tokens until we get to the specified token, then consume
473	/// it (unless StopBeforeMatch is specified). Because we cannot guarantee
474	/// that the token will ever occur, this skips to the next token, or to some
475	/// likely good stopping point. If Flags has StopAtSemi flag, skipping will
476	/// stop at a ';' character. Balances (), [], and {} delimiter tokens while
477	/// skipping.
478	///
479	/// If SkipUntil finds the specified token, it returns true, otherwise it
480	/// returns false.
481	bool SkipUntil(tok::TokenKind T,
482	SkipUntilFlags Flags = static_cast<SkipUntilFlags>(0)) {
483	return SkipUntil(Toks: llvm::ArrayRef(T), Flags);
484	}
485	bool SkipUntil(tok::TokenKind T1, tok::TokenKind T2,
486	SkipUntilFlags Flags = static_cast<SkipUntilFlags>(0)) {
487	tok::TokenKind TokArray[] = {T1, T2};
488	return SkipUntil(Toks: TokArray, Flags);
489	}
490	bool SkipUntil(tok::TokenKind T1, tok::TokenKind T2, tok::TokenKind T3,
491	SkipUntilFlags Flags = static_cast<SkipUntilFlags>(0)) {
492	tok::TokenKind TokArray[] = {T1, T2, T3};
493	return SkipUntil(Toks: TokArray, Flags);
494	}
495
496	/// SkipUntil - Read tokens until we get to the specified token, then consume
497	/// it (unless no flag StopBeforeMatch). Because we cannot guarantee that the
498	/// token will ever occur, this skips to the next token, or to some likely
499	/// good stopping point. If StopAtSemi is true, skipping will stop at a ';'
500	/// character.
501	///
502	/// If SkipUntil finds the specified token, it returns true, otherwise it
503	/// returns false.
504	bool SkipUntil(ArrayRef<tok::TokenKind> Toks,
505	SkipUntilFlags Flags = static_cast<SkipUntilFlags>(0));
506
507	private:
508	Preprocessor &PP;
509
510	/// Tok - The current token we are peeking ahead. All parsing methods assume
511	/// that this is valid.
512	Token Tok;
513
514	// PrevTokLocation - The location of the token we previously
515	// consumed. This token is used for diagnostics where we expected to
516	// see a token following another token (e.g., the ';' at the end of
517	// a statement).
518	SourceLocation PrevTokLocation;
519
520	/// Tracks an expected type for the current token when parsing an expression.
521	/// Used by code completion for ranking.
522	PreferredTypeBuilder PreferredType;
523
524	unsigned short ParenCount = 0, BracketCount = 0, BraceCount = 0;
525	unsigned short MisplacedModuleBeginCount = 0;
526
527	/// Actions - These are the callbacks we invoke as we parse various constructs
528	/// in the file.
529	Sema &Actions;
530
531	DiagnosticsEngine &Diags;
532
533	StackExhaustionHandler StackHandler;
534
535	/// ScopeCache - Cache scopes to reduce malloc traffic.
536	static constexpr int ScopeCacheSize = 16;
537	unsigned NumCachedScopes;
538	Scope *ScopeCache[ScopeCacheSize];
539
540	/// Identifiers used for SEH handling in Borland. These are only
541	/// allowed in particular circumstances
542	// __except block
543	IdentifierInfo *Ident__exception_code, *Ident___exception_code,
544	*Ident_GetExceptionCode;
545	// __except filter expression
546	IdentifierInfo *Ident__exception_info, *Ident___exception_info,
547	*Ident_GetExceptionInfo;
548	// __finally
549	IdentifierInfo *Ident__abnormal_termination, *Ident___abnormal_termination,
550	*Ident_AbnormalTermination;
551
552	/// Contextual keywords for Microsoft extensions.
553	IdentifierInfo *Ident__except;
554
555	// C++2a contextual keywords.
556	mutable IdentifierInfo *Ident_import;
557	mutable IdentifierInfo *Ident_module;
558
559	std::unique_ptr<CommentHandler> CommentSemaHandler;
560
561	/// Gets set to true after calling ProduceSignatureHelp, it is for a
562	/// workaround to make sure ProduceSignatureHelp is only called at the deepest
563	/// function call.
564	bool CalledSignatureHelp = false;
565
566	IdentifierInfo *getSEHExceptKeyword();
567
568	/// Whether to skip parsing of function bodies.
569	///
570	/// This option can be used, for example, to speed up searches for
571	/// declarations/definitions when indexing.
572	bool SkipFunctionBodies;
573
574	//===--------------------------------------------------------------------===//
575	// Low-Level token peeking and consumption methods.
576	//
577
578	/// isTokenParen - Return true if the cur token is '(' or ')'.
579	bool isTokenParen() const { return Tok.isOneOf(K1: tok::l_paren, K2: tok::r_paren); }
580	/// isTokenBracket - Return true if the cur token is '[' or ']'.
581	bool isTokenBracket() const {
582	return Tok.isOneOf(K1: tok::l_square, K2: tok::r_square);
583	}
584	/// isTokenBrace - Return true if the cur token is '{' or '}'.
585	bool isTokenBrace() const { return Tok.isOneOf(K1: tok::l_brace, K2: tok::r_brace); }
586	/// isTokenStringLiteral - True if this token is a string-literal.
587	bool isTokenStringLiteral() const {
588	return tok::isStringLiteral(K: Tok.getKind());
589	}
590	/// isTokenSpecial - True if this token requires special consumption methods.
591	bool isTokenSpecial() const {
592	return isTokenStringLiteral() || isTokenParen() || isTokenBracket() ||
593	isTokenBrace() || Tok.is(K: tok::code_completion) || Tok.isAnnotation();
594	}
595
596	/// Returns true if the current token is '=' or is a type of '='.
597	/// For typos, give a fixit to '='
598	bool isTokenEqualOrEqualTypo();
599
600	/// Return the current token to the token stream and make the given
601	/// token the current token.
602	void UnconsumeToken(Token &Consumed) {
603	Token Next = Tok;
604	PP.EnterToken(Tok: Consumed, /*IsReinject*/ IsReinject: true);
605	PP.Lex(Result&: Tok);
606	PP.EnterToken(Tok: Next, /*IsReinject*/ IsReinject: true);
607	}
608
609	SourceLocation ConsumeAnnotationToken() {
610	assert(Tok.isAnnotation() && "wrong consume method");
611	SourceLocation Loc = Tok.getLocation();
612	PrevTokLocation = Tok.getAnnotationEndLoc();
613	PP.Lex(Result&: Tok);
614	return Loc;
615	}
616
617	/// ConsumeParen - This consume method keeps the paren count up-to-date.
618	///
619	SourceLocation ConsumeParen() {
620	assert(isTokenParen() && "wrong consume method");
621	if (Tok.getKind() == tok::l_paren)
622	++ParenCount;
623	else if (ParenCount) {
624	AngleBrackets.clear(P&: *this);
625	--ParenCount; // Don't let unbalanced )'s drive the count negative.
626	}
627	PrevTokLocation = Tok.getLocation();
628	PP.Lex(Result&: Tok);
629	return PrevTokLocation;
630	}
631
632	/// ConsumeBracket - This consume method keeps the bracket count up-to-date.
633	///
634	SourceLocation ConsumeBracket() {
635	assert(isTokenBracket() && "wrong consume method");
636	if (Tok.getKind() == tok::l_square)
637	++BracketCount;
638	else if (BracketCount) {
639	AngleBrackets.clear(P&: *this);
640	--BracketCount; // Don't let unbalanced ]'s drive the count negative.
641	}
642
643	PrevTokLocation = Tok.getLocation();
644	PP.Lex(Result&: Tok);
645	return PrevTokLocation;
646	}
647
648	/// ConsumeBrace - This consume method keeps the brace count up-to-date.
649	///
650	SourceLocation ConsumeBrace() {
651	assert(isTokenBrace() && "wrong consume method");
652	if (Tok.getKind() == tok::l_brace)
653	++BraceCount;
654	else if (BraceCount) {
655	AngleBrackets.clear(P&: *this);
656	--BraceCount; // Don't let unbalanced }'s drive the count negative.
657	}
658
659	PrevTokLocation = Tok.getLocation();
660	PP.Lex(Result&: Tok);
661	return PrevTokLocation;
662	}
663
664	/// ConsumeStringToken - Consume the current 'peek token', lexing a new one
665	/// and returning the token kind. This method is specific to strings, as it
666	/// handles string literal concatenation, as per C99 5.1.1.2, translation
667	/// phase #6.
668	SourceLocation ConsumeStringToken() {
669	assert(isTokenStringLiteral() &&
670	"Should only consume string literals with this method");
671	PrevTokLocation = Tok.getLocation();
672	PP.Lex(Result&: Tok);
673	return PrevTokLocation;
674	}
675
676	/// Consume the current code-completion token.
677	///
678	/// This routine can be called to consume the code-completion token and
679	/// continue processing in special cases where \c cutOffParsing() isn't
680	/// desired, such as token caching or completion with lookahead.
681	SourceLocation ConsumeCodeCompletionToken() {
682	assert(Tok.is(tok::code_completion));
683	PrevTokLocation = Tok.getLocation();
684	PP.Lex(Result&: Tok);
685	return PrevTokLocation;
686	}
687
688	/// When we are consuming a code-completion token without having matched
689	/// specific position in the grammar, provide code-completion results based
690	/// on context.
691	///
692	/// \returns the source location of the code-completion token.
693	SourceLocation handleUnexpectedCodeCompletionToken();
694
695	/// Abruptly cut off parsing; mainly used when we have reached the
696	/// code-completion point.
697	void cutOffParsing() {
698	if (PP.isCodeCompletionEnabled())
699	PP.setCodeCompletionReached();
700	// Cut off parsing by acting as if we reached the end-of-file.
701	Tok.setKind(tok::eof);
702	}
703
704	/// Determine if we're at the end of the file or at a transition
705	/// between modules.
706	bool isEofOrEom() {
707	tok::TokenKind Kind = Tok.getKind();
708	return Kind == tok::eof || Kind == tok::annot_module_begin ||
709	Kind == tok::annot_module_end || Kind == tok::annot_module_include ||
710	Kind == tok::annot_repl_input_end;
711	}
712
713	static void setTypeAnnotation(Token &Tok, TypeResult T) {
714	assert((T.isInvalid() || T.get()) &&
715	"produced a valid-but-null type annotation?");
716	Tok.setAnnotationValue(T.isInvalid() ? nullptr : T.get().getAsOpaquePtr());
717	}
718
719	static NamedDecl *getNonTypeAnnotation(const Token &Tok) {
720	return static_cast<NamedDecl *>(Tok.getAnnotationValue());
721	}
722
723	static void setNonTypeAnnotation(Token &Tok, NamedDecl *ND) {
724	Tok.setAnnotationValue(ND);
725	}
726
727	static IdentifierInfo *getIdentifierAnnotation(const Token &Tok) {
728	return static_cast<IdentifierInfo *>(Tok.getAnnotationValue());
729	}
730
731	static void setIdentifierAnnotation(Token &Tok, IdentifierInfo *ND) {
732	Tok.setAnnotationValue(ND);
733	}
734
735	/// Read an already-translated primary expression out of an annotation
736	/// token.
737	static ExprResult getExprAnnotation(const Token &Tok) {
738	return ExprResult::getFromOpaquePointer(P: Tok.getAnnotationValue());
739	}
740
741	/// Set the primary expression corresponding to the given annotation
742	/// token.
743	static void setExprAnnotation(Token &Tok, ExprResult ER) {
744	Tok.setAnnotationValue(ER.getAsOpaquePointer());
745	}
746
747	/// Attempt to classify the name at the current token position. This may
748	/// form a type, scope or primary expression annotation, or replace the token
749	/// with a typo-corrected keyword. This is only appropriate when the current
750	/// name must refer to an entity which has already been declared.
751	///
752	/// \param CCC Indicates how to perform typo-correction for this name. If
753	/// NULL, no typo correction will be performed.
754	/// \param AllowImplicitTypename Whether we are in a context where a dependent
755	/// nested-name-specifier without typename is treated as a type (e.g.
756	/// T::type).
757	AnnotatedNameKind
758	TryAnnotateName(CorrectionCandidateCallback *CCC = nullptr,
759	ImplicitTypenameContext AllowImplicitTypename =
760	ImplicitTypenameContext::No);
761
762	/// Push a tok::annot_cxxscope token onto the token stream.
763	void AnnotateScopeToken(CXXScopeSpec &SS, bool IsNewAnnotation);
764
765	/// TryKeywordIdentFallback - For compatibility with system headers using
766	/// keywords as identifiers, attempt to convert the current token to an
767	/// identifier and optionally disable the keyword for the remainder of the
768	/// translation unit. This returns false if the token was not replaced,
769	/// otherwise emits a diagnostic and returns true.
770	bool TryKeywordIdentFallback(bool DisableKeyword);
771
772	/// Get the TemplateIdAnnotation from the token and put it in the
773	/// cleanup pool so that it gets destroyed when parsing the current top level
774	/// declaration is finished.
775	TemplateIdAnnotation *takeTemplateIdAnnotation(const Token &tok);
776
777	/// ExpectAndConsume - The parser expects that 'ExpectedTok' is next in the
778	/// input. If so, it is consumed and false is returned.
779	///
780	/// If a trivial punctuator misspelling is encountered, a FixIt error
781	/// diagnostic is issued and false is returned after recovery.
782	///
783	/// If the input is malformed, this emits the specified diagnostic and true is
784	/// returned.
785	bool ExpectAndConsume(tok::TokenKind ExpectedTok,
786	unsigned Diag = diag::err_expected,
787	StringRef DiagMsg = "");
788
789	/// The parser expects a semicolon and, if present, will consume it.
790	///
791	/// If the next token is not a semicolon, this emits the specified diagnostic,
792	/// or, if there's just some closing-delimiter noise (e.g., ')' or ']') prior
793	/// to the semicolon, consumes that extra token.
794	bool ExpectAndConsumeSemi(unsigned DiagID, StringRef TokenUsed = "");
795
796	/// Consume any extra semi-colons until the end of the line.
797	void ConsumeExtraSemi(ExtraSemiKind Kind, DeclSpec::TST T = TST_unspecified);
798
799	/// Return false if the next token is an identifier. An 'expected identifier'
800	/// error is emitted otherwise.
801	///
802	/// The parser tries to recover from the error by checking if the next token
803	/// is a C++ keyword when parsing Objective-C++. Return false if the recovery
804	/// was successful.
805	bool expectIdentifier();
806
807	/// Kinds of compound pseudo-tokens formed by a sequence of two real tokens.
808	enum class CompoundToken {
809	/// A '(' '{' beginning a statement-expression.
810	StmtExprBegin,
811	/// A '}' ')' ending a statement-expression.
812	StmtExprEnd,
813	/// A '[' '[' beginning a C++11 or C23 attribute.
814	AttrBegin,
815	/// A ']' ']' ending a C++11 or C23 attribute.
816	AttrEnd,
817	/// A '::' '*' forming a C++ pointer-to-member declaration.
818	MemberPtr,
819	};
820
821	/// Check that a compound operator was written in a "sensible" way, and warn
822	/// if not.
823	void checkCompoundToken(SourceLocation FirstTokLoc,
824	tok::TokenKind FirstTokKind, CompoundToken Op);
825
826	void diagnoseUseOfC11Keyword(const Token &Tok);
827
828	/// RAII object used to modify the scope flags for the current scope.
829	class ParseScopeFlags {
830	Scope *CurScope;
831	unsigned OldFlags = 0;
832	ParseScopeFlags(const ParseScopeFlags &) = delete;
833	void operator=(const ParseScopeFlags &) = delete;
834
835	public:
836	/// Set the flags for the current scope to ScopeFlags. If ManageFlags is
837	/// false, this object does nothing.
838	ParseScopeFlags(Parser *Self, unsigned ScopeFlags, bool ManageFlags = true);
839
840	/// Restore the flags for the current scope to what they were before this
841	/// object overrode them.
842	~ParseScopeFlags();
843	};
844
845	/// Emits a diagnostic suggesting parentheses surrounding a
846	/// given range.
847	///
848	/// \param Loc The location where we'll emit the diagnostic.
849	/// \param DK The kind of diagnostic to emit.
850	/// \param ParenRange Source range enclosing code that should be
851	/// parenthesized.
852	void SuggestParentheses(SourceLocation Loc, unsigned DK,
853	SourceRange ParenRange);
854
855	//===--------------------------------------------------------------------===//
856	// C99 6.9: External Definitions.
857
858	/// ParseExternalDeclaration:
859	///
860	/// The `Attrs` that are passed in are C++11 attributes and appertain to the
861	/// declaration.
862	///
863	/// \verbatim
864	/// external-declaration: [C99 6.9], declaration: [C++ dcl.dcl]
865	/// function-definition
866	/// declaration
867	/// [GNU] asm-definition
868	/// [GNU] __extension__ external-declaration
869	/// [OBJC] objc-class-definition
870	/// [OBJC] objc-class-declaration
871	/// [OBJC] objc-alias-declaration
872	/// [OBJC] objc-protocol-definition
873	/// [OBJC] objc-method-definition
874	/// [OBJC] @end
875	/// [C++] linkage-specification
876	/// [GNU] asm-definition:
877	/// simple-asm-expr ';'
878	/// [C++11] empty-declaration
879	/// [C++11] attribute-declaration
880	///
881	/// [C++11] empty-declaration:
882	/// ';'
883	///
884	/// [C++0x/GNU] 'extern' 'template' declaration
885	///
886	/// [C++20] module-import-declaration
887	/// \endverbatim
888	///
889	DeclGroupPtrTy ParseExternalDeclaration(ParsedAttributes &DeclAttrs,
890	ParsedAttributes &DeclSpecAttrs,
891	ParsingDeclSpec *DS = nullptr);
892
893	/// Determine whether the current token, if it occurs after a
894	/// declarator, continues a declaration or declaration list.
895	bool isDeclarationAfterDeclarator();
896
897	/// Determine whether the current token, if it occurs after a
898	/// declarator, indicates the start of a function definition.
899	bool isStartOfFunctionDefinition(const ParsingDeclarator &Declarator);
900
901	DeclGroupPtrTy ParseDeclarationOrFunctionDefinition(
902	ParsedAttributes &DeclAttrs, ParsedAttributes &DeclSpecAttrs,
903	ParsingDeclSpec *DS = nullptr, AccessSpecifier AS = AS_none);
904
905	/// Parse either a function-definition or a declaration. We can't tell which
906	/// we have until we read up to the compound-statement in function-definition.
907	/// TemplateParams, if non-NULL, provides the template parameters when we're
908	/// parsing a C++ template-declaration.
909	///
910	/// \verbatim
911	/// function-definition: [C99 6.9.1]
912	/// decl-specs declarator declaration-list[opt] compound-statement
913	/// [C90] function-definition: [C99 6.7.1] - implicit int result
914	/// [C90] decl-specs[opt] declarator declaration-list[opt] compound-statement
915	///
916	/// declaration: [C99 6.7]
917	/// declaration-specifiers init-declarator-list[opt] ';'
918	/// [!C99] init-declarator-list ';' [TODO: warn in c99 mode]
919	/// [OMP] threadprivate-directive
920	/// [OMP] allocate-directive [TODO]
921	/// \endverbatim
922	///
923	DeclGroupPtrTy ParseDeclOrFunctionDefInternal(ParsedAttributes &Attrs,
924	ParsedAttributes &DeclSpecAttrs,
925	ParsingDeclSpec &DS,
926	AccessSpecifier AS);
927
928	void SkipFunctionBody();
929
930	struct ParsedTemplateInfo;
931	class LateParsedAttrList;
932
933	/// ParseFunctionDefinition - We parsed and verified that the specified
934	/// Declarator is well formed. If this is a K&R-style function, read the
935	/// parameters declaration-list, then start the compound-statement.
936	///
937	/// \verbatim
938	/// function-definition: [C99 6.9.1]
939	/// decl-specs declarator declaration-list[opt] compound-statement
940	/// [C90] function-definition: [C99 6.7.1] - implicit int result
941	/// [C90] decl-specs[opt] declarator declaration-list[opt] compound-statement
942	/// [C++] function-definition: [C++ 8.4]
943	/// decl-specifier-seq[opt] declarator ctor-initializer[opt]
944	/// function-body
945	/// [C++] function-definition: [C++ 8.4]
946	/// decl-specifier-seq[opt] declarator function-try-block
947	/// \endverbatim
948	///
949	Decl *ParseFunctionDefinition(
950	ParsingDeclarator &D,
951	const ParsedTemplateInfo &TemplateInfo = ParsedTemplateInfo(),
952	LateParsedAttrList *LateParsedAttrs = nullptr);
953
954	/// ParseKNRParamDeclarations - Parse 'declaration-list[opt]' which provides
955	/// types for a function with a K&R-style identifier list for arguments.
956	void ParseKNRParamDeclarations(Declarator &D);
957
958	/// ParseSimpleAsm
959	///
960	/// \verbatim
961	/// [GNU] simple-asm-expr:
962	/// 'asm' '(' asm-string-literal ')'
963	/// \endverbatim
964	///
965	/// EndLoc is filled with the location of the last token of the simple-asm.
966	ExprResult ParseSimpleAsm(bool ForAsmLabel, SourceLocation *EndLoc);
967
968	/// ParseAsmStringLiteral - This is just a normal string-literal, but is not
969	/// allowed to be a wide string, and is not subject to character translation.
970	/// Unlike GCC, we also diagnose an empty string literal when parsing for an
971	/// asm label as opposed to an asm statement, because such a construct does
972	/// not behave well.
973	///
974	/// \verbatim
975	/// [GNU] asm-string-literal:
976	/// string-literal
977	/// \endverbatim
978	///
979	ExprResult ParseAsmStringLiteral(bool ForAsmLabel);
980
981	/// Describes the condition of a Microsoft __if_exists or
982	/// __if_not_exists block.
983	struct IfExistsCondition {
984	/// The location of the initial keyword.
985	SourceLocation KeywordLoc;
986	/// Whether this is an __if_exists block (rather than an
987	/// __if_not_exists block).
988	bool IsIfExists;
989
990	/// Nested-name-specifier preceding the name.
991	CXXScopeSpec SS;
992
993	/// The name we're looking for.
994	UnqualifiedId Name;
995
996	/// The behavior of this __if_exists or __if_not_exists block
997	/// should.
998	IfExistsBehavior Behavior;
999	};
1000
1001	bool ParseMicrosoftIfExistsCondition(IfExistsCondition &Result);
1002	void ParseMicrosoftIfExistsExternalDeclaration();
1003
1004	//===--------------------------------------------------------------------===//
1005	// Modules
1006
1007	/// Parse a declaration beginning with the 'module' keyword or C++20
1008	/// context-sensitive keyword (optionally preceded by 'export').
1009	///
1010	/// \verbatim
1011	/// module-declaration: [C++20]
1012	/// 'export'[opt] 'module' module-name attribute-specifier-seq[opt] ';'
1013	///
1014	/// global-module-fragment: [C++2a]
1015	/// 'module' ';' top-level-declaration-seq[opt]
1016	/// module-declaration: [C++2a]
1017	/// 'export'[opt] 'module' module-name module-partition[opt]
1018	/// attribute-specifier-seq[opt] ';'
1019	/// private-module-fragment: [C++2a]
1020	/// 'module' ':' 'private' ';' top-level-declaration-seq[opt]
1021	/// \endverbatim
1022	DeclGroupPtrTy ParseModuleDecl(Sema::ModuleImportState &ImportState);
1023
1024	/// Parse a module import declaration. This is essentially the same for
1025	/// Objective-C and C++20 except for the leading '@' (in ObjC) and the
1026	/// trailing optional attributes (in C++).
1027	///
1028	/// \verbatim
1029	/// [ObjC] @import declaration:
1030	/// '@' 'import' module-name ';'
1031	/// [ModTS] module-import-declaration:
1032	/// 'import' module-name attribute-specifier-seq[opt] ';'
1033	/// [C++20] module-import-declaration:
1034	/// 'export'[opt] 'import' module-name
1035	/// attribute-specifier-seq[opt] ';'
1036	/// 'export'[opt] 'import' module-partition
1037	/// attribute-specifier-seq[opt] ';'
1038	/// 'export'[opt] 'import' header-name
1039	/// attribute-specifier-seq[opt] ';'
1040	/// \endverbatim
1041	Decl *ParseModuleImport(SourceLocation AtLoc,
1042	Sema::ModuleImportState &ImportState);
1043
1044	/// Try recover parser when module annotation appears where it must not
1045	/// be found.
1046	/// \returns false if the recover was successful and parsing may be continued,
1047	/// or true if parser must bail out to top level and handle the token there.
1048	bool parseMisplacedModuleImport();
1049
1050	bool tryParseMisplacedModuleImport() {
1051	tok::TokenKind Kind = Tok.getKind();
1052	if (Kind == tok::annot_module_begin || Kind == tok::annot_module_end ||
1053	Kind == tok::annot_module_include)
1054	return parseMisplacedModuleImport();
1055	return false;
1056	}
1057
1058	/// Parse a C++ / Objective-C module name (both forms use the same
1059	/// grammar).
1060	///
1061	/// \verbatim
1062	/// module-name:
1063	/// module-name-qualifier[opt] identifier
1064	/// module-name-qualifier:
1065	/// module-name-qualifier[opt] identifier '.'
1066	/// \endverbatim
1067	bool ParseModuleName(SourceLocation UseLoc,
1068	SmallVectorImpl<IdentifierLoc> &Path, bool IsImport);
1069
1070	//===--------------------------------------------------------------------===//
1071	// Preprocessor code-completion pass-through
1072	void CodeCompleteDirective(bool InConditional) override;
1073	void CodeCompleteInConditionalExclusion() override;
1074	void CodeCompleteMacroName(bool IsDefinition) override;
1075	void CodeCompletePreprocessorExpression() override;
1076	void CodeCompleteMacroArgument(IdentifierInfo *Macro, MacroInfo *MacroInfo,
1077	unsigned ArgumentIndex) override;
1078	void CodeCompleteIncludedFile(llvm::StringRef Dir, bool IsAngled) override;
1079	void CodeCompleteNaturalLanguage() override;
1080
1081	///@}
1082
1083	//
1084	//
1085	// -------------------------------------------------------------------------
1086	//
1087	//
1088
1089	/// \name C++ Class Inline Methods
1090	/// Implementations are in ParseCXXInlineMethods.cpp
1091	///@{
1092
1093	private:
1094	struct ParsingClass;
1095
1096	/// [class.mem]p1: "... the class is regarded as complete within
1097	/// - function bodies
1098	/// - default arguments
1099	/// - exception-specifications (TODO: C++0x)
1100	/// - and brace-or-equal-initializers for non-static data members
1101	/// (including such things in nested classes)."
1102	/// LateParsedDeclarations build the tree of those elements so they can
1103	/// be parsed after parsing the top-level class.
1104	class LateParsedDeclaration {
1105	public:
1106	virtual ~LateParsedDeclaration();
1107
1108	virtual void ParseLexedMethodDeclarations();
1109	virtual void ParseLexedMemberInitializers();
1110	virtual void ParseLexedMethodDefs();
1111	virtual void ParseLexedAttributes();
1112	virtual void ParseLexedPragmas();
1113	};
1114
1115	/// Inner node of the LateParsedDeclaration tree that parses
1116	/// all its members recursively.
1117	class LateParsedClass : public LateParsedDeclaration {
1118	public:
1119	LateParsedClass(Parser *P, ParsingClass *C);
1120	~LateParsedClass() override;
1121
1122	void ParseLexedMethodDeclarations() override;
1123	void ParseLexedMemberInitializers() override;
1124	void ParseLexedMethodDefs() override;
1125	void ParseLexedAttributes() override;
1126	void ParseLexedPragmas() override;
1127
1128	// Delete copy constructor and copy assignment operator.
1129	LateParsedClass(const LateParsedClass &) = delete;
1130	LateParsedClass &operator=(const LateParsedClass &) = delete;
1131
1132	private:
1133	Parser *Self;
1134	ParsingClass *Class;
1135	};
1136
1137	/// Contains the lexed tokens of an attribute with arguments that
1138	/// may reference member variables and so need to be parsed at the
1139	/// end of the class declaration after parsing all other member
1140	/// member declarations.
1141	/// FIXME: Perhaps we should change the name of LateParsedDeclaration to
1142	/// LateParsedTokens.
1143	struct LateParsedAttribute : public LateParsedDeclaration {
1144	Parser *Self;
1145	CachedTokens Toks;
1146	IdentifierInfo &AttrName;
1147	IdentifierInfo *MacroII = nullptr;
1148	SourceLocation AttrNameLoc;
1149	SmallVector<Decl *, 2> Decls;
1150
1151	explicit LateParsedAttribute(Parser *P, IdentifierInfo &Name,
1152	SourceLocation Loc)
1153	: Self(P), AttrName(Name), AttrNameLoc(Loc) {}
1154
1155	void ParseLexedAttributes() override;
1156
1157	void addDecl(Decl *D) { Decls.push_back(Elt: D); }
1158	};
1159
1160	/// Contains the lexed tokens of a pragma with arguments that
1161	/// may reference member variables and so need to be parsed at the
1162	/// end of the class declaration after parsing all other member
1163	/// member declarations.
1164	class LateParsedPragma : public LateParsedDeclaration {
1165	Parser *Self = nullptr;
1166	AccessSpecifier AS = AS_none;
1167	CachedTokens Toks;
1168
1169	public:
1170	explicit LateParsedPragma(Parser *P, AccessSpecifier AS)
1171	: Self(P), AS(AS) {}
1172
1173	void takeToks(CachedTokens &Cached) { Toks.swap(RHS&: Cached); }
1174	const CachedTokens &toks() const { return Toks; }
1175	AccessSpecifier getAccessSpecifier() const { return AS; }
1176
1177	void ParseLexedPragmas() override;
1178	};
1179
1180	// A list of late-parsed attributes. Used by ParseGNUAttributes.
1181	class LateParsedAttrList : public SmallVector<LateParsedAttribute *, 2> {
1182	public:
1183	LateParsedAttrList(bool PSoon = false,
1184	bool LateAttrParseExperimentalExtOnly = false)
1185	: ParseSoon(PSoon),
1186	LateAttrParseExperimentalExtOnly(LateAttrParseExperimentalExtOnly) {}
1187
1188	bool parseSoon() { return ParseSoon; }
1189	/// returns true iff the attribute to be parsed should only be late parsed
1190	/// if it is annotated with `LateAttrParseExperimentalExt`
1191	bool lateAttrParseExperimentalExtOnly() {
1192	return LateAttrParseExperimentalExtOnly;
1193	}
1194
1195	private:
1196	bool ParseSoon; // Are we planning to parse these shortly after creation?
1197	bool LateAttrParseExperimentalExtOnly;
1198	};
1199
1200	/// Contains the lexed tokens of a member function definition
1201	/// which needs to be parsed at the end of the class declaration
1202	/// after parsing all other member declarations.
1203	struct LexedMethod : public LateParsedDeclaration {
1204	Parser *Self;
1205	Decl *D;
1206	CachedTokens Toks;
1207
1208	explicit LexedMethod(Parser *P, Decl *MD) : Self(P), D(MD) {}
1209
1210	void ParseLexedMethodDefs() override;
1211	};
1212
1213	/// LateParsedDefaultArgument - Keeps track of a parameter that may
1214	/// have a default argument that cannot be parsed yet because it
1215	/// occurs within a member function declaration inside the class
1216	/// (C++ [class.mem]p2).
1217	struct LateParsedDefaultArgument {
1218	explicit LateParsedDefaultArgument(
1219	Decl *P, std::unique_ptr<CachedTokens> Toks = nullptr)
1220	: Param(P), Toks(std::move(Toks)) {}
1221
1222	/// Param - The parameter declaration for this parameter.
1223	Decl *Param;
1224
1225	/// Toks - The sequence of tokens that comprises the default
1226	/// argument expression, not including the '=' or the terminating
1227	/// ')' or ','. This will be NULL for parameters that have no
1228	/// default argument.
1229	std::unique_ptr<CachedTokens> Toks;
1230	};
1231
1232	/// LateParsedMethodDeclaration - A method declaration inside a class that
1233	/// contains at least one entity whose parsing needs to be delayed
1234	/// until the class itself is completely-defined, such as a default
1235	/// argument (C++ [class.mem]p2).
1236	struct LateParsedMethodDeclaration : public LateParsedDeclaration {
1237	explicit LateParsedMethodDeclaration(Parser *P, Decl *M)
1238	: Self(P), Method(M), ExceptionSpecTokens(nullptr) {}
1239
1240	void ParseLexedMethodDeclarations() override;
1241
1242	Parser *Self;
1243
1244	/// Method - The method declaration.
1245	Decl *Method;
1246
1247	/// DefaultArgs - Contains the parameters of the function and
1248	/// their default arguments. At least one of the parameters will
1249	/// have a default argument, but all of the parameters of the
1250	/// method will be stored so that they can be reintroduced into
1251	/// scope at the appropriate times.
1252	SmallVector<LateParsedDefaultArgument, 8> DefaultArgs;
1253
1254	/// The set of tokens that make up an exception-specification that
1255	/// has not yet been parsed.
1256	CachedTokens *ExceptionSpecTokens;
1257	};
1258
1259	/// LateParsedMemberInitializer - An initializer for a non-static class data
1260	/// member whose parsing must to be delayed until the class is completely
1261	/// defined (C++11 [class.mem]p2).
1262	struct LateParsedMemberInitializer : public LateParsedDeclaration {
1263	LateParsedMemberInitializer(Parser *P, Decl *FD) : Self(P), Field(FD) {}
1264
1265	void ParseLexedMemberInitializers() override;
1266
1267	Parser *Self;
1268
1269	/// Field - The field declaration.
1270	Decl *Field;
1271
1272	/// CachedTokens - The sequence of tokens that comprises the initializer,
1273	/// including any leading '='.
1274	CachedTokens Toks;
1275	};
1276
1277	/// LateParsedDeclarationsContainer - During parsing of a top (non-nested)
1278	/// C++ class, its method declarations that contain parts that won't be
1279	/// parsed until after the definition is completed (C++ [class.mem]p2),
1280	/// the method declarations and possibly attached inline definitions
1281	/// will be stored here with the tokens that will be parsed to create those
1282	/// entities.
1283	typedef SmallVector<LateParsedDeclaration *, 2>
1284	LateParsedDeclarationsContainer;
1285
1286	/// Utility to re-enter a possibly-templated scope while parsing its
1287	/// late-parsed components.
1288	struct ReenterTemplateScopeRAII;
1289
1290	/// Utility to re-enter a class scope while parsing its late-parsed
1291	/// components.
1292	struct ReenterClassScopeRAII;
1293
1294	/// ParseCXXInlineMethodDef - We parsed and verified that the specified
1295	/// Declarator is a well formed C++ inline method definition. Now lex its body
1296	/// and store its tokens for parsing after the C++ class is complete.
1297	NamedDecl *ParseCXXInlineMethodDef(AccessSpecifier AS,
1298	const ParsedAttributesView &AccessAttrs,
1299	ParsingDeclarator &D,
1300	const ParsedTemplateInfo &TemplateInfo,
1301	const VirtSpecifiers &VS,
1302	SourceLocation PureSpecLoc);
1303
1304	/// Parse the optional ("message") part of a deleted-function-body.
1305	StringLiteral *ParseCXXDeletedFunctionMessage();
1306
1307	/// If we've encountered '= delete' in a context where it is ill-formed, such
1308	/// as in the declaration of a non-function, also skip the ("message") part if
1309	/// it is present to avoid issuing further diagnostics.
1310	void SkipDeletedFunctionBody();
1311
1312	/// ParseCXXNonStaticMemberInitializer - We parsed and verified that the
1313	/// specified Declarator is a well formed C++ non-static data member
1314	/// declaration. Now lex its initializer and store its tokens for parsing
1315	/// after the class is complete.
1316	void ParseCXXNonStaticMemberInitializer(Decl *VarD);
1317
1318	/// Wrapper class which calls ParseLexedAttribute, after setting up the
1319	/// scope appropriately.
1320	void ParseLexedAttributes(ParsingClass &Class);
1321
1322	/// Parse all attributes in LAs, and attach them to Decl D.
1323	void ParseLexedAttributeList(LateParsedAttrList &LAs, Decl *D,
1324	bool EnterScope, bool OnDefinition);
1325
1326	/// Finish parsing an attribute for which parsing was delayed.
1327	/// This will be called at the end of parsing a class declaration
1328	/// for each LateParsedAttribute. We consume the saved tokens and
1329	/// create an attribute with the arguments filled in. We add this
1330	/// to the Attribute list for the decl.
1331	void ParseLexedAttribute(LateParsedAttribute &LA, bool EnterScope,
1332	bool OnDefinition);
1333
1334	/// ParseLexedMethodDeclarations - We finished parsing the member
1335	/// specification of a top (non-nested) C++ class. Now go over the
1336	/// stack of method declarations with some parts for which parsing was
1337	/// delayed (such as default arguments) and parse them.
1338	void ParseLexedMethodDeclarations(ParsingClass &Class);
1339	void ParseLexedMethodDeclaration(LateParsedMethodDeclaration &LM);
1340
1341	/// ParseLexedMethodDefs - We finished parsing the member specification of a
1342	/// top (non-nested) C++ class. Now go over the stack of lexed methods that
1343	/// were collected during its parsing and parse them all.
1344	void ParseLexedMethodDefs(ParsingClass &Class);
1345	void ParseLexedMethodDef(LexedMethod &LM);
1346
1347	/// ParseLexedMemberInitializers - We finished parsing the member
1348	/// specification of a top (non-nested) C++ class. Now go over the stack of
1349	/// lexed data member initializers that were collected during its parsing and
1350	/// parse them all.
1351	void ParseLexedMemberInitializers(ParsingClass &Class);
1352	void ParseLexedMemberInitializer(LateParsedMemberInitializer &MI);
1353
1354	///@}
1355
1356	//
1357	//
1358	// -------------------------------------------------------------------------
1359	//
1360	//
1361
1362	/// \name Declarations
1363	/// Implementations are in ParseDecl.cpp
1364	///@{
1365
1366	public:
1367	/// SkipMalformedDecl - Read tokens until we get to some likely good stopping
1368	/// point for skipping past a simple-declaration.
1369	///
1370	/// Skip until we reach something which seems like a sensible place to pick
1371	/// up parsing after a malformed declaration. This will sometimes stop sooner
1372	/// than SkipUntil(tok::r_brace) would, but will never stop later.
1373	void SkipMalformedDecl();
1374
1375	/// ParseTypeName
1376	/// \verbatim
1377	/// type-name: [C99 6.7.6]
1378	/// specifier-qualifier-list abstract-declarator[opt]
1379	/// \endverbatim
1380	///
1381	/// Called type-id in C++.
1382	TypeResult
1383	ParseTypeName(SourceRange *Range = nullptr,
1384	DeclaratorContext Context = DeclaratorContext::TypeName,
1385	AccessSpecifier AS = AS_none, Decl **OwnedType = nullptr,
1386	ParsedAttributes *Attrs = nullptr);
1387
1388	private:
1389	/// Ident_vector, Ident_bool, Ident_Bool - cached IdentifierInfos for "vector"
1390	/// and "bool" fast comparison. Only present if AltiVec or ZVector are
1391	/// enabled.
1392	IdentifierInfo *Ident_vector;
1393	IdentifierInfo *Ident_bool;
1394	IdentifierInfo *Ident_Bool;
1395
1396	/// Ident_pixel - cached IdentifierInfos for "pixel" fast comparison.
1397	/// Only present if AltiVec enabled.
1398	IdentifierInfo *Ident_pixel;
1399
1400	/// Identifier for "introduced".
1401	IdentifierInfo *Ident_introduced;
1402
1403	/// Identifier for "deprecated".
1404	IdentifierInfo *Ident_deprecated;
1405
1406	/// Identifier for "obsoleted".
1407	IdentifierInfo *Ident_obsoleted;
1408
1409	/// Identifier for "unavailable".
1410	IdentifierInfo *Ident_unavailable;
1411
1412	/// Identifier for "message".
1413	IdentifierInfo *Ident_message;
1414
1415	/// Identifier for "strict".
1416	IdentifierInfo *Ident_strict;
1417
1418	/// Identifier for "replacement".
1419	IdentifierInfo *Ident_replacement;
1420
1421	/// Identifier for "environment".
1422	IdentifierInfo *Ident_environment;
1423
1424	/// Identifiers used by the 'external_source_symbol' attribute.
1425	IdentifierInfo *Ident_language, *Ident_defined_in,
1426	*Ident_generated_declaration, *Ident_USR;
1427
1428	/// Factory object for creating ParsedAttr objects.
1429	AttributeFactory AttrFactory;
1430
1431	/// TryAltiVecToken - Check for context-sensitive AltiVec identifier tokens,
1432	/// replacing them with the non-context-sensitive keywords. This returns
1433	/// true if the token was replaced.
1434	bool TryAltiVecToken(DeclSpec &DS, SourceLocation Loc, const char *&PrevSpec,
1435	unsigned &DiagID, bool &isInvalid) {
1436	if (!getLangOpts().AltiVec && !getLangOpts().ZVector)
1437	return false;
1438
1439	if (Tok.getIdentifierInfo() != Ident_vector &&
1440	Tok.getIdentifierInfo() != Ident_bool &&
1441	Tok.getIdentifierInfo() != Ident_Bool &&
1442	(!getLangOpts().AltiVec || Tok.getIdentifierInfo() != Ident_pixel))
1443	return false;
1444
1445	return TryAltiVecTokenOutOfLine(DS, Loc, PrevSpec, DiagID, isInvalid);
1446	}
1447
1448	/// TryAltiVecVectorToken - Check for context-sensitive AltiVec vector
1449	/// identifier token, replacing it with the non-context-sensitive __vector.
1450	/// This returns true if the token was replaced.
1451	bool TryAltiVecVectorToken() {
1452	if ((!getLangOpts().AltiVec && !getLangOpts().ZVector) ||
1453	Tok.getIdentifierInfo() != Ident_vector)
1454	return false;
1455	return TryAltiVecVectorTokenOutOfLine();
1456	}
1457
1458	/// TryAltiVecVectorTokenOutOfLine - Out of line body that should only be
1459	/// called from TryAltiVecVectorToken.
1460	bool TryAltiVecVectorTokenOutOfLine();
1461	bool TryAltiVecTokenOutOfLine(DeclSpec &DS, SourceLocation Loc,
1462	const char *&PrevSpec, unsigned &DiagID,
1463	bool &isInvalid);
1464
1465	void ParseLexedCAttributeList(LateParsedAttrList &LA, bool EnterScope,
1466	ParsedAttributes *OutAttrs = nullptr);
1467
1468	/// Finish parsing an attribute for which parsing was delayed.
1469	/// This will be called at the end of parsing a class declaration
1470	/// for each LateParsedAttribute. We consume the saved tokens and
1471	/// create an attribute with the arguments filled in. We add this
1472	/// to the Attribute list for the decl.
1473	void ParseLexedCAttribute(LateParsedAttribute &LA, bool EnterScope,
1474	ParsedAttributes *OutAttrs = nullptr);
1475
1476	void ParseLexedPragmas(ParsingClass &Class);
1477	void ParseLexedPragma(LateParsedPragma &LP);
1478
1479	/// Consume tokens and store them in the passed token container until
1480	/// we've passed the try keyword and constructor initializers and have
1481	/// consumed the opening brace of the function body. The opening brace will be
1482	/// consumed if and only if there was no error.
1483	///
1484	/// \return True on error.
1485	bool ConsumeAndStoreFunctionPrologue(CachedTokens &Toks);
1486
1487	/// ConsumeAndStoreInitializer - Consume and store the token at the passed
1488	/// token container until the end of the current initializer expression
1489	/// (either a default argument or an in-class initializer for a non-static
1490	/// data member).
1491	///
1492	/// Returns \c true if we reached the end of something initializer-shaped,
1493	/// \c false if we bailed out.
1494	bool ConsumeAndStoreInitializer(CachedTokens &Toks, CachedInitKind CIK);
1495
1496	/// Consume and store tokens from the '?' to the ':' in a conditional
1497	/// expression.
1498	bool ConsumeAndStoreConditional(CachedTokens &Toks);
1499	bool ConsumeAndStoreUntil(tok::TokenKind T1, CachedTokens &Toks,
1500	bool StopAtSemi = true,
1501	bool ConsumeFinalToken = true) {
1502	return ConsumeAndStoreUntil(T1, T2: T1, Toks, StopAtSemi, ConsumeFinalToken);
1503	}
1504
1505	/// ConsumeAndStoreUntil - Consume and store the token at the passed token
1506	/// container until the token 'T' is reached (which gets
1507	/// consumed/stored too, if ConsumeFinalToken).
1508	/// If StopAtSemi is true, then we will stop early at a ';' character.
1509	/// Returns true if token 'T1' or 'T2' was found.
1510	/// NOTE: This is a specialized version of Parser::SkipUntil.
1511	bool ConsumeAndStoreUntil(tok::TokenKind T1, tok::TokenKind T2,
1512	CachedTokens &Toks, bool StopAtSemi = true,
1513	bool ConsumeFinalToken = true);
1514
1515	//===--------------------------------------------------------------------===//
1516	// C99 6.7: Declarations.
1517
1518	/// A context for parsing declaration specifiers. TODO: flesh this
1519	/// out, there are other significant restrictions on specifiers than
1520	/// would be best implemented in the parser.
1521	enum class DeclSpecContext {
1522	DSC_normal, // normal context
1523	DSC_class, // class context, enables 'friend'
1524	DSC_type_specifier, // C++ type-specifier-seq or C specifier-qualifier-list
1525	DSC_trailing, // C++11 trailing-type-specifier in a trailing return type
1526	DSC_alias_declaration, // C++11 type-specifier-seq in an alias-declaration
1527	DSC_conv_operator, // C++ type-specifier-seq in an conversion operator
1528	DSC_top_level, // top-level/namespace declaration context
1529	DSC_template_param, // template parameter context
1530	DSC_template_arg, // template argument context
1531	DSC_template_type_arg, // template type argument context
1532	DSC_objc_method_result, // ObjC method result context, enables
1533	// 'instancetype'
1534	DSC_condition, // condition declaration context
1535	DSC_association, // A _Generic selection expression's type association
1536	DSC_new, // C++ new expression
1537	};
1538
1539	/// Is this a context in which we are parsing just a type-specifier (or
1540	/// trailing-type-specifier)?
1541	static bool isTypeSpecifier(DeclSpecContext DSC) {
1542	switch (DSC) {
1543	case DeclSpecContext::DSC_normal:
1544	case DeclSpecContext::DSC_template_param:
1545	case DeclSpecContext::DSC_template_arg:
1546	case DeclSpecContext::DSC_class:
1547	case DeclSpecContext::DSC_top_level:
1548	case DeclSpecContext::DSC_objc_method_result:
1549	case DeclSpecContext::DSC_condition:
1550	return false;
1551
1552	case DeclSpecContext::DSC_template_type_arg:
1553	case DeclSpecContext::DSC_type_specifier:
1554	case DeclSpecContext::DSC_conv_operator:
1555	case DeclSpecContext::DSC_trailing:
1556	case DeclSpecContext::DSC_alias_declaration:
1557	case DeclSpecContext::DSC_association:
1558	case DeclSpecContext::DSC_new:
1559	return true;
1560	}
1561	llvm_unreachable("Missing DeclSpecContext case");
1562	}
1563
1564	/// Whether a defining-type-specifier is permitted in a given context.
1565	enum class AllowDefiningTypeSpec {
1566	/// The grammar doesn't allow a defining-type-specifier here, and we must
1567	/// not parse one (eg, because a '{' could mean something else).
1568	No,
1569	/// The grammar doesn't allow a defining-type-specifier here, but we permit
1570	/// one for error recovery purposes. Sema will reject.
1571	NoButErrorRecovery,
1572	/// The grammar allows a defining-type-specifier here, even though it's
1573	/// always invalid. Sema will reject.
1574	YesButInvalid,
1575	/// The grammar allows a defining-type-specifier here, and one can be valid.
1576	Yes
1577	};
1578
1579	/// Is this a context in which we are parsing defining-type-specifiers (and
1580	/// so permit class and enum definitions in addition to non-defining class and
1581	/// enum elaborated-type-specifiers)?
1582	static AllowDefiningTypeSpec
1583	isDefiningTypeSpecifierContext(DeclSpecContext DSC, bool IsCPlusPlus) {
1584	switch (DSC) {
1585	case DeclSpecContext::DSC_normal:
1586	case DeclSpecContext::DSC_class:
1587	case DeclSpecContext::DSC_top_level:
1588	case DeclSpecContext::DSC_alias_declaration:
1589	case DeclSpecContext::DSC_objc_method_result:
1590	return AllowDefiningTypeSpec::Yes;
1591
1592	case DeclSpecContext::DSC_condition:
1593	case DeclSpecContext::DSC_template_param:
1594	return AllowDefiningTypeSpec::YesButInvalid;
1595
1596	case DeclSpecContext::DSC_template_type_arg:
1597	case DeclSpecContext::DSC_type_specifier:
1598	return AllowDefiningTypeSpec::NoButErrorRecovery;
1599
1600	case DeclSpecContext::DSC_association:
1601	return IsCPlusPlus ? AllowDefiningTypeSpec::NoButErrorRecovery
1602	: AllowDefiningTypeSpec::Yes;
1603
1604	case DeclSpecContext::DSC_trailing:
1605	case DeclSpecContext::DSC_conv_operator:
1606	case DeclSpecContext::DSC_template_arg:
1607	case DeclSpecContext::DSC_new:
1608	return AllowDefiningTypeSpec::No;
1609	}
1610	llvm_unreachable("Missing DeclSpecContext case");
1611	}
1612
1613	/// Is this a context in which an opaque-enum-declaration can appear?
1614	static bool isOpaqueEnumDeclarationContext(DeclSpecContext DSC) {
1615	switch (DSC) {
1616	case DeclSpecContext::DSC_normal:
1617	case DeclSpecContext::DSC_class:
1618	case DeclSpecContext::DSC_top_level:
1619	return true;
1620
1621	case DeclSpecContext::DSC_alias_declaration:
1622	case DeclSpecContext::DSC_objc_method_result:
1623	case DeclSpecContext::DSC_condition:
1624	case DeclSpecContext::DSC_template_param:
1625	case DeclSpecContext::DSC_template_type_arg:
1626	case DeclSpecContext::DSC_type_specifier:
1627	case DeclSpecContext::DSC_trailing:
1628	case DeclSpecContext::DSC_association:
1629	case DeclSpecContext::DSC_conv_operator:
1630	case DeclSpecContext::DSC_template_arg:
1631	case DeclSpecContext::DSC_new:
1632
1633	return false;
1634	}
1635	llvm_unreachable("Missing DeclSpecContext case");
1636	}
1637
1638	/// Is this a context in which we can perform class template argument
1639	/// deduction?
1640	static bool isClassTemplateDeductionContext(DeclSpecContext DSC) {
1641	switch (DSC) {
1642	case DeclSpecContext::DSC_normal:
1643	case DeclSpecContext::DSC_template_param:
1644	case DeclSpecContext::DSC_template_arg:
1645	case DeclSpecContext::DSC_class:
1646	case DeclSpecContext::DSC_top_level:
1647	case DeclSpecContext::DSC_condition:
1648	case DeclSpecContext::DSC_type_specifier:
1649	case DeclSpecContext::DSC_association:
1650	case DeclSpecContext::DSC_conv_operator:
1651	case DeclSpecContext::DSC_new:
1652	return true;
1653
1654	case DeclSpecContext::DSC_objc_method_result:
1655	case DeclSpecContext::DSC_template_type_arg:
1656	case DeclSpecContext::DSC_trailing:
1657	case DeclSpecContext::DSC_alias_declaration:
1658	return false;
1659	}
1660	llvm_unreachable("Missing DeclSpecContext case");
1661	}
1662
1663	// Is this a context in which an implicit 'typename' is allowed?
1664	static ImplicitTypenameContext
1665	getImplicitTypenameContext(DeclSpecContext DSC) {
1666	switch (DSC) {
1667	case DeclSpecContext::DSC_class:
1668	case DeclSpecContext::DSC_top_level:
1669	case DeclSpecContext::DSC_type_specifier:
1670	case DeclSpecContext::DSC_template_type_arg:
1671	case DeclSpecContext::DSC_trailing:
1672	case DeclSpecContext::DSC_alias_declaration:
1673	case DeclSpecContext::DSC_template_param:
1674	case DeclSpecContext::DSC_new:
1675	return ImplicitTypenameContext::Yes;
1676
1677	case DeclSpecContext::DSC_normal:
1678	case DeclSpecContext::DSC_objc_method_result:
1679	case DeclSpecContext::DSC_condition:
1680	case DeclSpecContext::DSC_template_arg:
1681	case DeclSpecContext::DSC_conv_operator:
1682	case DeclSpecContext::DSC_association:
1683	return ImplicitTypenameContext::No;
1684	}
1685	llvm_unreachable("Missing DeclSpecContext case");
1686	}
1687
1688	/// Information on a C++0x for-range-initializer found while parsing a
1689	/// declaration which turns out to be a for-range-declaration.
1690	struct ForRangeInit {
1691	SourceLocation ColonLoc;
1692	ExprResult RangeExpr;
1693	SmallVector<MaterializeTemporaryExpr *, 8> LifetimeExtendTemps;
1694	bool ParsedForRangeDecl() { return !ColonLoc.isInvalid(); }
1695	};
1696	struct ForRangeInfo : ForRangeInit {
1697	StmtResult LoopVar;
1698	};
1699
1700	/// ParseDeclaration - Parse a full 'declaration', which consists of
1701	/// declaration-specifiers, some number of declarators, and a semicolon.
1702	/// 'Context' should be a DeclaratorContext value. This returns the
1703	/// location of the semicolon in DeclEnd.
1704	///
1705	/// \verbatim
1706	/// declaration: [C99 6.7]
1707	/// block-declaration ->
1708	/// simple-declaration
1709	/// others [FIXME]
1710	/// [C++] template-declaration
1711	/// [C++] namespace-definition
1712	/// [C++] using-directive
1713	/// [C++] using-declaration
1714	/// [C++11/C11] static_assert-declaration
1715	/// others... [FIXME]
1716	/// \endverbatim
1717	///
1718	DeclGroupPtrTy ParseDeclaration(DeclaratorContext Context,
1719	SourceLocation &DeclEnd,
1720	ParsedAttributes &DeclAttrs,
1721	ParsedAttributes &DeclSpecAttrs,
1722	SourceLocation *DeclSpecStart = nullptr);
1723
1724	/// \verbatim
1725	/// simple-declaration: [C99 6.7: declaration] [C++ 7p1: dcl.dcl]
1726	/// declaration-specifiers init-declarator-list[opt] ';'
1727	/// [C++11] attribute-specifier-seq decl-specifier-seq[opt]
1728	/// init-declarator-list ';'
1729	///[C90/C++]init-declarator-list ';' [TODO]
1730	/// [OMP] threadprivate-directive
1731	/// [OMP] allocate-directive [TODO]
1732	///
1733	/// for-range-declaration: [C++11 6.5p1: stmt.ranged]
1734	/// attribute-specifier-seq[opt] type-specifier-seq declarator
1735	/// \endverbatim
1736	///
1737	/// If RequireSemi is false, this does not check for a ';' at the end of the
1738	/// declaration. If it is true, it checks for and eats it.
1739	///
1740	/// If FRI is non-null, we might be parsing a for-range-declaration instead
1741	/// of a simple-declaration. If we find that we are, we also parse the
1742	/// for-range-initializer, and place it here.
1743	///
1744	/// DeclSpecStart is used when decl-specifiers are parsed before parsing
1745	/// the Declaration. The SourceLocation for this Decl is set to
1746	/// DeclSpecStart if DeclSpecStart is non-null.
1747	DeclGroupPtrTy
1748	ParseSimpleDeclaration(DeclaratorContext Context, SourceLocation &DeclEnd,
1749	ParsedAttributes &DeclAttrs,
1750	ParsedAttributes &DeclSpecAttrs, bool RequireSemi,
1751	ForRangeInit *FRI = nullptr,
1752	SourceLocation *DeclSpecStart = nullptr);
1753
1754	/// ParseDeclGroup - Having concluded that this is either a function
1755	/// definition or a group of object declarations, actually parse the
1756	/// result.
1757	///
1758	/// Returns true if this might be the start of a declarator, or a common typo
1759	/// for a declarator.
1760	bool MightBeDeclarator(DeclaratorContext Context);
1761	DeclGroupPtrTy ParseDeclGroup(ParsingDeclSpec &DS, DeclaratorContext Context,
1762	ParsedAttributes &Attrs,
1763	ParsedTemplateInfo &TemplateInfo,
1764	SourceLocation *DeclEnd = nullptr,
1765	ForRangeInit *FRI = nullptr);
1766
1767	/// Parse 'declaration' after parsing 'declaration-specifiers
1768	/// declarator'. This method parses the remainder of the declaration
1769	/// (including any attributes or initializer, among other things) and
1770	/// finalizes the declaration.
1771	///
1772	/// \verbatim
1773	/// init-declarator: [C99 6.7]
1774	/// declarator
1775	/// declarator '=' initializer
1776	/// [GNU] declarator simple-asm-expr[opt] attributes[opt]
1777	/// [GNU] declarator simple-asm-expr[opt] attributes[opt] '=' initializer
1778	/// [C++] declarator initializer[opt]
1779	///
1780	/// [C++] initializer:
1781	/// [C++] '=' initializer-clause
1782	/// [C++] '(' expression-list ')'
1783	/// [C++0x] '=' 'default' [TODO]
1784	/// [C++0x] '=' 'delete'
1785	/// [C++0x] braced-init-list
1786	/// \endverbatim
1787	///
1788	/// According to the standard grammar, =default and =delete are function
1789	/// definitions, but that definitely doesn't fit with the parser here.
1790	///
1791	Decl *ParseDeclarationAfterDeclarator(
1792	Declarator &D,
1793	const ParsedTemplateInfo &TemplateInfo = ParsedTemplateInfo());
1794
1795	/// Parse an optional simple-asm-expr and attributes, and attach them to a
1796	/// declarator. Returns true on an error.
1797	bool ParseAsmAttributesAfterDeclarator(Declarator &D);
1798	Decl *ParseDeclarationAfterDeclaratorAndAttributes(
1799	Declarator &D,
1800	const ParsedTemplateInfo &TemplateInfo = ParsedTemplateInfo(),
1801	ForRangeInit *FRI = nullptr);
1802
1803	/// ParseImplicitInt - This method is called when we have an non-typename
1804	/// identifier in a declspec (which normally terminates the decl spec) when
1805	/// the declspec has no type specifier. In this case, the declspec is either
1806	/// malformed or is "implicit int" (in K&R and C89).
1807	///
1808	/// This method handles diagnosing this prettily and returns false if the
1809	/// declspec is done being processed. If it recovers and thinks there may be
1810	/// other pieces of declspec after it, it returns true.
1811	///
1812	bool ParseImplicitInt(DeclSpec &DS, CXXScopeSpec *SS,
1813	ParsedTemplateInfo &TemplateInfo, AccessSpecifier AS,
1814	DeclSpecContext DSC, ParsedAttributes &Attrs);
1815
1816	/// Determine the declaration specifier context from the declarator
1817	/// context.
1818	///
1819	/// \param Context the declarator context, which is one of the
1820	/// DeclaratorContext enumerator values.
1821	DeclSpecContext
1822	getDeclSpecContextFromDeclaratorContext(DeclaratorContext Context);
1823	void
1824	ParseDeclarationSpecifiers(DeclSpec &DS, ParsedTemplateInfo &TemplateInfo,
1825	AccessSpecifier AS = AS_none,
1826	DeclSpecContext DSC = DeclSpecContext::DSC_normal,
1827	LateParsedAttrList *LateAttrs = nullptr) {
1828	return ParseDeclarationSpecifiers(DS, TemplateInfo, AS, DSC, LateAttrs,
1829	AllowImplicitTypename: getImplicitTypenameContext(DSC));
1830	}
1831
1832	/// ParseDeclarationSpecifiers
1833	/// \verbatim
1834	/// declaration-specifiers: [C99 6.7]
1835	/// storage-class-specifier declaration-specifiers[opt]
1836	/// type-specifier declaration-specifiers[opt]
1837	/// [C99] function-specifier declaration-specifiers[opt]
1838	/// [C11] alignment-specifier declaration-specifiers[opt]
1839	/// [GNU] attributes declaration-specifiers[opt]
1840	/// [Clang] '__module_private__' declaration-specifiers[opt]
1841	/// [ObjC1] '__kindof' declaration-specifiers[opt]
1842	///
1843	/// storage-class-specifier: [C99 6.7.1]
1844	/// 'typedef'
1845	/// 'extern'
1846	/// 'static'
1847	/// 'auto'
1848	/// 'register'
1849	/// [C++] 'mutable'
1850	/// [C++11] 'thread_local'
1851	/// [C11] '_Thread_local'
1852	/// [GNU] '__thread'
1853	/// function-specifier: [C99 6.7.4]
1854	/// [C99] 'inline'
1855	/// [C++] 'virtual'
1856	/// [C++] 'explicit'
1857	/// [OpenCL] '__kernel'
1858	/// 'friend': [C++ dcl.friend]
1859	/// 'constexpr': [C++0x dcl.constexpr]
1860	/// \endverbatim
1861	void
1862	ParseDeclarationSpecifiers(DeclSpec &DS, ParsedTemplateInfo &TemplateInfo,
1863	AccessSpecifier AS, DeclSpecContext DSC,
1864	LateParsedAttrList *LateAttrs,
1865	ImplicitTypenameContext AllowImplicitTypename);
1866
1867	/// Determine whether we're looking at something that might be a declarator
1868	/// in a simple-declaration. If it can't possibly be a declarator, maybe
1869	/// diagnose a missing semicolon after a prior tag definition in the decl
1870	/// specifier.
1871	///
1872	/// \return \c true if an error occurred and this can't be any kind of
1873	/// declaration.
1874	bool DiagnoseMissingSemiAfterTagDefinition(
1875	DeclSpec &DS, AccessSpecifier AS, DeclSpecContext DSContext,
1876	LateParsedAttrList *LateAttrs = nullptr);
1877
1878	void ParseSpecifierQualifierList(
1879	DeclSpec &DS, AccessSpecifier AS = AS_none,
1880	DeclSpecContext DSC = DeclSpecContext::DSC_normal) {
1881	ParseSpecifierQualifierList(DS, AllowImplicitTypename: getImplicitTypenameContext(DSC), AS, DSC);
1882	}
1883
1884	/// ParseSpecifierQualifierList
1885	/// \verbatim
1886	/// specifier-qualifier-list:
1887	/// type-specifier specifier-qualifier-list[opt]
1888	/// type-qualifier specifier-qualifier-list[opt]
1889	/// [GNU] attributes specifier-qualifier-list[opt]
1890	/// \endverbatim
1891	///
1892	void ParseSpecifierQualifierList(
1893	DeclSpec &DS, ImplicitTypenameContext AllowImplicitTypename,
1894	AccessSpecifier AS = AS_none,
1895	DeclSpecContext DSC = DeclSpecContext::DSC_normal);
1896
1897	/// ParseEnumSpecifier
1898	/// \verbatim
1899	/// enum-specifier: [C99 6.7.2.2]
1900	/// 'enum' identifier[opt] '{' enumerator-list '}'
1901	///[C99/C++]'enum' identifier[opt] '{' enumerator-list ',' '}'
1902	/// [GNU] 'enum' attributes[opt] identifier[opt] '{' enumerator-list ',' [opt]
1903	/// '}' attributes[opt]
1904	/// [MS] 'enum' __declspec[opt] identifier[opt] '{' enumerator-list ',' [opt]
1905	/// '}'
1906	/// 'enum' identifier
1907	/// [GNU] 'enum' attributes[opt] identifier
1908	///
1909	/// [C++11] enum-head '{' enumerator-list[opt] '}'
1910	/// [C++11] enum-head '{' enumerator-list ',' '}'
1911	///
1912	/// enum-head: [C++11]
1913	/// enum-key attribute-specifier-seq[opt] identifier[opt] enum-base[opt]
1914	/// enum-key attribute-specifier-seq[opt] nested-name-specifier
1915	/// identifier enum-base[opt]
1916	///
1917	/// enum-key: [C++11]
1918	/// 'enum'
1919	/// 'enum' 'class'
1920	/// 'enum' 'struct'
1921	///
1922	/// enum-base: [C++11]
1923	/// ':' type-specifier-seq
1924	///
1925	/// [C++] elaborated-type-specifier:
1926	/// [C++] 'enum' nested-name-specifier[opt] identifier
1927	/// \endverbatim
1928	///
1929	void ParseEnumSpecifier(SourceLocation TagLoc, DeclSpec &DS,
1930	const ParsedTemplateInfo &TemplateInfo,
1931	AccessSpecifier AS, DeclSpecContext DSC);
1932
1933	/// ParseEnumBody - Parse a {} enclosed enumerator-list.
1934	/// \verbatim
1935	/// enumerator-list:
1936	/// enumerator
1937	/// enumerator-list ',' enumerator
1938	/// enumerator:
1939	/// enumeration-constant attributes[opt]
1940	/// enumeration-constant attributes[opt] '=' constant-expression
1941	/// enumeration-constant:
1942	/// identifier
1943	/// \endverbatim
1944	///
1945	void ParseEnumBody(SourceLocation StartLoc, Decl *TagDecl,
1946	SkipBodyInfo *SkipBody = nullptr);
1947
1948	/// ParseStructUnionBody
1949	/// \verbatim
1950	/// struct-contents:
1951	/// struct-declaration-list
1952	/// [EXT] empty
1953	/// [GNU] "struct-declaration-list" without terminating ';'
1954	/// struct-declaration-list:
1955	/// struct-declaration
1956	/// struct-declaration-list struct-declaration
1957	/// [OBC] '@' 'defs' '(' class-name ')'
1958	/// \endverbatim
1959	///
1960	void ParseStructUnionBody(SourceLocation StartLoc, DeclSpec::TST TagType,
1961	RecordDecl *TagDecl);
1962
1963	/// ParseStructDeclaration - Parse a struct declaration without the
1964	/// terminating semicolon.
1965	///
1966	/// Note that a struct declaration refers to a declaration in a struct,
1967	/// not to the declaration of a struct.
1968	///
1969	/// \verbatim
1970	/// struct-declaration:
1971	/// [C23] attributes-specifier-seq[opt]
1972	/// specifier-qualifier-list struct-declarator-list
1973	/// [GNU] __extension__ struct-declaration
1974	/// [GNU] specifier-qualifier-list
1975	/// struct-declarator-list:
1976	/// struct-declarator
1977	/// struct-declarator-list ',' struct-declarator
1978	/// [GNU] struct-declarator-list ',' attributes[opt] struct-declarator
1979	/// struct-declarator:
1980	/// declarator
1981	/// [GNU] declarator attributes[opt]
1982	/// declarator[opt] ':' constant-expression
1983	/// [GNU] declarator[opt] ':' constant-expression attributes[opt]
1984	/// \endverbatim
1985	///
1986	void ParseStructDeclaration(
1987	ParsingDeclSpec &DS,
1988	llvm::function_ref<Decl *(ParsingFieldDeclarator &)> FieldsCallback,
1989	LateParsedAttrList *LateFieldAttrs = nullptr);
1990
1991	DeclGroupPtrTy ParseTopLevelStmtDecl();
1992
1993	/// isDeclarationSpecifier() - Return true if the current token is part of a
1994	/// declaration specifier.
1995	///
1996	/// \param AllowImplicitTypename whether this is a context where T::type [T
1997	/// dependent] can appear.
1998	/// \param DisambiguatingWithExpression True to indicate that the purpose of
1999	/// this check is to disambiguate between an expression and a declaration.
2000	bool isDeclarationSpecifier(ImplicitTypenameContext AllowImplicitTypename,
2001	bool DisambiguatingWithExpression = false);
2002
2003	/// isTypeSpecifierQualifier - Return true if the current token could be the
2004	/// start of a specifier-qualifier-list.
2005	bool isTypeSpecifierQualifier();
2006
2007	/// isKnownToBeTypeSpecifier - Return true if we know that the specified token
2008	/// is definitely a type-specifier. Return false if it isn't part of a type
2009	/// specifier or if we're not sure.
2010	bool isKnownToBeTypeSpecifier(const Token &Tok) const;
2011
2012	/// Starting with a scope specifier, identifier, or
2013	/// template-id that refers to the current class, determine whether
2014	/// this is a constructor declarator.
2015	bool isConstructorDeclarator(
2016	bool Unqualified, bool DeductionGuide = false,
2017	DeclSpec::FriendSpecified IsFriend = DeclSpec::FriendSpecified::No,
2018	const ParsedTemplateInfo *TemplateInfo = nullptr);
2019
2020	/// Diagnoses use of _ExtInt as being deprecated, and diagnoses use of
2021	/// _BitInt as an extension when appropriate.
2022	void DiagnoseBitIntUse(const Token &Tok);
2023
2024	// Check for the start of an attribute-specifier-seq in a context where an
2025	// attribute is not allowed.
2026	bool CheckProhibitedCXX11Attribute() {
2027	assert(Tok.is(tok::l_square));
2028	if (NextToken().isNot(K: tok::l_square))
2029	return false;
2030	return DiagnoseProhibitedCXX11Attribute();
2031	}
2032
2033	/// DiagnoseProhibitedCXX11Attribute - We have found the opening square
2034	/// brackets of a C++11 attribute-specifier in a location where an attribute
2035	/// is not permitted. By C++11 [dcl.attr.grammar]p6, this is ill-formed.
2036	/// Diagnose this situation.
2037	///
2038	/// \return \c true if we skipped an attribute-like chunk of tokens, \c false
2039	/// if this doesn't appear to actually be an attribute-specifier, and the
2040	/// caller should try to parse it.
2041	bool DiagnoseProhibitedCXX11Attribute();
2042
2043	void CheckMisplacedCXX11Attribute(ParsedAttributes &Attrs,
2044	SourceLocation CorrectLocation) {
2045	if (!Tok.isRegularKeywordAttribute() &&
2046	(Tok.isNot(K: tok::l_square) || NextToken().isNot(K: tok::l_square)) &&
2047	Tok.isNot(K: tok::kw_alignas))
2048	return;
2049	DiagnoseMisplacedCXX11Attribute(Attrs, CorrectLocation);
2050	}
2051
2052	/// We have found the opening square brackets of a C++11
2053	/// attribute-specifier in a location where an attribute is not permitted, but
2054	/// we know where the attributes ought to be written. Parse them anyway, and
2055	/// provide a fixit moving them to the right place.
2056	void DiagnoseMisplacedCXX11Attribute(ParsedAttributes &Attrs,
2057	SourceLocation CorrectLocation);
2058
2059	// Usually, `__attribute__((attrib)) class Foo {} var` means that attribute
2060	// applies to var, not the type Foo.
2061	// As an exception to the rule, __declspec(align(...)) before the
2062	// class-key affects the type instead of the variable.
2063	// Also, Microsoft-style [attributes] seem to affect the type instead of the
2064	// variable.
2065	// This function moves attributes that should apply to the type off DS to
2066	// Attrs.
2067	void stripTypeAttributesOffDeclSpec(ParsedAttributes &Attrs, DeclSpec &DS,
2068	TagUseKind TUK);
2069
2070	// FixItLoc = possible correct location for the attributes
2071	void ProhibitAttributes(ParsedAttributes &Attrs,
2072	SourceLocation FixItLoc = SourceLocation()) {
2073	if (Attrs.Range.isInvalid())
2074	return;
2075	DiagnoseProhibitedAttributes(Attrs, FixItLoc);
2076	Attrs.clear();
2077	}
2078
2079	void ProhibitAttributes(ParsedAttributesView &Attrs,
2080	SourceLocation FixItLoc = SourceLocation()) {
2081	if (Attrs.Range.isInvalid())
2082	return;
2083	DiagnoseProhibitedAttributes(Attrs, FixItLoc);
2084	Attrs.clearListOnly();
2085	}
2086	void DiagnoseProhibitedAttributes(const ParsedAttributesView &Attrs,
2087	SourceLocation FixItLoc);
2088
2089	// Forbid C++11 and C23 attributes that appear on certain syntactic locations
2090	// which standard permits but we don't supported yet, for example, attributes
2091	// appertain to decl specifiers.
2092	// For the most cases we don't want to warn on unknown type attributes, but
2093	// left them to later diagnoses. However, for a few cases like module
2094	// declarations and module import declarations, we should do it.
2095	void ProhibitCXX11Attributes(ParsedAttributes &Attrs, unsigned AttrDiagID,
2096	unsigned KeywordDiagId,
2097	bool DiagnoseEmptyAttrs = false,
2098	bool WarnOnUnknownAttrs = false);
2099
2100	/// Emit warnings for C++11 and C23 attributes that are in a position that
2101	/// clang accepts as an extension.
2102	void DiagnoseCXX11AttributeExtension(ParsedAttributes &Attrs);
2103
2104	ExprResult ParseUnevaluatedStringInAttribute(const IdentifierInfo &AttrName);
2105
2106	bool
2107	ParseAttributeArgumentList(const clang::IdentifierInfo &AttrName,
2108	SmallVectorImpl<Expr *> &Exprs,
2109	ParsedAttributeArgumentsProperties ArgsProperties);
2110
2111	/// Parses syntax-generic attribute arguments for attributes which are
2112	/// known to the implementation, and adds them to the given ParsedAttributes
2113	/// list with the given attribute syntax. Returns the number of arguments
2114	/// parsed for the attribute.
2115	unsigned
2116	ParseAttributeArgsCommon(IdentifierInfo *AttrName, SourceLocation AttrNameLoc,
2117	ParsedAttributes &Attrs, SourceLocation *EndLoc,
2118	IdentifierInfo *ScopeName, SourceLocation ScopeLoc,
2119	ParsedAttr::Form Form);
2120
2121	enum ParseAttrKindMask {
2122	PAKM_GNU = 1 << 0,
2123	PAKM_Declspec = 1 << 1,
2124	PAKM_CXX11 = 1 << 2,
2125	};
2126
2127	/// \brief Parse attributes based on what syntaxes are desired, allowing for
2128	/// the order to vary. e.g. with PAKM_GNU | PAKM_Declspec:
2129	/// __attribute__((...)) __declspec(...) __attribute__((...)))
2130	/// Note that Microsoft attributes (spelled with single square brackets) are
2131	/// not supported by this because of parsing ambiguities with other
2132	/// constructs.
2133	///
2134	/// There are some attribute parse orderings that should not be allowed in
2135	/// arbitrary order. e.g.,
2136	///
2137	/// \verbatim
2138	/// [[]] __attribute__(()) int i; // OK
2139	/// __attribute__(()) [[]] int i; // Not OK
2140	/// \endverbatim
2141	///
2142	/// Such situations should use the specific attribute parsing functionality.
2143	void ParseAttributes(unsigned WhichAttrKinds, ParsedAttributes &Attrs,
2144	LateParsedAttrList *LateAttrs = nullptr);
2145	/// \brief Possibly parse attributes based on what syntaxes are desired,
2146	/// allowing for the order to vary.
2147	bool MaybeParseAttributes(unsigned WhichAttrKinds, ParsedAttributes &Attrs,
2148	LateParsedAttrList *LateAttrs = nullptr) {
2149	if (Tok.isOneOf(K1: tok::kw___attribute, K2: tok::kw___declspec) ||
2150	isAllowedCXX11AttributeSpecifier()) {
2151	ParseAttributes(WhichAttrKinds, Attrs, LateAttrs);
2152	return true;
2153	}
2154	return false;
2155	}
2156
2157	void MaybeParseGNUAttributes(Declarator &D,
2158	LateParsedAttrList *LateAttrs = nullptr) {
2159	if (Tok.is(K: tok::kw___attribute)) {
2160	ParsedAttributes Attrs(AttrFactory);
2161	ParseGNUAttributes(Attrs, LateAttrs, D: &D);
2162	D.takeAttributes(attrs&: Attrs);
2163	}
2164	}
2165
2166	bool MaybeParseGNUAttributes(ParsedAttributes &Attrs,
2167	LateParsedAttrList *LateAttrs = nullptr) {
2168	if (Tok.is(K: tok::kw___attribute)) {
2169	ParseGNUAttributes(Attrs, LateAttrs);
2170	return true;
2171	}
2172	return false;
2173	}
2174
2175	/// ParseSingleGNUAttribute - Parse a single GNU attribute.
2176	///
2177	/// \verbatim
2178	/// [GNU] attrib:
2179	/// empty
2180	/// attrib-name
2181	/// attrib-name '(' identifier ')'
2182	/// attrib-name '(' identifier ',' nonempty-expr-list ')'
2183	/// attrib-name '(' argument-expression-list [C99 6.5.2] ')'
2184	///
2185	/// [GNU] attrib-name:
2186	/// identifier
2187	/// typespec
2188	/// typequal
2189	/// storageclass
2190	/// \endverbatim
2191	bool ParseSingleGNUAttribute(ParsedAttributes &Attrs, SourceLocation &EndLoc,
2192	LateParsedAttrList *LateAttrs = nullptr,
2193	Declarator *D = nullptr);
2194
2195	/// ParseGNUAttributes - Parse a non-empty attributes list.
2196	///
2197	/// \verbatim
2198	/// [GNU] attributes:
2199	/// attribute
2200	/// attributes attribute
2201	///
2202	/// [GNU] attribute:
2203	/// '__attribute__' '(' '(' attribute-list ')' ')'
2204	///
2205	/// [GNU] attribute-list:
2206	/// attrib
2207	/// attribute_list ',' attrib
2208	///
2209	/// [GNU] attrib:
2210	/// empty
2211	/// attrib-name
2212	/// attrib-name '(' identifier ')'
2213	/// attrib-name '(' identifier ',' nonempty-expr-list ')'
2214	/// attrib-name '(' argument-expression-list [C99 6.5.2] ')'
2215	///
2216	/// [GNU] attrib-name:
2217	/// identifier
2218	/// typespec
2219	/// typequal
2220	/// storageclass
2221	/// \endverbatim
2222	///
2223	/// Whether an attribute takes an 'identifier' is determined by the
2224	/// attrib-name. GCC's behavior here is not worth imitating:
2225	///
2226	/// * In C mode, if the attribute argument list starts with an identifier
2227	/// followed by a ',' or an ')', and the identifier doesn't resolve to
2228	/// a type, it is parsed as an identifier. If the attribute actually
2229	/// wanted an expression, it's out of luck (but it turns out that no
2230	/// attributes work that way, because C constant expressions are very
2231	/// limited).
2232	/// * In C++ mode, if the attribute argument list starts with an identifier,
2233	/// and the attribute *wants* an identifier, it is parsed as an identifier.
2234	/// At block scope, any additional tokens between the identifier and the
2235	/// ',' or ')' are ignored, otherwise they produce a parse error.
2236	///
2237	/// We follow the C++ model, but don't allow junk after the identifier.
2238	void ParseGNUAttributes(ParsedAttributes &Attrs,
2239	LateParsedAttrList *LateAttrs = nullptr,
2240	Declarator *D = nullptr);
2241
2242	/// Parse the arguments to a parameterized GNU attribute or
2243	/// a C++11 attribute in "gnu" namespace.
2244	void ParseGNUAttributeArgs(IdentifierInfo *AttrName,
2245	SourceLocation AttrNameLoc,
2246	ParsedAttributes &Attrs, SourceLocation *EndLoc,
2247	IdentifierInfo *ScopeName, SourceLocation ScopeLoc,
2248	ParsedAttr::Form Form, Declarator *D);
2249	IdentifierLoc *ParseIdentifierLoc();
2250
2251	unsigned
2252	ParseClangAttributeArgs(IdentifierInfo *AttrName, SourceLocation AttrNameLoc,
2253	ParsedAttributes &Attrs, SourceLocation *EndLoc,
2254	IdentifierInfo *ScopeName, SourceLocation ScopeLoc,
2255	ParsedAttr::Form Form);
2256
2257	void MaybeParseCXX11Attributes(Declarator &D) {
2258	if (isAllowedCXX11AttributeSpecifier()) {
2259	ParsedAttributes Attrs(AttrFactory);
2260	ParseCXX11Attributes(attrs&: Attrs);
2261	D.takeAttributes(attrs&: Attrs);
2262	}
2263	}
2264
2265	bool MaybeParseCXX11Attributes(ParsedAttributes &Attrs,
2266	bool OuterMightBeMessageSend = false) {
2267	if (isAllowedCXX11AttributeSpecifier(Disambiguate: false, OuterMightBeMessageSend)) {
2268	ParseCXX11Attributes(attrs&: Attrs);
2269	return true;
2270	}
2271	return false;
2272	}
2273
2274	bool MaybeParseMicrosoftAttributes(ParsedAttributes &Attrs) {
2275	bool AttrsParsed = false;
2276	if ((getLangOpts().MicrosoftExt || getLangOpts().HLSL) &&
2277	Tok.is(K: tok::l_square)) {
2278	ParsedAttributes AttrsWithRange(AttrFactory);
2279	ParseMicrosoftAttributes(Attrs&: AttrsWithRange);
2280	AttrsParsed = !AttrsWithRange.empty();
2281	Attrs.takeAllFrom(Other&: AttrsWithRange);
2282	}
2283	return AttrsParsed;
2284	}
2285	bool MaybeParseMicrosoftDeclSpecs(ParsedAttributes &Attrs) {
2286	if (getLangOpts().DeclSpecKeyword && Tok.is(K: tok::kw___declspec)) {
2287	ParseMicrosoftDeclSpecs(Attrs);
2288	return true;
2289	}
2290	return false;
2291	}
2292
2293	/// \verbatim
2294	/// [MS] decl-specifier:
2295	/// __declspec ( extended-decl-modifier-seq )
2296	///
2297	/// [MS] extended-decl-modifier-seq:
2298	/// extended-decl-modifier[opt]
2299	/// extended-decl-modifier extended-decl-modifier-seq
2300	/// \endverbatim
2301	void ParseMicrosoftDeclSpecs(ParsedAttributes &Attrs);
2302	bool ParseMicrosoftDeclSpecArgs(IdentifierInfo *AttrName,
2303	SourceLocation AttrNameLoc,
2304	ParsedAttributes &Attrs);
2305	void ParseMicrosoftTypeAttributes(ParsedAttributes &attrs);
2306	void ParseWebAssemblyFuncrefTypeAttribute(ParsedAttributes &Attrs);
2307	void DiagnoseAndSkipExtendedMicrosoftTypeAttributes();
2308	SourceLocation SkipExtendedMicrosoftTypeAttributes();
2309
2310	void ParseBorlandTypeAttributes(ParsedAttributes &attrs);
2311	void ParseOpenCLKernelAttributes(ParsedAttributes &attrs);
2312	void ParseOpenCLQualifiers(ParsedAttributes &Attrs);
2313	void ParseNullabilityTypeSpecifiers(ParsedAttributes &attrs);
2314	void ParseCUDAFunctionAttributes(ParsedAttributes &attrs);
2315	bool isHLSLQualifier(const Token &Tok) const;
2316	void ParseHLSLQualifiers(ParsedAttributes &Attrs);
2317
2318	/// Parse a version number.
2319	///
2320	/// \verbatim
2321	/// version:
2322	/// simple-integer
2323	/// simple-integer '.' simple-integer
2324	/// simple-integer '_' simple-integer
2325	/// simple-integer '.' simple-integer '.' simple-integer
2326	/// simple-integer '_' simple-integer '_' simple-integer
2327	/// \endverbatim
2328	VersionTuple ParseVersionTuple(SourceRange &Range);
2329
2330	/// Parse the contents of the "availability" attribute.
2331	///
2332	/// \verbatim
2333	/// availability-attribute:
2334	/// 'availability' '(' platform ',' opt-strict version-arg-list,
2335	/// opt-replacement, opt-message')'
2336	///
2337	/// platform:
2338	/// identifier
2339	///
2340	/// opt-strict:
2341	/// 'strict' ','
2342	///
2343	/// version-arg-list:
2344	/// version-arg
2345	/// version-arg ',' version-arg-list
2346	///
2347	/// version-arg:
2348	/// 'introduced' '=' version
2349	/// 'deprecated' '=' version
2350	/// 'obsoleted' = version
2351	/// 'unavailable'
2352	/// opt-replacement:
2353	/// 'replacement' '=' <string>
2354	/// opt-message:
2355	/// 'message' '=' <string>
2356	/// \endverbatim
2357	void ParseAvailabilityAttribute(IdentifierInfo &Availability,
2358	SourceLocation AvailabilityLoc,
2359	ParsedAttributes &attrs,
2360	SourceLocation *endLoc,
2361	IdentifierInfo *ScopeName,
2362	SourceLocation ScopeLoc,
2363	ParsedAttr::Form Form);
2364
2365	/// Parse the contents of the "external_source_symbol" attribute.
2366	///
2367	/// \verbatim
2368	/// external-source-symbol-attribute:
2369	/// 'external_source_symbol' '(' keyword-arg-list ')'
2370	///
2371	/// keyword-arg-list:
2372	/// keyword-arg
2373	/// keyword-arg ',' keyword-arg-list
2374	///
2375	/// keyword-arg:
2376	/// 'language' '=' <string>
2377	/// 'defined_in' '=' <string>
2378	/// 'USR' '=' <string>
2379	/// 'generated_declaration'
2380	/// \endverbatim
2381	void ParseExternalSourceSymbolAttribute(IdentifierInfo &ExternalSourceSymbol,
2382	SourceLocation Loc,
2383	ParsedAttributes &Attrs,
2384	SourceLocation *EndLoc,
2385	IdentifierInfo *ScopeName,
2386	SourceLocation ScopeLoc,
2387	ParsedAttr::Form Form);
2388
2389	/// Parse the contents of the "objc_bridge_related" attribute.
2390	/// \verbatim
2391	/// objc_bridge_related '(' related_class ',' opt-class_method ',' opt-instance_method ')'
2392	/// related_class:
2393	/// Identifier
2394	///
2395	/// opt-class_method:
2396	/// Identifier: | <empty>
2397	///
2398	/// opt-instance_method:
2399	/// Identifier | <empty>
2400	/// \endverbatim
2401	///
2402	void ParseObjCBridgeRelatedAttribute(IdentifierInfo &ObjCBridgeRelated,
2403	SourceLocation ObjCBridgeRelatedLoc,
2404	ParsedAttributes &Attrs,
2405	SourceLocation *EndLoc,
2406	IdentifierInfo *ScopeName,
2407	SourceLocation ScopeLoc,
2408	ParsedAttr::Form Form);
2409
2410	void ParseSwiftNewTypeAttribute(IdentifierInfo &AttrName,
2411	SourceLocation AttrNameLoc,
2412	ParsedAttributes &Attrs,
2413	SourceLocation *EndLoc,
2414	IdentifierInfo *ScopeName,
2415	SourceLocation ScopeLoc,
2416	ParsedAttr::Form Form);
2417
2418	void ParseTypeTagForDatatypeAttribute(IdentifierInfo &AttrName,
2419	SourceLocation AttrNameLoc,
2420	ParsedAttributes &Attrs,
2421	SourceLocation *EndLoc,
2422	IdentifierInfo *ScopeName,
2423	SourceLocation ScopeLoc,
2424	ParsedAttr::Form Form);
2425
2426	void ParseAttributeWithTypeArg(IdentifierInfo &AttrName,
2427	SourceLocation AttrNameLoc,
2428	ParsedAttributes &Attrs,
2429	IdentifierInfo *ScopeName,
2430	SourceLocation ScopeLoc,
2431	ParsedAttr::Form Form);
2432
2433	void DistributeCLateParsedAttrs(Decl *Dcl, LateParsedAttrList *LateAttrs);
2434
2435	/// Bounds attributes (e.g., counted_by):
2436	/// \verbatim
2437	/// AttrName '(' expression ')'
2438	/// \endverbatim
2439	void ParseBoundsAttribute(IdentifierInfo &AttrName,
2440	SourceLocation AttrNameLoc, ParsedAttributes &Attrs,
2441	IdentifierInfo *ScopeName, SourceLocation ScopeLoc,
2442	ParsedAttr::Form Form);
2443
2444	/// \verbatim
2445	/// [GNU] typeof-specifier:
2446	/// typeof ( expressions )
2447	/// typeof ( type-name )
2448	/// [GNU/C++] typeof unary-expression
2449	/// [C23] typeof-specifier:
2450	/// typeof '(' typeof-specifier-argument ')'
2451	/// typeof_unqual '(' typeof-specifier-argument ')'
2452	///
2453	/// typeof-specifier-argument:
2454	/// expression
2455	/// type-name
2456	/// \endverbatim
2457	///
2458	void ParseTypeofSpecifier(DeclSpec &DS);
2459
2460	/// \verbatim
2461	/// [C11] atomic-specifier:
2462	/// _Atomic ( type-name )
2463	/// \endverbatim
2464	///
2465	void ParseAtomicSpecifier(DeclSpec &DS);
2466
2467	/// ParseAlignArgument - Parse the argument to an alignment-specifier.
2468	///
2469	/// \verbatim
2470	/// [C11] type-id
2471	/// [C11] constant-expression
2472	/// [C++0x] type-id ...[opt]
2473	/// [C++0x] assignment-expression ...[opt]
2474	/// \endverbatim
2475	ExprResult ParseAlignArgument(StringRef KWName, SourceLocation Start,
2476	SourceLocation &EllipsisLoc, bool &IsType,
2477	ParsedType &Ty);
2478
2479	/// ParseAlignmentSpecifier - Parse an alignment-specifier, and add the
2480	/// attribute to Attrs.
2481	///
2482	/// \verbatim
2483	/// alignment-specifier:
2484	/// [C11] '_Alignas' '(' type-id ')'
2485	/// [C11] '_Alignas' '(' constant-expression ')'
2486	/// [C++11] 'alignas' '(' type-id ...[opt] ')'
2487	/// [C++11] 'alignas' '(' assignment-expression ...[opt] ')'
2488	/// \endverbatim
2489	void ParseAlignmentSpecifier(ParsedAttributes &Attrs,
2490	SourceLocation *endLoc = nullptr);
2491	ExprResult ParseExtIntegerArgument();
2492
2493	/// \verbatim
2494	/// type-qualifier:
2495	/// ('__ptrauth') '(' constant-expression
2496	/// (',' constant-expression)[opt]
2497	/// (',' constant-expression)[opt] ')'
2498	/// \endverbatim
2499	void ParsePtrauthQualifier(ParsedAttributes &Attrs);
2500
2501	/// DeclaratorScopeObj - RAII object used in Parser::ParseDirectDeclarator to
2502	/// enter a new C++ declarator scope and exit it when the function is
2503	/// finished.
2504	class DeclaratorScopeObj {
2505	Parser &P;
2506	CXXScopeSpec &SS;
2507	bool EnteredScope;
2508	bool CreatedScope;
2509
2510	public:
2511	DeclaratorScopeObj(Parser &p, CXXScopeSpec &ss)
2512	: P(p), SS(ss), EnteredScope(false), CreatedScope(false) {}
2513
2514	void EnterDeclaratorScope() {
2515	assert(!EnteredScope && "Already entered the scope!");
2516	assert(SS.isSet() && "C++ scope was not set!");
2517
2518	CreatedScope = true;
2519	P.EnterScope(ScopeFlags: 0); // Not a decl scope.
2520
2521	if (!P.Actions.ActOnCXXEnterDeclaratorScope(S: P.getCurScope(), SS))
2522	EnteredScope = true;
2523	}
2524
2525	~DeclaratorScopeObj() {
2526	if (EnteredScope) {
2527	assert(SS.isSet() && "C++ scope was cleared ?");
2528	P.Actions.ActOnCXXExitDeclaratorScope(S: P.getCurScope(), SS);
2529	}
2530	if (CreatedScope)
2531	P.ExitScope();
2532	}
2533	};
2534
2535	/// ParseDeclarator - Parse and verify a newly-initialized declarator.
2536	void ParseDeclarator(Declarator &D);
2537	/// A function that parses a variant of direct-declarator.
2538	typedef void (Parser::*DirectDeclParseFunction)(Declarator &);
2539
2540	/// ParseDeclaratorInternal - Parse a C or C++ declarator. The
2541	/// direct-declarator is parsed by the function passed to it. Pass null, and
2542	/// the direct-declarator isn't parsed at all, making this function
2543	/// effectively parse the C++ ptr-operator production.
2544	///
2545	/// If the grammar of this construct is extended, matching changes must also
2546	/// be made to TryParseDeclarator and MightBeDeclarator, and possibly to
2547	/// isConstructorDeclarator.
2548	///
2549	/// \verbatim
2550	/// declarator: [C99 6.7.5] [C++ 8p4, dcl.decl]
2551	/// [C] pointer[opt] direct-declarator
2552	/// [C++] direct-declarator
2553	/// [C++] ptr-operator declarator
2554	///
2555	/// pointer: [C99 6.7.5]
2556	/// '*' type-qualifier-list[opt]
2557	/// '*' type-qualifier-list[opt] pointer
2558	///
2559	/// ptr-operator:
2560	/// '*' cv-qualifier-seq[opt]
2561	/// '&'
2562	/// [C++0x] '&&'
2563	/// [GNU] '&' restrict[opt] attributes[opt]
2564	/// [GNU?] '&&' restrict[opt] attributes[opt]
2565	/// '::'[opt] nested-name-specifier '*' cv-qualifier-seq[opt]
2566	/// \endverbatim
2567	void ParseDeclaratorInternal(Declarator &D,
2568	DirectDeclParseFunction DirectDeclParser);
2569
2570	enum AttrRequirements {
2571	AR_NoAttributesParsed = 0, ///< No attributes are diagnosed.
2572	AR_GNUAttributesParsedAndRejected = 1 << 0, ///< Diagnose GNU attributes.
2573	AR_GNUAttributesParsed = 1 << 1,
2574	AR_CXX11AttributesParsed = 1 << 2,
2575	AR_DeclspecAttributesParsed = 1 << 3,
2576	AR_AllAttributesParsed = AR_GNUAttributesParsed | AR_CXX11AttributesParsed |
2577	AR_DeclspecAttributesParsed,
2578	AR_VendorAttributesParsed =
2579	AR_GNUAttributesParsed | AR_DeclspecAttributesParsed
2580	};
2581
2582	/// ParseTypeQualifierListOpt
2583	/// \verbatim
2584	/// type-qualifier-list: [C99 6.7.5]
2585	/// type-qualifier
2586	/// [vendor] attributes
2587	/// [ only if AttrReqs & AR_VendorAttributesParsed ]
2588	/// type-qualifier-list type-qualifier
2589	/// [vendor] type-qualifier-list attributes
2590	/// [ only if AttrReqs & AR_VendorAttributesParsed ]
2591	/// [C++0x] attribute-specifier[opt] is allowed before cv-qualifier-seq
2592	/// [ only if AttReqs & AR_CXX11AttributesParsed ]
2593	/// \endverbatim
2594	/// Note: vendor can be GNU, MS, etc and can be explicitly controlled via
2595	/// AttrRequirements bitmask values.
2596	void ParseTypeQualifierListOpt(
2597	DeclSpec &DS, unsigned AttrReqs = AR_AllAttributesParsed,
2598	bool AtomicOrPtrauthAllowed = true, bool IdentifierRequired = false,
2599	llvm::function_ref<void()> CodeCompletionHandler = {});
2600
2601	/// ParseDirectDeclarator
2602	/// \verbatim
2603	/// direct-declarator: [C99 6.7.5]
2604	/// [C99] identifier
2605	/// '(' declarator ')'
2606	/// [GNU] '(' attributes declarator ')'
2607	/// [C90] direct-declarator '[' constant-expression[opt] ']'
2608	/// [C99] direct-declarator '[' type-qual-list[opt] assignment-expr[opt] ']'
2609	/// [C99] direct-declarator '[' 'static' type-qual-list[opt] assign-expr ']'
2610	/// [C99] direct-declarator '[' type-qual-list 'static' assignment-expr ']'
2611	/// [C99] direct-declarator '[' type-qual-list[opt] '*' ']'
2612	/// [C++11] direct-declarator '[' constant-expression[opt] ']'
2613	/// attribute-specifier-seq[opt]
2614	/// direct-declarator '(' parameter-type-list ')'
2615	/// direct-declarator '(' identifier-list[opt] ')'
2616	/// [GNU] direct-declarator '(' parameter-forward-declarations
2617	/// parameter-type-list[opt] ')'
2618	/// [C++] direct-declarator '(' parameter-declaration-clause ')'
2619	/// cv-qualifier-seq[opt] exception-specification[opt]
2620	/// [C++11] direct-declarator '(' parameter-declaration-clause ')'
2621	/// attribute-specifier-seq[opt] cv-qualifier-seq[opt]
2622	/// ref-qualifier[opt] exception-specification[opt]
2623	/// [C++] declarator-id
2624	/// [C++11] declarator-id attribute-specifier-seq[opt]
2625	///
2626	/// declarator-id: [C++ 8]
2627	/// '...'[opt] id-expression
2628	/// '::'[opt] nested-name-specifier[opt] type-name
2629	///
2630	/// id-expression: [C++ 5.1]
2631	/// unqualified-id
2632	/// qualified-id
2633	///
2634	/// unqualified-id: [C++ 5.1]
2635	/// identifier
2636	/// operator-function-id
2637	/// conversion-function-id
2638	/// '~' class-name
2639	/// template-id
2640	///
2641	/// C++17 adds the following, which we also handle here:
2642	///
2643	/// simple-declaration:
2644	/// <decl-spec> '[' identifier-list ']' brace-or-equal-initializer ';'
2645	/// \endverbatim
2646	///
2647	/// Note, any additional constructs added here may need corresponding changes
2648	/// in isConstructorDeclarator.
2649	void ParseDirectDeclarator(Declarator &D);
2650	void ParseDecompositionDeclarator(Declarator &D);
2651
2652	/// ParseParenDeclarator - We parsed the declarator D up to a paren. This is
2653	/// only called before the identifier, so these are most likely just grouping
2654	/// parens for precedence. If we find that these are actually function
2655	/// parameter parens in an abstract-declarator, we call
2656	/// ParseFunctionDeclarator.
2657	///
2658	/// \verbatim
2659	/// direct-declarator:
2660	/// '(' declarator ')'
2661	/// [GNU] '(' attributes declarator ')'
2662	/// direct-declarator '(' parameter-type-list ')'
2663	/// direct-declarator '(' identifier-list[opt] ')'
2664	/// [GNU] direct-declarator '(' parameter-forward-declarations
2665	/// parameter-type-list[opt] ')'
2666	/// \endverbatim
2667	///
2668	void ParseParenDeclarator(Declarator &D);
2669
2670	/// ParseFunctionDeclarator - We are after the identifier and have parsed the
2671	/// declarator D up to a paren, which indicates that we are parsing function
2672	/// arguments.
2673	///
2674	/// If FirstArgAttrs is non-null, then the caller parsed those attributes
2675	/// immediately after the open paren - they will be applied to the DeclSpec
2676	/// of the first parameter.
2677	///
2678	/// If RequiresArg is true, then the first argument of the function is
2679	/// required to be present and required to not be an identifier list.
2680	///
2681	/// For C++, after the parameter-list, it also parses the
2682	/// cv-qualifier-seq[opt], (C++11) ref-qualifier[opt],
2683	/// exception-specification[opt], (C++11) attribute-specifier-seq[opt],
2684	/// (C++11) trailing-return-type[opt] and (C++2a) the trailing
2685	/// requires-clause.
2686	///
2687	/// \verbatim
2688	/// [C++11] exception-specification:
2689	/// dynamic-exception-specification
2690	/// noexcept-specification
2691	/// \endverbatim
2692	///
2693	void ParseFunctionDeclarator(Declarator &D, ParsedAttributes &FirstArgAttrs,
2694	BalancedDelimiterTracker &Tracker,
2695	bool IsAmbiguous, bool RequiresArg = false);
2696	void InitCXXThisScopeForDeclaratorIfRelevant(
2697	const Declarator &D, const DeclSpec &DS,
2698	std::optional<Sema::CXXThisScopeRAII> &ThisScope);
2699
2700	/// ParseRefQualifier - Parses a member function ref-qualifier. Returns
2701	/// true if a ref-qualifier is found.
2702	bool ParseRefQualifier(bool &RefQualifierIsLValueRef,
2703	SourceLocation &RefQualifierLoc);
2704
2705	/// isFunctionDeclaratorIdentifierList - This parameter list may have an
2706	/// identifier list form for a K&R-style function: void foo(a,b,c)
2707	///
2708	/// Note that identifier-lists are only allowed for normal declarators, not
2709	/// for abstract-declarators.
2710	bool isFunctionDeclaratorIdentifierList();
2711
2712	/// ParseFunctionDeclaratorIdentifierList - While parsing a function
2713	/// declarator we found a K&R-style identifier list instead of a typed
2714	/// parameter list.
2715	///
2716	/// After returning, ParamInfo will hold the parsed parameters.
2717	///
2718	/// \verbatim
2719	/// identifier-list: [C99 6.7.5]
2720	/// identifier
2721	/// identifier-list ',' identifier
2722	/// \endverbatim
2723	///
2724	void ParseFunctionDeclaratorIdentifierList(
2725	Declarator &D, SmallVectorImpl<DeclaratorChunk::ParamInfo> &ParamInfo);
2726	void ParseParameterDeclarationClause(
2727	Declarator &D, ParsedAttributes &attrs,
2728	SmallVectorImpl<DeclaratorChunk::ParamInfo> &ParamInfo,
2729	SourceLocation &EllipsisLoc) {
2730	return ParseParameterDeclarationClause(
2731	DeclaratorContext: D.getContext(), attrs, ParamInfo, EllipsisLoc,
2732	IsACXXFunctionDeclaration: D.getCXXScopeSpec().isSet() &&
2733	D.isFunctionDeclaratorAFunctionDeclaration());
2734	}
2735
2736	/// ParseParameterDeclarationClause - Parse a (possibly empty) parameter-list
2737	/// after the opening parenthesis. This function will not parse a K&R-style
2738	/// identifier list.
2739	///
2740	/// DeclContext is the context of the declarator being parsed. If
2741	/// FirstArgAttrs is non-null, then the caller parsed those attributes
2742	/// immediately after the open paren - they will be applied to the DeclSpec of
2743	/// the first parameter.
2744	///
2745	/// After returning, ParamInfo will hold the parsed parameters. EllipsisLoc
2746	/// will be the location of the ellipsis, if any was parsed.
2747	///
2748	/// \verbatim
2749	/// parameter-type-list: [C99 6.7.5]
2750	/// parameter-list
2751	/// parameter-list ',' '...'
2752	/// [C++] parameter-list '...'
2753	///
2754	/// parameter-list: [C99 6.7.5]
2755	/// parameter-declaration
2756	/// parameter-list ',' parameter-declaration
2757	///
2758	/// parameter-declaration: [C99 6.7.5]
2759	/// declaration-specifiers declarator
2760	/// [C++] declaration-specifiers declarator '=' assignment-expression
2761	/// [C++11] initializer-clause
2762	/// [GNU] declaration-specifiers declarator attributes
2763	/// declaration-specifiers abstract-declarator[opt]
2764	/// [C++] declaration-specifiers abstract-declarator[opt]
2765	/// '=' assignment-expression
2766	/// [GNU] declaration-specifiers abstract-declarator[opt] attributes
2767	/// [C++11] attribute-specifier-seq parameter-declaration
2768	/// [C++2b] attribute-specifier-seq 'this' parameter-declaration
2769	/// \endverbatim
2770	///
2771	void ParseParameterDeclarationClause(
2772	DeclaratorContext DeclaratorContext, ParsedAttributes &attrs,
2773	SmallVectorImpl<DeclaratorChunk::ParamInfo> &ParamInfo,
2774	SourceLocation &EllipsisLoc, bool IsACXXFunctionDeclaration = false);
2775
2776	/// \verbatim
2777	/// [C90] direct-declarator '[' constant-expression[opt] ']'
2778	/// [C99] direct-declarator '[' type-qual-list[opt] assignment-expr[opt] ']'
2779	/// [C99] direct-declarator '[' 'static' type-qual-list[opt] assign-expr ']'
2780	/// [C99] direct-declarator '[' type-qual-list 'static' assignment-expr ']'
2781	/// [C99] direct-declarator '[' type-qual-list[opt] '*' ']'
2782	/// [C++11] direct-declarator '[' constant-expression[opt] ']'
2783	/// attribute-specifier-seq[opt]
2784	/// \endverbatim
2785	void ParseBracketDeclarator(Declarator &D);
2786
2787	/// Diagnose brackets before an identifier.
2788	void ParseMisplacedBracketDeclarator(Declarator &D);
2789
2790	/// Parse the given string as a type.
2791	///
2792	/// This is a dangerous utility function currently employed only by API notes.
2793	/// It is not a general entry-point for safely parsing types from strings.
2794	///
2795	/// \param TypeStr The string to be parsed as a type.
2796	/// \param Context The name of the context in which this string is being
2797	/// parsed, which will be used in diagnostics.
2798	/// \param IncludeLoc The location at which this parse was triggered.
2799	TypeResult ParseTypeFromString(StringRef TypeStr, StringRef Context,
2800	SourceLocation IncludeLoc);
2801
2802	///@}
2803
2804	//
2805	//
2806	// -------------------------------------------------------------------------
2807	//
2808	//
2809
2810	/// \name C++ Declarations
2811	/// Implementations are in ParseDeclCXX.cpp
2812	///@{
2813
2814	private:
2815	/// Contextual keywords for Microsoft extensions.
2816	mutable IdentifierInfo *Ident_sealed;
2817	mutable IdentifierInfo *Ident_abstract;
2818
2819	/// C++11 contextual keywords.
2820	mutable IdentifierInfo *Ident_final;
2821	mutable IdentifierInfo *Ident_GNU_final;
2822	mutable IdentifierInfo *Ident_override;
2823	mutable IdentifierInfo *Ident_trivially_relocatable_if_eligible;
2824	mutable IdentifierInfo *Ident_replaceable_if_eligible;
2825
2826	/// Representation of a class that has been parsed, including
2827	/// any member function declarations or definitions that need to be
2828	/// parsed after the corresponding top-level class is complete.
2829	struct ParsingClass {
2830	ParsingClass(Decl *TagOrTemplate, bool TopLevelClass, bool IsInterface)
2831	: TopLevelClass(TopLevelClass), IsInterface(IsInterface),
2832	TagOrTemplate(TagOrTemplate) {}
2833
2834	/// Whether this is a "top-level" class, meaning that it is
2835	/// not nested within another class.
2836	bool TopLevelClass : 1;
2837
2838	/// Whether this class is an __interface.
2839	bool IsInterface : 1;
2840
2841	/// The class or class template whose definition we are parsing.
2842	Decl *TagOrTemplate;
2843
2844	/// LateParsedDeclarations - Method declarations, inline definitions and
2845	/// nested classes that contain pieces whose parsing will be delayed until
2846	/// the top-level class is fully defined.
2847	LateParsedDeclarationsContainer LateParsedDeclarations;
2848	};
2849
2850	/// The stack of classes that is currently being
2851	/// parsed. Nested and local classes will be pushed onto this stack
2852	/// when they are parsed, and removed afterward.
2853	std::stack<ParsingClass *> ClassStack;
2854
2855	ParsingClass &getCurrentClass() {
2856	assert(!ClassStack.empty() && "No lexed method stacks!");
2857	return *ClassStack.top();
2858	}
2859
2860	/// RAII object used to manage the parsing of a class definition.
2861	class ParsingClassDefinition {
2862	Parser &P;
2863	bool Popped;
2864	Sema::ParsingClassState State;
2865
2866	public:
2867	ParsingClassDefinition(Parser &P, Decl *TagOrTemplate, bool TopLevelClass,
2868	bool IsInterface)
2869	: P(P), Popped(false),
2870	State(P.PushParsingClass(TagOrTemplate, TopLevelClass, IsInterface)) {
2871	}
2872
2873	/// Pop this class of the stack.
2874	void Pop() {
2875	assert(!Popped && "Nested class has already been popped");
2876	Popped = true;
2877	P.PopParsingClass(State);
2878	}
2879
2880	~ParsingClassDefinition() {
2881	if (!Popped)
2882	P.PopParsingClass(State);
2883	}
2884	};
2885
2886	/// Parse a C++ exception-specification if present (C++0x [except.spec]).
2887	///
2888	/// \verbatim
2889	/// exception-specification:
2890	/// dynamic-exception-specification
2891	/// noexcept-specification
2892	///
2893	/// noexcept-specification:
2894	/// 'noexcept'
2895	/// 'noexcept' '(' constant-expression ')'
2896	/// \endverbatim
2897	ExceptionSpecificationType tryParseExceptionSpecification(
2898	bool Delayed, SourceRange &SpecificationRange,
2899	SmallVectorImpl<ParsedType> &DynamicExceptions,
2900	SmallVectorImpl<SourceRange> &DynamicExceptionRanges,
2901	ExprResult &NoexceptExpr, CachedTokens *&ExceptionSpecTokens);
2902
2903	/// ParseDynamicExceptionSpecification - Parse a C++
2904	/// dynamic-exception-specification (C++ [except.spec]).
2905	/// EndLoc is filled with the location of the last token of the specification.
2906	///
2907	/// \verbatim
2908	/// dynamic-exception-specification:
2909	/// 'throw' '(' type-id-list [opt] ')'
2910	/// [MS] 'throw' '(' '...' ')'
2911	///
2912	/// type-id-list:
2913	/// type-id ... [opt]
2914	/// type-id-list ',' type-id ... [opt]
2915	/// \endverbatim
2916	///
2917	ExceptionSpecificationType
2918	ParseDynamicExceptionSpecification(SourceRange &SpecificationRange,
2919	SmallVectorImpl<ParsedType> &Exceptions,
2920	SmallVectorImpl<SourceRange> &Ranges);
2921
2922	//===--------------------------------------------------------------------===//
2923	// C++0x 8: Function declaration trailing-return-type
2924
2925	/// ParseTrailingReturnType - Parse a trailing return type on a new-style
2926	/// function declaration.
2927	TypeResult ParseTrailingReturnType(SourceRange &Range,
2928	bool MayBeFollowedByDirectInit);
2929
2930	/// Parse a requires-clause as part of a function declaration.
2931	void ParseTrailingRequiresClause(Declarator &D);
2932
2933	void ParseMicrosoftIfExistsClassDeclaration(DeclSpec::TST TagType,
2934	ParsedAttributes &AccessAttrs,
2935	AccessSpecifier &CurAS);
2936
2937	SourceLocation ParsePackIndexingType(DeclSpec &DS);
2938	void AnnotateExistingIndexedTypeNamePack(ParsedType T,
2939	SourceLocation StartLoc,
2940	SourceLocation EndLoc);
2941
2942	/// Return true if the next token should be treated as a [[]] attribute,
2943	/// or as a keyword that behaves like one. The former is only true if
2944	/// [[]] attributes are enabled, whereas the latter is true whenever
2945	/// such a keyword appears. The arguments are as for
2946	/// isCXX11AttributeSpecifier.
2947	bool isAllowedCXX11AttributeSpecifier(bool Disambiguate = false,
2948	bool OuterMightBeMessageSend = false) {
2949	return (Tok.isRegularKeywordAttribute() ||
2950	isCXX11AttributeSpecifier(Disambiguate, OuterMightBeMessageSend) !=
2951	CXX11AttributeKind::NotAttributeSpecifier);
2952	}
2953
2954	/// Skip C++11 and C23 attributes and return the end location of the
2955	/// last one.
2956	/// \returns SourceLocation() if there are no attributes.
2957	SourceLocation SkipCXX11Attributes();
2958
2959	/// Diagnose and skip C++11 and C23 attributes that appear in syntactic
2960	/// locations where attributes are not allowed.
2961	void DiagnoseAndSkipCXX11Attributes();
2962
2963	void ParseOpenMPAttributeArgs(const IdentifierInfo *AttrName,
2964	CachedTokens &OpenMPTokens);
2965
2966	/// Parse a C++11 or C23 attribute-specifier.
2967	///
2968	/// \verbatim
2969	/// [C++11] attribute-specifier:
2970	/// '[' '[' attribute-list ']' ']'
2971	/// alignment-specifier
2972	///
2973	/// [C++11] attribute-list:
2974	/// attribute[opt]
2975	/// attribute-list ',' attribute[opt]
2976	/// attribute '...'
2977	/// attribute-list ',' attribute '...'
2978	///
2979	/// [C++11] attribute:
2980	/// attribute-token attribute-argument-clause[opt]
2981	///
2982	/// [C++11] attribute-token:
2983	/// identifier
2984	/// attribute-scoped-token
2985	///
2986	/// [C++11] attribute-scoped-token:
2987	/// attribute-namespace '::' identifier
2988	///
2989	/// [C++11] attribute-namespace:
2990	/// identifier
2991	/// \endverbatim
2992	void ParseCXX11AttributeSpecifierInternal(ParsedAttributes &Attrs,
2993	CachedTokens &OpenMPTokens,
2994	SourceLocation *EndLoc = nullptr);
2995	void ParseCXX11AttributeSpecifier(ParsedAttributes &Attrs,
2996	SourceLocation *EndLoc = nullptr) {
2997	CachedTokens OpenMPTokens;
2998	ParseCXX11AttributeSpecifierInternal(Attrs, OpenMPTokens, EndLoc);
2999	ReplayOpenMPAttributeTokens(OpenMPTokens);
3000	}
3001
3002	/// ParseCXX11Attributes - Parse a C++11 or C23 attribute-specifier-seq.
3003	///
3004	/// \verbatim
3005	/// attribute-specifier-seq:
3006	/// attribute-specifier-seq[opt] attribute-specifier
3007	/// \endverbatim
3008	void ParseCXX11Attributes(ParsedAttributes &attrs);
3009
3010	/// ParseCXX11AttributeArgs -- Parse a C++11 attribute-argument-clause.
3011	/// Parses a C++11 (or C23)-style attribute argument list. Returns true
3012	/// if this results in adding an attribute to the ParsedAttributes list.
3013	///
3014	/// \verbatim
3015	/// [C++11] attribute-argument-clause:
3016	/// '(' balanced-token-seq ')'
3017	///
3018	/// [C++11] balanced-token-seq:
3019	/// balanced-token
3020	/// balanced-token-seq balanced-token
3021	///
3022	/// [C++11] balanced-token:
3023	/// '(' balanced-token-seq ')'
3024	/// '[' balanced-token-seq ']'
3025	/// '{' balanced-token-seq '}'
3026	/// any token but '(', ')', '[', ']', '{', or '}'
3027	/// \endverbatim
3028	bool ParseCXX11AttributeArgs(IdentifierInfo *AttrName,
3029	SourceLocation AttrNameLoc,
3030	ParsedAttributes &Attrs, SourceLocation *EndLoc,
3031	IdentifierInfo *ScopeName,
3032	SourceLocation ScopeLoc,
3033	CachedTokens &OpenMPTokens);
3034
3035	/// Parse the argument to C++23's [[assume()]] attribute. Returns true on
3036	/// error.
3037	bool
3038	ParseCXXAssumeAttributeArg(ParsedAttributes &Attrs, IdentifierInfo *AttrName,
3039	SourceLocation AttrNameLoc,
3040	IdentifierInfo *ScopeName, SourceLocation ScopeLoc,
3041	SourceLocation *EndLoc, ParsedAttr::Form Form);
3042
3043	/// Try to parse an 'identifier' which appears within an attribute-token.
3044	///
3045	/// \return the parsed identifier on success, and 0 if the next token is not
3046	/// an attribute-token.
3047	///
3048	/// C++11 [dcl.attr.grammar]p3:
3049	/// If a keyword or an alternative token that satisfies the syntactic
3050	/// requirements of an identifier is contained in an attribute-token,
3051	/// it is considered an identifier.
3052	IdentifierInfo *TryParseCXX11AttributeIdentifier(
3053	SourceLocation &Loc,
3054	SemaCodeCompletion::AttributeCompletion Completion =
3055	SemaCodeCompletion::AttributeCompletion::None,
3056	const IdentifierInfo *EnclosingScope = nullptr);
3057
3058	/// Parse uuid() attribute when it appears in a [] Microsoft attribute.
3059	void ParseMicrosoftUuidAttributeArgs(ParsedAttributes &Attrs);
3060
3061	/// ParseMicrosoftAttributes - Parse Microsoft attributes [Attr]
3062	///
3063	/// \verbatim
3064	/// [MS] ms-attribute:
3065	/// '[' token-seq ']'
3066	///
3067	/// [MS] ms-attribute-seq:
3068	/// ms-attribute[opt]
3069	/// ms-attribute ms-attribute-seq
3070	/// \endverbatim
3071	void ParseMicrosoftAttributes(ParsedAttributes &Attrs);
3072
3073	void ParseMicrosoftInheritanceClassAttributes(ParsedAttributes &attrs);
3074	void ParseNullabilityClassAttributes(ParsedAttributes &attrs);
3075
3076	/// ParseDecltypeSpecifier - Parse a C++11 decltype specifier.
3077	///
3078	/// \verbatim
3079	/// 'decltype' ( expression )
3080	/// 'decltype' ( 'auto' ) [C++1y]
3081	/// \endverbatim
3082	///
3083	SourceLocation ParseDecltypeSpecifier(DeclSpec &DS);
3084	void AnnotateExistingDecltypeSpecifier(const DeclSpec &DS,
3085	SourceLocation StartLoc,
3086	SourceLocation EndLoc);
3087
3088	/// isCXX11VirtSpecifier - Determine whether the given token is a C++11
3089	/// virt-specifier.
3090	///
3091	/// \verbatim
3092	/// virt-specifier:
3093	/// override
3094	/// final
3095	/// __final
3096	/// \endverbatim
3097	VirtSpecifiers::Specifier isCXX11VirtSpecifier(const Token &Tok) const;
3098	VirtSpecifiers::Specifier isCXX11VirtSpecifier() const {
3099	return isCXX11VirtSpecifier(Tok);
3100	}
3101
3102	/// ParseOptionalCXX11VirtSpecifierSeq - Parse a virt-specifier-seq.
3103	///
3104	/// \verbatim
3105	/// virt-specifier-seq:
3106	/// virt-specifier
3107	/// virt-specifier-seq virt-specifier
3108	/// \endverbatim
3109	void ParseOptionalCXX11VirtSpecifierSeq(VirtSpecifiers &VS, bool IsInterface,
3110	SourceLocation FriendLoc);
3111
3112	/// isCXX11FinalKeyword - Determine whether the next token is a C++11
3113	/// 'final' or Microsoft 'sealed' contextual keyword.
3114	bool isCXX11FinalKeyword() const;
3115
3116	/// isClassCompatibleKeyword - Determine whether the next token is a C++11
3117	/// 'final', a C++26 'trivially_relocatable_if_eligible',
3118	/// 'replaceable_if_eligible', or Microsoft 'sealed' or 'abstract' contextual
3119	/// keyword.
3120	bool isClassCompatibleKeyword() const;
3121
3122	bool MaybeParseTypeTransformTypeSpecifier(DeclSpec &DS);
3123	DeclSpec::TST TypeTransformTokToDeclSpec();
3124
3125	void DiagnoseUnexpectedNamespace(NamedDecl *Context);
3126
3127	/// ParseNamespace - We know that the current token is a namespace keyword.
3128	/// This may either be a top level namespace or a block-level namespace alias.
3129	/// If there was an inline keyword, it has already been parsed.
3130	///
3131	/// \verbatim
3132	/// namespace-definition: [C++: namespace.def]
3133	/// named-namespace-definition
3134	/// unnamed-namespace-definition
3135	/// nested-namespace-definition
3136	///
3137	/// named-namespace-definition:
3138	/// 'inline'[opt] 'namespace' attributes[opt] identifier '{'
3139	/// namespace-body '}'
3140	///
3141	/// unnamed-namespace-definition:
3142	/// 'inline'[opt] 'namespace' attributes[opt] '{' namespace-body '}'
3143	///
3144	/// nested-namespace-definition:
3145	/// 'namespace' enclosing-namespace-specifier '::' 'inline'[opt]
3146	/// identifier '{' namespace-body '}'
3147	///
3148	/// enclosing-namespace-specifier:
3149	/// identifier
3150	/// enclosing-namespace-specifier '::' 'inline'[opt] identifier
3151	///
3152	/// namespace-alias-definition: [C++ 7.3.2: namespace.alias]
3153	/// 'namespace' identifier '=' qualified-namespace-specifier ';'
3154	/// \endverbatim
3155	///
3156	DeclGroupPtrTy ParseNamespace(DeclaratorContext Context,
3157	SourceLocation &DeclEnd,
3158	SourceLocation InlineLoc = SourceLocation());
3159
3160	struct InnerNamespaceInfo {
3161	SourceLocation NamespaceLoc;
3162	SourceLocation InlineLoc;
3163	SourceLocation IdentLoc;
3164	IdentifierInfo *Ident;
3165	};
3166	using InnerNamespaceInfoList = llvm::SmallVector<InnerNamespaceInfo, 4>;
3167
3168	/// ParseInnerNamespace - Parse the contents of a namespace.
3169	void ParseInnerNamespace(const InnerNamespaceInfoList &InnerNSs,
3170	unsigned int index, SourceLocation &InlineLoc,
3171	ParsedAttributes &attrs,
3172	BalancedDelimiterTracker &Tracker);
3173
3174	/// ParseLinkage - We know that the current token is a string_literal
3175	/// and just before that, that extern was seen.
3176	///
3177	/// \verbatim
3178	/// linkage-specification: [C++ 7.5p2: dcl.link]
3179	/// 'extern' string-literal '{' declaration-seq[opt] '}'
3180	/// 'extern' string-literal declaration
3181	/// \endverbatim
3182	///
3183	Decl *ParseLinkage(ParsingDeclSpec &DS, DeclaratorContext Context);
3184
3185	/// Parse a standard C++ Modules export-declaration.
3186	///
3187	/// \verbatim
3188	/// export-declaration:
3189	/// 'export' declaration
3190	/// 'export' '{' declaration-seq[opt] '}'
3191	/// \endverbatim
3192	///
3193	/// HLSL: Parse export function declaration.
3194	///
3195	/// \verbatim
3196	/// export-function-declaration:
3197	/// 'export' function-declaration
3198	///
3199	/// export-declaration-group:
3200	/// 'export' '{' function-declaration-seq[opt] '}'
3201	/// \endverbatim
3202	///
3203	Decl *ParseExportDeclaration();
3204
3205	/// ParseUsingDirectiveOrDeclaration - Parse C++ using using-declaration or
3206	/// using-directive. Assumes that current token is 'using'.
3207	DeclGroupPtrTy ParseUsingDirectiveOrDeclaration(
3208	DeclaratorContext Context, const ParsedTemplateInfo &TemplateInfo,
3209	SourceLocation &DeclEnd, ParsedAttributes &Attrs);
3210
3211	/// ParseUsingDirective - Parse C++ using-directive, assumes
3212	/// that current token is 'namespace' and 'using' was already parsed.
3213	///
3214	/// \verbatim
3215	/// using-directive: [C++ 7.3.p4: namespace.udir]
3216	/// 'using' 'namespace' ::[opt] nested-name-specifier[opt]
3217	/// namespace-name ;
3218	/// [GNU] using-directive:
3219	/// 'using' 'namespace' ::[opt] nested-name-specifier[opt]
3220	/// namespace-name attributes[opt] ;
3221	/// \endverbatim
3222	///
3223	Decl *ParseUsingDirective(DeclaratorContext Context, SourceLocation UsingLoc,
3224	SourceLocation &DeclEnd, ParsedAttributes &attrs);
3225
3226	struct UsingDeclarator {
3227	SourceLocation TypenameLoc;
3228	CXXScopeSpec SS;
3229	UnqualifiedId Name;
3230	SourceLocation EllipsisLoc;
3231
3232	void clear() {
3233	TypenameLoc = EllipsisLoc = SourceLocation();
3234	SS.clear();
3235	Name.clear();
3236	}
3237	};
3238
3239	/// Parse a using-declarator (or the identifier in a C++11 alias-declaration).
3240	///
3241	/// \verbatim
3242	/// using-declarator:
3243	/// 'typename'[opt] nested-name-specifier unqualified-id
3244	/// \endverbatim
3245	///
3246	bool ParseUsingDeclarator(DeclaratorContext Context, UsingDeclarator &D);
3247
3248	/// ParseUsingDeclaration - Parse C++ using-declaration or alias-declaration.
3249	/// Assumes that 'using' was already seen.
3250	///
3251	/// \verbatim
3252	/// using-declaration: [C++ 7.3.p3: namespace.udecl]
3253	/// 'using' using-declarator-list[opt] ;
3254	///
3255	/// using-declarator-list: [C++1z]
3256	/// using-declarator '...'[opt]
3257	/// using-declarator-list ',' using-declarator '...'[opt]
3258	///
3259	/// using-declarator-list: [C++98-14]
3260	/// using-declarator
3261	///
3262	/// alias-declaration: C++11 [dcl.dcl]p1
3263	/// 'using' identifier attribute-specifier-seq[opt] = type-id ;
3264	///
3265	/// using-enum-declaration: [C++20, dcl.enum]
3266	/// 'using' elaborated-enum-specifier ;
3267	/// The terminal name of the elaborated-enum-specifier undergoes
3268	/// type-only lookup
3269	///
3270	/// elaborated-enum-specifier:
3271	/// 'enum' nested-name-specifier[opt] identifier
3272	/// \endverbatim
3273	DeclGroupPtrTy ParseUsingDeclaration(DeclaratorContext Context,
3274	const ParsedTemplateInfo &TemplateInfo,
3275	SourceLocation UsingLoc,
3276	SourceLocation &DeclEnd,
3277	ParsedAttributes &Attrs,
3278	AccessSpecifier AS = AS_none);
3279	Decl *ParseAliasDeclarationAfterDeclarator(
3280	const ParsedTemplateInfo &TemplateInfo, SourceLocation UsingLoc,
3281	UsingDeclarator &D, SourceLocation &DeclEnd, AccessSpecifier AS,
3282	ParsedAttributes &Attrs, Decl **OwnedType = nullptr);
3283
3284	/// ParseStaticAssertDeclaration - Parse C++0x or C11
3285	/// static_assert-declaration.
3286	///
3287	/// \verbatim
3288	/// [C++0x] static_assert-declaration:
3289	/// static_assert ( constant-expression , string-literal ) ;
3290	///
3291	/// [C11] static_assert-declaration:
3292	/// _Static_assert ( constant-expression , string-literal ) ;
3293	/// \endverbatim
3294	///
3295	Decl *ParseStaticAssertDeclaration(SourceLocation &DeclEnd);
3296
3297	/// ParseNamespaceAlias - Parse the part after the '=' in a namespace
3298	/// alias definition.
3299	///
3300	Decl *ParseNamespaceAlias(SourceLocation NamespaceLoc,
3301	SourceLocation AliasLoc, IdentifierInfo *Alias,
3302	SourceLocation &DeclEnd);
3303
3304	//===--------------------------------------------------------------------===//
3305	// C++ 9: classes [class] and C structs/unions.
3306
3307	/// Determine whether the following tokens are valid after a type-specifier
3308	/// which could be a standalone declaration. This will conservatively return
3309	/// true if there's any doubt, and is appropriate for insert-';' fixits.
3310	bool isValidAfterTypeSpecifier(bool CouldBeBitfield);
3311
3312	/// ParseClassSpecifier - Parse a C++ class-specifier [C++ class] or
3313	/// elaborated-type-specifier [C++ dcl.type.elab]; we can't tell which
3314	/// until we reach the start of a definition or see a token that
3315	/// cannot start a definition.
3316	///
3317	/// \verbatim
3318	/// class-specifier: [C++ class]
3319	/// class-head '{' member-specification[opt] '}'
3320	/// class-head '{' member-specification[opt] '}' attributes[opt]
3321	/// class-head:
3322	/// class-key identifier[opt] base-clause[opt]
3323	/// class-key nested-name-specifier identifier base-clause[opt]
3324	/// class-key nested-name-specifier[opt] simple-template-id
3325	/// base-clause[opt]
3326	/// [GNU] class-key attributes[opt] identifier[opt] base-clause[opt]
3327	/// [GNU] class-key attributes[opt] nested-name-specifier
3328	/// identifier base-clause[opt]
3329	/// [GNU] class-key attributes[opt] nested-name-specifier[opt]
3330	/// simple-template-id base-clause[opt]
3331	/// class-key:
3332	/// 'class'
3333	/// 'struct'
3334	/// 'union'
3335	///
3336	/// elaborated-type-specifier: [C++ dcl.type.elab]
3337	/// class-key ::[opt] nested-name-specifier[opt] identifier
3338	/// class-key ::[opt] nested-name-specifier[opt] 'template'[opt]
3339	/// simple-template-id
3340	///
3341	/// Note that the C++ class-specifier and elaborated-type-specifier,
3342	/// together, subsume the C99 struct-or-union-specifier:
3343	///
3344	/// struct-or-union-specifier: [C99 6.7.2.1]
3345	/// struct-or-union identifier[opt] '{' struct-contents '}'
3346	/// struct-or-union identifier
3347	/// [GNU] struct-or-union attributes[opt] identifier[opt] '{' struct-contents
3348	/// '}' attributes[opt]
3349	/// [GNU] struct-or-union attributes[opt] identifier
3350	/// struct-or-union:
3351	/// 'struct'
3352	/// 'union'
3353	/// \endverbatim
3354	void ParseClassSpecifier(tok::TokenKind TagTokKind, SourceLocation TagLoc,
3355	DeclSpec &DS, ParsedTemplateInfo &TemplateInfo,
3356	AccessSpecifier AS, bool EnteringContext,
3357	DeclSpecContext DSC, ParsedAttributes &Attributes);
3358	void SkipCXXMemberSpecification(SourceLocation StartLoc,
3359	SourceLocation AttrFixitLoc, unsigned TagType,
3360	Decl *TagDecl);
3361
3362	/// ParseCXXMemberSpecification - Parse the class definition.
3363	///
3364	/// \verbatim
3365	/// member-specification:
3366	/// member-declaration member-specification[opt]
3367	/// access-specifier ':' member-specification[opt]
3368	/// \endverbatim
3369	///
3370	void ParseCXXMemberSpecification(SourceLocation StartLoc,
3371	SourceLocation AttrFixitLoc,
3372	ParsedAttributes &Attrs, unsigned TagType,
3373	Decl *TagDecl);
3374
3375	/// ParseCXXMemberInitializer - Parse the brace-or-equal-initializer.
3376	/// Also detect and reject any attempted defaulted/deleted function
3377	/// definition. The location of the '=', if any, will be placed in EqualLoc.
3378	///
3379	/// This does not check for a pure-specifier; that's handled elsewhere.
3380	///
3381	/// \verbatim
3382	/// brace-or-equal-initializer:
3383	/// '=' initializer-expression
3384	/// braced-init-list
3385	///
3386	/// initializer-clause:
3387	/// assignment-expression
3388	/// braced-init-list
3389	///
3390	/// defaulted/deleted function-definition:
3391	/// '=' 'default'
3392	/// '=' 'delete'
3393	/// \endverbatim
3394	///
3395	/// Prior to C++0x, the assignment-expression in an initializer-clause must
3396	/// be a constant-expression.
3397	ExprResult ParseCXXMemberInitializer(Decl *D, bool IsFunction,
3398	SourceLocation &EqualLoc);
3399
3400	/// Parse a C++ member-declarator up to, but not including, the optional
3401	/// brace-or-equal-initializer or pure-specifier.
3402	bool ParseCXXMemberDeclaratorBeforeInitializer(Declarator &DeclaratorInfo,
3403	VirtSpecifiers &VS,
3404	ExprResult &BitfieldSize,
3405	LateParsedAttrList &LateAttrs);
3406
3407	/// Look for declaration specifiers possibly occurring after C++11
3408	/// virt-specifier-seq and diagnose them.
3409	void
3410	MaybeParseAndDiagnoseDeclSpecAfterCXX11VirtSpecifierSeq(Declarator &D,
3411	VirtSpecifiers &VS);
3412
3413	/// ParseCXXClassMemberDeclaration - Parse a C++ class member declaration.
3414	///
3415	/// \verbatim
3416	/// member-declaration:
3417	/// decl-specifier-seq[opt] member-declarator-list[opt] ';'
3418	/// function-definition ';'[opt]
3419	/// [C++26] friend-type-declaration
3420	/// ::[opt] nested-name-specifier template[opt] unqualified-id ';'[TODO]
3421	/// using-declaration [TODO]
3422	/// [C++0x] static_assert-declaration
3423	/// template-declaration
3424	/// [GNU] '__extension__' member-declaration
3425	///
3426	/// member-declarator-list:
3427	/// member-declarator
3428	/// member-declarator-list ',' member-declarator
3429	///
3430	/// member-declarator:
3431	/// declarator virt-specifier-seq[opt] pure-specifier[opt]
3432	/// [C++2a] declarator requires-clause
3433	/// declarator constant-initializer[opt]
3434	/// [C++11] declarator brace-or-equal-initializer[opt]
3435	/// identifier[opt] ':' constant-expression
3436	///
3437	/// virt-specifier-seq:
3438	/// virt-specifier
3439	/// virt-specifier-seq virt-specifier
3440	///
3441	/// virt-specifier:
3442	/// override
3443	/// final
3444	/// [MS] sealed
3445	///
3446	/// pure-specifier:
3447	/// '= 0'
3448	///
3449	/// constant-initializer:
3450	/// '=' constant-expression
3451	///
3452	/// friend-type-declaration:
3453	/// 'friend' friend-type-specifier-list ;
3454	///
3455	/// friend-type-specifier-list:
3456	/// friend-type-specifier ...[opt]
3457	/// friend-type-specifier-list , friend-type-specifier ...[opt]
3458	///
3459	/// friend-type-specifier:
3460	/// simple-type-specifier
3461	/// elaborated-type-specifier
3462	/// typename-specifier
3463	/// \endverbatim
3464	///
3465	DeclGroupPtrTy ParseCXXClassMemberDeclaration(
3466	AccessSpecifier AS, ParsedAttributes &Attr,
3467	ParsedTemplateInfo &TemplateInfo,
3468	ParsingDeclRAIIObject *DiagsFromTParams = nullptr);
3469	DeclGroupPtrTy
3470	ParseCXXClassMemberDeclarationWithPragmas(AccessSpecifier &AS,
3471	ParsedAttributes &AccessAttrs,
3472	DeclSpec::TST TagType, Decl *Tag);
3473
3474	/// ParseConstructorInitializer - Parse a C++ constructor initializer,
3475	/// which explicitly initializes the members or base classes of a
3476	/// class (C++ [class.base.init]). For example, the three initializers
3477	/// after the ':' in the Derived constructor below:
3478	///
3479	/// @code
3480	/// class Base { };
3481	/// class Derived : Base {
3482	/// int x;
3483	/// float f;
3484	/// public:
3485	/// Derived(float f) : Base(), x(17), f(f) { }
3486	/// };
3487	/// @endcode
3488	///
3489	/// \verbatim
3490	/// [C++] ctor-initializer:
3491	/// ':' mem-initializer-list
3492	///
3493	/// [C++] mem-initializer-list:
3494	/// mem-initializer ...[opt]
3495	/// mem-initializer ...[opt] , mem-initializer-list
3496	/// \endverbatim
3497	void ParseConstructorInitializer(Decl *ConstructorDecl);
3498
3499	/// ParseMemInitializer - Parse a C++ member initializer, which is
3500	/// part of a constructor initializer that explicitly initializes one
3501	/// member or base class (C++ [class.base.init]). See
3502	/// ParseConstructorInitializer for an example.
3503	///
3504	/// \verbatim
3505	/// [C++] mem-initializer:
3506	/// mem-initializer-id '(' expression-list[opt] ')'
3507	/// [C++0x] mem-initializer-id braced-init-list
3508	///
3509	/// [C++] mem-initializer-id:
3510	/// '::'[opt] nested-name-specifier[opt] class-name
3511	/// identifier
3512	/// \endverbatim
3513	MemInitResult ParseMemInitializer(Decl *ConstructorDecl);
3514
3515	/// If the given declarator has any parts for which parsing has to be
3516	/// delayed, e.g., default arguments or an exception-specification, create a
3517	/// late-parsed method declaration record to handle the parsing at the end of
3518	/// the class definition.
3519	void HandleMemberFunctionDeclDelays(Declarator &DeclaratorInfo,
3520	Decl *ThisDecl);
3521
3522	//===--------------------------------------------------------------------===//
3523	// C++ 10: Derived classes [class.derived]
3524
3525	/// ParseBaseTypeSpecifier - Parse a C++ base-type-specifier which is either a
3526	/// class name or decltype-specifier. Note that we only check that the result
3527	/// names a type; semantic analysis will need to verify that the type names a
3528	/// class. The result is either a type or null, depending on whether a type
3529	/// name was found.
3530	///
3531	/// \verbatim
3532	/// base-type-specifier: [C++11 class.derived]
3533	/// class-or-decltype
3534	/// class-or-decltype: [C++11 class.derived]
3535	/// nested-name-specifier[opt] class-name
3536	/// decltype-specifier
3537	/// class-name: [C++ class.name]
3538	/// identifier
3539	/// simple-template-id
3540	/// \endverbatim
3541	///
3542	/// In C++98, instead of base-type-specifier, we have:
3543	///
3544	/// \verbatim
3545	/// ::[opt] nested-name-specifier[opt] class-name
3546	/// \endverbatim
3547	TypeResult ParseBaseTypeSpecifier(SourceLocation &BaseLoc,
3548	SourceLocation &EndLocation);
3549
3550	/// ParseBaseClause - Parse the base-clause of a C++ class [C++
3551	/// class.derived].
3552	///
3553	/// \verbatim
3554	/// base-clause : [C++ class.derived]
3555	/// ':' base-specifier-list
3556	/// base-specifier-list:
3557	/// base-specifier '...'[opt]
3558	/// base-specifier-list ',' base-specifier '...'[opt]
3559	/// \endverbatim
3560	void ParseBaseClause(Decl *ClassDecl);
3561
3562	/// ParseBaseSpecifier - Parse a C++ base-specifier. A base-specifier is
3563	/// one entry in the base class list of a class specifier, for example:
3564	/// class foo : public bar, virtual private baz {
3565	/// 'public bar' and 'virtual private baz' are each base-specifiers.
3566	///
3567	/// \verbatim
3568	/// base-specifier: [C++ class.derived]
3569	/// attribute-specifier-seq[opt] base-type-specifier
3570	/// attribute-specifier-seq[opt] 'virtual' access-specifier[opt]
3571	/// base-type-specifier
3572	/// attribute-specifier-seq[opt] access-specifier 'virtual'[opt]
3573	/// base-type-specifier
3574	/// \endverbatim
3575	BaseResult ParseBaseSpecifier(Decl *ClassDecl);
3576
3577	/// getAccessSpecifierIfPresent - Determine whether the next token is
3578	/// a C++ access-specifier.
3579	///
3580	/// \verbatim
3581	/// access-specifier: [C++ class.derived]
3582	/// 'private'
3583	/// 'protected'
3584	/// 'public'
3585	/// \endverbatim
3586	AccessSpecifier getAccessSpecifierIfPresent() const;
3587
3588	bool isCXX2CTriviallyRelocatableKeyword(Token Tok) const;
3589	bool isCXX2CTriviallyRelocatableKeyword() const;
3590	void ParseCXX2CTriviallyRelocatableSpecifier(SourceLocation &TRS);
3591
3592	bool isCXX2CReplaceableKeyword(Token Tok) const;
3593	bool isCXX2CReplaceableKeyword() const;
3594	void ParseCXX2CReplaceableSpecifier(SourceLocation &MRS);
3595
3596	/// 'final', a C++26 'trivially_relocatable_if_eligible',
3597	/// 'replaceable_if_eligible', or Microsoft 'sealed' or 'abstract' contextual
3598	/// keyword.
3599	bool isClassCompatibleKeyword(Token Tok) const;
3600
3601	void ParseMicrosoftRootSignatureAttributeArgs(ParsedAttributes &Attrs);
3602
3603	///@}
3604
3605	//
3606	//
3607	// -------------------------------------------------------------------------
3608	//
3609	//
3610
3611	/// \name Expressions
3612	/// Implementations are in ParseExpr.cpp
3613	///@{
3614
3615	public:
3616	friend class OffsetOfStateRAIIObject;
3617
3618	typedef Sema::FullExprArg FullExprArg;
3619
3620	//===--------------------------------------------------------------------===//
3621	// C99 6.5: Expressions.
3622
3623	/// Simple precedence-based parser for binary/ternary operators.
3624	///
3625	/// Note: we diverge from the C99 grammar when parsing the
3626	/// assignment-expression production. C99 specifies that the LHS of an
3627	/// assignment operator should be parsed as a unary-expression, but
3628	/// consistency dictates that it be a conditional-expession. In practice, the
3629	/// important thing here is that the LHS of an assignment has to be an
3630	/// l-value, which productions between unary-expression and
3631	/// conditional-expression don't produce. Because we want consistency, we
3632	/// parse the LHS as a conditional-expression, then check for l-value-ness in
3633	/// semantic analysis stages.
3634	///
3635	/// \verbatim
3636	/// pm-expression: [C++ 5.5]
3637	/// cast-expression
3638	/// pm-expression '.*' cast-expression
3639	/// pm-expression '->*' cast-expression
3640	///
3641	/// multiplicative-expression: [C99 6.5.5]
3642	/// Note: in C++, apply pm-expression instead of cast-expression
3643	/// cast-expression
3644	/// multiplicative-expression '*' cast-expression
3645	/// multiplicative-expression '/' cast-expression
3646	/// multiplicative-expression '%' cast-expression
3647	///
3648	/// additive-expression: [C99 6.5.6]
3649	/// multiplicative-expression
3650	/// additive-expression '+' multiplicative-expression
3651	/// additive-expression '-' multiplicative-expression
3652	///
3653	/// shift-expression: [C99 6.5.7]
3654	/// additive-expression
3655	/// shift-expression '<<' additive-expression
3656	/// shift-expression '>>' additive-expression
3657	///
3658	/// compare-expression: [C++20 expr.spaceship]
3659	/// shift-expression
3660	/// compare-expression '<=>' shift-expression
3661	///
3662	/// relational-expression: [C99 6.5.8]
3663	/// compare-expression
3664	/// relational-expression '<' compare-expression
3665	/// relational-expression '>' compare-expression
3666	/// relational-expression '<=' compare-expression
3667	/// relational-expression '>=' compare-expression
3668	///
3669	/// equality-expression: [C99 6.5.9]
3670	/// relational-expression
3671	/// equality-expression '==' relational-expression
3672	/// equality-expression '!=' relational-expression
3673	///
3674	/// AND-expression: [C99 6.5.10]
3675	/// equality-expression
3676	/// AND-expression '&' equality-expression
3677	///
3678	/// exclusive-OR-expression: [C99 6.5.11]
3679	/// AND-expression
3680	/// exclusive-OR-expression '^' AND-expression
3681	///
3682	/// inclusive-OR-expression: [C99 6.5.12]
3683	/// exclusive-OR-expression
3684	/// inclusive-OR-expression '|' exclusive-OR-expression
3685	///
3686	/// logical-AND-expression: [C99 6.5.13]
3687	/// inclusive-OR-expression
3688	/// logical-AND-expression '&&' inclusive-OR-expression
3689	///
3690	/// logical-OR-expression: [C99 6.5.14]
3691	/// logical-AND-expression
3692	/// logical-OR-expression '||' logical-AND-expression
3693	///
3694	/// conditional-expression: [C99 6.5.15]
3695	/// logical-OR-expression
3696	/// logical-OR-expression '?' expression ':' conditional-expression
3697	/// [GNU] logical-OR-expression '?' ':' conditional-expression
3698	/// [C++] the third operand is an assignment-expression
3699	///
3700	/// assignment-expression: [C99 6.5.16]
3701	/// conditional-expression
3702	/// unary-expression assignment-operator assignment-expression
3703	/// [C++] throw-expression [C++ 15]
3704	///
3705	/// assignment-operator: one of
3706	/// = *= /= %= += -= <<= >>= &= ^= |=
3707	///
3708	/// expression: [C99 6.5.17]
3709	/// assignment-expression ...[opt]
3710	/// expression ',' assignment-expression ...[opt]
3711	/// \endverbatim
3712	ExprResult
3713	ParseExpression(TypeCastState isTypeCast = TypeCastState::NotTypeCast);
3714
3715	ExprResult ParseConstantExpressionInExprEvalContext(
3716	TypeCastState isTypeCast = TypeCastState::NotTypeCast);
3717	ExprResult ParseConstantExpression();
3718	ExprResult ParseArrayBoundExpression();
3719	ExprResult ParseCaseExpression(SourceLocation CaseLoc);
3720
3721	/// Parse a constraint-expression.
3722	///
3723	/// \verbatim
3724	/// constraint-expression: C++2a[temp.constr.decl]p1
3725	/// logical-or-expression
3726	/// \endverbatim
3727	ExprResult ParseConstraintExpression();
3728
3729	/// \brief Parse a constraint-logical-and-expression.
3730	///
3731	/// \verbatim
3732	/// C++2a[temp.constr.decl]p1
3733	/// constraint-logical-and-expression:
3734	/// primary-expression
3735	/// constraint-logical-and-expression '&&' primary-expression
3736	///
3737	/// \endverbatim
3738	ExprResult ParseConstraintLogicalAndExpression(bool IsTrailingRequiresClause);
3739
3740	/// \brief Parse a constraint-logical-or-expression.
3741	///
3742	/// \verbatim
3743	/// C++2a[temp.constr.decl]p1
3744	/// constraint-logical-or-expression:
3745	/// constraint-logical-and-expression
3746	/// constraint-logical-or-expression '||'
3747	/// constraint-logical-and-expression
3748	///
3749	/// \endverbatim
3750	ExprResult ParseConstraintLogicalOrExpression(bool IsTrailingRequiresClause);
3751
3752	/// Parse an expr that doesn't include (top-level) commas.
3753	ExprResult ParseAssignmentExpression(
3754	TypeCastState isTypeCast = TypeCastState::NotTypeCast);
3755
3756	ExprResult ParseConditionalExpression();
3757
3758	/// ParseStringLiteralExpression - This handles the various token types that
3759	/// form string literals, and also handles string concatenation [C99 5.1.1.2,
3760	/// translation phase #6].
3761	///
3762	/// \verbatim
3763	/// primary-expression: [C99 6.5.1]
3764	/// string-literal
3765	/// \endverbatim
3766	ExprResult ParseStringLiteralExpression(bool AllowUserDefinedLiteral = false);
3767	ExprResult ParseUnevaluatedStringLiteralExpression();
3768
3769	private:
3770	/// Whether the '>' token acts as an operator or not. This will be
3771	/// true except when we are parsing an expression within a C++
3772	/// template argument list, where the '>' closes the template
3773	/// argument list.
3774	bool GreaterThanIsOperator;
3775
3776	// C++ type trait keywords that can be reverted to identifiers and still be
3777	// used as type traits.
3778	llvm::SmallDenseMap<IdentifierInfo *, tok::TokenKind> RevertibleTypeTraits;
3779
3780	OffsetOfKind OffsetOfState = OffsetOfKind::Outside;
3781
3782	/// The location of the expression statement that is being parsed right now.
3783	/// Used to determine if an expression that is being parsed is a statement or
3784	/// just a regular sub-expression.
3785	SourceLocation ExprStatementTokLoc;
3786
3787	/// Checks if the \p Level is valid for use in a fold expression.
3788	bool isFoldOperator(prec::Level Level) const;
3789
3790	/// Checks if the \p Kind is a valid operator for fold expressions.
3791	bool isFoldOperator(tok::TokenKind Kind) const;
3792
3793	/// We have just started parsing the definition of a new class,
3794	/// so push that class onto our stack of classes that is currently
3795	/// being parsed.
3796	Sema::ParsingClassState
3797	PushParsingClass(Decl *TagOrTemplate, bool TopLevelClass, bool IsInterface);
3798
3799	/// Deallocate the given parsed class and all of its nested
3800	/// classes.
3801	void DeallocateParsedClasses(ParsingClass *Class);
3802
3803	/// Pop the top class of the stack of classes that are
3804	/// currently being parsed.
3805	///
3806	/// This routine should be called when we have finished parsing the
3807	/// definition of a class, but have not yet popped the Scope
3808	/// associated with the class's definition.
3809	void PopParsingClass(Sema::ParsingClassState);
3810
3811	ExprResult ParseStringLiteralExpression(bool AllowUserDefinedLiteral,
3812	bool Unevaluated);
3813
3814	/// This routine is called when the '@' is seen and consumed.
3815	/// Current token is an Identifier and is not a 'try'. This
3816	/// routine is necessary to disambiguate \@try-statement from,
3817	/// for example, \@encode-expression.
3818	///
3819	ExprResult ParseExpressionWithLeadingAt(SourceLocation AtLoc);
3820
3821	/// This routine is called when a leading '__extension__' is seen and
3822	/// consumed. This is necessary because the token gets consumed in the
3823	/// process of disambiguating between an expression and a declaration.
3824	ExprResult ParseExpressionWithLeadingExtension(SourceLocation ExtLoc);
3825
3826	/// Parse a binary expression that starts with \p LHS and has a
3827	/// precedence of at least \p MinPrec.
3828	ExprResult ParseRHSOfBinaryExpression(ExprResult LHS, prec::Level MinPrec);
3829
3830	bool isRevertibleTypeTrait(const IdentifierInfo *Id,
3831	clang::tok::TokenKind *Kind = nullptr);
3832
3833	/// Parse a cast-expression, or, if \pisUnaryExpression is true, parse
3834	/// a unary-expression.
3835	///
3836	/// \p isAddressOfOperand exists because an id-expression that is the operand
3837	/// of address-of gets special treatment due to member pointers. NotCastExpr
3838	/// is set to true if the token is not the start of a cast-expression, and no
3839	/// diagnostic is emitted in this case and no tokens are consumed.
3840	///
3841	/// \verbatim
3842	/// cast-expression: [C99 6.5.4]
3843	/// unary-expression
3844	/// '(' type-name ')' cast-expression
3845	///
3846	/// unary-expression: [C99 6.5.3]
3847	/// postfix-expression
3848	/// '++' unary-expression
3849	/// '--' unary-expression
3850	/// [Coro] 'co_await' cast-expression
3851	/// unary-operator cast-expression
3852	/// 'sizeof' unary-expression
3853	/// 'sizeof' '(' type-name ')'
3854	/// [C++11] 'sizeof' '...' '(' identifier ')'
3855	/// [GNU] '__alignof' unary-expression
3856	/// [GNU] '__alignof' '(' type-name ')'
3857	/// [C11] '_Alignof' '(' type-name ')'
3858	/// [C++11] 'alignof' '(' type-id ')'
3859	/// [C2y] '_Countof' unary-expression
3860	/// [C2y] '_Countof' '(' type-name ')'
3861	/// [GNU] '&&' identifier
3862	/// [C++11] 'noexcept' '(' expression ')' [C++11 5.3.7]
3863	/// [C++] new-expression
3864	/// [C++] delete-expression
3865	///
3866	/// unary-operator: one of
3867	/// '&' '*' '+' '-' '~' '!'
3868	/// [GNU] '__extension__' '__real' '__imag'
3869	///
3870	/// primary-expression: [C99 6.5.1]
3871	/// [C99] identifier
3872	/// [C++] id-expression
3873	/// constant
3874	/// string-literal
3875	/// [C++] boolean-literal [C++ 2.13.5]
3876	/// [C++11] 'nullptr' [C++11 2.14.7]
3877	/// [C++11] user-defined-literal
3878	/// '(' expression ')'
3879	/// [C11] generic-selection
3880	/// [C++2a] requires-expression
3881	/// '__func__' [C99 6.4.2.2]
3882	/// [GNU] '__FUNCTION__'
3883	/// [MS] '__FUNCDNAME__'
3884	/// [MS] 'L__FUNCTION__'
3885	/// [MS] '__FUNCSIG__'
3886	/// [MS] 'L__FUNCSIG__'
3887	/// [GNU] '__PRETTY_FUNCTION__'
3888	/// [GNU] '(' compound-statement ')'
3889	/// [GNU] '__builtin_va_arg' '(' assignment-expression ',' type-name ')'
3890	/// [GNU] '__builtin_offsetof' '(' type-name ',' offsetof-member-designator')'
3891	/// [GNU] '__builtin_choose_expr' '(' assign-expr ',' assign-expr ','
3892	/// assign-expr ')'
3893	/// [GNU] '__builtin_FILE' '(' ')'
3894	/// [CLANG] '__builtin_FILE_NAME' '(' ')'
3895	/// [GNU] '__builtin_FUNCTION' '(' ')'
3896	/// [MS] '__builtin_FUNCSIG' '(' ')'
3897	/// [GNU] '__builtin_LINE' '(' ')'
3898	/// [CLANG] '__builtin_COLUMN' '(' ')'
3899	/// [GNU] '__builtin_source_location' '(' ')'
3900	/// [GNU] '__builtin_types_compatible_p' '(' type-name ',' type-name ')'
3901	/// [GNU] '__null'
3902	/// [OBJC] '[' objc-message-expr ']'
3903	/// [OBJC] '\@selector' '(' objc-selector-arg ')'
3904	/// [OBJC] '\@protocol' '(' identifier ')'
3905	/// [OBJC] '\@encode' '(' type-name ')'
3906	/// [OBJC] objc-string-literal
3907	/// [C++] simple-type-specifier '(' expression-list[opt] ')' [C++ 5.2.3]
3908	/// [C++11] simple-type-specifier braced-init-list [C++11 5.2.3]
3909	/// [C++] typename-specifier '(' expression-list[opt] ')' [C++ 5.2.3]
3910	/// [C++11] typename-specifier braced-init-list [C++11 5.2.3]
3911	/// [C++] 'const_cast' '<' type-name '>' '(' expression ')' [C++ 5.2p1]
3912	/// [C++] 'dynamic_cast' '<' type-name '>' '(' expression ')' [C++ 5.2p1]
3913	/// [C++] 'reinterpret_cast' '<' type-name '>' '(' expression ')' [C++ 5.2p1]
3914	/// [C++] 'static_cast' '<' type-name '>' '(' expression ')' [C++ 5.2p1]
3915	/// [C++] 'typeid' '(' expression ')' [C++ 5.2p1]
3916	/// [C++] 'typeid' '(' type-id ')' [C++ 5.2p1]
3917	/// [C++] 'this' [C++ 9.3.2]
3918	/// [G++] unary-type-trait '(' type-id ')'
3919	/// [G++] binary-type-trait '(' type-id ',' type-id ')' [TODO]
3920	/// [EMBT] array-type-trait '(' type-id ',' integer ')'
3921	/// [clang] '^' block-literal
3922	///
3923	/// constant: [C99 6.4.4]
3924	/// integer-constant
3925	/// floating-constant
3926	/// enumeration-constant -> identifier
3927	/// character-constant
3928	///
3929	/// id-expression: [C++ 5.1]
3930	/// unqualified-id
3931	/// qualified-id
3932	///
3933	/// unqualified-id: [C++ 5.1]
3934	/// identifier
3935	/// operator-function-id
3936	/// conversion-function-id
3937	/// '~' class-name
3938	/// template-id
3939	///
3940	/// new-expression: [C++ 5.3.4]
3941	/// '::'[opt] 'new' new-placement[opt] new-type-id
3942	/// new-initializer[opt]
3943	/// '::'[opt] 'new' new-placement[opt] '(' type-id ')'
3944	/// new-initializer[opt]
3945	///
3946	/// delete-expression: [C++ 5.3.5]
3947	/// '::'[opt] 'delete' cast-expression
3948	/// '::'[opt] 'delete' '[' ']' cast-expression
3949	///
3950	/// [GNU/Embarcadero] unary-type-trait:
3951	/// '__is_arithmetic'
3952	/// '__is_floating_point'
3953	/// '__is_integral'
3954	/// '__is_lvalue_expr'
3955	/// '__is_rvalue_expr'
3956	/// '__is_complete_type'
3957	/// '__is_void'
3958	/// '__is_array'
3959	/// '__is_function'
3960	/// '__is_reference'
3961	/// '__is_lvalue_reference'
3962	/// '__is_rvalue_reference'
3963	/// '__is_fundamental'
3964	/// '__is_object'
3965	/// '__is_scalar'
3966	/// '__is_compound'
3967	/// '__is_pointer'
3968	/// '__is_member_object_pointer'
3969	/// '__is_member_function_pointer'
3970	/// '__is_member_pointer'
3971	/// '__is_const'
3972	/// '__is_volatile'
3973	/// '__is_trivial'
3974	/// '__is_standard_layout'
3975	/// '__is_signed'
3976	/// '__is_unsigned'
3977	///
3978	/// [GNU] unary-type-trait:
3979	/// '__has_nothrow_assign'
3980	/// '__has_nothrow_copy'
3981	/// '__has_nothrow_constructor'
3982	/// '__has_trivial_assign' [TODO]
3983	/// '__has_trivial_copy' [TODO]
3984	/// '__has_trivial_constructor'
3985	/// '__has_trivial_destructor'
3986	/// '__has_virtual_destructor'
3987	/// '__is_abstract' [TODO]
3988	/// '__is_class'
3989	/// '__is_empty' [TODO]
3990	/// '__is_enum'
3991	/// '__is_final'
3992	/// '__is_pod'
3993	/// '__is_polymorphic'
3994	/// '__is_sealed' [MS]
3995	/// '__is_trivial'
3996	/// '__is_union'
3997	/// '__has_unique_object_representations'
3998	///
3999	/// [Clang] unary-type-trait:
4000	/// '__is_aggregate'
4001	/// '__trivially_copyable'
4002	///
4003	/// binary-type-trait:
4004	/// [GNU] '__is_base_of'
4005	/// [MS] '__is_convertible_to'
4006	/// '__is_convertible'
4007	/// '__is_same'
4008	///
4009	/// [Embarcadero] array-type-trait:
4010	/// '__array_rank'
4011	/// '__array_extent'
4012	///
4013	/// [Embarcadero] expression-trait:
4014	/// '__is_lvalue_expr'
4015	/// '__is_rvalue_expr'
4016	/// \endverbatim
4017	///
4018	ExprResult ParseCastExpression(CastParseKind ParseKind,
4019	bool isAddressOfOperand, bool &NotCastExpr,
4020	TypeCastState isTypeCast,
4021	bool isVectorLiteral = false,
4022	bool *NotPrimaryExpression = nullptr);
4023	ExprResult
4024	ParseCastExpression(CastParseKind ParseKind, bool isAddressOfOperand = false,
4025	TypeCastState isTypeCast = TypeCastState::NotTypeCast,
4026	bool isVectorLiteral = false,
4027	bool *NotPrimaryExpression = nullptr);
4028
4029	/// Returns true if the next token cannot start an expression.
4030	bool isNotExpressionStart();
4031
4032	/// Returns true if the next token would start a postfix-expression
4033	/// suffix.
4034	bool isPostfixExpressionSuffixStart() {
4035	tok::TokenKind K = Tok.getKind();
4036	return (K == tok::l_square || K == tok::l_paren || K == tok::period ||
4037	K == tok::arrow || K == tok::plusplus || K == tok::minusminus);
4038	}
4039
4040	/// Once the leading part of a postfix-expression is parsed, this
4041	/// method parses any suffixes that apply.
4042	///
4043	/// \verbatim
4044	/// postfix-expression: [C99 6.5.2]
4045	/// primary-expression
4046	/// postfix-expression '[' expression ']'
4047	/// postfix-expression '[' braced-init-list ']'
4048	/// postfix-expression '[' expression-list [opt] ']' [C++23 12.4.5]
4049	/// postfix-expression '(' argument-expression-list[opt] ')'
4050	/// postfix-expression '.' identifier
4051	/// postfix-expression '->' identifier
4052	/// postfix-expression '++'
4053	/// postfix-expression '--'
4054	/// '(' type-name ')' '{' initializer-list '}'
4055	/// '(' type-name ')' '{' initializer-list ',' '}'
4056	///
4057	/// argument-expression-list: [C99 6.5.2]
4058	/// argument-expression ...[opt]
4059	/// argument-expression-list ',' assignment-expression ...[opt]
4060	/// \endverbatim
4061	ExprResult ParsePostfixExpressionSuffix(ExprResult LHS);
4062
4063	/// Parse a sizeof or alignof expression.
4064	///
4065	/// \verbatim
4066	/// unary-expression: [C99 6.5.3]
4067	/// 'sizeof' unary-expression
4068	/// 'sizeof' '(' type-name ')'
4069	/// [C++11] 'sizeof' '...' '(' identifier ')'
4070	/// [Clang] '__datasizeof' unary-expression
4071	/// [Clang] '__datasizeof' '(' type-name ')'
4072	/// [GNU] '__alignof' unary-expression
4073	/// [GNU] '__alignof' '(' type-name ')'
4074	/// [C11] '_Alignof' '(' type-name ')'
4075	/// [C++11] 'alignof' '(' type-id ')'
4076	/// [C2y] '_Countof' unary-expression
4077	/// [C2y] '_Countof' '(' type-name ')'
4078	/// \endverbatim
4079	ExprResult ParseUnaryExprOrTypeTraitExpression();
4080
4081	/// ParseBuiltinPrimaryExpression
4082	///
4083	/// \verbatim
4084	/// primary-expression: [C99 6.5.1]
4085	/// [GNU] '__builtin_va_arg' '(' assignment-expression ',' type-name ')'
4086	/// [GNU] '__builtin_offsetof' '(' type-name ',' offsetof-member-designator')'
4087	/// [GNU] '__builtin_choose_expr' '(' assign-expr ',' assign-expr ','
4088	/// assign-expr ')'
4089	/// [GNU] '__builtin_types_compatible_p' '(' type-name ',' type-name ')'
4090	/// [GNU] '__builtin_FILE' '(' ')'
4091	/// [CLANG] '__builtin_FILE_NAME' '(' ')'
4092	/// [GNU] '__builtin_FUNCTION' '(' ')'
4093	/// [MS] '__builtin_FUNCSIG' '(' ')'
4094	/// [GNU] '__builtin_LINE' '(' ')'
4095	/// [CLANG] '__builtin_COLUMN' '(' ')'
4096	/// [GNU] '__builtin_source_location' '(' ')'
4097	/// [OCL] '__builtin_astype' '(' assignment-expression ',' type-name ')'
4098	///
4099	/// [GNU] offsetof-member-designator:
4100	/// [GNU] identifier
4101	/// [GNU] offsetof-member-designator '.' identifier
4102	/// [GNU] offsetof-member-designator '[' expression ']'
4103	/// \endverbatim
4104	ExprResult ParseBuiltinPrimaryExpression();
4105
4106	/// Parse a __builtin_sycl_unique_stable_name expression. Accepts a type-id
4107	/// as a parameter.
4108	ExprResult ParseSYCLUniqueStableNameExpression();
4109
4110	/// ParseExprAfterUnaryExprOrTypeTrait - We parsed a typeof/sizeof/alignof/
4111	/// vec_step and we are at the start of an expression or a parenthesized
4112	/// type-id. OpTok is the operand token (typeof/sizeof/alignof). Returns the
4113	/// expression (isCastExpr == false) or the type (isCastExpr == true).
4114	///
4115	/// \verbatim
4116	/// unary-expression: [C99 6.5.3]
4117	/// 'sizeof' unary-expression
4118	/// 'sizeof' '(' type-name ')'
4119	/// [Clang] '__datasizeof' unary-expression
4120	/// [Clang] '__datasizeof' '(' type-name ')'
4121	/// [GNU] '__alignof' unary-expression
4122	/// [GNU] '__alignof' '(' type-name ')'
4123	/// [C11] '_Alignof' '(' type-name ')'
4124	/// [C++0x] 'alignof' '(' type-id ')'
4125	///
4126	/// [GNU] typeof-specifier:
4127	/// typeof ( expressions )
4128	/// typeof ( type-name )
4129	/// [GNU/C++] typeof unary-expression
4130	/// [C23] typeof-specifier:
4131	/// typeof '(' typeof-specifier-argument ')'
4132	/// typeof_unqual '(' typeof-specifier-argument ')'
4133	///
4134	/// typeof-specifier-argument:
4135	/// expression
4136	/// type-name
4137	///
4138	/// [OpenCL 1.1 6.11.12] vec_step built-in function:
4139	/// vec_step ( expressions )
4140	/// vec_step ( type-name )
4141	/// \endverbatim
4142	ExprResult ParseExprAfterUnaryExprOrTypeTrait(const Token &OpTok,
4143	bool &isCastExpr,
4144	ParsedType &CastTy,
4145	SourceRange &CastRange);
4146
4147	/// ParseExpressionList - Used for C/C++ (argument-)expression-list.
4148	///
4149	/// \verbatim
4150	/// argument-expression-list:
4151	/// assignment-expression
4152	/// argument-expression-list , assignment-expression
4153	///
4154	/// [C++] expression-list:
4155	/// [C++] assignment-expression
4156	/// [C++] expression-list , assignment-expression
4157	///
4158	/// [C++0x] expression-list:
4159	/// [C++0x] initializer-list
4160	///
4161	/// [C++0x] initializer-list
4162	/// [C++0x] initializer-clause ...[opt]
4163	/// [C++0x] initializer-list , initializer-clause ...[opt]
4164	///
4165	/// [C++0x] initializer-clause:
4166	/// [C++0x] assignment-expression
4167	/// [C++0x] braced-init-list
4168	/// \endverbatim
4169	bool ParseExpressionList(SmallVectorImpl<Expr *> &Exprs,
4170	llvm::function_ref<void()> ExpressionStarts =
4171	llvm::function_ref<void()>(),
4172	bool FailImmediatelyOnInvalidExpr = false,
4173	bool EarlyTypoCorrection = false);
4174
4175	/// ParseSimpleExpressionList - A simple comma-separated list of expressions,
4176	/// used for misc language extensions.
4177	///
4178	/// \verbatim
4179	/// simple-expression-list:
4180	/// assignment-expression
4181	/// simple-expression-list , assignment-expression
4182	/// \endverbatim
4183	bool ParseSimpleExpressionList(SmallVectorImpl<Expr *> &Exprs);
4184
4185	/// ParseParenExpression - This parses the unit that starts with a '(' token,
4186	/// based on what is allowed by ExprType. The actual thing parsed is returned
4187	/// in ExprType. If stopIfCastExpr is true, it will only return the parsed
4188	/// type, not the parsed cast-expression.
4189	///
4190	/// \verbatim
4191	/// primary-expression: [C99 6.5.1]
4192	/// '(' expression ')'
4193	/// [GNU] '(' compound-statement ')' (if !ParenExprOnly)
4194	/// postfix-expression: [C99 6.5.2]
4195	/// '(' type-name ')' '{' initializer-list '}'
4196	/// '(' type-name ')' '{' initializer-list ',' '}'
4197	/// cast-expression: [C99 6.5.4]
4198	/// '(' type-name ')' cast-expression
4199	/// [ARC] bridged-cast-expression
4200	/// [ARC] bridged-cast-expression:
4201	/// (__bridge type-name) cast-expression
4202	/// (__bridge_transfer type-name) cast-expression
4203	/// (__bridge_retained type-name) cast-expression
4204	/// fold-expression: [C++1z]
4205	/// '(' cast-expression fold-operator '...' ')'
4206	/// '(' '...' fold-operator cast-expression ')'
4207	/// '(' cast-expression fold-operator '...'
4208	/// fold-operator cast-expression ')'
4209	/// [OPENMP] Array shaping operation
4210	/// '(' '[' expression ']' { '[' expression ']' } cast-expression
4211	/// \endverbatim
4212	ExprResult ParseParenExpression(ParenParseOption &ExprType,
4213	bool stopIfCastExpr, bool isTypeCast,
4214	ParsedType &CastTy,
4215	SourceLocation &RParenLoc);
4216
4217	/// ParseCompoundLiteralExpression - We have parsed the parenthesized
4218	/// type-name and we are at the left brace.
4219	///
4220	/// \verbatim
4221	/// postfix-expression: [C99 6.5.2]
4222	/// '(' type-name ')' '{' initializer-list '}'
4223	/// '(' type-name ')' '{' initializer-list ',' '}'
4224	/// \endverbatim
4225	ExprResult ParseCompoundLiteralExpression(ParsedType Ty,
4226	SourceLocation LParenLoc,
4227	SourceLocation RParenLoc);
4228
4229	/// ParseGenericSelectionExpression - Parse a C11 generic-selection
4230	/// [C11 6.5.1.1].
4231	///
4232	/// \verbatim
4233	/// generic-selection:
4234	/// _Generic ( assignment-expression , generic-assoc-list )
4235	/// generic-assoc-list:
4236	/// generic-association
4237	/// generic-assoc-list , generic-association
4238	/// generic-association:
4239	/// type-name : assignment-expression
4240	/// default : assignment-expression
4241	/// \endverbatim
4242	///
4243	/// As an extension, Clang also accepts:
4244	/// \verbatim
4245	/// generic-selection:
4246	/// _Generic ( type-name, generic-assoc-list )
4247	/// \endverbatim
4248	ExprResult ParseGenericSelectionExpression();
4249
4250	/// ParseObjCBoolLiteral - This handles the objective-c Boolean literals.
4251	///
4252	/// '__objc_yes'
4253	/// '__objc_no'
4254	ExprResult ParseObjCBoolLiteral();
4255
4256	/// Parse A C++1z fold-expression after the opening paren and optional
4257	/// left-hand-side expression.
4258	///
4259	/// \verbatim
4260	/// fold-expression:
4261	/// ( cast-expression fold-operator ... )
4262	/// ( ... fold-operator cast-expression )
4263	/// ( cast-expression fold-operator ... fold-operator cast-expression )
4264	/// \endverbatim
4265	ExprResult ParseFoldExpression(ExprResult LHS, BalancedDelimiterTracker &T);
4266
4267	void injectEmbedTokens();
4268
4269	//===--------------------------------------------------------------------===//
4270	// clang Expressions
4271
4272	/// ParseBlockLiteralExpression - Parse a block literal, which roughly looks
4273	/// like ^(int x){ return x+1; }
4274	///
4275	/// \verbatim
4276	/// block-literal:
4277	/// [clang] '^' block-args[opt] compound-statement
4278	/// [clang] '^' block-id compound-statement
4279	/// [clang] block-args:
4280	/// [clang] '(' parameter-list ')'
4281	/// \endverbatim
4282	ExprResult ParseBlockLiteralExpression(); // ^{...}
4283
4284	/// Parse an assignment expression where part of an Objective-C message
4285	/// send has already been parsed.
4286	///
4287	/// In this case \p LBracLoc indicates the location of the '[' of the message
4288	/// send, and either \p ReceiverName or \p ReceiverExpr is non-null indicating
4289	/// the receiver of the message.
4290	///
4291	/// Since this handles full assignment-expression's, it handles postfix
4292	/// expressions and other binary operators for these expressions as well.
4293	ExprResult ParseAssignmentExprWithObjCMessageExprStart(
4294	SourceLocation LBracloc, SourceLocation SuperLoc, ParsedType ReceiverType,
4295	Expr *ReceiverExpr);
4296
4297	/// Return true if we know that we are definitely looking at a
4298	/// decl-specifier, and isn't part of an expression such as a function-style
4299	/// cast. Return false if it's no a decl-specifier, or we're not sure.
4300	bool isKnownToBeDeclarationSpecifier() {
4301	if (getLangOpts().CPlusPlus)
4302	return isCXXDeclarationSpecifier(AllowImplicitTypename: ImplicitTypenameContext::No) ==
4303	TPResult::True;
4304	return isDeclarationSpecifier(AllowImplicitTypename: ImplicitTypenameContext::No, DisambiguatingWithExpression: true);
4305	}
4306
4307	/// Checks whether the current tokens form a type-id or an expression for the
4308	/// purposes of use as the initial operand to a generic selection expression.
4309	/// This requires special handling in C++ because it accepts either a type or
4310	/// an expression, and we need to disambiguate which is which. However, we
4311	/// cannot use the same logic as we've used for sizeof expressions, because
4312	/// that logic relies on the operator only accepting a single argument,
4313	/// whereas _Generic accepts a list of arguments.
4314	bool isTypeIdForGenericSelection() {
4315	if (getLangOpts().CPlusPlus) {
4316	bool isAmbiguous;
4317	return isCXXTypeId(Context: TentativeCXXTypeIdContext::AsGenericSelectionArgument,
4318	isAmbiguous);
4319	}
4320	return isTypeSpecifierQualifier();
4321	}
4322
4323	/// Checks if the current tokens form type-id or expression.
4324	/// It is similar to isTypeIdInParens but does not suppose that type-id
4325	/// is in parenthesis.
4326	bool isTypeIdUnambiguously() {
4327	if (getLangOpts().CPlusPlus) {
4328	bool isAmbiguous;
4329	return isCXXTypeId(Context: TentativeCXXTypeIdContext::Unambiguous, isAmbiguous);
4330	}
4331	return isTypeSpecifierQualifier();
4332	}
4333
4334	/// ParseBlockId - Parse a block-id, which roughly looks like int (int x).
4335	///
4336	/// \verbatim
4337	/// [clang] block-id:
4338	/// [clang] specifier-qualifier-list block-declarator
4339	/// \endverbatim
4340	void ParseBlockId(SourceLocation CaretLoc);
4341
4342	/// Parse availability query specification.
4343	///
4344	/// \verbatim
4345	/// availability-spec:
4346	/// '*'
4347	/// identifier version-tuple
4348	/// \endverbatim
4349	std::optional<AvailabilitySpec> ParseAvailabilitySpec();
4350	ExprResult ParseAvailabilityCheckExpr(SourceLocation StartLoc);
4351
4352	/// Tries to parse cast part of OpenMP array shaping operation:
4353	/// \verbatim
4354	/// '[' expression ']' { '[' expression ']' } ')'
4355	/// \endverbatim
4356	bool tryParseOpenMPArrayShapingCastPart();
4357
4358	ExprResult ParseBuiltinPtrauthTypeDiscriminator();
4359
4360	///@}
4361
4362	//
4363	//
4364	// -------------------------------------------------------------------------
4365	//
4366	//
4367
4368	/// \name C++ Expressions
4369	/// Implementations are in ParseExprCXX.cpp
4370	///@{
4371
4372	public:
4373	/// Parse a C++ unqualified-id (or a C identifier), which describes the
4374	/// name of an entity.
4375	///
4376	/// \verbatim
4377	/// unqualified-id: [C++ expr.prim.general]
4378	/// identifier
4379	/// operator-function-id
4380	/// conversion-function-id
4381	/// [C++0x] literal-operator-id [TODO]
4382	/// ~ class-name
4383	/// template-id
4384	/// \endverbatim
4385	///
4386	/// \param SS The nested-name-specifier that preceded this unqualified-id. If
4387	/// non-empty, then we are parsing the unqualified-id of a qualified-id.
4388	///
4389	/// \param ObjectType if this unqualified-id occurs within a member access
4390	/// expression, the type of the base object whose member is being accessed.
4391	///
4392	/// \param ObjectHadErrors if this unqualified-id occurs within a member
4393	/// access expression, indicates whether the original subexpressions had any
4394	/// errors. When true, diagnostics for missing 'template' keyword will be
4395	/// supressed.
4396	///
4397	/// \param EnteringContext whether we are entering the scope of the
4398	/// nested-name-specifier.
4399	///
4400	/// \param AllowDestructorName whether we allow parsing of a destructor name.
4401	///
4402	/// \param AllowConstructorName whether we allow parsing a constructor name.
4403	///
4404	/// \param AllowDeductionGuide whether we allow parsing a deduction guide
4405	/// name.
4406	///
4407	/// \param Result on a successful parse, contains the parsed unqualified-id.
4408	///
4409	/// \returns true if parsing fails, false otherwise.
4410	bool ParseUnqualifiedId(CXXScopeSpec &SS, ParsedType ObjectType,
4411	bool ObjectHadErrors, bool EnteringContext,
4412	bool AllowDestructorName, bool AllowConstructorName,
4413	bool AllowDeductionGuide,
4414	SourceLocation *TemplateKWLoc, UnqualifiedId &Result);
4415
4416	private:
4417	/// ColonIsSacred - When this is false, we aggressively try to recover from
4418	/// code like "foo : bar" as if it were a typo for "foo :: bar". This is not
4419	/// safe in case statements and a few other things. This is managed by the
4420	/// ColonProtectionRAIIObject RAII object.
4421	bool ColonIsSacred;
4422
4423	/// ParseCXXAmbiguousParenExpression - We have parsed the left paren of a
4424	/// parenthesized ambiguous type-id. This uses tentative parsing to
4425	/// disambiguate based on the context past the parens.
4426	ExprResult ParseCXXAmbiguousParenExpression(
4427	ParenParseOption &ExprType, ParsedType &CastTy,
4428	BalancedDelimiterTracker &Tracker, ColonProtectionRAIIObject &ColonProt);
4429
4430	//===--------------------------------------------------------------------===//
4431	// C++ Expressions
4432	ExprResult tryParseCXXIdExpression(CXXScopeSpec &SS, bool isAddressOfOperand,
4433	Token &Replacement);
4434
4435	ExprResult tryParseCXXPackIndexingExpression(ExprResult PackIdExpression);
4436	ExprResult ParseCXXPackIndexingExpression(ExprResult PackIdExpression);
4437
4438	/// ParseCXXIdExpression - Handle id-expression.
4439	///
4440	/// \verbatim
4441	/// id-expression:
4442	/// unqualified-id
4443	/// qualified-id
4444	///
4445	/// qualified-id:
4446	/// '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
4447	/// '::' identifier
4448	/// '::' operator-function-id
4449	/// '::' template-id
4450	///
4451	/// NOTE: The standard specifies that, for qualified-id, the parser does not
4452	/// expect:
4453	///
4454	/// '::' conversion-function-id
4455	/// '::' '~' class-name
4456	/// \endverbatim
4457	///
4458	/// This may cause a slight inconsistency on diagnostics:
4459	///
4460	/// class C {};
4461	/// namespace A {}
4462	/// void f() {
4463	/// :: A :: ~ C(); // Some Sema error about using destructor with a
4464	/// // namespace.
4465	/// :: ~ C(); // Some Parser error like 'unexpected ~'.
4466	/// }
4467	///
4468	/// We simplify the parser a bit and make it work like:
4469	///
4470	/// \verbatim
4471	/// qualified-id:
4472	/// '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
4473	/// '::' unqualified-id
4474	/// \endverbatim
4475	///
4476	/// That way Sema can handle and report similar errors for namespaces and the
4477	/// global scope.
4478	///
4479	/// The isAddressOfOperand parameter indicates that this id-expression is a
4480	/// direct operand of the address-of operator. This is, besides member
4481	/// contexts, the only place where a qualified-id naming a non-static class
4482	/// member may appear.
4483	///
4484	ExprResult ParseCXXIdExpression(bool isAddressOfOperand = false);
4485
4486	// Are the two tokens adjacent in the same source file?
4487	bool areTokensAdjacent(const Token &A, const Token &B);
4488
4489	// Check for '<::' which should be '< ::' instead of '[:' when following
4490	// a template name.
4491	void CheckForTemplateAndDigraph(Token &Next, ParsedType ObjectTypePtr,
4492	bool EnteringContext, IdentifierInfo &II,
4493	CXXScopeSpec &SS);
4494
4495	/// Parse global scope or nested-name-specifier if present.
4496	///
4497	/// Parses a C++ global scope specifier ('::') or nested-name-specifier (which
4498	/// may be preceded by '::'). Note that this routine will not parse ::new or
4499	/// ::delete; it will just leave them in the token stream.
4500	///
4501	/// \verbatim
4502	/// '::'[opt] nested-name-specifier
4503	/// '::'
4504	///
4505	/// nested-name-specifier:
4506	/// type-name '::'
4507	/// namespace-name '::'
4508	/// nested-name-specifier identifier '::'
4509	/// nested-name-specifier 'template'[opt] simple-template-id '::'
4510	/// \endverbatim
4511	///
4512	///
4513	/// \param SS the scope specifier that will be set to the parsed
4514	/// nested-name-specifier (or empty)
4515	///
4516	/// \param ObjectType if this nested-name-specifier is being parsed following
4517	/// the "." or "->" of a member access expression, this parameter provides the
4518	/// type of the object whose members are being accessed.
4519	///
4520	/// \param ObjectHadErrors if this unqualified-id occurs within a member
4521	/// access expression, indicates whether the original subexpressions had any
4522	/// errors. When true, diagnostics for missing 'template' keyword will be
4523	/// supressed.
4524	///
4525	/// \param EnteringContext whether we will be entering into the context of
4526	/// the nested-name-specifier after parsing it.
4527	///
4528	/// \param MayBePseudoDestructor When non-NULL, points to a flag that
4529	/// indicates whether this nested-name-specifier may be part of a
4530	/// pseudo-destructor name. In this case, the flag will be set false
4531	/// if we don't actually end up parsing a destructor name. Moreover,
4532	/// if we do end up determining that we are parsing a destructor name,
4533	/// the last component of the nested-name-specifier is not parsed as
4534	/// part of the scope specifier.
4535	///
4536	/// \param IsTypename If \c true, this nested-name-specifier is known to be
4537	/// part of a type name. This is used to improve error recovery.
4538	///
4539	/// \param LastII When non-NULL, points to an IdentifierInfo* that will be
4540	/// filled in with the leading identifier in the last component of the
4541	/// nested-name-specifier, if any.
4542	///
4543	/// \param OnlyNamespace If true, only considers namespaces in lookup.
4544	///
4545	///
4546	/// \returns true if there was an error parsing a scope specifier
4547	bool ParseOptionalCXXScopeSpecifier(
4548	CXXScopeSpec &SS, ParsedType ObjectType, bool ObjectHasErrors,
4549	bool EnteringContext, bool *MayBePseudoDestructor = nullptr,
4550	bool IsTypename = false, const IdentifierInfo **LastII = nullptr,
4551	bool OnlyNamespace = false, bool InUsingDeclaration = false,
4552	bool Disambiguation = false);
4553
4554	//===--------------------------------------------------------------------===//
4555	// C++11 5.1.2: Lambda expressions
4556
4557	/// Result of tentatively parsing a lambda-introducer.
4558	enum class LambdaIntroducerTentativeParse {
4559	/// This appears to be a lambda-introducer, which has been fully parsed.
4560	Success,
4561	/// This is a lambda-introducer, but has not been fully parsed, and this
4562	/// function needs to be called again to parse it.
4563	Incomplete,
4564	/// This is definitely an Objective-C message send expression, rather than
4565	/// a lambda-introducer, attribute-specifier, or array designator.
4566	MessageSend,
4567	/// This is not a lambda-introducer.
4568	Invalid,
4569	};
4570
4571	/// ParseLambdaExpression - Parse a C++11 lambda expression.
4572	///
4573	/// \verbatim
4574	/// lambda-expression:
4575	/// lambda-introducer lambda-declarator compound-statement
4576	/// lambda-introducer '<' template-parameter-list '>'
4577	/// requires-clause[opt] lambda-declarator compound-statement
4578	///
4579	/// lambda-introducer:
4580	/// '[' lambda-capture[opt] ']'
4581	///
4582	/// lambda-capture:
4583	/// capture-default
4584	/// capture-list
4585	/// capture-default ',' capture-list
4586	///
4587	/// capture-default:
4588	/// '&'
4589	/// '='
4590	///
4591	/// capture-list:
4592	/// capture
4593	/// capture-list ',' capture
4594	///
4595	/// capture:
4596	/// simple-capture
4597	/// init-capture [C++1y]
4598	///
4599	/// simple-capture:
4600	/// identifier
4601	/// '&' identifier
4602	/// 'this'
4603	///
4604	/// init-capture: [C++1y]
4605	/// identifier initializer
4606	/// '&' identifier initializer
4607	///
4608	/// lambda-declarator:
4609	/// lambda-specifiers [C++23]
4610	/// '(' parameter-declaration-clause ')' lambda-specifiers
4611	/// requires-clause[opt]
4612	///
4613	/// lambda-specifiers:
4614	/// decl-specifier-seq[opt] noexcept-specifier[opt]
4615	/// attribute-specifier-seq[opt] trailing-return-type[opt]
4616	/// \endverbatim
4617	///
4618	ExprResult ParseLambdaExpression();
4619
4620	/// Use lookahead and potentially tentative parsing to determine if we are
4621	/// looking at a C++11 lambda expression, and parse it if we are.
4622	///
4623	/// If we are not looking at a lambda expression, returns ExprError().
4624	ExprResult TryParseLambdaExpression();
4625
4626	/// Parse a lambda introducer.
4627	/// \param Intro A LambdaIntroducer filled in with information about the
4628	/// contents of the lambda-introducer.
4629	/// \param Tentative If non-null, we are disambiguating between a
4630	/// lambda-introducer and some other construct. In this mode, we do not
4631	/// produce any diagnostics or take any other irreversible action
4632	/// unless we're sure that this is a lambda-expression.
4633	/// \return \c true if parsing (or disambiguation) failed with a diagnostic
4634	/// and the caller should bail out / recover.
4635	bool
4636	ParseLambdaIntroducer(LambdaIntroducer &Intro,
4637	LambdaIntroducerTentativeParse *Tentative = nullptr);
4638
4639	/// ParseLambdaExpressionAfterIntroducer - Parse the rest of a lambda
4640	/// expression.
4641	ExprResult ParseLambdaExpressionAfterIntroducer(LambdaIntroducer &Intro);
4642
4643	//===--------------------------------------------------------------------===//
4644	// C++ 5.2p1: C++ Casts
4645
4646	/// ParseCXXCasts - This handles the various ways to cast expressions to
4647	/// another type.
4648	///
4649	/// \verbatim
4650	/// postfix-expression: [C++ 5.2p1]
4651	/// 'dynamic_cast' '<' type-name '>' '(' expression ')'
4652	/// 'static_cast' '<' type-name '>' '(' expression ')'
4653	/// 'reinterpret_cast' '<' type-name '>' '(' expression ')'
4654	/// 'const_cast' '<' type-name '>' '(' expression ')'
4655	/// \endverbatim
4656	///
4657	/// C++ for OpenCL s2.3.1 adds:
4658	/// 'addrspace_cast' '<' type-name '>' '(' expression ')'
4659	ExprResult ParseCXXCasts();
4660
4661	/// Parse a __builtin_bit_cast(T, E), used to implement C++2a std::bit_cast.
4662	ExprResult ParseBuiltinBitCast();
4663
4664	//===--------------------------------------------------------------------===//
4665	// C++ 5.2p1: C++ Type Identification
4666
4667	/// ParseCXXTypeid - This handles the C++ typeid expression.
4668	///
4669	/// \verbatim
4670	/// postfix-expression: [C++ 5.2p1]
4671	/// 'typeid' '(' expression ')'
4672	/// 'typeid' '(' type-id ')'
4673	/// \endverbatim
4674	///
4675	ExprResult ParseCXXTypeid();
4676
4677	//===--------------------------------------------------------------------===//
4678	// C++ : Microsoft __uuidof Expression
4679
4680	/// ParseCXXUuidof - This handles the Microsoft C++ __uuidof expression.
4681	///
4682	/// \verbatim
4683	/// '__uuidof' '(' expression ')'
4684	/// '__uuidof' '(' type-id ')'
4685	/// \endverbatim
4686	///
4687	ExprResult ParseCXXUuidof();
4688
4689	//===--------------------------------------------------------------------===//
4690	// C++ 5.2.4: C++ Pseudo-Destructor Expressions
4691
4692	/// Parse a C++ pseudo-destructor expression after the base,
4693	/// . or -> operator, and nested-name-specifier have already been
4694	/// parsed. We're handling this fragment of the grammar:
4695	///
4696	/// \verbatim
4697	/// postfix-expression: [C++2a expr.post]
4698	/// postfix-expression . template[opt] id-expression
4699	/// postfix-expression -> template[opt] id-expression
4700	///
4701	/// id-expression:
4702	/// qualified-id
4703	/// unqualified-id
4704	///
4705	/// qualified-id:
4706	/// nested-name-specifier template[opt] unqualified-id
4707	///
4708	/// nested-name-specifier:
4709	/// type-name ::
4710	/// decltype-specifier :: FIXME: not implemented, but probably only
4711	/// allowed in C++ grammar by accident
4712	/// nested-name-specifier identifier ::
4713	/// nested-name-specifier template[opt] simple-template-id ::
4714	/// [...]
4715	///
4716	/// unqualified-id:
4717	/// ~ type-name
4718	/// ~ decltype-specifier
4719	/// [...]
4720	/// \endverbatim
4721	///
4722	/// ... where the all but the last component of the nested-name-specifier
4723	/// has already been parsed, and the base expression is not of a non-dependent
4724	/// class type.
4725	ExprResult ParseCXXPseudoDestructor(Expr *Base, SourceLocation OpLoc,
4726	tok::TokenKind OpKind, CXXScopeSpec &SS,
4727	ParsedType ObjectType);
4728
4729	//===--------------------------------------------------------------------===//
4730	// C++ 9.3.2: C++ 'this' pointer
4731
4732	/// ParseCXXThis - This handles the C++ 'this' pointer.
4733	///
4734	/// C++ 9.3.2: In the body of a non-static member function, the keyword this
4735	/// is a non-lvalue expression whose value is the address of the object for
4736	/// which the function is called.
4737	ExprResult ParseCXXThis();
4738
4739	//===--------------------------------------------------------------------===//
4740	// C++ 15: C++ Throw Expression
4741
4742	/// ParseThrowExpression - This handles the C++ throw expression.
4743	///
4744	/// \verbatim
4745	/// throw-expression: [C++ 15]
4746	/// 'throw' assignment-expression[opt]
4747	/// \endverbatim
4748	ExprResult ParseThrowExpression();
4749
4750	//===--------------------------------------------------------------------===//
4751	// C++ 2.13.5: C++ Boolean Literals
4752
4753	/// ParseCXXBoolLiteral - This handles the C++ Boolean literals.
4754	///
4755	/// \verbatim
4756	/// boolean-literal: [C++ 2.13.5]
4757	/// 'true'
4758	/// 'false'
4759	/// \endverbatim
4760	ExprResult ParseCXXBoolLiteral();
4761
4762	//===--------------------------------------------------------------------===//
4763	// C++ 5.2.3: Explicit type conversion (functional notation)
4764
4765	/// ParseCXXTypeConstructExpression - Parse construction of a specified type.
4766	/// Can be interpreted either as function-style casting ("int(x)")
4767	/// or class type construction ("ClassType(x,y,z)")
4768	/// or creation of a value-initialized type ("int()").
4769	/// See [C++ 5.2.3].
4770	///
4771	/// \verbatim
4772	/// postfix-expression: [C++ 5.2p1]
4773	/// simple-type-specifier '(' expression-list[opt] ')'
4774	/// [C++0x] simple-type-specifier braced-init-list
4775	/// typename-specifier '(' expression-list[opt] ')'
4776	/// [C++0x] typename-specifier braced-init-list
4777	/// \endverbatim
4778	///
4779	/// In C++1z onwards, the type specifier can also be a template-name.
4780	ExprResult ParseCXXTypeConstructExpression(const DeclSpec &DS);
4781
4782	/// ParseCXXSimpleTypeSpecifier - [C++ 7.1.5.2] Simple type specifiers.
4783	/// This should only be called when the current token is known to be part of
4784	/// simple-type-specifier.
4785	///
4786	/// \verbatim
4787	/// simple-type-specifier:
4788	/// '::'[opt] nested-name-specifier[opt] type-name
4789	/// '::'[opt] nested-name-specifier 'template' simple-template-id [TODO]
4790	/// char
4791	/// wchar_t
4792	/// bool
4793	/// short
4794	/// int
4795	/// long
4796	/// signed
4797	/// unsigned
4798	/// float
4799	/// double
4800	/// void
4801	/// [GNU] typeof-specifier
4802	/// [C++0x] auto [TODO]
4803	///
4804	/// type-name:
4805	/// class-name
4806	/// enum-name
4807	/// typedef-name
4808	/// \endverbatim
4809	///
4810	void ParseCXXSimpleTypeSpecifier(DeclSpec &DS);
4811
4812	/// ParseCXXTypeSpecifierSeq - Parse a C++ type-specifier-seq (C++
4813	/// [dcl.name]), which is a non-empty sequence of type-specifiers,
4814	/// e.g., "const short int". Note that the DeclSpec is *not* finished
4815	/// by parsing the type-specifier-seq, because these sequences are
4816	/// typically followed by some form of declarator. Returns true and
4817	/// emits diagnostics if this is not a type-specifier-seq, false
4818	/// otherwise.
4819	///
4820	/// \verbatim
4821	/// type-specifier-seq: [C++ 8.1]
4822	/// type-specifier type-specifier-seq[opt]
4823	/// \endverbatim
4824	///
4825	bool ParseCXXTypeSpecifierSeq(
4826	DeclSpec &DS, DeclaratorContext Context = DeclaratorContext::TypeName);
4827
4828	//===--------------------------------------------------------------------===//
4829	// C++ 5.3.4 and 5.3.5: C++ new and delete
4830
4831	/// ParseExpressionListOrTypeId - Parse either an expression-list or a
4832	/// type-id. This ambiguity appears in the syntax of the C++ new operator.
4833	///
4834	/// \verbatim
4835	/// new-expression:
4836	/// '::'[opt] 'new' new-placement[opt] '(' type-id ')'
4837	/// new-initializer[opt]
4838	///
4839	/// new-placement:
4840	/// '(' expression-list ')'
4841	/// \endverbatim
4842	///
4843	bool ParseExpressionListOrTypeId(SmallVectorImpl<Expr *> &Exprs,
4844	Declarator &D);
4845
4846	/// ParseDirectNewDeclarator - Parses a direct-new-declarator. Intended to be
4847	/// passed to ParseDeclaratorInternal.
4848	///
4849	/// \verbatim
4850	/// direct-new-declarator:
4851	/// '[' expression[opt] ']'
4852	/// direct-new-declarator '[' constant-expression ']'
4853	/// \endverbatim
4854	///
4855	void ParseDirectNewDeclarator(Declarator &D);
4856
4857	/// ParseCXXNewExpression - Parse a C++ new-expression. New is used to
4858	/// allocate memory in a typesafe manner and call constructors.
4859	///
4860	/// This method is called to parse the new expression after the optional ::
4861	/// has been already parsed. If the :: was present, "UseGlobal" is true and
4862	/// "Start" is its location. Otherwise, "Start" is the location of the 'new'
4863	/// token.
4864	///
4865	/// \verbatim
4866	/// new-expression:
4867	/// '::'[opt] 'new' new-placement[opt] new-type-id
4868	/// new-initializer[opt]
4869	/// '::'[opt] 'new' new-placement[opt] '(' type-id ')'
4870	/// new-initializer[opt]
4871	///
4872	/// new-placement:
4873	/// '(' expression-list ')'
4874	///
4875	/// new-type-id:
4876	/// type-specifier-seq new-declarator[opt]
4877	/// [GNU] attributes type-specifier-seq new-declarator[opt]
4878	///
4879	/// new-declarator:
4880	/// ptr-operator new-declarator[opt]
4881	/// direct-new-declarator
4882	///
4883	/// new-initializer:
4884	/// '(' expression-list[opt] ')'
4885	/// [C++0x] braced-init-list
4886	/// \endverbatim
4887	///
4888	ExprResult ParseCXXNewExpression(bool UseGlobal, SourceLocation Start);
4889
4890	/// ParseCXXDeleteExpression - Parse a C++ delete-expression. Delete is used
4891	/// to free memory allocated by new.
4892	///
4893	/// This method is called to parse the 'delete' expression after the optional
4894	/// '::' has been already parsed. If the '::' was present, "UseGlobal" is
4895	/// true and "Start" is its location. Otherwise, "Start" is the location of
4896	/// the 'delete' token.
4897	///
4898	/// \verbatim
4899	/// delete-expression:
4900	/// '::'[opt] 'delete' cast-expression
4901	/// '::'[opt] 'delete' '[' ']' cast-expression
4902	/// \endverbatim
4903	ExprResult ParseCXXDeleteExpression(bool UseGlobal, SourceLocation Start);
4904
4905	//===--------------------------------------------------------------------===//
4906	// C++ if/switch/while/for condition expression.
4907
4908	/// ParseCXXCondition - if/switch/while condition expression.
4909	///
4910	/// \verbatim
4911	/// condition:
4912	/// expression
4913	/// type-specifier-seq declarator '=' assignment-expression
4914	/// [C++11] type-specifier-seq declarator '=' initializer-clause
4915	/// [C++11] type-specifier-seq declarator braced-init-list
4916	/// [Clang] type-specifier-seq ref-qualifier[opt] '[' identifier-list ']'
4917	/// brace-or-equal-initializer
4918	/// [GNU] type-specifier-seq declarator simple-asm-expr[opt] attributes[opt]
4919	/// '=' assignment-expression
4920	/// \endverbatim
4921	///
4922	/// In C++1z, a condition may in some contexts be preceded by an
4923	/// optional init-statement. This function will parse that too.
4924	///
4925	/// \param InitStmt If non-null, an init-statement is permitted, and if
4926	/// present will be parsed and stored here.
4927	///
4928	/// \param Loc The location of the start of the statement that requires this
4929	/// condition, e.g., the "for" in a for loop.
4930	///
4931	/// \param MissingOK Whether an empty condition is acceptable here. Otherwise
4932	/// it is considered an error to be recovered from.
4933	///
4934	/// \param FRI If non-null, a for range declaration is permitted, and if
4935	/// present will be parsed and stored here, and a null result will be
4936	/// returned.
4937	///
4938	/// \param EnterForConditionScope If true, enter a continue/break scope at the
4939	/// appropriate moment for a 'for' loop.
4940	///
4941	/// \returns The parsed condition.
4942	Sema::ConditionResult ParseCXXCondition(StmtResult *InitStmt,
4943	SourceLocation Loc,
4944	Sema::ConditionKind CK,
4945	bool MissingOK,
4946	ForRangeInfo *FRI = nullptr,
4947	bool EnterForConditionScope = false);
4948	DeclGroupPtrTy ParseAliasDeclarationInInitStatement(DeclaratorContext Context,
4949	ParsedAttributes &Attrs);
4950
4951	//===--------------------------------------------------------------------===//
4952	// C++ Coroutines
4953
4954	/// Parse the C++ Coroutines co_yield expression.
4955	///
4956	/// \verbatim
4957	/// co_yield-expression:
4958	/// 'co_yield' assignment-expression[opt]
4959	/// \endverbatim
4960	ExprResult ParseCoyieldExpression();
4961
4962	//===--------------------------------------------------------------------===//
4963	// C++ Concepts
4964
4965	/// ParseRequiresExpression - Parse a C++2a requires-expression.
4966	/// C++2a [expr.prim.req]p1
4967	/// A requires-expression provides a concise way to express requirements
4968	/// on template arguments. A requirement is one that can be checked by
4969	/// name lookup (6.4) or by checking properties of types and expressions.
4970	///
4971	/// \verbatim
4972	/// requires-expression:
4973	/// 'requires' requirement-parameter-list[opt] requirement-body
4974	///
4975	/// requirement-parameter-list:
4976	/// '(' parameter-declaration-clause[opt] ')'
4977	///
4978	/// requirement-body:
4979	/// '{' requirement-seq '}'
4980	///
4981	/// requirement-seq:
4982	/// requirement
4983	/// requirement-seq requirement
4984	///
4985	/// requirement:
4986	/// simple-requirement
4987	/// type-requirement
4988	/// compound-requirement
4989	/// nested-requirement
4990	/// \endverbatim
4991	ExprResult ParseRequiresExpression();
4992
4993	/// isTypeIdInParens - Assumes that a '(' was parsed and now we want to know
4994	/// whether the parens contain an expression or a type-id.
4995	/// Returns true for a type-id and false for an expression.
4996	bool isTypeIdInParens(bool &isAmbiguous) {
4997	if (getLangOpts().CPlusPlus)
4998	return isCXXTypeId(Context: TentativeCXXTypeIdContext::InParens, isAmbiguous);
4999	isAmbiguous = false;
5000	return isTypeSpecifierQualifier();
5001	}
5002	bool isTypeIdInParens() {
5003	bool isAmbiguous;
5004	return isTypeIdInParens(isAmbiguous);
5005	}
5006
5007	/// Finish parsing a C++ unqualified-id that is a template-id of
5008	/// some form.
5009	///
5010	/// This routine is invoked when a '<' is encountered after an identifier or
5011	/// operator-function-id is parsed by \c ParseUnqualifiedId() to determine
5012	/// whether the unqualified-id is actually a template-id. This routine will
5013	/// then parse the template arguments and form the appropriate template-id to
5014	/// return to the caller.
5015	///
5016	/// \param SS the nested-name-specifier that precedes this template-id, if
5017	/// we're actually parsing a qualified-id.
5018	///
5019	/// \param ObjectType if this unqualified-id occurs within a member access
5020	/// expression, the type of the base object whose member is being accessed.
5021	///
5022	/// \param ObjectHadErrors this unqualified-id occurs within a member access
5023	/// expression, indicates whether the original subexpressions had any errors.
5024	///
5025	/// \param Name for constructor and destructor names, this is the actual
5026	/// identifier that may be a template-name.
5027	///
5028	/// \param NameLoc the location of the class-name in a constructor or
5029	/// destructor.
5030	///
5031	/// \param EnteringContext whether we're entering the scope of the
5032	/// nested-name-specifier.
5033	///
5034	/// \param Id as input, describes the template-name or operator-function-id
5035	/// that precedes the '<'. If template arguments were parsed successfully,
5036	/// will be updated with the template-id.
5037	///
5038	/// \param AssumeTemplateId When true, this routine will assume that the name
5039	/// refers to a template without performing name lookup to verify.
5040	///
5041	/// \returns true if a parse error occurred, false otherwise.
5042	bool ParseUnqualifiedIdTemplateId(CXXScopeSpec &SS, ParsedType ObjectType,
5043	bool ObjectHadErrors,
5044	SourceLocation TemplateKWLoc,
5045	IdentifierInfo *Name,
5046	SourceLocation NameLoc,
5047	bool EnteringContext, UnqualifiedId &Id,
5048	bool AssumeTemplateId);
5049
5050	/// Parse an operator-function-id or conversion-function-id as part
5051	/// of a C++ unqualified-id.
5052	///
5053	/// This routine is responsible only for parsing the operator-function-id or
5054	/// conversion-function-id; it does not handle template arguments in any way.
5055	///
5056	/// \verbatim
5057	/// operator-function-id: [C++ 13.5]
5058	/// 'operator' operator
5059	///
5060	/// operator: one of
5061	/// new delete new[] delete[]
5062	/// + - * / % ^ & | ~
5063	/// ! = < > += -= *= /= %=
5064	/// ^= &= |= << >> >>= <<= == !=
5065	/// <= >= && || ++ -- , ->* ->
5066	/// () [] <=>
5067	///
5068	/// conversion-function-id: [C++ 12.3.2]
5069	/// operator conversion-type-id
5070	///
5071	/// conversion-type-id:
5072	/// type-specifier-seq conversion-declarator[opt]
5073	///
5074	/// conversion-declarator:
5075	/// ptr-operator conversion-declarator[opt]
5076	/// \endverbatim
5077	///
5078	/// \param SS The nested-name-specifier that preceded this unqualified-id. If
5079	/// non-empty, then we are parsing the unqualified-id of a qualified-id.
5080	///
5081	/// \param EnteringContext whether we are entering the scope of the
5082	/// nested-name-specifier.
5083	///
5084	/// \param ObjectType if this unqualified-id occurs within a member access
5085	/// expression, the type of the base object whose member is being accessed.
5086	///
5087	/// \param Result on a successful parse, contains the parsed unqualified-id.
5088	///
5089	/// \returns true if parsing fails, false otherwise.
5090	bool ParseUnqualifiedIdOperator(CXXScopeSpec &SS, bool EnteringContext,
5091	ParsedType ObjectType, UnqualifiedId &Result);
5092
5093	//===--------------------------------------------------------------------===//
5094	// C++11/G++: Type Traits [Type-Traits.html in the GCC manual]
5095
5096	/// Parse the built-in type-trait pseudo-functions that allow
5097	/// implementation of the TR1/C++11 type traits templates.
5098	///
5099	/// \verbatim
5100	/// primary-expression:
5101	/// unary-type-trait '(' type-id ')'
5102	/// binary-type-trait '(' type-id ',' type-id ')'
5103	/// type-trait '(' type-id-seq ')'
5104	///
5105	/// type-id-seq:
5106	/// type-id ...[opt] type-id-seq[opt]
5107	/// \endverbatim
5108	///
5109	ExprResult ParseTypeTrait();
5110
5111	//===--------------------------------------------------------------------===//
5112	// Embarcadero: Arary and Expression Traits
5113
5114	/// ParseArrayTypeTrait - Parse the built-in array type-trait
5115	/// pseudo-functions.
5116	///
5117	/// \verbatim
5118	/// primary-expression:
5119	/// [Embarcadero] '__array_rank' '(' type-id ')'
5120	/// [Embarcadero] '__array_extent' '(' type-id ',' expression ')'
5121	/// \endverbatim
5122	///
5123	ExprResult ParseArrayTypeTrait();
5124
5125	/// ParseExpressionTrait - Parse built-in expression-trait
5126	/// pseudo-functions like __is_lvalue_expr( xxx ).
5127	///
5128	/// \verbatim
5129	/// primary-expression:
5130	/// [Embarcadero] expression-trait '(' expression ')'
5131	/// \endverbatim
5132	///
5133	ExprResult ParseExpressionTrait();
5134
5135	///@}
5136
5137	//
5138	//
5139	// -------------------------------------------------------------------------
5140	//
5141	//
5142
5143	/// \name HLSL Constructs
5144	/// Implementations are in ParseHLSL.cpp
5145	///@{
5146
5147	private:
5148	bool MaybeParseHLSLAnnotations(Declarator &D,
5149	SourceLocation *EndLoc = nullptr,
5150	bool CouldBeBitField = false) {
5151	assert(getLangOpts().HLSL && "MaybeParseHLSLAnnotations is for HLSL only");
5152	if (Tok.is(K: tok::colon)) {
5153	ParsedAttributes Attrs(AttrFactory);
5154	ParseHLSLAnnotations(Attrs, EndLoc, CouldBeBitField);
5155	D.takeAttributes(attrs&: Attrs);
5156	return true;
5157	}
5158	return false;
5159	}
5160
5161	void MaybeParseHLSLAnnotations(ParsedAttributes &Attrs,
5162	SourceLocation *EndLoc = nullptr) {
5163	assert(getLangOpts().HLSL && "MaybeParseHLSLAnnotations is for HLSL only");
5164	if (Tok.is(K: tok::colon))
5165	ParseHLSLAnnotations(Attrs, EndLoc);
5166	}
5167
5168	void ParseHLSLAnnotations(ParsedAttributes &Attrs,
5169	SourceLocation *EndLoc = nullptr,
5170	bool CouldBeBitField = false);
5171	Decl *ParseHLSLBuffer(SourceLocation &DeclEnd);
5172
5173	///@}
5174
5175	//
5176	//
5177	// -------------------------------------------------------------------------
5178	//
5179	//
5180
5181	/// \name Initializers
5182	/// Implementations are in ParseInit.cpp
5183	///@{
5184
5185	private:
5186	//===--------------------------------------------------------------------===//
5187	// C99 6.7.8: Initialization.
5188
5189	/// ParseInitializer
5190	/// \verbatim
5191	/// initializer: [C99 6.7.8]
5192	/// assignment-expression
5193	/// '{' ...
5194	/// \endverbatim
5195	ExprResult ParseInitializer() {
5196	if (Tok.isNot(K: tok::l_brace))
5197	return ParseAssignmentExpression();
5198	return ParseBraceInitializer();
5199	}
5200
5201	/// MayBeDesignationStart - Return true if the current token might be the
5202	/// start of a designator. If we can tell it is impossible that it is a
5203	/// designator, return false.
5204	bool MayBeDesignationStart();
5205
5206	/// ParseBraceInitializer - Called when parsing an initializer that has a
5207	/// leading open brace.
5208	///
5209	/// \verbatim
5210	/// initializer: [C99 6.7.8]
5211	/// '{' initializer-list '}'
5212	/// '{' initializer-list ',' '}'
5213	/// [C23] '{' '}'
5214	///
5215	/// initializer-list:
5216	/// designation[opt] initializer ...[opt]
5217	/// initializer-list ',' designation[opt] initializer ...[opt]
5218	/// \endverbatim
5219	///
5220	ExprResult ParseBraceInitializer();
5221
5222	struct DesignatorCompletionInfo {
5223	SmallVectorImpl<Expr *> &InitExprs;
5224	QualType PreferredBaseType;
5225	};
5226
5227	/// ParseInitializerWithPotentialDesignator - Parse the 'initializer'
5228	/// production checking to see if the token stream starts with a designator.
5229	///
5230	/// C99:
5231	///
5232	/// \verbatim
5233	/// designation:
5234	/// designator-list '='
5235	/// [GNU] array-designator
5236	/// [GNU] identifier ':'
5237	///
5238	/// designator-list:
5239	/// designator
5240	/// designator-list designator
5241	///
5242	/// designator:
5243	/// array-designator
5244	/// '.' identifier
5245	///
5246	/// array-designator:
5247	/// '[' constant-expression ']'
5248	/// [GNU] '[' constant-expression '...' constant-expression ']'
5249	/// \endverbatim
5250	///
5251	/// C++20:
5252	///
5253	/// \verbatim
5254	/// designated-initializer-list:
5255	/// designated-initializer-clause
5256	/// designated-initializer-list ',' designated-initializer-clause
5257	///
5258	/// designated-initializer-clause:
5259	/// designator brace-or-equal-initializer
5260	///
5261	/// designator:
5262	/// '.' identifier
5263	/// \endverbatim
5264	///
5265	/// We allow the C99 syntax extensions in C++20, but do not allow the C++20
5266	/// extension (a braced-init-list after the designator with no '=') in C99.
5267	///
5268	/// NOTE: [OBC] allows '[ objc-receiver objc-message-args ]' as an
5269	/// initializer (because it is an expression). We need to consider this case
5270	/// when parsing array designators.
5271	///
5272	/// \p CodeCompleteCB is called with Designation parsed so far.
5273	ExprResult ParseInitializerWithPotentialDesignator(DesignatorCompletionInfo);
5274
5275	ExprResult createEmbedExpr();
5276
5277	/// A SmallVector of expressions.
5278	typedef SmallVector<Expr *, 12> ExprVector;
5279
5280	// Return true if a comma (or closing brace) is necessary after the
5281	// __if_exists/if_not_exists statement.
5282	bool ParseMicrosoftIfExistsBraceInitializer(ExprVector &InitExprs,
5283	bool &InitExprsOk);
5284
5285	///@}
5286
5287	//
5288	//
5289	// -------------------------------------------------------------------------
5290	//
5291	//
5292
5293	/// \name Objective-C Constructs
5294	/// Implementations are in ParseObjc.cpp
5295	///@{
5296
5297	public:
5298	friend class InMessageExpressionRAIIObject;
5299	friend class ObjCDeclContextSwitch;
5300
5301	ObjCContainerDecl *getObjCDeclContext() const {
5302	return Actions.ObjC().getObjCDeclContext();
5303	}
5304
5305	/// Retrieve the underscored keyword (_Nonnull, _Nullable) that corresponds
5306	/// to the given nullability kind.
5307	IdentifierInfo *getNullabilityKeyword(NullabilityKind nullability) {
5308	return Actions.getNullabilityKeyword(nullability);
5309	}
5310
5311	private:
5312	/// Objective-C contextual keywords.
5313	IdentifierInfo *Ident_instancetype;
5314
5315	/// Ident_super - IdentifierInfo for "super", to support fast
5316	/// comparison.
5317	IdentifierInfo *Ident_super;
5318
5319	/// When true, we are directly inside an Objective-C message
5320	/// send expression.
5321	///
5322	/// This is managed by the \c InMessageExpressionRAIIObject class, and
5323	/// should not be set directly.
5324	bool InMessageExpression;
5325
5326	/// True if we are within an Objective-C container while parsing C-like decls.
5327	///
5328	/// This is necessary because Sema thinks we have left the container
5329	/// to parse the C-like decls, meaning Actions.ObjC().getObjCDeclContext()
5330	/// will be NULL.
5331	bool ParsingInObjCContainer;
5332
5333	/// Returns true if the current token is the identifier 'instancetype'.
5334	///
5335	/// Should only be used in Objective-C language modes.
5336	bool isObjCInstancetype() {
5337	assert(getLangOpts().ObjC);
5338	if (Tok.isAnnotation())
5339	return false;
5340	if (!Ident_instancetype)
5341	Ident_instancetype = PP.getIdentifierInfo(Name: "instancetype");
5342	return Tok.getIdentifierInfo() == Ident_instancetype;
5343	}
5344
5345	/// ObjCDeclContextSwitch - An object used to switch context from
5346	/// an objective-c decl context to its enclosing decl context and
5347	/// back.
5348	class ObjCDeclContextSwitch {
5349	Parser &P;
5350	ObjCContainerDecl *DC;
5351	SaveAndRestore<bool> WithinObjCContainer;
5352
5353	public:
5354	explicit ObjCDeclContextSwitch(Parser &p)
5355	: P(p), DC(p.getObjCDeclContext()),
5356	WithinObjCContainer(P.ParsingInObjCContainer, DC != nullptr) {
5357	if (DC)
5358	P.Actions.ObjC().ActOnObjCTemporaryExitContainerContext(ObjCCtx: DC);
5359	}
5360	~ObjCDeclContextSwitch() {
5361	if (DC)
5362	P.Actions.ObjC().ActOnObjCReenterContainerContext(ObjCCtx: DC);
5363	}
5364	};
5365
5366	void CheckNestedObjCContexts(SourceLocation AtLoc);
5367
5368	void ParseLexedObjCMethodDefs(LexedMethod &LM, bool parseMethod);
5369
5370	// Objective-C External Declarations
5371
5372	/// Skips attributes after an Objective-C @ directive. Emits a diagnostic.
5373	void MaybeSkipAttributes(tok::ObjCKeywordKind Kind);
5374
5375	/// ParseObjCAtDirectives - Handle parts of the external-declaration
5376	/// production:
5377	/// \verbatim
5378	/// external-declaration: [C99 6.9]
5379	/// [OBJC] objc-class-definition
5380	/// [OBJC] objc-class-declaration
5381	/// [OBJC] objc-alias-declaration
5382	/// [OBJC] objc-protocol-definition
5383	/// [OBJC] objc-method-definition
5384	/// [OBJC] '@' 'end'
5385	/// \endverbatim
5386	DeclGroupPtrTy ParseObjCAtDirectives(ParsedAttributes &DeclAttrs,
5387	ParsedAttributes &DeclSpecAttrs);
5388
5389	///
5390	/// \verbatim
5391	/// objc-class-declaration:
5392	/// '@' 'class' objc-class-forward-decl (',' objc-class-forward-decl)* ';'
5393	///
5394	/// objc-class-forward-decl:
5395	/// identifier objc-type-parameter-list[opt]
5396	/// \endverbatim
5397	///
5398	DeclGroupPtrTy ParseObjCAtClassDeclaration(SourceLocation atLoc);
5399
5400	///
5401	/// \verbatim
5402	/// objc-interface:
5403	/// objc-class-interface-attributes[opt] objc-class-interface
5404	/// objc-category-interface
5405	///
5406	/// objc-class-interface:
5407	/// '@' 'interface' identifier objc-type-parameter-list[opt]
5408	/// objc-superclass[opt] objc-protocol-refs[opt]
5409	/// objc-class-instance-variables[opt]
5410	/// objc-interface-decl-list
5411	/// @end
5412	///
5413	/// objc-category-interface:
5414	/// '@' 'interface' identifier objc-type-parameter-list[opt]
5415	/// '(' identifier[opt] ')' objc-protocol-refs[opt]
5416	/// objc-interface-decl-list
5417	/// @end
5418	///
5419	/// objc-superclass:
5420	/// ':' identifier objc-type-arguments[opt]
5421	///
5422	/// objc-class-interface-attributes:
5423	/// __attribute__((visibility("default")))
5424	/// __attribute__((visibility("hidden")))
5425	/// __attribute__((deprecated))
5426	/// __attribute__((unavailable))
5427	/// __attribute__((objc_exception)) - used by NSException on 64-bit
5428	/// __attribute__((objc_root_class))
5429	/// \endverbatim
5430	///
5431	Decl *ParseObjCAtInterfaceDeclaration(SourceLocation AtLoc,
5432	ParsedAttributes &prefixAttrs);
5433
5434	/// Class to handle popping type parameters when leaving the scope.
5435	class ObjCTypeParamListScope;
5436
5437	/// Parse an objc-type-parameter-list.
5438	ObjCTypeParamList *parseObjCTypeParamList();
5439
5440	/// Parse an Objective-C type parameter list, if present, or capture
5441	/// the locations of the protocol identifiers for a list of protocol
5442	/// references.
5443	///
5444	/// \verbatim
5445	/// objc-type-parameter-list:
5446	/// '<' objc-type-parameter (',' objc-type-parameter)* '>'
5447	///
5448	/// objc-type-parameter:
5449	/// objc-type-parameter-variance? identifier objc-type-parameter-bound[opt]
5450	///
5451	/// objc-type-parameter-bound:
5452	/// ':' type-name
5453	///
5454	/// objc-type-parameter-variance:
5455	/// '__covariant'
5456	/// '__contravariant'
5457	/// \endverbatim
5458	///
5459	/// \param lAngleLoc The location of the starting '<'.
5460	///
5461	/// \param protocolIdents Will capture the list of identifiers, if the
5462	/// angle brackets contain a list of protocol references rather than a
5463	/// type parameter list.
5464	///
5465	/// \param rAngleLoc The location of the ending '>'.
5466	ObjCTypeParamList *parseObjCTypeParamListOrProtocolRefs(
5467	ObjCTypeParamListScope &Scope, SourceLocation &lAngleLoc,
5468	SmallVectorImpl<IdentifierLoc> &protocolIdents, SourceLocation &rAngleLoc,
5469	bool mayBeProtocolList = true);
5470
5471	void HelperActionsForIvarDeclarations(ObjCContainerDecl *interfaceDecl,
5472	SourceLocation atLoc,
5473	BalancedDelimiterTracker &T,
5474	SmallVectorImpl<Decl *> &AllIvarDecls,
5475	bool RBraceMissing);
5476
5477	/// \verbatim
5478	/// objc-class-instance-variables:
5479	/// '{' objc-instance-variable-decl-list[opt] '}'
5480	///
5481	/// objc-instance-variable-decl-list:
5482	/// objc-visibility-spec
5483	/// objc-instance-variable-decl ';'
5484	/// ';'
5485	/// objc-instance-variable-decl-list objc-visibility-spec
5486	/// objc-instance-variable-decl-list objc-instance-variable-decl ';'
5487	/// objc-instance-variable-decl-list static_assert-declaration
5488	/// objc-instance-variable-decl-list ';'
5489	///
5490	/// objc-visibility-spec:
5491	/// @private
5492	/// @protected
5493	/// @public
5494	/// @package [OBJC2]
5495	///
5496	/// objc-instance-variable-decl:
5497	/// struct-declaration
5498	/// \endverbatim
5499	///
5500	void ParseObjCClassInstanceVariables(ObjCContainerDecl *interfaceDecl,
5501	tok::ObjCKeywordKind visibility,
5502	SourceLocation atLoc);
5503
5504	/// \verbatim
5505	/// objc-protocol-refs:
5506	/// '<' identifier-list '>'
5507	/// \endverbatim
5508	///
5509	bool ParseObjCProtocolReferences(
5510	SmallVectorImpl<Decl *> &P, SmallVectorImpl<SourceLocation> &PLocs,
5511	bool WarnOnDeclarations, bool ForObjCContainer, SourceLocation &LAngleLoc,
5512	SourceLocation &EndProtoLoc, bool consumeLastToken);
5513
5514	/// Parse the first angle-bracket-delimited clause for an
5515	/// Objective-C object or object pointer type, which may be either
5516	/// type arguments or protocol qualifiers.
5517	///
5518	/// \verbatim
5519	/// objc-type-arguments:
5520	/// '<' type-name '...'[opt] (',' type-name '...'[opt])* '>'
5521	/// \endverbatim
5522	///
5523	void parseObjCTypeArgsOrProtocolQualifiers(
5524	ParsedType baseType, SourceLocation &typeArgsLAngleLoc,
5525	SmallVectorImpl<ParsedType> &typeArgs, SourceLocation &typeArgsRAngleLoc,
5526	SourceLocation &protocolLAngleLoc, SmallVectorImpl<Decl *> &protocols,
5527	SmallVectorImpl<SourceLocation> &protocolLocs,
5528	SourceLocation &protocolRAngleLoc, bool consumeLastToken,
5529	bool warnOnIncompleteProtocols);
5530
5531	/// Parse either Objective-C type arguments or protocol qualifiers; if the
5532	/// former, also parse protocol qualifiers afterward.
5533	void parseObjCTypeArgsAndProtocolQualifiers(
5534	ParsedType baseType, SourceLocation &typeArgsLAngleLoc,
5535	SmallVectorImpl<ParsedType> &typeArgs, SourceLocation &typeArgsRAngleLoc,
5536	SourceLocation &protocolLAngleLoc, SmallVectorImpl<Decl *> &protocols,
5537	SmallVectorImpl<SourceLocation> &protocolLocs,
5538	SourceLocation &protocolRAngleLoc, bool consumeLastToken);
5539
5540	/// Parse a protocol qualifier type such as '<NSCopying>', which is
5541	/// an anachronistic way of writing 'id<NSCopying>'.
5542	TypeResult parseObjCProtocolQualifierType(SourceLocation &rAngleLoc);
5543
5544	/// Parse Objective-C type arguments and protocol qualifiers, extending the
5545	/// current type with the parsed result.
5546	TypeResult parseObjCTypeArgsAndProtocolQualifiers(SourceLocation loc,
5547	ParsedType type,
5548	bool consumeLastToken,
5549	SourceLocation &endLoc);
5550
5551	/// \verbatim
5552	/// objc-interface-decl-list:
5553	/// empty
5554	/// objc-interface-decl-list objc-property-decl [OBJC2]
5555	/// objc-interface-decl-list objc-method-requirement [OBJC2]
5556	/// objc-interface-decl-list objc-method-proto ';'
5557	/// objc-interface-decl-list declaration
5558	/// objc-interface-decl-list ';'
5559	///
5560	/// objc-method-requirement: [OBJC2]
5561	/// @required
5562	/// @optional
5563	/// \endverbatim
5564	///
5565	void ParseObjCInterfaceDeclList(tok::ObjCKeywordKind contextKey, Decl *CDecl);
5566
5567	/// \verbatim
5568	/// objc-protocol-declaration:
5569	/// objc-protocol-definition
5570	/// objc-protocol-forward-reference
5571	///
5572	/// objc-protocol-definition:
5573	/// \@protocol identifier
5574	/// objc-protocol-refs[opt]
5575	/// objc-interface-decl-list
5576	/// \@end
5577	///
5578	/// objc-protocol-forward-reference:
5579	/// \@protocol identifier-list ';'
5580	/// \endverbatim
5581	///
5582	/// "\@protocol identifier ;" should be resolved as "\@protocol
5583	/// identifier-list ;": objc-interface-decl-list may not start with a
5584	/// semicolon in the first alternative if objc-protocol-refs are omitted.
5585	DeclGroupPtrTy ParseObjCAtProtocolDeclaration(SourceLocation atLoc,
5586	ParsedAttributes &prefixAttrs);
5587
5588	struct ObjCImplParsingDataRAII {
5589	Parser &P;
5590	Decl *Dcl;
5591	bool HasCFunction;
5592	typedef SmallVector<LexedMethod *, 8> LateParsedObjCMethodContainer;
5593	LateParsedObjCMethodContainer LateParsedObjCMethods;
5594
5595	ObjCImplParsingDataRAII(Parser &parser, Decl *D)
5596	: P(parser), Dcl(D), HasCFunction(false) {
5597	P.CurParsedObjCImpl = this;
5598	Finished = false;
5599	}
5600	~ObjCImplParsingDataRAII();
5601
5602	void finish(SourceRange AtEnd);
5603	bool isFinished() const { return Finished; }
5604
5605	private:
5606	bool Finished;
5607	};
5608	ObjCImplParsingDataRAII *CurParsedObjCImpl;
5609
5610	/// StashAwayMethodOrFunctionBodyTokens - Consume the tokens and store them
5611	/// for later parsing.
5612	void StashAwayMethodOrFunctionBodyTokens(Decl *MDecl);
5613
5614	/// \verbatim
5615	/// objc-implementation:
5616	/// objc-class-implementation-prologue
5617	/// objc-category-implementation-prologue
5618	///
5619	/// objc-class-implementation-prologue:
5620	/// @implementation identifier objc-superclass[opt]
5621	/// objc-class-instance-variables[opt]
5622	///
5623	/// objc-category-implementation-prologue:
5624	/// @implementation identifier ( identifier )
5625	/// \endverbatim
5626	DeclGroupPtrTy ParseObjCAtImplementationDeclaration(SourceLocation AtLoc,
5627	ParsedAttributes &Attrs);
5628	DeclGroupPtrTy ParseObjCAtEndDeclaration(SourceRange atEnd);
5629
5630	/// \verbatim
5631	/// compatibility-alias-decl:
5632	/// @compatibility_alias alias-name class-name ';'
5633	/// \endverbatim
5634	///
5635	Decl *ParseObjCAtAliasDeclaration(SourceLocation atLoc);
5636
5637	/// \verbatim
5638	/// property-synthesis:
5639	/// @synthesize property-ivar-list ';'
5640	///
5641	/// property-ivar-list:
5642	/// property-ivar
5643	/// property-ivar-list ',' property-ivar
5644	///
5645	/// property-ivar:
5646	/// identifier
5647	/// identifier '=' identifier
5648	/// \endverbatim
5649	///
5650	Decl *ParseObjCPropertySynthesize(SourceLocation atLoc);
5651
5652	/// \verbatim
5653	/// property-dynamic:
5654	/// @dynamic property-list
5655	///
5656	/// property-list:
5657	/// identifier
5658	/// property-list ',' identifier
5659	/// \endverbatim
5660	///
5661	Decl *ParseObjCPropertyDynamic(SourceLocation atLoc);
5662
5663	/// \verbatim
5664	/// objc-selector:
5665	/// identifier
5666	/// one of
5667	/// enum struct union if else while do for switch case default
5668	/// break continue return goto asm sizeof typeof __alignof
5669	/// unsigned long const short volatile signed restrict _Complex
5670	/// in out inout bycopy byref oneway int char float double void _Bool
5671	/// \endverbatim
5672	///
5673	IdentifierInfo *ParseObjCSelectorPiece(SourceLocation &MethodLocation);
5674
5675	IdentifierInfo *ObjCTypeQuals[llvm::to_underlying(E: ObjCTypeQual::NumQuals)];
5676
5677	/// \verbatim
5678	/// objc-for-collection-in: 'in'
5679	/// \endverbatim
5680	///
5681	bool isTokIdentifier_in() const;
5682
5683	/// \verbatim
5684	/// objc-type-name:
5685	/// '(' objc-type-qualifiers[opt] type-name ')'
5686	/// '(' objc-type-qualifiers[opt] ')'
5687	/// \endverbatim
5688	///
5689	ParsedType ParseObjCTypeName(ObjCDeclSpec &DS, DeclaratorContext Ctx,
5690	ParsedAttributes *ParamAttrs);
5691
5692	/// \verbatim
5693	/// objc-method-proto:
5694	/// objc-instance-method objc-method-decl objc-method-attributes[opt]
5695	/// objc-class-method objc-method-decl objc-method-attributes[opt]
5696	///
5697	/// objc-instance-method: '-'
5698	/// objc-class-method: '+'
5699	///
5700	/// objc-method-attributes: [OBJC2]
5701	/// __attribute__((deprecated))
5702	/// \endverbatim
5703	///
5704	Decl *ParseObjCMethodPrototype(
5705	tok::ObjCKeywordKind MethodImplKind = tok::objc_not_keyword,
5706	bool MethodDefinition = true);
5707
5708	/// \verbatim
5709	/// objc-method-decl:
5710	/// objc-selector
5711	/// objc-keyword-selector objc-parmlist[opt]
5712	/// objc-type-name objc-selector
5713	/// objc-type-name objc-keyword-selector objc-parmlist[opt]
5714	///
5715	/// objc-keyword-selector:
5716	/// objc-keyword-decl
5717	/// objc-keyword-selector objc-keyword-decl
5718	///
5719	/// objc-keyword-decl:
5720	/// objc-selector ':' objc-type-name objc-keyword-attributes[opt] identifier
5721	/// objc-selector ':' objc-keyword-attributes[opt] identifier
5722	/// ':' objc-type-name objc-keyword-attributes[opt] identifier
5723	/// ':' objc-keyword-attributes[opt] identifier
5724	///
5725	/// objc-parmlist:
5726	/// objc-parms objc-ellipsis[opt]
5727	///
5728	/// objc-parms:
5729	/// objc-parms , parameter-declaration
5730	///
5731	/// objc-ellipsis:
5732	/// , ...
5733	///
5734	/// objc-keyword-attributes: [OBJC2]
5735	/// __attribute__((unused))
5736	/// \endverbatim
5737	///
5738	Decl *ParseObjCMethodDecl(
5739	SourceLocation mLoc, tok::TokenKind mType,
5740	tok::ObjCKeywordKind MethodImplKind = tok::objc_not_keyword,
5741	bool MethodDefinition = true);
5742
5743	/// Parse property attribute declarations.
5744	///
5745	/// \verbatim
5746	/// property-attr-decl: '(' property-attrlist ')'
5747	/// property-attrlist:
5748	/// property-attribute
5749	/// property-attrlist ',' property-attribute
5750	/// property-attribute:
5751	/// getter '=' identifier
5752	/// setter '=' identifier ':'
5753	/// direct
5754	/// readonly
5755	/// readwrite
5756	/// assign
5757	/// retain
5758	/// copy
5759	/// nonatomic
5760	/// atomic
5761	/// strong
5762	/// weak
5763	/// unsafe_unretained
5764	/// nonnull
5765	/// nullable
5766	/// null_unspecified
5767	/// null_resettable
5768	/// class
5769	/// \endverbatim
5770	///
5771	void ParseObjCPropertyAttribute(ObjCDeclSpec &DS);
5772
5773	/// \verbatim
5774	/// objc-method-def: objc-method-proto ';'[opt] '{' body '}'
5775	/// \endverbatim
5776	///
5777	Decl *ParseObjCMethodDefinition();
5778
5779	//===--------------------------------------------------------------------===//
5780	// Objective-C Expressions
5781	ExprResult ParseObjCAtExpression(SourceLocation AtLocation);
5782	ExprResult ParseObjCStringLiteral(SourceLocation AtLoc);
5783
5784	/// ParseObjCCharacterLiteral -
5785	/// \verbatim
5786	/// objc-scalar-literal : '@' character-literal
5787	/// ;
5788	/// \endverbatim
5789	ExprResult ParseObjCCharacterLiteral(SourceLocation AtLoc);
5790
5791	/// ParseObjCNumericLiteral -
5792	/// \verbatim
5793	/// objc-scalar-literal : '@' scalar-literal
5794	/// ;
5795	/// scalar-literal : | numeric-constant /* any numeric constant. */
5796	/// ;
5797	/// \endverbatim
5798	ExprResult ParseObjCNumericLiteral(SourceLocation AtLoc);
5799
5800	/// ParseObjCBooleanLiteral -
5801	/// \verbatim
5802	/// objc-scalar-literal : '@' boolean-keyword
5803	/// ;
5804	/// boolean-keyword: 'true' | 'false' | '__objc_yes' | '__objc_no'
5805	/// ;
5806	/// \endverbatim
5807	ExprResult ParseObjCBooleanLiteral(SourceLocation AtLoc, bool ArgValue);
5808
5809	ExprResult ParseObjCArrayLiteral(SourceLocation AtLoc);
5810	ExprResult ParseObjCDictionaryLiteral(SourceLocation AtLoc);
5811
5812	/// ParseObjCBoxedExpr -
5813	/// \verbatim
5814	/// objc-box-expression:
5815	/// @( assignment-expression )
5816	/// \endverbatim
5817	ExprResult ParseObjCBoxedExpr(SourceLocation AtLoc);
5818
5819	/// \verbatim
5820	/// objc-encode-expression:
5821	/// \@encode ( type-name )
5822	/// \endverbatim
5823	ExprResult ParseObjCEncodeExpression(SourceLocation AtLoc);
5824
5825	/// \verbatim
5826	/// objc-selector-expression
5827	/// @selector '(' '('[opt] objc-keyword-selector ')'[opt] ')'
5828	/// \endverbatim
5829	ExprResult ParseObjCSelectorExpression(SourceLocation AtLoc);
5830
5831	/// \verbatim
5832	/// objc-protocol-expression
5833	/// \@protocol ( protocol-name )
5834	/// \endverbatim
5835	ExprResult ParseObjCProtocolExpression(SourceLocation AtLoc);
5836
5837	/// Determine whether the parser is currently referring to a an
5838	/// Objective-C message send, using a simplified heuristic to avoid overhead.
5839	///
5840	/// This routine will only return true for a subset of valid message-send
5841	/// expressions.
5842	bool isSimpleObjCMessageExpression();
5843
5844	/// \verbatim
5845	/// objc-message-expr:
5846	/// '[' objc-receiver objc-message-args ']'
5847	///
5848	/// objc-receiver: [C]
5849	/// 'super'
5850	/// expression
5851	/// class-name
5852	/// type-name
5853	/// \endverbatim
5854	///
5855	ExprResult ParseObjCMessageExpression();
5856
5857	/// Parse the remainder of an Objective-C message following the
5858	/// '[' objc-receiver.
5859	///
5860	/// This routine handles sends to super, class messages (sent to a
5861	/// class name), and instance messages (sent to an object), and the
5862	/// target is represented by \p SuperLoc, \p ReceiverType, or \p
5863	/// ReceiverExpr, respectively. Only one of these parameters may have
5864	/// a valid value.
5865	///
5866	/// \param LBracLoc The location of the opening '['.
5867	///
5868	/// \param SuperLoc If this is a send to 'super', the location of the
5869	/// 'super' keyword that indicates a send to the superclass.
5870	///
5871	/// \param ReceiverType If this is a class message, the type of the
5872	/// class we are sending a message to.
5873	///
5874	/// \param ReceiverExpr If this is an instance message, the expression
5875	/// used to compute the receiver object.
5876	///
5877	/// \verbatim
5878	/// objc-message-args:
5879	/// objc-selector
5880	/// objc-keywordarg-list
5881	///
5882	/// objc-keywordarg-list:
5883	/// objc-keywordarg
5884	/// objc-keywordarg-list objc-keywordarg
5885	///
5886	/// objc-keywordarg:
5887	/// selector-name[opt] ':' objc-keywordexpr
5888	///
5889	/// objc-keywordexpr:
5890	/// nonempty-expr-list
5891	///
5892	/// nonempty-expr-list:
5893	/// assignment-expression
5894	/// nonempty-expr-list , assignment-expression
5895	/// \endverbatim
5896	///
5897	ExprResult ParseObjCMessageExpressionBody(SourceLocation LBracloc,
5898	SourceLocation SuperLoc,
5899	ParsedType ReceiverType,
5900	Expr *ReceiverExpr);
5901
5902	/// Parse the receiver of an Objective-C++ message send.
5903	///
5904	/// This routine parses the receiver of a message send in
5905	/// Objective-C++ either as a type or as an expression. Note that this
5906	/// routine must not be called to parse a send to 'super', since it
5907	/// has no way to return such a result.
5908	///
5909	/// \param IsExpr Whether the receiver was parsed as an expression.
5910	///
5911	/// \param TypeOrExpr If the receiver was parsed as an expression (\c
5912	/// IsExpr is true), the parsed expression. If the receiver was parsed
5913	/// as a type (\c IsExpr is false), the parsed type.
5914	///
5915	/// \returns True if an error occurred during parsing or semantic
5916	/// analysis, in which case the arguments do not have valid
5917	/// values. Otherwise, returns false for a successful parse.
5918	///
5919	/// \verbatim
5920	/// objc-receiver: [C++]
5921	/// 'super' [not parsed here]
5922	/// expression
5923	/// simple-type-specifier
5924	/// typename-specifier
5925	/// \endverbatim
5926	bool ParseObjCXXMessageReceiver(bool &IsExpr, void *&TypeOrExpr);
5927
5928	//===--------------------------------------------------------------------===//
5929	// Objective-C Statements
5930
5931	enum class ParsedStmtContext;
5932
5933	StmtResult ParseObjCAtStatement(SourceLocation atLoc,
5934	ParsedStmtContext StmtCtx);
5935
5936	/// \verbatim
5937	/// objc-try-catch-statement:
5938	/// @try compound-statement objc-catch-list[opt]
5939	/// @try compound-statement objc-catch-list[opt] @finally compound-statement
5940	///
5941	/// objc-catch-list:
5942	/// @catch ( parameter-declaration ) compound-statement
5943	/// objc-catch-list @catch ( catch-parameter-declaration ) compound-statement
5944	/// catch-parameter-declaration:
5945	/// parameter-declaration
5946	/// '...' [OBJC2]
5947	/// \endverbatim
5948	///
5949	StmtResult ParseObjCTryStmt(SourceLocation atLoc);
5950
5951	/// \verbatim
5952	/// objc-throw-statement:
5953	/// throw expression[opt];
5954	/// \endverbatim
5955	///
5956	StmtResult ParseObjCThrowStmt(SourceLocation atLoc);
5957
5958	/// \verbatim
5959	/// objc-synchronized-statement:
5960	/// @synchronized '(' expression ')' compound-statement
5961	/// \endverbatim
5962	///
5963	StmtResult ParseObjCSynchronizedStmt(SourceLocation atLoc);
5964
5965	/// \verbatim
5966	/// objc-autoreleasepool-statement:
5967	/// @autoreleasepool compound-statement
5968	/// \endverbatim
5969	///
5970	StmtResult ParseObjCAutoreleasePoolStmt(SourceLocation atLoc);
5971
5972	/// ParseObjCTypeQualifierList - This routine parses the objective-c's type
5973	/// qualifier list and builds their bitmask representation in the input
5974	/// argument.
5975	///
5976	/// \verbatim
5977	/// objc-type-qualifiers:
5978	/// objc-type-qualifier
5979	/// objc-type-qualifiers objc-type-qualifier
5980	///
5981	/// objc-type-qualifier:
5982	/// 'in'
5983	/// 'out'
5984	/// 'inout'
5985	/// 'oneway'
5986	/// 'bycopy's
5987	/// 'byref'
5988	/// 'nonnull'
5989	/// 'nullable'
5990	/// 'null_unspecified'
5991	/// \endverbatim
5992	///
5993	void ParseObjCTypeQualifierList(ObjCDeclSpec &DS, DeclaratorContext Context);
5994
5995	/// Determine whether we are currently at the start of an Objective-C
5996	/// class message that appears to be missing the open bracket '['.
5997	bool isStartOfObjCClassMessageMissingOpenBracket();
5998
5999	///@}
6000
6001	//
6002	//
6003	// -------------------------------------------------------------------------
6004	//
6005	//
6006
6007	/// \name OpenACC Constructs
6008	/// Implementations are in ParseOpenACC.cpp
6009	///@{
6010
6011	public:
6012	friend class ParsingOpenACCDirectiveRAII;
6013
6014	/// Parse OpenACC directive on a declaration.
6015	///
6016	/// Placeholder for now, should just ignore the directives after emitting a
6017	/// diagnostic. Eventually will be split into a few functions to parse
6018	/// different situations.
6019	DeclGroupPtrTy ParseOpenACCDirectiveDecl(AccessSpecifier &AS,
6020	ParsedAttributes &Attrs,
6021	DeclSpec::TST TagType,
6022	Decl *TagDecl);
6023
6024	// Parse OpenACC Directive on a Statement.
6025	StmtResult ParseOpenACCDirectiveStmt();
6026
6027	private:
6028	/// Parsing OpenACC directive mode.
6029	bool OpenACCDirectiveParsing = false;
6030
6031	/// Currently parsing a situation where an OpenACC array section could be
6032	/// legal, such as a 'var-list'.
6033	bool AllowOpenACCArraySections = false;
6034
6035	/// RAII object to set reset OpenACC parsing a context where Array Sections
6036	/// are allowed.
6037	class OpenACCArraySectionRAII {
6038	Parser &P;
6039
6040	public:
6041	OpenACCArraySectionRAII(Parser &P) : P(P) {
6042	assert(!P.AllowOpenACCArraySections);
6043	P.AllowOpenACCArraySections = true;
6044	}
6045	~OpenACCArraySectionRAII() {
6046	assert(P.AllowOpenACCArraySections);
6047	P.AllowOpenACCArraySections = false;
6048	}
6049	};
6050
6051	/// A struct to hold the information that got parsed by ParseOpenACCDirective,
6052	/// so that the callers of it can use that to construct the appropriate AST
6053	/// nodes.
6054	struct OpenACCDirectiveParseInfo {
6055	OpenACCDirectiveKind DirKind;
6056	SourceLocation StartLoc;
6057	SourceLocation DirLoc;
6058	SourceLocation LParenLoc;
6059	SourceLocation RParenLoc;
6060	SourceLocation EndLoc;
6061	SourceLocation MiscLoc;
6062	OpenACCAtomicKind AtomicKind;
6063	SmallVector<Expr *> Exprs;
6064	SmallVector<OpenACCClause *> Clauses;
6065	// TODO OpenACC: As we implement support for the Atomic, Routine, and Cache
6066	// constructs, we likely want to put that information in here as well.
6067	};
6068
6069	struct OpenACCWaitParseInfo {
6070	bool Failed = false;
6071	Expr *DevNumExpr = nullptr;
6072	SourceLocation QueuesLoc;
6073	SmallVector<Expr *> QueueIdExprs;
6074
6075	SmallVector<Expr *> getAllExprs() {
6076	SmallVector<Expr *> Out;
6077	Out.push_back(Elt: DevNumExpr);
6078	llvm::append_range(C&: Out, R&: QueueIdExprs);
6079	return Out;
6080	}
6081	};
6082	struct OpenACCCacheParseInfo {
6083	bool Failed = false;
6084	SourceLocation ReadOnlyLoc;
6085	SmallVector<Expr *> Vars;
6086	};
6087
6088	/// Represents the 'error' state of parsing an OpenACC Clause, and stores
6089	/// whether we can continue parsing, or should give up on the directive.
6090	enum class OpenACCParseCanContinue { Cannot = 0, Can = 1 };
6091
6092	/// A type to represent the state of parsing an OpenACC Clause. Situations
6093	/// that result in an OpenACCClause pointer are a success and can continue
6094	/// parsing, however some other situations can also continue.
6095	/// FIXME: This is better represented as a std::expected when we get C++23.
6096	using OpenACCClauseParseResult =
6097	llvm::PointerIntPair<OpenACCClause *, 1, OpenACCParseCanContinue>;
6098
6099	OpenACCClauseParseResult OpenACCCanContinue();
6100	OpenACCClauseParseResult OpenACCCannotContinue();
6101	OpenACCClauseParseResult OpenACCSuccess(OpenACCClause *Clause);
6102
6103	/// Parses the OpenACC directive (the entire pragma) including the clause
6104	/// list, but does not produce the main AST node.
6105	OpenACCDirectiveParseInfo ParseOpenACCDirective();
6106	/// Helper that parses an ID Expression based on the language options.
6107	ExprResult ParseOpenACCIDExpression();
6108
6109	/// Parses the variable list for the `cache` construct.
6110	///
6111	/// OpenACC 3.3, section 2.10:
6112	/// In C and C++, the syntax of the cache directive is:
6113	///
6114	/// #pragma acc cache ([readonly:]var-list) new-line
6115	OpenACCCacheParseInfo ParseOpenACCCacheVarList();
6116
6117	/// Tries to parse the 'modifier-list' for a 'copy', 'copyin', 'copyout', or
6118	/// 'create' clause.
6119	OpenACCModifierKind tryParseModifierList(OpenACCClauseKind CK);
6120
6121	using OpenACCVarParseResult = std::pair<ExprResult, OpenACCParseCanContinue>;
6122
6123	/// Parses a single variable in a variable list for OpenACC.
6124	///
6125	/// OpenACC 3.3, section 1.6:
6126	/// In this spec, a 'var' (in italics) is one of the following:
6127	/// - a variable name (a scalar, array, or composite variable name)
6128	/// - a subarray specification with subscript ranges
6129	/// - an array element
6130	/// - a member of a composite variable
6131	/// - a common block name between slashes (fortran only)
6132	OpenACCVarParseResult ParseOpenACCVar(OpenACCDirectiveKind DK,
6133	OpenACCClauseKind CK);
6134
6135	/// Parses the variable list for the variety of places that take a var-list.
6136	llvm::SmallVector<Expr *> ParseOpenACCVarList(OpenACCDirectiveKind DK,
6137	OpenACCClauseKind CK);
6138
6139	/// Parses any parameters for an OpenACC Clause, including required/optional
6140	/// parens.
6141	///
6142	/// The OpenACC Clause List is a comma or space-delimited list of clauses (see
6143	/// the comment on ParseOpenACCClauseList). The concept of a 'clause' doesn't
6144	/// really have its owner grammar and each individual one has its own
6145	/// definition. However, they all are named with a single-identifier (or
6146	/// auto/default!) token, followed in some cases by either braces or parens.
6147	OpenACCClauseParseResult
6148	ParseOpenACCClauseParams(ArrayRef<const OpenACCClause *> ExistingClauses,
6149	OpenACCDirectiveKind DirKind, OpenACCClauseKind Kind,
6150	SourceLocation ClauseLoc);
6151
6152	/// Parses a single clause in a clause-list for OpenACC. Returns nullptr on
6153	/// error.
6154	OpenACCClauseParseResult
6155	ParseOpenACCClause(ArrayRef<const OpenACCClause *> ExistingClauses,
6156	OpenACCDirectiveKind DirKind);
6157
6158	/// Parses the clause-list for an OpenACC directive.
6159	///
6160	/// OpenACC 3.3, section 1.7:
6161	/// To simplify the specification and convey appropriate constraint
6162	/// information, a pqr-list is a comma-separated list of pdr items. The one
6163	/// exception is a clause-list, which is a list of one or more clauses
6164	/// optionally separated by commas.
6165	SmallVector<OpenACCClause *>
6166	ParseOpenACCClauseList(OpenACCDirectiveKind DirKind);
6167
6168	/// OpenACC 3.3, section 2.16:
6169	/// In this section and throughout the specification, the term wait-argument
6170	/// means:
6171	/// \verbatim
6172	/// [ devnum : int-expr : ] [ queues : ] async-argument-list
6173	/// \endverbatim
6174	OpenACCWaitParseInfo ParseOpenACCWaitArgument(SourceLocation Loc,
6175	bool IsDirective);
6176
6177	/// Parses the clause of the 'bind' argument, which can be a string literal or
6178	/// an identifier.
6179	std::variant<std::monostate, StringLiteral *, IdentifierInfo *>
6180	ParseOpenACCBindClauseArgument();
6181
6182	/// A type to represent the state of parsing after an attempt to parse an
6183	/// OpenACC int-expr. This is useful to determine whether an int-expr list can
6184	/// continue parsing after a failed int-expr.
6185	using OpenACCIntExprParseResult =
6186	std::pair<ExprResult, OpenACCParseCanContinue>;
6187	/// Parses the clause kind of 'int-expr', which can be any integral
6188	/// expression.
6189	OpenACCIntExprParseResult ParseOpenACCIntExpr(OpenACCDirectiveKind DK,
6190	OpenACCClauseKind CK,
6191	SourceLocation Loc);
6192	/// Parses the argument list for 'num_gangs', which allows up to 3
6193	/// 'int-expr's.
6194	bool ParseOpenACCIntExprList(OpenACCDirectiveKind DK, OpenACCClauseKind CK,
6195	SourceLocation Loc,
6196	llvm::SmallVectorImpl<Expr *> &IntExprs);
6197
6198	/// Parses the 'device-type-list', which is a list of identifiers.
6199	///
6200	/// OpenACC 3.3 Section 2.4:
6201	/// The argument to the device_type clause is a comma-separated list of one or
6202	/// more device architecture name identifiers, or an asterisk.
6203	///
6204	/// The syntax of the device_type clause is
6205	/// device_type( * )
6206	/// device_type( device-type-list )
6207	///
6208	/// The device_type clause may be abbreviated to dtype.
6209	bool ParseOpenACCDeviceTypeList(llvm::SmallVector<IdentifierLoc> &Archs);
6210
6211	/// Parses the 'async-argument', which is an integral value with two
6212	/// 'special' values that are likely negative (but come from Macros).
6213	///
6214	/// OpenACC 3.3 section 2.16:
6215	/// In this section and throughout the specification, the term async-argument
6216	/// means a nonnegative scalar integer expression (int for C or C++, integer
6217	/// for Fortran), or one of the special values acc_async_noval or
6218	/// acc_async_sync, as defined in the C header file and the Fortran openacc
6219	/// module. The special values are negative values, so as not to conflict with
6220	/// a user-specified nonnegative async-argument.
6221	OpenACCIntExprParseResult ParseOpenACCAsyncArgument(OpenACCDirectiveKind DK,
6222	OpenACCClauseKind CK,
6223	SourceLocation Loc);
6224
6225	/// Parses the 'size-expr', which is an integral value, or an asterisk.
6226	/// Asterisk is represented by a OpenACCAsteriskSizeExpr
6227	///
6228	/// OpenACC 3.3 Section 2.9:
6229	/// size-expr is one of:
6230	/// *
6231	/// int-expr
6232	/// Note that this is specified under 'gang-arg-list', but also applies to
6233	/// 'tile' via reference.
6234	ExprResult ParseOpenACCSizeExpr(OpenACCClauseKind CK);
6235
6236	/// Parses a comma delimited list of 'size-expr's.
6237	bool ParseOpenACCSizeExprList(OpenACCClauseKind CK,
6238	llvm::SmallVectorImpl<Expr *> &SizeExprs);
6239
6240	/// Parses a 'gang-arg-list', used for the 'gang' clause.
6241	///
6242	/// OpenACC 3.3 Section 2.9:
6243	///
6244	/// where gang-arg is one of:
6245	/// \verbatim
6246	/// [num:]int-expr
6247	/// dim:int-expr
6248	/// static:size-expr
6249	/// \endverbatim
6250	bool ParseOpenACCGangArgList(SourceLocation GangLoc,
6251	llvm::SmallVectorImpl<OpenACCGangKind> &GKs,
6252	llvm::SmallVectorImpl<Expr *> &IntExprs);
6253
6254	using OpenACCGangArgRes = std::pair<OpenACCGangKind, ExprResult>;
6255	/// Parses a 'gang-arg', used for the 'gang' clause. Returns a pair of the
6256	/// ExprResult (which contains the validity of the expression), plus the gang
6257	/// kind for the current argument.
6258	OpenACCGangArgRes ParseOpenACCGangArg(SourceLocation GangLoc);
6259	/// Parses a 'condition' expr, ensuring it results in a
6260	ExprResult ParseOpenACCConditionExpr();
6261	DeclGroupPtrTy
6262	ParseOpenACCAfterRoutineDecl(AccessSpecifier &AS, ParsedAttributes &Attrs,
6263	DeclSpec::TST TagType, Decl *TagDecl,
6264	OpenACCDirectiveParseInfo &DirInfo);
6265	StmtResult ParseOpenACCAfterRoutineStmt(OpenACCDirectiveParseInfo &DirInfo);
6266
6267	///@}
6268
6269	//
6270	//
6271	// -------------------------------------------------------------------------
6272	//
6273	//
6274
6275	/// \name OpenMP Constructs
6276	/// Implementations are in ParseOpenMP.cpp
6277	///@{
6278
6279	private:
6280	friend class ParsingOpenMPDirectiveRAII;
6281
6282	/// Parsing OpenMP directive mode.
6283	bool OpenMPDirectiveParsing = false;
6284
6285	/// Current kind of OpenMP clause
6286	OpenMPClauseKind OMPClauseKind = llvm::omp::OMPC_unknown;
6287
6288	void ReplayOpenMPAttributeTokens(CachedTokens &OpenMPTokens) {
6289	// If parsing the attributes found an OpenMP directive, emit those tokens
6290	// to the parse stream now.
6291	if (!OpenMPTokens.empty()) {
6292	PP.EnterToken(Tok, /*IsReinject*/ IsReinject: true);
6293	PP.EnterTokenStream(Toks: OpenMPTokens, /*DisableMacroExpansion*/ DisableMacroExpansion: true,
6294	/*IsReinject*/ IsReinject: true);
6295	ConsumeAnyToken(/*ConsumeCodeCompletionTok*/ ConsumeCodeCompletionTok: true);
6296	}
6297	}
6298
6299	//===--------------------------------------------------------------------===//
6300	// OpenMP: Directives and clauses.
6301
6302	/// Parse clauses for '#pragma omp declare simd'.
6303	DeclGroupPtrTy ParseOMPDeclareSimdClauses(DeclGroupPtrTy Ptr,
6304	CachedTokens &Toks,
6305	SourceLocation Loc);
6306
6307	/// Parse a property kind into \p TIProperty for the selector set \p Set and
6308	/// selector \p Selector.
6309	void parseOMPTraitPropertyKind(OMPTraitProperty &TIProperty,
6310	llvm::omp::TraitSet Set,
6311	llvm::omp::TraitSelector Selector,
6312	llvm::StringMap<SourceLocation> &Seen);
6313
6314	/// Parse a selector kind into \p TISelector for the selector set \p Set.
6315	void parseOMPTraitSelectorKind(OMPTraitSelector &TISelector,
6316	llvm::omp::TraitSet Set,
6317	llvm::StringMap<SourceLocation> &Seen);
6318
6319	/// Parse a selector set kind into \p TISet.
6320	void parseOMPTraitSetKind(OMPTraitSet &TISet,
6321	llvm::StringMap<SourceLocation> &Seen);
6322
6323	/// Parses an OpenMP context property.
6324	void parseOMPContextProperty(OMPTraitSelector &TISelector,
6325	llvm::omp::TraitSet Set,
6326	llvm::StringMap<SourceLocation> &Seen);
6327
6328	/// Parses an OpenMP context selector.
6329	///
6330	/// \verbatim
6331	/// <trait-selector-name> ['('[<trait-score>] <trait-property> [, <t-p>]* ')']
6332	/// \endverbatim
6333	void parseOMPContextSelector(OMPTraitSelector &TISelector,
6334	llvm::omp::TraitSet Set,
6335	llvm::StringMap<SourceLocation> &SeenSelectors);
6336
6337	/// Parses an OpenMP context selector set.
6338	///
6339	/// \verbatim
6340	/// <trait-set-selector-name> '=' '{' <trait-selector> [, <trait-selector>]* '}'
6341	/// \endverbatim
6342	void parseOMPContextSelectorSet(OMPTraitSet &TISet,
6343	llvm::StringMap<SourceLocation> &SeenSets);
6344
6345	/// Parse OpenMP context selectors:
6346	///
6347	/// \verbatim
6348	/// <trait-set-selector> [, <trait-set-selector>]*
6349	/// \endverbatim
6350	bool parseOMPContextSelectors(SourceLocation Loc, OMPTraitInfo &TI);
6351
6352	/// Parse an 'append_args' clause for '#pragma omp declare variant'.
6353	bool parseOpenMPAppendArgs(SmallVectorImpl<OMPInteropInfo> &InteropInfos);
6354
6355	/// Parse a `match` clause for an '#pragma omp declare variant'. Return true
6356	/// if there was an error.
6357	bool parseOMPDeclareVariantMatchClause(SourceLocation Loc, OMPTraitInfo &TI,
6358	OMPTraitInfo *ParentTI);
6359
6360	/// Parse clauses for '#pragma omp declare variant ( variant-func-id )
6361	/// clause'.
6362	void ParseOMPDeclareVariantClauses(DeclGroupPtrTy Ptr, CachedTokens &Toks,
6363	SourceLocation Loc);
6364
6365	/// Parse 'omp [begin] assume[s]' directive.
6366	///
6367	/// `omp assumes` or `omp begin/end assumes` <clause> [[,]<clause>]...
6368	/// where
6369	///
6370	/// \verbatim
6371	/// clause:
6372	/// 'ext_IMPL_DEFINED'
6373	/// 'absent' '(' directive-name [, directive-name]* ')'
6374	/// 'contains' '(' directive-name [, directive-name]* ')'
6375	/// 'holds' '(' scalar-expression ')'
6376	/// 'no_openmp'
6377	/// 'no_openmp_routines'
6378	/// 'no_openmp_constructs' (OpenMP 6.0)
6379	/// 'no_parallelism'
6380	/// \endverbatim
6381	///
6382	void ParseOpenMPAssumesDirective(OpenMPDirectiveKind DKind,
6383	SourceLocation Loc);
6384
6385	/// Parse 'omp end assumes' directive.
6386	void ParseOpenMPEndAssumesDirective(SourceLocation Loc);
6387
6388	/// Parses clauses for directive.
6389	///
6390	/// \verbatim
6391	/// <clause> [clause[ [,] clause] ... ]
6392	///
6393	/// clauses: for error directive
6394	/// 'at' '(' compilation | execution ')'
6395	/// 'severity' '(' fatal | warning ')'
6396	/// 'message' '(' msg-string ')'
6397	/// ....
6398	/// \endverbatim
6399	///
6400	/// \param DKind Kind of current directive.
6401	/// \param clauses for current directive.
6402	/// \param start location for clauses of current directive
6403	void ParseOpenMPClauses(OpenMPDirectiveKind DKind,
6404	SmallVectorImpl<clang::OMPClause *> &Clauses,
6405	SourceLocation Loc);
6406
6407	/// Parse clauses for '#pragma omp [begin] declare target'.
6408	void ParseOMPDeclareTargetClauses(SemaOpenMP::DeclareTargetContextInfo &DTCI);
6409
6410	/// Parse '#pragma omp end declare target'.
6411	void ParseOMPEndDeclareTargetDirective(OpenMPDirectiveKind BeginDKind,
6412	OpenMPDirectiveKind EndDKind,
6413	SourceLocation Loc);
6414
6415	/// Skip tokens until a `annot_pragma_openmp_end` was found. Emit a warning if
6416	/// it is not the current token.
6417	void skipUntilPragmaOpenMPEnd(OpenMPDirectiveKind DKind);
6418
6419	/// Check the \p FoundKind against the \p ExpectedKind, if not issue an error
6420	/// that the "end" matching the "begin" directive of kind \p BeginKind was not
6421	/// found. Finally, if the expected kind was found or if \p SkipUntilOpenMPEnd
6422	/// is set, skip ahead using the helper `skipUntilPragmaOpenMPEnd`.
6423	void parseOMPEndDirective(OpenMPDirectiveKind BeginKind,
6424	OpenMPDirectiveKind ExpectedKind,
6425	OpenMPDirectiveKind FoundKind,
6426	SourceLocation MatchingLoc, SourceLocation FoundLoc,
6427	bool SkipUntilOpenMPEnd);
6428
6429	/// Parses declarative OpenMP directives.
6430	///
6431	/// \verbatim
6432	/// threadprivate-directive:
6433	/// annot_pragma_openmp 'threadprivate' simple-variable-list
6434	/// annot_pragma_openmp_end
6435	///
6436	/// allocate-directive:
6437	/// annot_pragma_openmp 'allocate' simple-variable-list [<clause>]
6438	/// annot_pragma_openmp_end
6439	///
6440	/// declare-reduction-directive:
6441	/// annot_pragma_openmp 'declare' 'reduction' [...]
6442	/// annot_pragma_openmp_end
6443	///
6444	/// declare-mapper-directive:
6445	/// annot_pragma_openmp 'declare' 'mapper' '(' [<mapper-identifer> ':']
6446	/// <type> <var> ')' [<clause>[[,] <clause>] ... ]
6447	/// annot_pragma_openmp_end
6448	///
6449	/// declare-simd-directive:
6450	/// annot_pragma_openmp 'declare simd' {<clause> [,]}
6451	/// annot_pragma_openmp_end
6452	/// <function declaration/definition>
6453	///
6454	/// requires directive:
6455	/// annot_pragma_openmp 'requires' <clause> [[[,] <clause>] ... ]
6456	/// annot_pragma_openmp_end
6457	///
6458	/// assumes directive:
6459	/// annot_pragma_openmp 'assumes' <clause> [[[,] <clause>] ... ]
6460	/// annot_pragma_openmp_end
6461	/// or
6462	/// annot_pragma_openmp 'begin assumes' <clause> [[[,] <clause>] ... ]
6463	/// annot_pragma_openmp 'end assumes'
6464	/// annot_pragma_openmp_end
6465	/// \endverbatim
6466	///
6467	DeclGroupPtrTy ParseOpenMPDeclarativeDirectiveWithExtDecl(
6468	AccessSpecifier &AS, ParsedAttributes &Attrs, bool Delayed = false,
6469	DeclSpec::TST TagType = DeclSpec::TST_unspecified,
6470	Decl *TagDecl = nullptr);
6471
6472	/// Parse 'omp declare reduction' construct.
6473	///
6474	/// \verbatim
6475	/// declare-reduction-directive:
6476	/// annot_pragma_openmp 'declare' 'reduction'
6477	/// '(' <reduction_id> ':' <type> {',' <type>} ':' <expression> ')'
6478	/// ['initializer' '(' ('omp_priv' '=' <expression>)|<function_call> ')']
6479	/// annot_pragma_openmp_end
6480	/// \endverbatim
6481	/// <reduction_id> is either a base language identifier or one of the
6482	/// following operators: '+', '-', '*', '&', '|', '^', '&&' and '||'.
6483	///
6484	DeclGroupPtrTy ParseOpenMPDeclareReductionDirective(AccessSpecifier AS);
6485
6486	/// Parses initializer for provided omp_priv declaration inside the reduction
6487	/// initializer.
6488	void ParseOpenMPReductionInitializerForDecl(VarDecl *OmpPrivParm);
6489
6490	/// Parses 'omp declare mapper' directive.
6491	///
6492	/// \verbatim
6493	/// declare-mapper-directive:
6494	/// annot_pragma_openmp 'declare' 'mapper' '(' [<mapper-identifier> ':']
6495	/// <type> <var> ')' [<clause>[[,] <clause>] ... ]
6496	/// annot_pragma_openmp_end
6497	/// \endverbatim
6498	/// <mapper-identifier> and <var> are base language identifiers.
6499	///
6500	DeclGroupPtrTy ParseOpenMPDeclareMapperDirective(AccessSpecifier AS);
6501
6502	/// Parses variable declaration in 'omp declare mapper' directive.
6503	TypeResult parseOpenMPDeclareMapperVarDecl(SourceRange &Range,
6504	DeclarationName &Name,
6505	AccessSpecifier AS = AS_none);
6506
6507	/// Parses simple list of variables.
6508	///
6509	/// \verbatim
6510	/// simple-variable-list:
6511	/// '(' id-expression {, id-expression} ')'
6512	/// \endverbatim
6513	///
6514	/// \param Kind Kind of the directive.
6515	/// \param Callback Callback function to be called for the list elements.
6516	/// \param AllowScopeSpecifier true, if the variables can have fully
6517	/// qualified names.
6518	///
6519	bool ParseOpenMPSimpleVarList(
6520	OpenMPDirectiveKind Kind,
6521	const llvm::function_ref<void(CXXScopeSpec &, DeclarationNameInfo)>
6522	&Callback,
6523	bool AllowScopeSpecifier);
6524
6525	/// Parses declarative or executable directive.
6526	///
6527	/// \verbatim
6528	/// threadprivate-directive:
6529	/// annot_pragma_openmp 'threadprivate' simple-variable-list
6530	/// annot_pragma_openmp_end
6531	///
6532	/// allocate-directive:
6533	/// annot_pragma_openmp 'allocate' simple-variable-list
6534	/// annot_pragma_openmp_end
6535	///
6536	/// declare-reduction-directive:
6537	/// annot_pragma_openmp 'declare' 'reduction' '(' <reduction_id> ':'
6538	/// <type> {',' <type>} ':' <expression> ')' ['initializer' '('
6539	/// ('omp_priv' '=' <expression>|<function_call>) ')']
6540	/// annot_pragma_openmp_end
6541	///
6542	/// declare-mapper-directive:
6543	/// annot_pragma_openmp 'declare' 'mapper' '(' [<mapper-identifer> ':']
6544	/// <type> <var> ')' [<clause>[[,] <clause>] ... ]
6545	/// annot_pragma_openmp_end
6546	///
6547	/// executable-directive:
6548	/// annot_pragma_openmp 'parallel' | 'simd' | 'for' | 'sections' |
6549	/// 'section' | 'single' | 'master' | 'critical' [ '(' <name> ')' ] |
6550	/// 'parallel for' | 'parallel sections' | 'parallel master' | 'task'
6551	/// | 'taskyield' | 'barrier' | 'taskwait' | 'flush' | 'ordered' |
6552	/// 'error' | 'atomic' | 'for simd' | 'parallel for simd' | 'target' |
6553	/// 'target data' | 'taskgroup' | 'teams' | 'taskloop' | 'taskloop
6554	/// simd' | 'master taskloop' | 'master taskloop simd' | 'parallel
6555	/// master taskloop' | 'parallel master taskloop simd' | 'distribute'
6556	/// | 'target enter data' | 'target exit data' | 'target parallel' |
6557	/// 'target parallel for' | 'target update' | 'distribute parallel
6558	/// for' | 'distribute paralle for simd' | 'distribute simd' | 'target
6559	/// parallel for simd' | 'target simd' | 'teams distribute' | 'teams
6560	/// distribute simd' | 'teams distribute parallel for simd' | 'teams
6561	/// distribute parallel for' | 'target teams' | 'target teams
6562	/// distribute' | 'target teams distribute parallel for' | 'target
6563	/// teams distribute parallel for simd' | 'target teams distribute
6564	/// simd' | 'masked' | 'parallel masked' {clause}
6565	/// annot_pragma_openmp_end
6566	/// \endverbatim
6567	///
6568	///
6569	/// \param StmtCtx The context in which we're parsing the directive.
6570	/// \param ReadDirectiveWithinMetadirective true if directive is within a
6571	/// metadirective and therefore ends on the closing paren.
6572	StmtResult ParseOpenMPDeclarativeOrExecutableDirective(
6573	ParsedStmtContext StmtCtx, bool ReadDirectiveWithinMetadirective = false);
6574
6575	/// Parses executable directive.
6576	///
6577	/// \param StmtCtx The context in which we're parsing the directive.
6578	/// \param DKind The kind of the executable directive.
6579	/// \param Loc Source location of the beginning of the directive.
6580	/// \param ReadDirectiveWithinMetadirective true if directive is within a
6581	/// metadirective and therefore ends on the closing paren.
6582	StmtResult
6583	ParseOpenMPExecutableDirective(ParsedStmtContext StmtCtx,
6584	OpenMPDirectiveKind DKind, SourceLocation Loc,
6585	bool ReadDirectiveWithinMetadirective);
6586
6587	/// Parses informational directive.
6588	///
6589	/// \param StmtCtx The context in which we're parsing the directive.
6590	/// \param DKind The kind of the informational directive.
6591	/// \param Loc Source location of the beginning of the directive.
6592	/// \param ReadDirectiveWithinMetadirective true if directive is within a
6593	/// metadirective and therefore ends on the closing paren.
6594	StmtResult ParseOpenMPInformationalDirective(
6595	ParsedStmtContext StmtCtx, OpenMPDirectiveKind DKind, SourceLocation Loc,
6596	bool ReadDirectiveWithinMetadirective);
6597
6598	/// Parses clause of kind \a CKind for directive of a kind \a Kind.
6599	///
6600	/// \verbatim
6601	/// clause:
6602	/// if-clause | final-clause | num_threads-clause | safelen-clause |
6603	/// default-clause | private-clause | firstprivate-clause |
6604	/// shared-clause | linear-clause | aligned-clause | collapse-clause |
6605	/// bind-clause | lastprivate-clause | reduction-clause |
6606	/// proc_bind-clause | schedule-clause | copyin-clause |
6607	/// copyprivate-clause | untied-clause | mergeable-clause | flush-clause
6608	/// | read-clause | write-clause | update-clause | capture-clause |
6609	/// seq_cst-clause | device-clause | simdlen-clause | threads-clause |
6610	/// simd-clause | num_teams-clause | thread_limit-clause |
6611	/// priority-clause | grainsize-clause | nogroup-clause |
6612	/// num_tasks-clause | hint-clause | to-clause | from-clause |
6613	/// is_device_ptr-clause | task_reduction-clause | in_reduction-clause |
6614	/// allocator-clause | allocate-clause | acq_rel-clause | acquire-clause
6615	/// | release-clause | relaxed-clause | depobj-clause | destroy-clause |
6616	/// detach-clause | inclusive-clause | exclusive-clause |
6617	/// uses_allocators-clause | use_device_addr-clause | has_device_addr
6618	/// \endverbatim
6619	///
6620	/// \param DKind Kind of current directive.
6621	/// \param CKind Kind of current clause.
6622	/// \param FirstClause true, if this is the first clause of a kind \a CKind
6623	/// in current directive.
6624	///
6625	OMPClause *ParseOpenMPClause(OpenMPDirectiveKind DKind,
6626	OpenMPClauseKind CKind, bool FirstClause);
6627
6628	/// Parses clause with a single expression of a kind \a Kind.
6629	///
6630	/// Parsing of OpenMP clauses with single expressions like 'final',
6631	/// 'collapse', 'safelen', 'num_threads', 'simdlen', 'num_teams',
6632	/// 'thread_limit', 'simdlen', 'priority', 'grainsize', 'num_tasks', 'hint' or
6633	/// 'detach'.
6634	///
6635	/// \verbatim
6636	/// final-clause:
6637	/// 'final' '(' expression ')'
6638	///
6639	/// num_threads-clause:
6640	/// 'num_threads' '(' expression ')'
6641	///
6642	/// safelen-clause:
6643	/// 'safelen' '(' expression ')'
6644	///
6645	/// simdlen-clause:
6646	/// 'simdlen' '(' expression ')'
6647	///
6648	/// collapse-clause:
6649	/// 'collapse' '(' expression ')'
6650	///
6651	/// priority-clause:
6652	/// 'priority' '(' expression ')'
6653	///
6654	/// grainsize-clause:
6655	/// 'grainsize' '(' expression ')'
6656	///
6657	/// num_tasks-clause:
6658	/// 'num_tasks' '(' expression ')'
6659	///
6660	/// hint-clause:
6661	/// 'hint' '(' expression ')'
6662	///
6663	/// allocator-clause:
6664	/// 'allocator' '(' expression ')'
6665	///
6666	/// detach-clause:
6667	/// 'detach' '(' event-handler-expression ')'
6668	///
6669	/// align-clause
6670	/// 'align' '(' positive-integer-constant ')'
6671	///
6672	/// holds-clause
6673	/// 'holds' '(' expression ')'
6674	/// \endverbatim
6675	///
6676	/// \param Kind Kind of current clause.
6677	/// \param ParseOnly true to skip the clause's semantic actions and return
6678	/// nullptr.
6679	///
6680	OMPClause *ParseOpenMPSingleExprClause(OpenMPClauseKind Kind, bool ParseOnly);
6681	/// Parses simple clause like 'default' or 'proc_bind' of a kind \a Kind.
6682	///
6683	/// \verbatim
6684	/// default-clause:
6685	/// 'default' '(' 'none' | 'shared' | 'private' | 'firstprivate' ')'
6686	///
6687	/// proc_bind-clause:
6688	/// 'proc_bind' '(' 'master' | 'close' | 'spread' ')'
6689	///
6690	/// bind-clause:
6691	/// 'bind' '(' 'teams' | 'parallel' | 'thread' ')'
6692	///
6693	/// update-clause:
6694	/// 'update' '(' 'in' | 'out' | 'inout' | 'mutexinoutset' |
6695	/// 'inoutset' ')'
6696	/// \endverbatim
6697	///
6698	/// \param Kind Kind of current clause.
6699	/// \param ParseOnly true to skip the clause's semantic actions and return
6700	/// nullptr.
6701	///
6702	OMPClause *ParseOpenMPSimpleClause(OpenMPClauseKind Kind, bool ParseOnly);
6703
6704	/// Parse indirect clause for '#pragma omp declare target' directive.
6705	/// 'indirect' '[' '(' invoked-by-fptr ')' ']'
6706	/// where invoked-by-fptr is a constant boolean expression that evaluates to
6707	/// true or false at compile time.
6708	/// \param ParseOnly true to skip the clause's semantic actions and return
6709	/// false;
6710	bool ParseOpenMPIndirectClause(SemaOpenMP::DeclareTargetContextInfo &DTCI,
6711	bool ParseOnly);
6712	/// Parses clause with a single expression and an additional argument
6713	/// of a kind \a Kind like 'schedule' or 'dist_schedule'.
6714	///
6715	/// \verbatim
6716	/// schedule-clause:
6717	/// 'schedule' '(' [ modifier [ ',' modifier ] ':' ] kind [',' expression ]
6718	/// ')'
6719	///
6720	/// if-clause:
6721	/// 'if' '(' [ directive-name-modifier ':' ] expression ')'
6722	///
6723	/// defaultmap:
6724	/// 'defaultmap' '(' modifier [ ':' kind ] ')'
6725	///
6726	/// device-clause:
6727	/// 'device' '(' [ device-modifier ':' ] expression ')'
6728	/// \endverbatim
6729	///
6730	/// \param DKind Directive kind.
6731	/// \param Kind Kind of current clause.
6732	/// \param ParseOnly true to skip the clause's semantic actions and return
6733	/// nullptr.
6734	///
6735	OMPClause *ParseOpenMPSingleExprWithArgClause(OpenMPDirectiveKind DKind,
6736	OpenMPClauseKind Kind,
6737	bool ParseOnly);
6738
6739	/// Parses the 'sizes' clause of a '#pragma omp tile' directive.
6740	OMPClause *ParseOpenMPSizesClause();
6741
6742	/// Parses the 'permutation' clause of a '#pragma omp interchange' directive.
6743	OMPClause *ParseOpenMPPermutationClause();
6744
6745	/// Parses clause without any additional arguments like 'ordered'.
6746	///
6747	/// \verbatim
6748	/// ordered-clause:
6749	/// 'ordered'
6750	///
6751	/// nowait-clause:
6752	/// 'nowait'
6753	///
6754	/// untied-clause:
6755	/// 'untied'
6756	///
6757	/// mergeable-clause:
6758	/// 'mergeable'
6759	///
6760	/// read-clause:
6761	/// 'read'
6762	///
6763	/// threads-clause:
6764	/// 'threads'
6765	///
6766	/// simd-clause:
6767	/// 'simd'
6768	///
6769	/// nogroup-clause:
6770	/// 'nogroup'
6771	/// \endverbatim
6772	///
6773	/// \param Kind Kind of current clause.
6774	/// \param ParseOnly true to skip the clause's semantic actions and return
6775	/// nullptr.
6776	///
6777	OMPClause *ParseOpenMPClause(OpenMPClauseKind Kind, bool ParseOnly = false);
6778
6779	/// Parses clause with the list of variables of a kind \a Kind:
6780	/// 'private', 'firstprivate', 'lastprivate',
6781	/// 'shared', 'copyin', 'copyprivate', 'flush', 'reduction', 'task_reduction',
6782	/// 'in_reduction', 'nontemporal', 'exclusive' or 'inclusive'.
6783	///
6784	/// \verbatim
6785	/// private-clause:
6786	/// 'private' '(' list ')'
6787	/// firstprivate-clause:
6788	/// 'firstprivate' '(' list ')'
6789	/// lastprivate-clause:
6790	/// 'lastprivate' '(' list ')'
6791	/// shared-clause:
6792	/// 'shared' '(' list ')'
6793	/// linear-clause:
6794	/// 'linear' '(' linear-list [ ':' linear-step ] ')'
6795	/// aligned-clause:
6796	/// 'aligned' '(' list [ ':' alignment ] ')'
6797	/// reduction-clause:
6798	/// 'reduction' '(' [ modifier ',' ] reduction-identifier ':' list ')'
6799	/// task_reduction-clause:
6800	/// 'task_reduction' '(' reduction-identifier ':' list ')'
6801	/// in_reduction-clause:
6802	/// 'in_reduction' '(' reduction-identifier ':' list ')'
6803	/// copyprivate-clause:
6804	/// 'copyprivate' '(' list ')'
6805	/// flush-clause:
6806	/// 'flush' '(' list ')'
6807	/// depend-clause:
6808	/// 'depend' '(' in | out | inout : list | source ')'
6809	/// map-clause:
6810	/// 'map' '(' [ [ always [,] ] [ close [,] ]
6811	/// [ mapper '(' mapper-identifier ')' [,] ]
6812	/// to | from | tofrom | alloc | release | delete ':' ] list ')';
6813	/// to-clause:
6814	/// 'to' '(' [ mapper '(' mapper-identifier ')' ':' ] list ')'
6815	/// from-clause:
6816	/// 'from' '(' [ mapper '(' mapper-identifier ')' ':' ] list ')'
6817	/// use_device_ptr-clause:
6818	/// 'use_device_ptr' '(' list ')'
6819	/// use_device_addr-clause:
6820	/// 'use_device_addr' '(' list ')'
6821	/// is_device_ptr-clause:
6822	/// 'is_device_ptr' '(' list ')'
6823	/// has_device_addr-clause:
6824	/// 'has_device_addr' '(' list ')'
6825	/// allocate-clause:
6826	/// 'allocate' '(' [ allocator ':' ] list ')'
6827	/// As of OpenMP 5.1 there's also
6828	/// 'allocate' '(' allocate-modifier: list ')'
6829	/// where allocate-modifier is: 'allocator' '(' allocator ')'
6830	/// nontemporal-clause:
6831	/// 'nontemporal' '(' list ')'
6832	/// inclusive-clause:
6833	/// 'inclusive' '(' list ')'
6834	/// exclusive-clause:
6835	/// 'exclusive' '(' list ')'
6836	/// \endverbatim
6837	///
6838	/// For 'linear' clause linear-list may have the following forms:
6839	/// list
6840	/// modifier(list)
6841	/// where modifier is 'val' (C) or 'ref', 'val' or 'uval'(C++).
6842	///
6843	/// \param Kind Kind of current clause.
6844	/// \param ParseOnly true to skip the clause's semantic actions and return
6845	/// nullptr.
6846	///
6847	OMPClause *ParseOpenMPVarListClause(OpenMPDirectiveKind DKind,
6848	OpenMPClauseKind Kind, bool ParseOnly);
6849
6850	/// Parses a clause consisting of a list of expressions.
6851	///
6852	/// \param Kind The clause to parse.
6853	/// \param ClauseNameLoc [out] The location of the clause name.
6854	/// \param OpenLoc [out] The location of '('.
6855	/// \param CloseLoc [out] The location of ')'.
6856	/// \param Exprs [out] The parsed expressions.
6857	/// \param ReqIntConst If true, each expression must be an integer constant.
6858	///
6859	/// \return Whether the clause was parsed successfully.
6860	bool ParseOpenMPExprListClause(OpenMPClauseKind Kind,
6861	SourceLocation &ClauseNameLoc,
6862	SourceLocation &OpenLoc,
6863	SourceLocation &CloseLoc,
6864	SmallVectorImpl<Expr *> &Exprs,
6865	bool ReqIntConst = false);
6866
6867	/// Parses simple expression in parens for single-expression clauses of OpenMP
6868	/// constructs.
6869	/// \verbatim
6870	/// <iterators> = 'iterator' '(' { [ <iterator-type> ] identifier =
6871	/// <range-specification> }+ ')'
6872	/// \endverbatim
6873	ExprResult ParseOpenMPIteratorsExpr();
6874
6875	/// Parses allocators and traits in the context of the uses_allocator clause.
6876	/// Expected format:
6877	/// \verbatim
6878	/// '(' { <allocator> [ '(' <allocator_traits> ')' ] }+ ')'
6879	/// \endverbatim
6880	OMPClause *ParseOpenMPUsesAllocatorClause(OpenMPDirectiveKind DKind);
6881
6882	/// Parses the 'interop' parts of the 'append_args' and 'init' clauses.
6883	bool ParseOMPInteropInfo(OMPInteropInfo &InteropInfo, OpenMPClauseKind Kind);
6884
6885	/// Parses clause with an interop variable of kind \a Kind.
6886	///
6887	/// \verbatim
6888	/// init-clause:
6889	/// init([interop-modifier, ]interop-type[[, interop-type] ... ]:interop-var)
6890	///
6891	/// destroy-clause:
6892	/// destroy(interop-var)
6893	///
6894	/// use-clause:
6895	/// use(interop-var)
6896	///
6897	/// interop-modifier:
6898	/// prefer_type(preference-list)
6899	///
6900	/// preference-list:
6901	/// foreign-runtime-id [, foreign-runtime-id]...
6902	///
6903	/// foreign-runtime-id:
6904	/// <string-literal> | <constant-integral-expression>
6905	///
6906	/// interop-type:
6907	/// target | targetsync
6908	/// \endverbatim
6909	///
6910	/// \param Kind Kind of current clause.
6911	/// \param ParseOnly true to skip the clause's semantic actions and return
6912	/// nullptr.
6913	//
6914	OMPClause *ParseOpenMPInteropClause(OpenMPClauseKind Kind, bool ParseOnly);
6915
6916	/// Parses a ompx_attribute clause
6917	///
6918	/// \param ParseOnly true to skip the clause's semantic actions and return
6919	/// nullptr.
6920	//
6921	OMPClause *ParseOpenMPOMPXAttributesClause(bool ParseOnly);
6922
6923	public:
6924	/// Parses simple expression in parens for single-expression clauses of OpenMP
6925	/// constructs.
6926	/// \param RLoc Returned location of right paren.
6927	ExprResult ParseOpenMPParensExpr(StringRef ClauseName, SourceLocation &RLoc,
6928	bool IsAddressOfOperand = false);
6929
6930	/// Parses a reserved locator like 'omp_all_memory'.
6931	bool ParseOpenMPReservedLocator(OpenMPClauseKind Kind,
6932	SemaOpenMP::OpenMPVarListDataTy &Data,
6933	const LangOptions &LangOpts);
6934	/// Parses clauses with list.
6935	bool ParseOpenMPVarList(OpenMPDirectiveKind DKind, OpenMPClauseKind Kind,
6936	SmallVectorImpl<Expr *> &Vars,
6937	SemaOpenMP::OpenMPVarListDataTy &Data);
6938
6939	/// Parses the mapper modifier in map, to, and from clauses.
6940	bool parseMapperModifier(SemaOpenMP::OpenMPVarListDataTy &Data);
6941
6942	/// Parse map-type-modifiers in map clause.
6943	/// map([ [map-type-modifier[,] [map-type-modifier[,] ...] [map-type] : ] list)
6944	/// where, map-type-modifier ::= always | close | mapper(mapper-identifier) |
6945	/// present
6946	/// where, map-type ::= alloc | delete | from | release | to | tofrom
6947	bool parseMapTypeModifiers(SemaOpenMP::OpenMPVarListDataTy &Data);
6948
6949	/// Parses 'omp begin declare variant' directive.
6950	/// The syntax is:
6951	/// \verbatim
6952	/// { #pragma omp begin declare variant clause }
6953	/// <function-declaration-or-definition-sequence>
6954	/// { #pragma omp end declare variant }
6955	/// \endverbatim
6956	///
6957	bool ParseOpenMPDeclareBeginVariantDirective(SourceLocation Loc);
6958
6959	///@}
6960
6961	//
6962	//
6963	// -------------------------------------------------------------------------
6964	//
6965	//
6966
6967	/// \name Pragmas
6968	/// Implementations are in ParsePragma.cpp
6969	///@{
6970
6971	private:
6972	std::unique_ptr<PragmaHandler> AlignHandler;
6973	std::unique_ptr<PragmaHandler> GCCVisibilityHandler;
6974	std::unique_ptr<PragmaHandler> OptionsHandler;
6975	std::unique_ptr<PragmaHandler> PackHandler;
6976	std::unique_ptr<PragmaHandler> MSStructHandler;
6977	std::unique_ptr<PragmaHandler> UnusedHandler;
6978	std::unique_ptr<PragmaHandler> WeakHandler;
6979	std::unique_ptr<PragmaHandler> RedefineExtnameHandler;
6980	std::unique_ptr<PragmaHandler> FPContractHandler;
6981	std::unique_ptr<PragmaHandler> OpenCLExtensionHandler;
6982	std::unique_ptr<PragmaHandler> OpenMPHandler;
6983	std::unique_ptr<PragmaHandler> OpenACCHandler;
6984	std::unique_ptr<PragmaHandler> PCSectionHandler;
6985	std::unique_ptr<PragmaHandler> MSCommentHandler;
6986	std::unique_ptr<PragmaHandler> MSDetectMismatchHandler;
6987	std::unique_ptr<PragmaHandler> FPEvalMethodHandler;
6988	std::unique_ptr<PragmaHandler> FloatControlHandler;
6989	std::unique_ptr<PragmaHandler> MSPointersToMembers;
6990	std::unique_ptr<PragmaHandler> MSVtorDisp;
6991	std::unique_ptr<PragmaHandler> MSInitSeg;
6992	std::unique_ptr<PragmaHandler> MSDataSeg;
6993	std::unique_ptr<PragmaHandler> MSBSSSeg;
6994	std::unique_ptr<PragmaHandler> MSConstSeg;
6995	std::unique_ptr<PragmaHandler> MSCodeSeg;
6996	std::unique_ptr<PragmaHandler> MSSection;
6997	std::unique_ptr<PragmaHandler> MSStrictGuardStackCheck;
6998	std::unique_ptr<PragmaHandler> MSRuntimeChecks;
6999	std::unique_ptr<PragmaHandler> MSIntrinsic;
7000	std::unique_ptr<PragmaHandler> MSFunction;
7001	std::unique_ptr<PragmaHandler> MSOptimize;
7002	std::unique_ptr<PragmaHandler> MSFenvAccess;
7003	std::unique_ptr<PragmaHandler> MSAllocText;
7004	std::unique_ptr<PragmaHandler> CUDAForceHostDeviceHandler;
7005	std::unique_ptr<PragmaHandler> OptimizeHandler;
7006	std::unique_ptr<PragmaHandler> LoopHintHandler;
7007	std::unique_ptr<PragmaHandler> UnrollHintHandler;
7008	std::unique_ptr<PragmaHandler> NoUnrollHintHandler;
7009	std::unique_ptr<PragmaHandler> UnrollAndJamHintHandler;
7010	std::unique_ptr<PragmaHandler> NoUnrollAndJamHintHandler;
7011	std::unique_ptr<PragmaHandler> FPHandler;
7012	std::unique_ptr<PragmaHandler> STDCFenvAccessHandler;
7013	std::unique_ptr<PragmaHandler> STDCFenvRoundHandler;
7014	std::unique_ptr<PragmaHandler> STDCCXLIMITHandler;
7015	std::unique_ptr<PragmaHandler> STDCUnknownHandler;
7016	std::unique_ptr<PragmaHandler> AttributePragmaHandler;
7017	std::unique_ptr<PragmaHandler> MaxTokensHerePragmaHandler;
7018	std::unique_ptr<PragmaHandler> MaxTokensTotalPragmaHandler;
7019	std::unique_ptr<PragmaHandler> RISCVPragmaHandler;
7020
7021	/// Initialize all pragma handlers.
7022	void initializePragmaHandlers();
7023
7024	/// Destroy and reset all pragma handlers.
7025	void resetPragmaHandlers();
7026
7027	/// Handle the annotation token produced for #pragma unused(...)
7028	///
7029	/// Each annot_pragma_unused is followed by the argument token so e.g.
7030	/// "#pragma unused(x,y)" becomes:
7031	/// annot_pragma_unused 'x' annot_pragma_unused 'y'
7032	void HandlePragmaUnused();
7033
7034	/// Handle the annotation token produced for
7035	/// #pragma GCC visibility...
7036	void HandlePragmaVisibility();
7037
7038	/// Handle the annotation token produced for
7039	/// #pragma pack...
7040	void HandlePragmaPack();
7041
7042	/// Handle the annotation token produced for
7043	/// #pragma ms_struct...
7044	void HandlePragmaMSStruct();
7045
7046	void HandlePragmaMSPointersToMembers();
7047
7048	void HandlePragmaMSVtorDisp();
7049
7050	void HandlePragmaMSPragma();
7051	bool HandlePragmaMSSection(StringRef PragmaName,
7052	SourceLocation PragmaLocation);
7053	bool HandlePragmaMSSegment(StringRef PragmaName,
7054	SourceLocation PragmaLocation);
7055
7056	// #pragma init_seg({ compiler | lib | user | "section-name" [, func-name]} )
7057	bool HandlePragmaMSInitSeg(StringRef PragmaName,
7058	SourceLocation PragmaLocation);
7059
7060	// #pragma strict_gs_check(pop)
7061	// #pragma strict_gs_check(push, "on" | "off")
7062	// #pragma strict_gs_check("on" | "off")
7063	bool HandlePragmaMSStrictGuardStackCheck(StringRef PragmaName,
7064	SourceLocation PragmaLocation);
7065	bool HandlePragmaMSFunction(StringRef PragmaName,
7066	SourceLocation PragmaLocation);
7067	bool HandlePragmaMSAllocText(StringRef PragmaName,
7068	SourceLocation PragmaLocation);
7069
7070	// #pragma optimize("gsty", on|off)
7071	bool HandlePragmaMSOptimize(StringRef PragmaName,
7072	SourceLocation PragmaLocation);
7073
7074	// #pragma intrinsic("foo")
7075	bool HandlePragmaMSIntrinsic(StringRef PragmaName,
7076	SourceLocation PragmaLocation);
7077
7078	/// Handle the annotation token produced for
7079	/// #pragma align...
7080	void HandlePragmaAlign();
7081
7082	/// Handle the annotation token produced for
7083	/// #pragma clang __debug dump...
7084	void HandlePragmaDump();
7085
7086	/// Handle the annotation token produced for
7087	/// #pragma weak id...
7088	void HandlePragmaWeak();
7089
7090	/// Handle the annotation token produced for
7091	/// #pragma weak id = id...
7092	void HandlePragmaWeakAlias();
7093
7094	/// Handle the annotation token produced for
7095	/// #pragma redefine_extname...
7096	void HandlePragmaRedefineExtname();
7097
7098	/// Handle the annotation token produced for
7099	/// #pragma STDC FP_CONTRACT...
7100	void HandlePragmaFPContract();
7101
7102	/// Handle the annotation token produced for
7103	/// #pragma STDC FENV_ACCESS...
7104	void HandlePragmaFEnvAccess();
7105
7106	/// Handle the annotation token produced for
7107	/// #pragma STDC FENV_ROUND...
7108	void HandlePragmaFEnvRound();
7109
7110	/// Handle the annotation token produced for
7111	/// #pragma STDC CX_LIMITED_RANGE...
7112	void HandlePragmaCXLimitedRange();
7113
7114	/// Handle the annotation token produced for
7115	/// #pragma float_control
7116	void HandlePragmaFloatControl();
7117
7118	/// \brief Handle the annotation token produced for
7119	/// #pragma clang fp ...
7120	void HandlePragmaFP();
7121
7122	/// Handle the annotation token produced for
7123	/// #pragma OPENCL EXTENSION...
7124	void HandlePragmaOpenCLExtension();
7125
7126	/// Handle the annotation token produced for
7127	/// #pragma clang __debug captured
7128	StmtResult HandlePragmaCaptured();
7129
7130	/// Handle the annotation token produced for
7131	/// #pragma clang loop and #pragma unroll.
7132	bool HandlePragmaLoopHint(LoopHint &Hint);
7133
7134	bool ParsePragmaAttributeSubjectMatchRuleSet(
7135	attr::ParsedSubjectMatchRuleSet &SubjectMatchRules,
7136	SourceLocation &AnyLoc, SourceLocation &LastMatchRuleEndLoc);
7137
7138	void HandlePragmaAttribute();
7139
7140	///@}
7141
7142	//
7143	//
7144	// -------------------------------------------------------------------------
7145	//
7146	//
7147
7148	/// \name Statements
7149	/// Implementations are in ParseStmt.cpp
7150	///@{
7151
7152	public:
7153	/// A SmallVector of statements.
7154	typedef SmallVector<Stmt *, 24> StmtVector;
7155
7156	/// The location of the first statement inside an else that might
7157	/// have a missleading indentation. If there is no
7158	/// MisleadingIndentationChecker on an else active, this location is invalid.
7159	SourceLocation MisleadingIndentationElseLoc;
7160
7161	private:
7162
7163	/// Flags describing a context in which we're parsing a statement.
7164	enum class ParsedStmtContext {
7165	/// This context permits declarations in language modes where declarations
7166	/// are not statements.
7167	AllowDeclarationsInC = 0x1,
7168	/// This context permits standalone OpenMP directives.
7169	AllowStandaloneOpenMPDirectives = 0x2,
7170	/// This context is at the top level of a GNU statement expression.
7171	InStmtExpr = 0x4,
7172
7173	/// The context of a regular substatement.
7174	SubStmt = 0,
7175	/// The context of a compound-statement.
7176	Compound = AllowDeclarationsInC | AllowStandaloneOpenMPDirectives,
7177
7178	LLVM_MARK_AS_BITMASK_ENUM(InStmtExpr)
7179	};
7180
7181	/// Act on an expression statement that might be the last statement in a
7182	/// GNU statement expression. Checks whether we are actually at the end of
7183	/// a statement expression and builds a suitable expression statement.
7184	StmtResult handleExprStmt(ExprResult E, ParsedStmtContext StmtCtx);
7185
7186	//===--------------------------------------------------------------------===//
7187	// C99 6.8: Statements and Blocks.
7188
7189	/// Parse a standalone statement (for instance, as the body of an 'if',
7190	/// 'while', or 'for').
7191	StmtResult
7192	ParseStatement(SourceLocation *TrailingElseLoc = nullptr,
7193	ParsedStmtContext StmtCtx = ParsedStmtContext::SubStmt);
7194
7195	/// ParseStatementOrDeclaration - Read 'statement' or 'declaration'.
7196	/// \verbatim
7197	/// StatementOrDeclaration:
7198	/// statement
7199	/// declaration
7200	///
7201	/// statement:
7202	/// labeled-statement
7203	/// compound-statement
7204	/// expression-statement
7205	/// selection-statement
7206	/// iteration-statement
7207	/// jump-statement
7208	/// [C++] declaration-statement
7209	/// [C++] try-block
7210	/// [MS] seh-try-block
7211	/// [OBC] objc-throw-statement
7212	/// [OBC] objc-try-catch-statement
7213	/// [OBC] objc-synchronized-statement
7214	/// [GNU] asm-statement
7215	/// [OMP] openmp-construct [TODO]
7216	///
7217	/// labeled-statement:
7218	/// identifier ':' statement
7219	/// 'case' constant-expression ':' statement
7220	/// 'default' ':' statement
7221	///
7222	/// selection-statement:
7223	/// if-statement
7224	/// switch-statement
7225	///
7226	/// iteration-statement:
7227	/// while-statement
7228	/// do-statement
7229	/// for-statement
7230	///
7231	/// expression-statement:
7232	/// expression[opt] ';'
7233	///
7234	/// jump-statement:
7235	/// 'goto' identifier ';'
7236	/// 'continue' ';'
7237	/// 'break' ';'
7238	/// 'return' expression[opt] ';'
7239	/// [GNU] 'goto' '*' expression ';'
7240	///
7241	/// [OBC] objc-throw-statement:
7242	/// [OBC] '@' 'throw' expression ';'
7243	/// [OBC] '@' 'throw' ';'
7244	/// \endverbatim
7245	///
7246	StmtResult
7247	ParseStatementOrDeclaration(StmtVector &Stmts, ParsedStmtContext StmtCtx,
7248	SourceLocation *TrailingElseLoc = nullptr);
7249
7250	StmtResult ParseStatementOrDeclarationAfterAttributes(
7251	StmtVector &Stmts, ParsedStmtContext StmtCtx,
7252	SourceLocation *TrailingElseLoc, ParsedAttributes &DeclAttrs,
7253	ParsedAttributes &DeclSpecAttrs);
7254
7255	/// Parse an expression statement.
7256	StmtResult ParseExprStatement(ParsedStmtContext StmtCtx);
7257
7258	/// ParseLabeledStatement - We have an identifier and a ':' after it.
7259	///
7260	/// \verbatim
7261	/// label:
7262	/// identifier ':'
7263	/// [GNU] identifier ':' attributes[opt]
7264	///
7265	/// labeled-statement:
7266	/// label statement
7267	/// \endverbatim
7268	///
7269	StmtResult ParseLabeledStatement(ParsedAttributes &Attrs,
7270	ParsedStmtContext StmtCtx);
7271
7272	/// ParseCaseStatement
7273	/// \verbatim
7274	/// labeled-statement:
7275	/// 'case' constant-expression ':' statement
7276	/// [GNU] 'case' constant-expression '...' constant-expression ':' statement
7277	/// \endverbatim
7278	///
7279	StmtResult ParseCaseStatement(ParsedStmtContext StmtCtx,
7280	bool MissingCase = false,
7281	ExprResult Expr = ExprResult());
7282
7283	/// ParseDefaultStatement
7284	/// \verbatim
7285	/// labeled-statement:
7286	/// 'default' ':' statement
7287	/// \endverbatim
7288	/// Note that this does not parse the 'statement' at the end.
7289	///
7290	StmtResult ParseDefaultStatement(ParsedStmtContext StmtCtx);
7291
7292	StmtResult ParseCompoundStatement(bool isStmtExpr = false);
7293
7294	/// ParseCompoundStatement - Parse a "{}" block.
7295	///
7296	/// \verbatim
7297	/// compound-statement: [C99 6.8.2]
7298	/// { block-item-list[opt] }
7299	/// [GNU] { label-declarations block-item-list } [TODO]
7300	///
7301	/// block-item-list:
7302	/// block-item
7303	/// block-item-list block-item
7304	///
7305	/// block-item:
7306	/// declaration
7307	/// [GNU] '__extension__' declaration
7308	/// statement
7309	///
7310	/// [GNU] label-declarations:
7311	/// [GNU] label-declaration
7312	/// [GNU] label-declarations label-declaration
7313	///
7314	/// [GNU] label-declaration:
7315	/// [GNU] '__label__' identifier-list ';'
7316	/// \endverbatim
7317	///
7318	StmtResult ParseCompoundStatement(bool isStmtExpr, unsigned ScopeFlags);
7319
7320	/// Parse any pragmas at the start of the compound expression. We handle these
7321	/// separately since some pragmas (FP_CONTRACT) must appear before any C
7322	/// statement in the compound, but may be intermingled with other pragmas.
7323	void ParseCompoundStatementLeadingPragmas();
7324
7325	void DiagnoseLabelAtEndOfCompoundStatement();
7326
7327	/// Consume any extra semi-colons resulting in null statements,
7328	/// returning true if any tok::semi were consumed.
7329	bool ConsumeNullStmt(StmtVector &Stmts);
7330
7331	/// ParseCompoundStatementBody - Parse a sequence of statements optionally
7332	/// followed by a label and invoke the ActOnCompoundStmt action. This expects
7333	/// the '{' to be the current token, and consume the '}' at the end of the
7334	/// block. It does not manipulate the scope stack.
7335	StmtResult ParseCompoundStatementBody(bool isStmtExpr = false);
7336
7337	/// ParseParenExprOrCondition:
7338	/// \verbatim
7339	/// [C ] '(' expression ')'
7340	/// [C++] '(' condition ')'
7341	/// [C++1z] '(' init-statement[opt] condition ')'
7342	/// \endverbatim
7343	///
7344	/// This function parses and performs error recovery on the specified
7345	/// condition or expression (depending on whether we're in C++ or C mode).
7346	/// This function goes out of its way to recover well. It returns true if
7347	/// there was a parser error (the right paren couldn't be found), which
7348	/// indicates that the caller should try to recover harder. It returns false
7349	/// if the condition is successfully parsed. Note that a successful parse can
7350	/// still have semantic errors in the condition. Additionally, it will assign
7351	/// the location of the outer-most '(' and ')', to LParenLoc and RParenLoc,
7352	/// respectively.
7353	bool ParseParenExprOrCondition(StmtResult *InitStmt,
7354	Sema::ConditionResult &CondResult,
7355	SourceLocation Loc, Sema::ConditionKind CK,
7356	SourceLocation &LParenLoc,
7357	SourceLocation &RParenLoc);
7358
7359	/// ParseIfStatement
7360	/// \verbatim
7361	/// if-statement: [C99 6.8.4.1]
7362	/// 'if' '(' expression ')' statement
7363	/// 'if' '(' expression ')' statement 'else' statement
7364	/// [C++] 'if' '(' condition ')' statement
7365	/// [C++] 'if' '(' condition ')' statement 'else' statement
7366	/// [C++23] 'if' '!' [opt] consteval compound-statement
7367	/// [C++23] 'if' '!' [opt] consteval compound-statement 'else' statement
7368	/// \endverbatim
7369	///
7370	StmtResult ParseIfStatement(SourceLocation *TrailingElseLoc);
7371
7372	/// ParseSwitchStatement
7373	/// \verbatim
7374	/// switch-statement:
7375	/// 'switch' '(' expression ')' statement
7376	/// [C++] 'switch' '(' condition ')' statement
7377	/// \endverbatim
7378	StmtResult ParseSwitchStatement(SourceLocation *TrailingElseLoc);
7379
7380	/// ParseWhileStatement
7381	/// \verbatim
7382	/// while-statement: [C99 6.8.5.1]
7383	/// 'while' '(' expression ')' statement
7384	/// [C++] 'while' '(' condition ')' statement
7385	/// \endverbatim
7386	StmtResult ParseWhileStatement(SourceLocation *TrailingElseLoc);
7387
7388	/// ParseDoStatement
7389	/// \verbatim
7390	/// do-statement: [C99 6.8.5.2]
7391	/// 'do' statement 'while' '(' expression ')' ';'
7392	/// \endverbatim
7393	/// Note: this lets the caller parse the end ';'.
7394	StmtResult ParseDoStatement();
7395
7396	/// ParseForStatement
7397	/// \verbatim
7398	/// for-statement: [C99 6.8.5.3]
7399	/// 'for' '(' expr[opt] ';' expr[opt] ';' expr[opt] ')' statement
7400	/// 'for' '(' declaration expr[opt] ';' expr[opt] ')' statement
7401	/// [C++] 'for' '(' for-init-statement condition[opt] ';' expression[opt] ')'
7402	/// [C++] statement
7403	/// [C++0x] 'for'
7404	/// 'co_await'[opt] [Coroutines]
7405	/// '(' for-range-declaration ':' for-range-initializer ')'
7406	/// statement
7407	/// [OBJC2] 'for' '(' declaration 'in' expr ')' statement
7408	/// [OBJC2] 'for' '(' expr 'in' expr ')' statement
7409	///
7410	/// [C++] for-init-statement:
7411	/// [C++] expression-statement
7412	/// [C++] simple-declaration
7413	/// [C++23] alias-declaration
7414	///
7415	/// [C++0x] for-range-declaration:
7416	/// [C++0x] attribute-specifier-seq[opt] type-specifier-seq declarator
7417	/// [C++0x] for-range-initializer:
7418	/// [C++0x] expression
7419	/// [C++0x] braced-init-list [TODO]
7420	/// \endverbatim
7421	StmtResult ParseForStatement(SourceLocation *TrailingElseLoc);
7422
7423	/// ParseGotoStatement
7424	/// \verbatim
7425	/// jump-statement:
7426	/// 'goto' identifier ';'
7427	/// [GNU] 'goto' '*' expression ';'
7428	/// \endverbatim
7429	///
7430	/// Note: this lets the caller parse the end ';'.
7431	///
7432	StmtResult ParseGotoStatement();
7433
7434	/// ParseContinueStatement
7435	/// \verbatim
7436	/// jump-statement:
7437	/// 'continue' ';'
7438	/// \endverbatim
7439	///
7440	/// Note: this lets the caller parse the end ';'.
7441	///
7442	StmtResult ParseContinueStatement();
7443
7444	/// ParseBreakStatement
7445	/// \verbatim
7446	/// jump-statement:
7447	/// 'break' ';'
7448	/// \endverbatim
7449	///
7450	/// Note: this lets the caller parse the end ';'.
7451	///
7452	StmtResult ParseBreakStatement();
7453
7454	/// ParseReturnStatement
7455	/// \verbatim
7456	/// jump-statement:
7457	/// 'return' expression[opt] ';'
7458	/// 'return' braced-init-list ';'
7459	/// 'co_return' expression[opt] ';'
7460	/// 'co_return' braced-init-list ';'
7461	/// \endverbatim
7462	StmtResult ParseReturnStatement();
7463
7464	StmtResult ParsePragmaLoopHint(StmtVector &Stmts, ParsedStmtContext StmtCtx,
7465	SourceLocation *TrailingElseLoc,
7466	ParsedAttributes &Attrs);
7467
7468	void ParseMicrosoftIfExistsStatement(StmtVector &Stmts);
7469
7470	//===--------------------------------------------------------------------===//
7471	// C++ 6: Statements and Blocks
7472
7473	/// ParseCXXTryBlock - Parse a C++ try-block.
7474	///
7475	/// \verbatim
7476	/// try-block:
7477	/// 'try' compound-statement handler-seq
7478	/// \endverbatim
7479	///
7480	StmtResult ParseCXXTryBlock();
7481
7482	/// ParseCXXTryBlockCommon - Parse the common part of try-block and
7483	/// function-try-block.
7484	///
7485	/// \verbatim
7486	/// try-block:
7487	/// 'try' compound-statement handler-seq
7488	///
7489	/// function-try-block:
7490	/// 'try' ctor-initializer[opt] compound-statement handler-seq
7491	///
7492	/// handler-seq:
7493	/// handler handler-seq[opt]
7494	///
7495	/// [Borland] try-block:
7496	/// 'try' compound-statement seh-except-block
7497	/// 'try' compound-statement seh-finally-block
7498	/// \endverbatim
7499	///
7500	StmtResult ParseCXXTryBlockCommon(SourceLocation TryLoc, bool FnTry = false);
7501
7502	/// ParseCXXCatchBlock - Parse a C++ catch block, called handler in the
7503	/// standard
7504	///
7505	/// \verbatim
7506	/// handler:
7507	/// 'catch' '(' exception-declaration ')' compound-statement
7508	///
7509	/// exception-declaration:
7510	/// attribute-specifier-seq[opt] type-specifier-seq declarator
7511	/// attribute-specifier-seq[opt] type-specifier-seq abstract-declarator[opt]
7512	/// '...'
7513	/// \endverbatim
7514	///
7515	StmtResult ParseCXXCatchBlock(bool FnCatch = false);
7516
7517	//===--------------------------------------------------------------------===//
7518	// MS: SEH Statements and Blocks
7519
7520	/// ParseSEHTryBlockCommon
7521	///
7522	/// \verbatim
7523	/// seh-try-block:
7524	/// '__try' compound-statement seh-handler
7525	///
7526	/// seh-handler:
7527	/// seh-except-block
7528	/// seh-finally-block
7529	/// \endverbatim
7530	///
7531	StmtResult ParseSEHTryBlock();
7532
7533	/// ParseSEHExceptBlock - Handle __except
7534	///
7535	/// \verbatim
7536	/// seh-except-block:
7537	/// '__except' '(' seh-filter-expression ')' compound-statement
7538	/// \endverbatim
7539	///
7540	StmtResult ParseSEHExceptBlock(SourceLocation Loc);
7541
7542	/// ParseSEHFinallyBlock - Handle __finally
7543	///
7544	/// \verbatim
7545	/// seh-finally-block:
7546	/// '__finally' compound-statement
7547	/// \endverbatim
7548	///
7549	StmtResult ParseSEHFinallyBlock(SourceLocation Loc);
7550
7551	StmtResult ParseSEHLeaveStatement();
7552
7553	Decl *ParseFunctionStatementBody(Decl *Decl, ParseScope &BodyScope);
7554
7555	/// ParseFunctionTryBlock - Parse a C++ function-try-block.
7556	///
7557	/// \verbatim
7558	/// function-try-block:
7559	/// 'try' ctor-initializer[opt] compound-statement handler-seq
7560	/// \endverbatim
7561	///
7562	Decl *ParseFunctionTryBlock(Decl *Decl, ParseScope &BodyScope);
7563
7564	/// When in code-completion, skip parsing of the function/method body
7565	/// unless the body contains the code-completion point.
7566	///
7567	/// \returns true if the function body was skipped.
7568	bool trySkippingFunctionBody();
7569
7570	/// isDeclarationStatement - Disambiguates between a declaration or an
7571	/// expression statement, when parsing function bodies.
7572	///
7573	/// \param DisambiguatingWithExpression - True to indicate that the purpose of
7574	/// this check is to disambiguate between an expression and a declaration.
7575	/// Returns true for declaration, false for expression.
7576	bool isDeclarationStatement(bool DisambiguatingWithExpression = false) {
7577	if (getLangOpts().CPlusPlus)
7578	return isCXXDeclarationStatement(DisambiguatingWithExpression);
7579	return isDeclarationSpecifier(AllowImplicitTypename: ImplicitTypenameContext::No, DisambiguatingWithExpression: true);
7580	}
7581
7582	/// isForInitDeclaration - Disambiguates between a declaration or an
7583	/// expression in the context of the C 'clause-1' or the C++
7584	// 'for-init-statement' part of a 'for' statement.
7585	/// Returns true for declaration, false for expression.
7586	bool isForInitDeclaration() {
7587	if (getLangOpts().OpenMP)
7588	Actions.OpenMP().startOpenMPLoop();
7589	if (getLangOpts().CPlusPlus)
7590	return Tok.is(K: tok::kw_using) ||
7591	isCXXSimpleDeclaration(/*AllowForRangeDecl=*/AllowForRangeDecl: true);
7592	return isDeclarationSpecifier(AllowImplicitTypename: ImplicitTypenameContext::No, DisambiguatingWithExpression: true);
7593	}
7594
7595	/// Determine whether this is a C++1z for-range-identifier.
7596	bool isForRangeIdentifier();
7597
7598	///@}
7599
7600	//
7601	//
7602	// -------------------------------------------------------------------------
7603	//
7604	//
7605
7606	/// \name `inline asm` Statement
7607	/// Implementations are in ParseStmtAsm.cpp
7608	///@{
7609
7610	public:
7611	/// Parse an identifier in an MS-style inline assembly block.
7612	ExprResult ParseMSAsmIdentifier(llvm::SmallVectorImpl<Token> &LineToks,
7613	unsigned &NumLineToksConsumed,
7614	bool IsUnevaluated);
7615
7616	private:
7617	/// ParseAsmStatement - Parse a GNU extended asm statement.
7618	/// \verbatim
7619	/// asm-statement:
7620	/// gnu-asm-statement
7621	/// ms-asm-statement
7622	///
7623	/// [GNU] gnu-asm-statement:
7624	/// 'asm' asm-qualifier-list[opt] '(' asm-argument ')' ';'
7625	///
7626	/// [GNU] asm-argument:
7627	/// asm-string-literal
7628	/// asm-string-literal ':' asm-operands[opt]
7629	/// asm-string-literal ':' asm-operands[opt] ':' asm-operands[opt]
7630	/// asm-string-literal ':' asm-operands[opt] ':' asm-operands[opt]
7631	/// ':' asm-clobbers
7632	///
7633	/// [GNU] asm-clobbers:
7634	/// asm-string-literal
7635	/// asm-clobbers ',' asm-string-literal
7636	/// \endverbatim
7637	///
7638	StmtResult ParseAsmStatement(bool &msAsm);
7639
7640	/// ParseMicrosoftAsmStatement. When -fms-extensions/-fasm-blocks is enabled,
7641	/// this routine is called to collect the tokens for an MS asm statement.
7642	///
7643	/// \verbatim
7644	/// [MS] ms-asm-statement:
7645	/// ms-asm-block
7646	/// ms-asm-block ms-asm-statement
7647	///
7648	/// [MS] ms-asm-block:
7649	/// '__asm' ms-asm-line '\n'
7650	/// '__asm' '{' ms-asm-instruction-block[opt] '}' ';'[opt]
7651	///
7652	/// [MS] ms-asm-instruction-block
7653	/// ms-asm-line
7654	/// ms-asm-line '\n' ms-asm-instruction-block
7655	/// \endverbatim
7656	///
7657	StmtResult ParseMicrosoftAsmStatement(SourceLocation AsmLoc);
7658
7659	/// ParseAsmOperands - Parse the asm-operands production as used by
7660	/// asm-statement, assuming the leading ':' token was eaten.
7661	///
7662	/// \verbatim
7663	/// [GNU] asm-operands:
7664	/// asm-operand
7665	/// asm-operands ',' asm-operand
7666	///
7667	/// [GNU] asm-operand:
7668	/// asm-string-literal '(' expression ')'
7669	/// '[' identifier ']' asm-string-literal '(' expression ')'
7670	/// \endverbatim
7671	///
7672	// FIXME: Avoid unnecessary std::string trashing.
7673	bool ParseAsmOperandsOpt(SmallVectorImpl<IdentifierInfo *> &Names,
7674	SmallVectorImpl<Expr *> &Constraints,
7675	SmallVectorImpl<Expr *> &Exprs);
7676
7677	class GNUAsmQualifiers {
7678	unsigned Qualifiers = AQ_unspecified;
7679
7680	public:
7681	enum AQ {
7682	AQ_unspecified = 0,
7683	AQ_volatile = 1,
7684	AQ_inline = 2,
7685	AQ_goto = 4,
7686	};
7687	static const char *getQualifierName(AQ Qualifier);
7688	bool setAsmQualifier(AQ Qualifier);
7689	inline bool isVolatile() const { return Qualifiers & AQ_volatile; };
7690	inline bool isInline() const { return Qualifiers & AQ_inline; };
7691	inline bool isGoto() const { return Qualifiers & AQ_goto; }
7692	};
7693
7694	// Determine if this is a GCC-style asm statement.
7695	bool isGCCAsmStatement(const Token &TokAfterAsm) const;
7696
7697	bool isGNUAsmQualifier(const Token &TokAfterAsm) const;
7698	GNUAsmQualifiers::AQ getGNUAsmQualifier(const Token &Tok) const;
7699
7700	/// parseGNUAsmQualifierListOpt - Parse a GNU extended asm qualifier list.
7701	/// \verbatim
7702	/// asm-qualifier:
7703	/// volatile
7704	/// inline
7705	/// goto
7706	///
7707	/// asm-qualifier-list:
7708	/// asm-qualifier
7709	/// asm-qualifier-list asm-qualifier
7710	/// \endverbatim
7711	bool parseGNUAsmQualifierListOpt(GNUAsmQualifiers &AQ);
7712
7713	///@}
7714
7715	//
7716	//
7717	// -------------------------------------------------------------------------
7718	//
7719	//
7720
7721	/// \name C++ Templates
7722	/// Implementations are in ParseTemplate.cpp
7723	///@{
7724
7725	public:
7726	typedef SmallVector<TemplateParameterList *, 4> TemplateParameterLists;
7727
7728	/// Re-enter a possible template scope, creating as many template parameter
7729	/// scopes as necessary.
7730	/// \return The number of template parameter scopes entered.
7731	unsigned ReenterTemplateScopes(MultiParseScope &S, Decl *D);
7732
7733	private:
7734	/// The "depth" of the template parameters currently being parsed.
7735	unsigned TemplateParameterDepth;
7736
7737	/// RAII class that manages the template parameter depth.
7738	class TemplateParameterDepthRAII {
7739	unsigned &Depth;
7740	unsigned AddedLevels;
7741
7742	public:
7743	explicit TemplateParameterDepthRAII(unsigned &Depth)
7744	: Depth(Depth), AddedLevels(0) {}
7745
7746	~TemplateParameterDepthRAII() { Depth -= AddedLevels; }
7747
7748	void operator++() {
7749	++Depth;
7750	++AddedLevels;
7751	}
7752	void addDepth(unsigned D) {
7753	Depth += D;
7754	AddedLevels += D;
7755	}
7756	void setAddedDepth(unsigned D) {
7757	Depth = Depth - AddedLevels + D;
7758	AddedLevels = D;
7759	}
7760
7761	unsigned getDepth() const { return Depth; }
7762	unsigned getOriginalDepth() const { return Depth - AddedLevels; }
7763	};
7764
7765	/// Gathers and cleans up TemplateIdAnnotations when parsing of a
7766	/// top-level declaration is finished.
7767	SmallVector<TemplateIdAnnotation *, 16> TemplateIds;
7768
7769	/// Don't destroy template annotations in MaybeDestroyTemplateIds even if
7770	/// we're at the end of a declaration. Instead, we defer the destruction until
7771	/// after a top-level declaration.
7772	/// Use DelayTemplateIdDestructionRAII rather than setting it directly.
7773	bool DelayTemplateIdDestruction = false;
7774
7775	void MaybeDestroyTemplateIds() {
7776	if (DelayTemplateIdDestruction)
7777	return;
7778	if (!TemplateIds.empty() &&
7779	(Tok.is(K: tok::eof) || !PP.mightHavePendingAnnotationTokens()))
7780	DestroyTemplateIds();
7781	}
7782	void DestroyTemplateIds();
7783
7784	/// RAII object to destroy TemplateIdAnnotations where possible, from a
7785	/// likely-good position during parsing.
7786	struct DestroyTemplateIdAnnotationsRAIIObj {
7787	Parser &Self;
7788
7789	DestroyTemplateIdAnnotationsRAIIObj(Parser &Self) : Self(Self) {}
7790	~DestroyTemplateIdAnnotationsRAIIObj() { Self.MaybeDestroyTemplateIds(); }
7791	};
7792
7793	struct DelayTemplateIdDestructionRAII {
7794	Parser &Self;
7795	bool PrevDelayTemplateIdDestruction;
7796
7797	DelayTemplateIdDestructionRAII(Parser &Self,
7798	bool DelayTemplateIdDestruction) noexcept
7799	: Self(Self),
7800	PrevDelayTemplateIdDestruction(Self.DelayTemplateIdDestruction) {
7801	Self.DelayTemplateIdDestruction = DelayTemplateIdDestruction;
7802	}
7803
7804	~DelayTemplateIdDestructionRAII() noexcept {
7805	Self.DelayTemplateIdDestruction = PrevDelayTemplateIdDestruction;
7806	}
7807	};
7808
7809	/// Identifiers which have been declared within a tentative parse.
7810	SmallVector<const IdentifierInfo *, 8> TentativelyDeclaredIdentifiers;
7811
7812	/// Tracker for '<' tokens that might have been intended to be treated as an
7813	/// angle bracket instead of a less-than comparison.
7814	///
7815	/// This happens when the user intends to form a template-id, but typoes the
7816	/// template-name or forgets a 'template' keyword for a dependent template
7817	/// name.
7818	///
7819	/// We track these locations from the point where we see a '<' with a
7820	/// name-like expression on its left until we see a '>' or '>>' that might
7821	/// match it.
7822	struct AngleBracketTracker {
7823	/// Flags used to rank candidate template names when there is more than one
7824	/// '<' in a scope.
7825	enum Priority : unsigned short {
7826	/// A non-dependent name that is a potential typo for a template name.
7827	PotentialTypo = 0x0,
7828	/// A dependent name that might instantiate to a template-name.
7829	DependentName = 0x2,
7830
7831	/// A space appears before the '<' token.
7832	SpaceBeforeLess = 0x0,
7833	/// No space before the '<' token
7834	NoSpaceBeforeLess = 0x1,
7835
7836	LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue*/ DependentName)
7837	};
7838
7839	struct Loc {
7840	Expr *TemplateName;
7841	SourceLocation LessLoc;
7842	AngleBracketTracker::Priority Priority;
7843	unsigned short ParenCount, BracketCount, BraceCount;
7844
7845	bool isActive(Parser &P) const {
7846	return P.ParenCount == ParenCount && P.BracketCount == BracketCount &&
7847	P.BraceCount == BraceCount;
7848	}
7849
7850	bool isActiveOrNested(Parser &P) const {
7851	return isActive(P) || P.ParenCount > ParenCount ||
7852	P.BracketCount > BracketCount || P.BraceCount > BraceCount;
7853	}
7854	};
7855
7856	SmallVector<Loc, 8> Locs;
7857
7858	/// Add an expression that might have been intended to be a template name.
7859	/// In the case of ambiguity, we arbitrarily select the innermost such
7860	/// expression, for example in 'foo < bar < baz', 'bar' is the current
7861	/// candidate. No attempt is made to track that 'foo' is also a candidate
7862	/// for the case where we see a second suspicious '>' token.
7863	void add(Parser &P, Expr *TemplateName, SourceLocation LessLoc,
7864	Priority Prio) {
7865	if (!Locs.empty() && Locs.back().isActive(P)) {
7866	if (Locs.back().Priority <= Prio) {
7867	Locs.back().TemplateName = TemplateName;
7868	Locs.back().LessLoc = LessLoc;
7869	Locs.back().Priority = Prio;
7870	}
7871	} else {
7872	Locs.push_back(Elt: {.TemplateName: TemplateName, .LessLoc: LessLoc, .Priority: Prio, .ParenCount: P.ParenCount,
7873	.BracketCount: P.BracketCount, .BraceCount: P.BraceCount});
7874	}
7875	}
7876
7877	/// Mark the current potential missing template location as having been
7878	/// handled (this happens if we pass a "corresponding" '>' or '>>' token
7879	/// or leave a bracket scope).
7880	void clear(Parser &P) {
7881	while (!Locs.empty() && Locs.back().isActiveOrNested(P))
7882	Locs.pop_back();
7883	}
7884
7885	/// Get the current enclosing expression that might hve been intended to be
7886	/// a template name.
7887	Loc *getCurrent(Parser &P) {
7888	if (!Locs.empty() && Locs.back().isActive(P))
7889	return &Locs.back();
7890	return nullptr;
7891	}
7892	};
7893
7894	AngleBracketTracker AngleBrackets;
7895
7896	/// Contains information about any template-specific
7897	/// information that has been parsed prior to parsing declaration
7898	/// specifiers.
7899	struct ParsedTemplateInfo {
7900	ParsedTemplateInfo()
7901	: Kind(ParsedTemplateKind::NonTemplate), TemplateParams(nullptr) {}
7902
7903	ParsedTemplateInfo(TemplateParameterLists *TemplateParams,
7904	bool isSpecialization,
7905	bool lastParameterListWasEmpty = false)
7906	: Kind(isSpecialization ? ParsedTemplateKind::ExplicitSpecialization
7907	: ParsedTemplateKind::Template),
7908	TemplateParams(TemplateParams),
7909	LastParameterListWasEmpty(lastParameterListWasEmpty) {}
7910
7911	explicit ParsedTemplateInfo(SourceLocation ExternLoc,
7912	SourceLocation TemplateLoc)
7913	: Kind(ParsedTemplateKind::ExplicitInstantiation),
7914	TemplateParams(nullptr), ExternLoc(ExternLoc),
7915	TemplateLoc(TemplateLoc), LastParameterListWasEmpty(false) {}
7916
7917	ParsedTemplateKind Kind;
7918
7919	/// The template parameter lists, for template declarations
7920	/// and explicit specializations.
7921	TemplateParameterLists *TemplateParams;
7922
7923	/// The location of the 'extern' keyword, if any, for an explicit
7924	/// instantiation
7925	SourceLocation ExternLoc;
7926
7927	/// The location of the 'template' keyword, for an explicit
7928	/// instantiation.
7929	SourceLocation TemplateLoc;
7930
7931	/// Whether the last template parameter list was empty.
7932	bool LastParameterListWasEmpty;
7933
7934	SourceRange getSourceRange() const LLVM_READONLY;
7935	};
7936
7937	/// Lex a delayed template function for late parsing.
7938	void LexTemplateFunctionForLateParsing(CachedTokens &Toks);
7939
7940	/// Late parse a C++ function template in Microsoft mode.
7941	void ParseLateTemplatedFuncDef(LateParsedTemplate &LPT);
7942
7943	static void LateTemplateParserCallback(void *P, LateParsedTemplate &LPT);
7944
7945	/// We've parsed something that could plausibly be intended to be a template
7946	/// name (\p LHS) followed by a '<' token, and the following code can't
7947	/// possibly be an expression. Determine if this is likely to be a template-id
7948	/// and if so, diagnose it.
7949	bool diagnoseUnknownTemplateId(ExprResult TemplateName, SourceLocation Less);
7950
7951	void checkPotentialAngleBracket(ExprResult &PotentialTemplateName);
7952	bool checkPotentialAngleBracketDelimiter(const AngleBracketTracker::Loc &,
7953	const Token &OpToken);
7954	bool checkPotentialAngleBracketDelimiter(const Token &OpToken) {
7955	if (auto *Info = AngleBrackets.getCurrent(P&: *this))
7956	return checkPotentialAngleBracketDelimiter(*Info, OpToken);
7957	return false;
7958	}
7959
7960	//===--------------------------------------------------------------------===//
7961	// C++ 14: Templates [temp]
7962
7963	/// Parse a template declaration, explicit instantiation, or
7964	/// explicit specialization.
7965	DeclGroupPtrTy
7966	ParseDeclarationStartingWithTemplate(DeclaratorContext Context,
7967	SourceLocation &DeclEnd,
7968	ParsedAttributes &AccessAttrs);
7969
7970	/// Parse a template declaration or an explicit specialization.
7971	///
7972	/// Template declarations include one or more template parameter lists
7973	/// and either the function or class template declaration. Explicit
7974	/// specializations contain one or more 'template < >' prefixes
7975	/// followed by a (possibly templated) declaration. Since the
7976	/// syntactic form of both features is nearly identical, we parse all
7977	/// of the template headers together and let semantic analysis sort
7978	/// the declarations from the explicit specializations.
7979	///
7980	/// \verbatim
7981	/// template-declaration: [C++ temp]
7982	/// 'export'[opt] 'template' '<' template-parameter-list '>' declaration
7983	///
7984	/// template-declaration: [C++2a]
7985	/// template-head declaration
7986	/// template-head concept-definition
7987	///
7988	/// TODO: requires-clause
7989	/// template-head: [C++2a]
7990	/// 'template' '<' template-parameter-list '>'
7991	/// requires-clause[opt]
7992	///
7993	/// explicit-specialization: [ C++ temp.expl.spec]
7994	/// 'template' '<' '>' declaration
7995	/// \endverbatim
7996	DeclGroupPtrTy ParseTemplateDeclarationOrSpecialization(
7997	DeclaratorContext Context, SourceLocation &DeclEnd,
7998	ParsedAttributes &AccessAttrs, AccessSpecifier AS);
7999
8000	clang::Parser::DeclGroupPtrTy ParseTemplateDeclarationOrSpecialization(
8001	DeclaratorContext Context, SourceLocation &DeclEnd, AccessSpecifier AS);
8002
8003	/// Parse a single declaration that declares a template,
8004	/// template specialization, or explicit instantiation of a template.
8005	///
8006	/// \param DeclEnd will receive the source location of the last token
8007	/// within this declaration.
8008	///
8009	/// \param AS the access specifier associated with this
8010	/// declaration. Will be AS_none for namespace-scope declarations.
8011	///
8012	/// \returns the new declaration.
8013	DeclGroupPtrTy ParseDeclarationAfterTemplate(
8014	DeclaratorContext Context, ParsedTemplateInfo &TemplateInfo,
8015	ParsingDeclRAIIObject &DiagsFromParams, SourceLocation &DeclEnd,
8016	ParsedAttributes &AccessAttrs, AccessSpecifier AS = AS_none);
8017
8018	/// ParseTemplateParameters - Parses a template-parameter-list enclosed in
8019	/// angle brackets. Depth is the depth of this template-parameter-list, which
8020	/// is the number of template headers directly enclosing this template header.
8021	/// TemplateParams is the current list of template parameters we're building.
8022	/// The template parameter we parse will be added to this list. LAngleLoc and
8023	/// RAngleLoc will receive the positions of the '<' and '>', respectively,
8024	/// that enclose this template parameter list.
8025	///
8026	/// \returns true if an error occurred, false otherwise.
8027	bool ParseTemplateParameters(MultiParseScope &TemplateScopes, unsigned Depth,
8028	SmallVectorImpl<NamedDecl *> &TemplateParams,
8029	SourceLocation &LAngleLoc,
8030	SourceLocation &RAngleLoc);
8031
8032	/// ParseTemplateParameterList - Parse a template parameter list. If
8033	/// the parsing fails badly (i.e., closing bracket was left out), this
8034	/// will try to put the token stream in a reasonable position (closing
8035	/// a statement, etc.) and return false.
8036	///
8037	/// \verbatim
8038	/// template-parameter-list: [C++ temp]
8039	/// template-parameter
8040	/// template-parameter-list ',' template-parameter
8041	/// \endverbatim
8042	bool ParseTemplateParameterList(unsigned Depth,
8043	SmallVectorImpl<NamedDecl *> &TemplateParams);
8044
8045	enum class TPResult;
8046
8047	/// Determine whether the parser is at the start of a template
8048	/// type parameter.
8049	TPResult isStartOfTemplateTypeParameter();
8050
8051	/// ParseTemplateParameter - Parse a template-parameter (C++ [temp.param]).
8052	///
8053	/// \verbatim
8054	/// template-parameter: [C++ temp.param]
8055	/// type-parameter
8056	/// parameter-declaration
8057	///
8058	/// type-parameter: (See below)
8059	/// type-parameter-key ...[opt] identifier[opt]
8060	/// type-parameter-key identifier[opt] = type-id
8061	/// (C++2a) type-constraint ...[opt] identifier[opt]
8062	/// (C++2a) type-constraint identifier[opt] = type-id
8063	/// 'template' '<' template-parameter-list '>' type-parameter-key
8064	/// ...[opt] identifier[opt]
8065	/// 'template' '<' template-parameter-list '>' type-parameter-key
8066	/// identifier[opt] '=' id-expression
8067	///
8068	/// type-parameter-key:
8069	/// class
8070	/// typename
8071	/// \endverbatim
8072	///
8073	NamedDecl *ParseTemplateParameter(unsigned Depth, unsigned Position);
8074
8075	/// ParseTypeParameter - Parse a template type parameter (C++ [temp.param]).
8076	/// Other kinds of template parameters are parsed in
8077	/// ParseTemplateTemplateParameter and ParseNonTypeTemplateParameter.
8078	///
8079	/// \verbatim
8080	/// type-parameter: [C++ temp.param]
8081	/// 'class' ...[opt][C++0x] identifier[opt]
8082	/// 'class' identifier[opt] '=' type-id
8083	/// 'typename' ...[opt][C++0x] identifier[opt]
8084	/// 'typename' identifier[opt] '=' type-id
8085	/// \endverbatim
8086	NamedDecl *ParseTypeParameter(unsigned Depth, unsigned Position);
8087
8088	/// ParseTemplateTemplateParameter - Handle the parsing of template
8089	/// template parameters.
8090	///
8091	/// \verbatim
8092	/// type-parameter: [C++ temp.param]
8093	/// template-head type-parameter-key ...[opt] identifier[opt]
8094	/// template-head type-parameter-key identifier[opt] = id-expression
8095	/// type-parameter-key:
8096	/// 'class'
8097	/// 'typename' [C++1z]
8098	/// template-head: [C++2a]
8099	/// 'template' '<' template-parameter-list '>'
8100	/// requires-clause[opt]
8101	/// \endverbatim
8102	NamedDecl *ParseTemplateTemplateParameter(unsigned Depth, unsigned Position);
8103
8104	/// ParseNonTypeTemplateParameter - Handle the parsing of non-type
8105	/// template parameters (e.g., in "template<int Size> class array;").
8106	///
8107	/// \verbatim
8108	/// template-parameter:
8109	/// ...
8110	/// parameter-declaration
8111	/// \endverbatim
8112	NamedDecl *ParseNonTypeTemplateParameter(unsigned Depth, unsigned Position);
8113
8114	/// Check whether the current token is a template-id annotation denoting a
8115	/// type-constraint.
8116	bool isTypeConstraintAnnotation();
8117
8118	/// Try parsing a type-constraint at the current location.
8119	///
8120	/// \verbatim
8121	/// type-constraint:
8122	/// nested-name-specifier[opt] concept-name
8123	/// nested-name-specifier[opt] concept-name
8124	/// '<' template-argument-list[opt] '>'[opt]
8125	/// \endverbatim
8126	///
8127	/// \returns true if an error occurred, and false otherwise.
8128	bool TryAnnotateTypeConstraint();
8129
8130	void DiagnoseMisplacedEllipsis(SourceLocation EllipsisLoc,
8131	SourceLocation CorrectLoc,
8132	bool AlreadyHasEllipsis,
8133	bool IdentifierHasName);
8134	void DiagnoseMisplacedEllipsisInDeclarator(SourceLocation EllipsisLoc,
8135	Declarator &D);
8136	// C++ 14.3: Template arguments [temp.arg]
8137	typedef SmallVector<ParsedTemplateArgument, 16> TemplateArgList;
8138
8139	/// Parses a '>' at the end of a template list.
8140	///
8141	/// If this function encounters '>>', '>>>', '>=', or '>>=', it tries
8142	/// to determine if these tokens were supposed to be a '>' followed by
8143	/// '>', '>>', '>=', or '>='. It emits an appropriate diagnostic if necessary.
8144	///
8145	/// \param RAngleLoc the location of the consumed '>'.
8146	///
8147	/// \param ConsumeLastToken if true, the '>' is consumed.
8148	///
8149	/// \param ObjCGenericList if true, this is the '>' closing an Objective-C
8150	/// type parameter or type argument list, rather than a C++ template parameter
8151	/// or argument list.
8152	///
8153	/// \returns true, if current token does not start with '>', false otherwise.
8154	bool ParseGreaterThanInTemplateList(SourceLocation LAngleLoc,
8155	SourceLocation &RAngleLoc,
8156	bool ConsumeLastToken,
8157	bool ObjCGenericList);
8158
8159	/// Parses a template-id that after the template name has
8160	/// already been parsed.
8161	///
8162	/// This routine takes care of parsing the enclosed template argument
8163	/// list ('<' template-parameter-list [opt] '>') and placing the
8164	/// results into a form that can be transferred to semantic analysis.
8165	///
8166	/// \param ConsumeLastToken if true, then we will consume the last
8167	/// token that forms the template-id. Otherwise, we will leave the
8168	/// last token in the stream (e.g., so that it can be replaced with an
8169	/// annotation token).
8170	bool ParseTemplateIdAfterTemplateName(bool ConsumeLastToken,
8171	SourceLocation &LAngleLoc,
8172	TemplateArgList &TemplateArgs,
8173	SourceLocation &RAngleLoc,
8174	TemplateTy NameHint = nullptr);
8175
8176	/// Replace the tokens that form a simple-template-id with an
8177	/// annotation token containing the complete template-id.
8178	///
8179	/// The first token in the stream must be the name of a template that
8180	/// is followed by a '<'. This routine will parse the complete
8181	/// simple-template-id and replace the tokens with a single annotation
8182	/// token with one of two different kinds: if the template-id names a
8183	/// type (and \p AllowTypeAnnotation is true), the annotation token is
8184	/// a type annotation that includes the optional nested-name-specifier
8185	/// (\p SS). Otherwise, the annotation token is a template-id
8186	/// annotation that does not include the optional
8187	/// nested-name-specifier.
8188	///
8189	/// \param Template the declaration of the template named by the first
8190	/// token (an identifier), as returned from \c Action::isTemplateName().
8191	///
8192	/// \param TNK the kind of template that \p Template
8193	/// refers to, as returned from \c Action::isTemplateName().
8194	///
8195	/// \param SS if non-NULL, the nested-name-specifier that precedes
8196	/// this template name.
8197	///
8198	/// \param TemplateKWLoc if valid, specifies that this template-id
8199	/// annotation was preceded by the 'template' keyword and gives the
8200	/// location of that keyword. If invalid (the default), then this
8201	/// template-id was not preceded by a 'template' keyword.
8202	///
8203	/// \param AllowTypeAnnotation if true (the default), then a
8204	/// simple-template-id that refers to a class template, template
8205	/// template parameter, or other template that produces a type will be
8206	/// replaced with a type annotation token. Otherwise, the
8207	/// simple-template-id is always replaced with a template-id
8208	/// annotation token.
8209	///
8210	/// \param TypeConstraint if true, then this is actually a type-constraint,
8211	/// meaning that the template argument list can be omitted (and the template
8212	/// in question must be a concept).
8213	///
8214	/// If an unrecoverable parse error occurs and no annotation token can be
8215	/// formed, this function returns true.
8216	///
8217	bool AnnotateTemplateIdToken(TemplateTy Template, TemplateNameKind TNK,
8218	CXXScopeSpec &SS, SourceLocation TemplateKWLoc,
8219	UnqualifiedId &TemplateName,
8220	bool AllowTypeAnnotation = true,
8221	bool TypeConstraint = false);
8222
8223	/// Replaces a template-id annotation token with a type
8224	/// annotation token.
8225	///
8226	/// If there was a failure when forming the type from the template-id,
8227	/// a type annotation token will still be created, but will have a
8228	/// NULL type pointer to signify an error.
8229	///
8230	/// \param SS The scope specifier appearing before the template-id, if any.
8231	///
8232	/// \param AllowImplicitTypename whether this is a context where T::type
8233	/// denotes a dependent type.
8234	/// \param IsClassName Is this template-id appearing in a context where we
8235	/// know it names a class, such as in an elaborated-type-specifier or
8236	/// base-specifier? ('typename' and 'template' are unneeded and disallowed
8237	/// in those contexts.)
8238	void
8239	AnnotateTemplateIdTokenAsType(CXXScopeSpec &SS,
8240	ImplicitTypenameContext AllowImplicitTypename,
8241	bool IsClassName = false);
8242
8243	/// ParseTemplateArgumentList - Parse a C++ template-argument-list
8244	/// (C++ [temp.names]). Returns true if there was an error.
8245	///
8246	/// \verbatim
8247	/// template-argument-list: [C++ 14.2]
8248	/// template-argument
8249	/// template-argument-list ',' template-argument
8250	/// \endverbatim
8251	///
8252	/// \param Template is only used for code completion, and may be null.
8253	bool ParseTemplateArgumentList(TemplateArgList &TemplateArgs,
8254	TemplateTy Template, SourceLocation OpenLoc);
8255
8256	/// Parse a C++ template template argument.
8257	ParsedTemplateArgument ParseTemplateTemplateArgument();
8258
8259	/// ParseTemplateArgument - Parse a C++ template argument (C++ [temp.names]).
8260	///
8261	/// \verbatim
8262	/// template-argument: [C++ 14.2]
8263	/// constant-expression
8264	/// type-id
8265	/// id-expression
8266	/// braced-init-list [C++26, DR]
8267	/// \endverbatim
8268	///
8269	ParsedTemplateArgument ParseTemplateArgument();
8270
8271	/// Parse a C++ explicit template instantiation
8272	/// (C++ [temp.explicit]).
8273	///
8274	/// \verbatim
8275	/// explicit-instantiation:
8276	/// 'extern' [opt] 'template' declaration
8277	/// \endverbatim
8278	///
8279	/// Note that the 'extern' is a GNU extension and C++11 feature.
8280	DeclGroupPtrTy ParseExplicitInstantiation(DeclaratorContext Context,
8281	SourceLocation ExternLoc,
8282	SourceLocation TemplateLoc,
8283	SourceLocation &DeclEnd,
8284	ParsedAttributes &AccessAttrs,
8285	AccessSpecifier AS = AS_none);
8286
8287	/// \brief Parse a single declaration that declares a concept.
8288	///
8289	/// \param DeclEnd will receive the source location of the last token
8290	/// within this declaration.
8291	///
8292	/// \returns the new declaration.
8293	Decl *ParseConceptDefinition(const ParsedTemplateInfo &TemplateInfo,
8294	SourceLocation &DeclEnd);
8295
8296	///@}
8297
8298	//
8299	//
8300	// -------------------------------------------------------------------------
8301	//
8302	//
8303
8304	/// \name Tentative Parsing
8305	/// Implementations are in ParseTentative.cpp
8306	///@{
8307
8308	private:
8309	/// TentativeParsingAction - An object that is used as a kind of "tentative
8310	/// parsing transaction". It gets instantiated to mark the token position and
8311	/// after the token consumption is done, Commit() or Revert() is called to
8312	/// either "commit the consumed tokens" or revert to the previously marked
8313	/// token position. Example:
8314	///
8315	/// TentativeParsingAction TPA(*this);
8316	/// ConsumeToken();
8317	/// ....
8318	/// TPA.Revert();
8319	///
8320	/// If the Unannotated parameter is true, any token annotations created
8321	/// during the tentative parse are reverted.
8322	class TentativeParsingAction {
8323	Parser &P;
8324	PreferredTypeBuilder PrevPreferredType;
8325	Token PrevTok;
8326	size_t PrevTentativelyDeclaredIdentifierCount;
8327	unsigned short PrevParenCount, PrevBracketCount, PrevBraceCount;
8328	bool isActive;
8329
8330	public:
8331	explicit TentativeParsingAction(Parser &p, bool Unannotated = false)
8332	: P(p), PrevPreferredType(P.PreferredType) {
8333	PrevTok = P.Tok;
8334	PrevTentativelyDeclaredIdentifierCount =
8335	P.TentativelyDeclaredIdentifiers.size();
8336	PrevParenCount = P.ParenCount;
8337	PrevBracketCount = P.BracketCount;
8338	PrevBraceCount = P.BraceCount;
8339	P.PP.EnableBacktrackAtThisPos(Unannotated);
8340	isActive = true;
8341	}
8342	void Commit() {
8343	assert(isActive && "Parsing action was finished!");
8344	P.TentativelyDeclaredIdentifiers.resize(
8345	N: PrevTentativelyDeclaredIdentifierCount);
8346	P.PP.CommitBacktrackedTokens();
8347	isActive = false;
8348	}
8349	void Revert() {
8350	assert(isActive && "Parsing action was finished!");
8351	P.PP.Backtrack();
8352	P.PreferredType = PrevPreferredType;
8353	P.Tok = PrevTok;
8354	P.TentativelyDeclaredIdentifiers.resize(
8355	N: PrevTentativelyDeclaredIdentifierCount);
8356	P.ParenCount = PrevParenCount;
8357	P.BracketCount = PrevBracketCount;
8358	P.BraceCount = PrevBraceCount;
8359	isActive = false;
8360	}
8361	~TentativeParsingAction() {
8362	assert(!isActive && "Forgot to call Commit or Revert!");
8363	}
8364	};
8365
8366	/// A TentativeParsingAction that automatically reverts in its destructor.
8367	/// Useful for disambiguation parses that will always be reverted.
8368	class RevertingTentativeParsingAction
8369	: private Parser::TentativeParsingAction {
8370	public:
8371	using TentativeParsingAction::TentativeParsingAction;
8372
8373	~RevertingTentativeParsingAction() { Revert(); }
8374	};
8375
8376	/// isCXXDeclarationStatement - C++-specialized function that disambiguates
8377	/// between a declaration or an expression statement, when parsing function
8378	/// bodies. Returns true for declaration, false for expression.
8379	///
8380	/// \verbatim
8381	/// declaration-statement:
8382	/// block-declaration
8383	///
8384	/// block-declaration:
8385	/// simple-declaration
8386	/// asm-definition
8387	/// namespace-alias-definition
8388	/// using-declaration
8389	/// using-directive
8390	/// [C++0x] static_assert-declaration
8391	///
8392	/// asm-definition:
8393	/// 'asm' '(' string-literal ')' ';'
8394	///
8395	/// namespace-alias-definition:
8396	/// 'namespace' identifier = qualified-namespace-specifier ';'
8397	///
8398	/// using-declaration:
8399	/// 'using' typename[opt] '::'[opt] nested-name-specifier
8400	/// unqualified-id ';'
8401	/// 'using' '::' unqualified-id ;
8402	///
8403	/// using-directive:
8404	/// 'using' 'namespace' '::'[opt] nested-name-specifier[opt]
8405	/// namespace-name ';'
8406	/// \endverbatim
8407	///
8408	bool isCXXDeclarationStatement(bool DisambiguatingWithExpression = false);
8409
8410	/// isCXXSimpleDeclaration - C++-specialized function that disambiguates
8411	/// between a simple-declaration or an expression-statement.
8412	/// If during the disambiguation process a parsing error is encountered,
8413	/// the function returns true to let the declaration parsing code handle it.
8414	/// Returns false if the statement is disambiguated as expression.
8415	///
8416	/// \verbatim
8417	/// simple-declaration:
8418	/// decl-specifier-seq init-declarator-list[opt] ';'
8419	/// decl-specifier-seq ref-qualifier[opt] '[' identifier-list ']'
8420	/// brace-or-equal-initializer ';' [C++17]
8421	/// \endverbatim
8422	///
8423	/// (if AllowForRangeDecl specified)
8424	/// for ( for-range-declaration : for-range-initializer ) statement
8425	///
8426	/// \verbatim
8427	/// for-range-declaration:
8428	/// decl-specifier-seq declarator
8429	/// decl-specifier-seq ref-qualifier[opt] '[' identifier-list ']'
8430	/// \endverbatim
8431	///
8432	/// In any of the above cases there can be a preceding
8433	/// attribute-specifier-seq, but the caller is expected to handle that.
8434	bool isCXXSimpleDeclaration(bool AllowForRangeDecl);
8435
8436	/// isCXXFunctionDeclarator - Disambiguates between a function declarator or
8437	/// a constructor-style initializer, when parsing declaration statements.
8438	/// Returns true for function declarator and false for constructor-style
8439	/// initializer. Sets 'IsAmbiguous' to true to indicate that this declaration
8440	/// might be a constructor-style initializer.
8441	/// If during the disambiguation process a parsing error is encountered,
8442	/// the function returns true to let the declaration parsing code handle it.
8443	///
8444	/// '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
8445	/// exception-specification[opt]
8446	///
8447	bool isCXXFunctionDeclarator(bool *IsAmbiguous = nullptr,
8448	ImplicitTypenameContext AllowImplicitTypename =
8449	ImplicitTypenameContext::No);
8450
8451	struct ConditionDeclarationOrInitStatementState;
8452	enum class ConditionOrInitStatement {
8453	Expression, ///< Disambiguated as an expression (either kind).
8454	ConditionDecl, ///< Disambiguated as the declaration form of condition.
8455	InitStmtDecl, ///< Disambiguated as a simple-declaration init-statement.
8456	ForRangeDecl, ///< Disambiguated as a for-range declaration.
8457	Error ///< Can't be any of the above!
8458	};
8459
8460	/// Disambiguates between a declaration in a condition, a
8461	/// simple-declaration in an init-statement, and an expression for
8462	/// a condition of a if/switch statement.
8463	///
8464	/// \verbatim
8465	/// condition:
8466	/// expression
8467	/// type-specifier-seq declarator '=' assignment-expression
8468	/// [C++11] type-specifier-seq declarator '=' initializer-clause
8469	/// [C++11] type-specifier-seq declarator braced-init-list
8470	/// [GNU] type-specifier-seq declarator simple-asm-expr[opt] attributes[opt]
8471	/// '=' assignment-expression
8472	/// simple-declaration:
8473	/// decl-specifier-seq init-declarator-list[opt] ';'
8474	/// \endverbatim
8475	///
8476	/// Note that, unlike isCXXSimpleDeclaration, we must disambiguate all the way
8477	/// to the ';' to disambiguate cases like 'int(x))' (an expression) from
8478	/// 'int(x);' (a simple-declaration in an init-statement).
8479	ConditionOrInitStatement
8480	isCXXConditionDeclarationOrInitStatement(bool CanBeInitStmt,
8481	bool CanBeForRangeDecl);
8482
8483	/// Determine whether the next set of tokens contains a type-id.
8484	///
8485	/// The context parameter states what context we're parsing right
8486	/// now, which affects how this routine copes with the token
8487	/// following the type-id. If the context is
8488	/// TentativeCXXTypeIdContext::InParens, we have already parsed the '(' and we
8489	/// will cease lookahead when we hit the corresponding ')'. If the context is
8490	/// TentativeCXXTypeIdContext::AsTemplateArgument, we've already parsed the
8491	/// '<' or ',' before this template argument, and will cease lookahead when we
8492	/// hit a
8493	/// '>', '>>' (in C++0x), or ','; or, in C++0x, an ellipsis immediately
8494	/// preceding such. Returns true for a type-id and false for an expression.
8495	/// If during the disambiguation process a parsing error is encountered,
8496	/// the function returns true to let the declaration parsing code handle it.
8497	///
8498	/// \verbatim
8499	/// type-id:
8500	/// type-specifier-seq abstract-declarator[opt]
8501	/// \endverbatim
8502	///
8503	bool isCXXTypeId(TentativeCXXTypeIdContext Context, bool &isAmbiguous);
8504
8505	bool isCXXTypeId(TentativeCXXTypeIdContext Context) {
8506	bool isAmbiguous;
8507	return isCXXTypeId(Context, isAmbiguous);
8508	}
8509
8510	/// TPResult - Used as the result value for functions whose purpose is to
8511	/// disambiguate C++ constructs by "tentatively parsing" them.
8512	enum class TPResult { True, False, Ambiguous, Error };
8513
8514	/// Determine whether we could have an enum-base.
8515	///
8516	/// \p AllowSemi If \c true, then allow a ';' after the enum-base; otherwise
8517	/// only consider this to be an enum-base if the next token is a '{'.
8518	///
8519	/// \return \c false if this cannot possibly be an enum base; \c true
8520	/// otherwise.
8521	bool isEnumBase(bool AllowSemi);
8522
8523	/// isCXXDeclarationSpecifier - Returns TPResult::True if it is a declaration
8524	/// specifier, TPResult::False if it is not, TPResult::Ambiguous if it could
8525	/// be either a decl-specifier or a function-style cast, and TPResult::Error
8526	/// if a parsing error was found and reported.
8527	///
8528	/// Does not consume tokens.
8529	///
8530	/// If InvalidAsDeclSpec is not null, some cases that would be ill-formed as
8531	/// declaration specifiers but possibly valid as some other kind of construct
8532	/// return TPResult::Ambiguous instead of TPResult::False. When this happens,
8533	/// the intent is to keep trying to disambiguate, on the basis that we might
8534	/// find a better reason to treat this construct as a declaration later on.
8535	/// When this happens and the name could possibly be valid in some other
8536	/// syntactic context, *InvalidAsDeclSpec is set to 'true'. The current cases
8537	/// that trigger this are:
8538	///
8539	/// * When parsing X::Y (with no 'typename') where X is dependent
8540	/// * When parsing X<Y> where X is undeclared
8541	///
8542	/// \verbatim
8543	/// decl-specifier:
8544	/// storage-class-specifier
8545	/// type-specifier
8546	/// function-specifier
8547	/// 'friend'
8548	/// 'typedef'
8549	/// [C++11] 'constexpr'
8550	/// [C++20] 'consteval'
8551	/// [GNU] attributes declaration-specifiers[opt]
8552	///
8553	/// storage-class-specifier:
8554	/// 'register'
8555	/// 'static'
8556	/// 'extern'
8557	/// 'mutable'
8558	/// 'auto'
8559	/// [GNU] '__thread'
8560	/// [C++11] 'thread_local'
8561	/// [C11] '_Thread_local'
8562	///
8563	/// function-specifier:
8564	/// 'inline'
8565	/// 'virtual'
8566	/// 'explicit'
8567	///
8568	/// typedef-name:
8569	/// identifier
8570	///
8571	/// type-specifier:
8572	/// simple-type-specifier
8573	/// class-specifier
8574	/// enum-specifier
8575	/// elaborated-type-specifier
8576	/// typename-specifier
8577	/// cv-qualifier
8578	///
8579	/// simple-type-specifier:
8580	/// '::'[opt] nested-name-specifier[opt] type-name
8581	/// '::'[opt] nested-name-specifier 'template'
8582	/// simple-template-id [TODO]
8583	/// 'char'
8584	/// 'wchar_t'
8585	/// 'bool'
8586	/// 'short'
8587	/// 'int'
8588	/// 'long'
8589	/// 'signed'
8590	/// 'unsigned'
8591	/// 'float'
8592	/// 'double'
8593	/// 'void'
8594	/// [GNU] typeof-specifier
8595	/// [GNU] '_Complex'
8596	/// [C++11] 'auto'
8597	/// [GNU] '__auto_type'
8598	/// [C++11] 'decltype' ( expression )
8599	/// [C++1y] 'decltype' ( 'auto' )
8600	///
8601	/// type-name:
8602	/// class-name
8603	/// enum-name
8604	/// typedef-name
8605	///
8606	/// elaborated-type-specifier:
8607	/// class-key '::'[opt] nested-name-specifier[opt] identifier
8608	/// class-key '::'[opt] nested-name-specifier[opt] 'template'[opt]
8609	/// simple-template-id
8610	/// 'enum' '::'[opt] nested-name-specifier[opt] identifier
8611	///
8612	/// enum-name:
8613	/// identifier
8614	///
8615	/// enum-specifier:
8616	/// 'enum' identifier[opt] '{' enumerator-list[opt] '}'
8617	/// 'enum' identifier[opt] '{' enumerator-list ',' '}'
8618	///
8619	/// class-specifier:
8620	/// class-head '{' member-specification[opt] '}'
8621	///
8622	/// class-head:
8623	/// class-key identifier[opt] base-clause[opt]
8624	/// class-key nested-name-specifier identifier base-clause[opt]
8625	/// class-key nested-name-specifier[opt] simple-template-id
8626	/// base-clause[opt]
8627	///
8628	/// class-key:
8629	/// 'class'
8630	/// 'struct'
8631	/// 'union'
8632	///
8633	/// cv-qualifier:
8634	/// 'const'
8635	/// 'volatile'
8636	/// [GNU] restrict
8637	/// \endverbatim
8638	///
8639	TPResult
8640	isCXXDeclarationSpecifier(ImplicitTypenameContext AllowImplicitTypename,
8641	TPResult BracedCastResult = TPResult::False,
8642	bool *InvalidAsDeclSpec = nullptr);
8643
8644	/// Given that isCXXDeclarationSpecifier returns \c TPResult::True or
8645	/// \c TPResult::Ambiguous, determine whether the decl-specifier would be
8646	/// a type-specifier other than a cv-qualifier.
8647	bool isCXXDeclarationSpecifierAType();
8648
8649	/// Determine whether we might be looking at the '<' template-argument-list
8650	/// '>' of a template-id or simple-template-id, rather than a less-than
8651	/// comparison. This will often fail and produce an ambiguity, but should
8652	/// never be wrong if it returns True or False.
8653	TPResult isTemplateArgumentList(unsigned TokensToSkip);
8654
8655	/// Determine whether an '(' after an 'explicit' keyword is part of a C++20
8656	/// 'explicit(bool)' declaration, in earlier language modes where that is an
8657	/// extension.
8658	TPResult isExplicitBool();
8659
8660	/// Determine whether an identifier has been tentatively declared as a
8661	/// non-type. Such tentative declarations should not be found to name a type
8662	/// during a tentative parse, but also should not be annotated as a non-type.
8663	bool isTentativelyDeclared(IdentifierInfo *II);
8664
8665	// "Tentative parsing" functions, used for disambiguation. If a parsing error
8666	// is encountered they will return TPResult::Error.
8667	// Returning TPResult::True/False indicates that the ambiguity was
8668	// resolved and tentative parsing may stop. TPResult::Ambiguous indicates
8669	// that more tentative parsing is necessary for disambiguation.
8670	// They all consume tokens, so backtracking should be used after calling them.
8671
8672	/// \verbatim
8673	/// simple-declaration:
8674	/// decl-specifier-seq init-declarator-list[opt] ';'
8675	///
8676	/// (if AllowForRangeDecl specified)
8677	/// for ( for-range-declaration : for-range-initializer ) statement
8678	/// for-range-declaration:
8679	/// attribute-specifier-seqopt type-specifier-seq declarator
8680	/// \endverbatim
8681	///
8682	TPResult TryParseSimpleDeclaration(bool AllowForRangeDecl);
8683
8684	/// \verbatim
8685	/// [GNU] typeof-specifier:
8686	/// 'typeof' '(' expressions ')'
8687	/// 'typeof' '(' type-name ')'
8688	/// \endverbatim
8689	///
8690	TPResult TryParseTypeofSpecifier();
8691
8692	/// [ObjC] protocol-qualifiers:
8693	/// '<' identifier-list '>'
8694	TPResult TryParseProtocolQualifiers();
8695
8696	TPResult TryParsePtrOperatorSeq();
8697
8698	/// \verbatim
8699	/// operator-function-id:
8700	/// 'operator' operator
8701	///
8702	/// operator: one of
8703	/// new delete new[] delete[] + - * / % ^ [...]
8704	///
8705	/// conversion-function-id:
8706	/// 'operator' conversion-type-id
8707	///
8708	/// conversion-type-id:
8709	/// type-specifier-seq conversion-declarator[opt]
8710	///
8711	/// conversion-declarator:
8712	/// ptr-operator conversion-declarator[opt]
8713	///
8714	/// literal-operator-id:
8715	/// 'operator' string-literal identifier
8716	/// 'operator' user-defined-string-literal
8717	/// \endverbatim
8718	TPResult TryParseOperatorId();
8719
8720	/// Tentatively parse an init-declarator-list in order to disambiguate it from
8721	/// an expression.
8722	///
8723	/// \verbatim
8724	/// init-declarator-list:
8725	/// init-declarator
8726	/// init-declarator-list ',' init-declarator
8727	///
8728	/// init-declarator:
8729	/// declarator initializer[opt]
8730	/// [GNU] declarator simple-asm-expr[opt] attributes[opt] initializer[opt]
8731	///
8732	/// initializer:
8733	/// brace-or-equal-initializer
8734	/// '(' expression-list ')'
8735	///
8736	/// brace-or-equal-initializer:
8737	/// '=' initializer-clause
8738	/// [C++11] braced-init-list
8739	///
8740	/// initializer-clause:
8741	/// assignment-expression
8742	/// braced-init-list
8743	///
8744	/// braced-init-list:
8745	/// '{' initializer-list ','[opt] '}'
8746	/// '{' '}'
8747	/// \endverbatim
8748	///
8749	TPResult TryParseInitDeclaratorList(bool MayHaveTrailingReturnType = false);
8750
8751	/// \verbatim
8752	/// declarator:
8753	/// direct-declarator
8754	/// ptr-operator declarator
8755	///
8756	/// direct-declarator:
8757	/// declarator-id
8758	/// direct-declarator '(' parameter-declaration-clause ')'
8759	/// cv-qualifier-seq[opt] exception-specification[opt]
8760	/// direct-declarator '[' constant-expression[opt] ']'
8761	/// '(' declarator ')'
8762	/// [GNU] '(' attributes declarator ')'
8763	///
8764	/// abstract-declarator:
8765	/// ptr-operator abstract-declarator[opt]
8766	/// direct-abstract-declarator
8767	///
8768	/// direct-abstract-declarator:
8769	/// direct-abstract-declarator[opt]
8770	/// '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
8771	/// exception-specification[opt]
8772	/// direct-abstract-declarator[opt] '[' constant-expression[opt] ']'
8773	/// '(' abstract-declarator ')'
8774	/// [C++0x] ...
8775	///
8776	/// ptr-operator:
8777	/// '*' cv-qualifier-seq[opt]
8778	/// '&'
8779	/// [C++0x] '&&' [TODO]
8780	/// '::'[opt] nested-name-specifier '*' cv-qualifier-seq[opt]
8781	///
8782	/// cv-qualifier-seq:
8783	/// cv-qualifier cv-qualifier-seq[opt]
8784	///
8785	/// cv-qualifier:
8786	/// 'const'
8787	/// 'volatile'
8788	///
8789	/// declarator-id:
8790	/// '...'[opt] id-expression
8791	///
8792	/// id-expression:
8793	/// unqualified-id
8794	/// qualified-id [TODO]
8795	///
8796	/// unqualified-id:
8797	/// identifier
8798	/// operator-function-id
8799	/// conversion-function-id
8800	/// literal-operator-id
8801	/// '~' class-name [TODO]
8802	/// '~' decltype-specifier [TODO]
8803	/// template-id [TODO]
8804	/// \endverbatim
8805	///
8806	TPResult TryParseDeclarator(bool mayBeAbstract, bool mayHaveIdentifier = true,
8807	bool mayHaveDirectInit = false,
8808	bool mayHaveTrailingReturnType = false);
8809
8810	/// \verbatim
8811	/// parameter-declaration-clause:
8812	/// parameter-declaration-list[opt] '...'[opt]
8813	/// parameter-declaration-list ',' '...'
8814	///
8815	/// parameter-declaration-list:
8816	/// parameter-declaration
8817	/// parameter-declaration-list ',' parameter-declaration
8818	///
8819	/// parameter-declaration:
8820	/// attribute-specifier-seq[opt] decl-specifier-seq declarator attributes[opt]
8821	/// attribute-specifier-seq[opt] decl-specifier-seq declarator attributes[opt]
8822	/// '=' assignment-expression
8823	/// attribute-specifier-seq[opt] decl-specifier-seq abstract-declarator[opt]
8824	/// attributes[opt]
8825	/// attribute-specifier-seq[opt] decl-specifier-seq abstract-declarator[opt]
8826	/// attributes[opt] '=' assignment-expression
8827	/// \endverbatim
8828	///
8829	TPResult TryParseParameterDeclarationClause(
8830	bool *InvalidAsDeclaration = nullptr, bool VersusTemplateArg = false,
8831	ImplicitTypenameContext AllowImplicitTypename =
8832	ImplicitTypenameContext::No);
8833
8834	/// TryParseFunctionDeclarator - We parsed a '(' and we want to try to
8835	/// continue parsing as a function declarator. If TryParseFunctionDeclarator
8836	/// fully parsed the function declarator, it will return TPResult::Ambiguous,
8837	/// otherwise it will return either False() or Error().
8838	///
8839	/// \verbatim
8840	/// '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
8841	/// exception-specification[opt]
8842	///
8843	/// exception-specification:
8844	/// 'throw' '(' type-id-list[opt] ')'
8845	/// \endverbatim
8846	///
8847	TPResult TryParseFunctionDeclarator(bool MayHaveTrailingReturnType = false);
8848
8849	// When parsing an identifier after an arrow it may be a member expression,
8850	// in which case we should not annotate it as an independant expression
8851	// so we just lookup that name, if it's not a type the construct is not
8852	// a function declaration.
8853	bool NameAfterArrowIsNonType();
8854
8855	/// \verbatim
8856	/// '[' constant-expression[opt] ']'
8857	/// \endverbatim
8858	///
8859	TPResult TryParseBracketDeclarator();
8860
8861	/// Try to consume a token sequence that we've already identified as
8862	/// (potentially) starting a decl-specifier.
8863	TPResult TryConsumeDeclarationSpecifier();
8864
8865	/// Try to skip a possibly empty sequence of 'attribute-specifier's without
8866	/// full validation of the syntactic structure of attributes.
8867	bool TrySkipAttributes();
8868
8869	//===--------------------------------------------------------------------===//
8870	// C++ 7: Declarations [dcl.dcl]
8871
8872	/// Returns true if this is a C++11 attribute-specifier. Per
8873	/// C++11 [dcl.attr.grammar]p6, two consecutive left square bracket tokens
8874	/// always introduce an attribute. In Objective-C++11, this rule does not
8875	/// apply if either '[' begins a message-send.
8876	///
8877	/// If Disambiguate is true, we try harder to determine whether a '[[' starts
8878	/// an attribute-specifier, and return
8879	/// CXX11AttributeKind::InvalidAttributeSpecifier if not.
8880	///
8881	/// If OuterMightBeMessageSend is true, we assume the outer '[' is either an
8882	/// Obj-C message send or the start of an attribute. Otherwise, we assume it
8883	/// is not an Obj-C message send.
8884	///
8885	/// C++11 [dcl.attr.grammar]:
8886	///
8887	/// \verbatim
8888	/// attribute-specifier:
8889	/// '[' '[' attribute-list ']' ']'
8890	/// alignment-specifier
8891	///
8892	/// attribute-list:
8893	/// attribute[opt]
8894	/// attribute-list ',' attribute[opt]
8895	/// attribute '...'
8896	/// attribute-list ',' attribute '...'
8897	///
8898	/// attribute:
8899	/// attribute-token attribute-argument-clause[opt]
8900	///
8901	/// attribute-token:
8902	/// identifier
8903	/// identifier '::' identifier
8904	///
8905	/// attribute-argument-clause:
8906	/// '(' balanced-token-seq ')'
8907	/// \endverbatim
8908	CXX11AttributeKind
8909	isCXX11AttributeSpecifier(bool Disambiguate = false,
8910	bool OuterMightBeMessageSend = false);
8911
8912	///@}
8913	};
8914
8915	} // end namespace clang
8916
8917	#endif
8918