[OpenMP][NFC] Remove the need to include `OpenMPClause.h`
[lldb.git] / clang / include / clang / Parse / Parser.h
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/AST/Availability.h"
17 #include "clang/Basic/BitmaskEnum.h"
18 #include "clang/Basic/OpenMPKinds.h"
19 #include "clang/Basic/OperatorPrecedence.h"
20 #include "clang/Basic/Specifiers.h"
21 #include "clang/Lex/CodeCompletionHandler.h"
22 #include "clang/Lex/Preprocessor.h"
23 #include "clang/Sema/DeclSpec.h"
24 #include "clang/Sema/Sema.h"
25 #include "llvm/ADT/SmallVector.h"
26 #include "llvm/Frontend/OpenMP/OMPContext.h"
27 #include "llvm/Support/Compiler.h"
28 #include "llvm/Support/PrettyStackTrace.h"
29 #include "llvm/Support/SaveAndRestore.h"
30 #include <memory>
31 #include <stack>
32
33 namespace clang {
34   class PragmaHandler;
35   class Scope;
36   class BalancedDelimiterTracker;
37   class CorrectionCandidateCallback;
38   class DeclGroupRef;
39   class DiagnosticBuilder;
40   struct LoopHint;
41   class Parser;
42   class ParsingDeclRAIIObject;
43   class ParsingDeclSpec;
44   class ParsingDeclarator;
45   class ParsingFieldDeclarator;
46   class ColonProtectionRAIIObject;
47   class InMessageExpressionRAIIObject;
48   class PoisonSEHIdentifiersRAIIObject;
49   class OMPClause;
50   class ObjCTypeParamList;
51   class ObjCTypeParameter;
52   struct OMPTraitProperty;
53   struct OMPTraitSelector;
54   struct OMPTraitSet;
55   class OMPTraitInfo;
56
57 /// Parser - This implements a parser for the C family of languages.  After
58 /// parsing units of the grammar, productions are invoked to handle whatever has
59 /// been read.
60 ///
61 class Parser : public CodeCompletionHandler {
62   friend class ColonProtectionRAIIObject;
63   friend class ParsingOpenMPDirectiveRAII;
64   friend class InMessageExpressionRAIIObject;
65   friend class PoisonSEHIdentifiersRAIIObject;
66   friend class ObjCDeclContextSwitch;
67   friend class ParenBraceBracketBalancer;
68   friend class BalancedDelimiterTracker;
69
70   Preprocessor &PP;
71
72   /// Tok - The current token we are peeking ahead.  All parsing methods assume
73   /// that this is valid.
74   Token Tok;
75
76   // PrevTokLocation - The location of the token we previously
77   // consumed. This token is used for diagnostics where we expected to
78   // see a token following another token (e.g., the ';' at the end of
79   // a statement).
80   SourceLocation PrevTokLocation;
81
82   /// Tracks an expected type for the current token when parsing an expression.
83   /// Used by code completion for ranking.
84   PreferredTypeBuilder PreferredType;
85
86   unsigned short ParenCount = 0, BracketCount = 0, BraceCount = 0;
87   unsigned short MisplacedModuleBeginCount = 0;
88
89   /// Actions - These are the callbacks we invoke as we parse various constructs
90   /// in the file.
91   Sema &Actions;
92
93   DiagnosticsEngine &Diags;
94
95   /// ScopeCache - Cache scopes to reduce malloc traffic.
96   enum { ScopeCacheSize = 16 };
97   unsigned NumCachedScopes;
98   Scope *ScopeCache[ScopeCacheSize];
99
100   /// Identifiers used for SEH handling in Borland. These are only
101   /// allowed in particular circumstances
102   // __except block
103   IdentifierInfo *Ident__exception_code,
104                  *Ident___exception_code,
105                  *Ident_GetExceptionCode;
106   // __except filter expression
107   IdentifierInfo *Ident__exception_info,
108                  *Ident___exception_info,
109                  *Ident_GetExceptionInfo;
110   // __finally
111   IdentifierInfo *Ident__abnormal_termination,
112                  *Ident___abnormal_termination,
113                  *Ident_AbnormalTermination;
114
115   /// Contextual keywords for Microsoft extensions.
116   IdentifierInfo *Ident__except;
117   mutable IdentifierInfo *Ident_sealed;
118
119   /// Ident_super - IdentifierInfo for "super", to support fast
120   /// comparison.
121   IdentifierInfo *Ident_super;
122   /// Ident_vector, Ident_bool - cached IdentifierInfos for "vector" and
123   /// "bool" fast comparison.  Only present if AltiVec or ZVector are enabled.
124   IdentifierInfo *Ident_vector;
125   IdentifierInfo *Ident_bool;
126   /// Ident_pixel - cached IdentifierInfos for "pixel" fast comparison.
127   /// Only present if AltiVec enabled.
128   IdentifierInfo *Ident_pixel;
129
130   /// Objective-C contextual keywords.
131   IdentifierInfo *Ident_instancetype;
132
133   /// Identifier for "introduced".
134   IdentifierInfo *Ident_introduced;
135
136   /// Identifier for "deprecated".
137   IdentifierInfo *Ident_deprecated;
138
139   /// Identifier for "obsoleted".
140   IdentifierInfo *Ident_obsoleted;
141
142   /// Identifier for "unavailable".
143   IdentifierInfo *Ident_unavailable;
144
145   /// Identifier for "message".
146   IdentifierInfo *Ident_message;
147
148   /// Identifier for "strict".
149   IdentifierInfo *Ident_strict;
150
151   /// Identifier for "replacement".
152   IdentifierInfo *Ident_replacement;
153
154   /// Identifiers used by the 'external_source_symbol' attribute.
155   IdentifierInfo *Ident_language, *Ident_defined_in,
156       *Ident_generated_declaration;
157
158   /// C++11 contextual keywords.
159   mutable IdentifierInfo *Ident_final;
160   mutable IdentifierInfo *Ident_GNU_final;
161   mutable IdentifierInfo *Ident_override;
162
163   // C++2a contextual keywords.
164   mutable IdentifierInfo *Ident_import;
165   mutable IdentifierInfo *Ident_module;
166
167   // C++ type trait keywords that can be reverted to identifiers and still be
168   // used as type traits.
169   llvm::SmallDenseMap<IdentifierInfo *, tok::TokenKind> RevertibleTypeTraits;
170
171   std::unique_ptr<PragmaHandler> AlignHandler;
172   std::unique_ptr<PragmaHandler> GCCVisibilityHandler;
173   std::unique_ptr<PragmaHandler> OptionsHandler;
174   std::unique_ptr<PragmaHandler> PackHandler;
175   std::unique_ptr<PragmaHandler> MSStructHandler;
176   std::unique_ptr<PragmaHandler> UnusedHandler;
177   std::unique_ptr<PragmaHandler> WeakHandler;
178   std::unique_ptr<PragmaHandler> RedefineExtnameHandler;
179   std::unique_ptr<PragmaHandler> FPContractHandler;
180   std::unique_ptr<PragmaHandler> OpenCLExtensionHandler;
181   std::unique_ptr<PragmaHandler> OpenMPHandler;
182   std::unique_ptr<PragmaHandler> PCSectionHandler;
183   std::unique_ptr<PragmaHandler> MSCommentHandler;
184   std::unique_ptr<PragmaHandler> MSDetectMismatchHandler;
185   std::unique_ptr<PragmaHandler> MSPointersToMembers;
186   std::unique_ptr<PragmaHandler> MSVtorDisp;
187   std::unique_ptr<PragmaHandler> MSInitSeg;
188   std::unique_ptr<PragmaHandler> MSDataSeg;
189   std::unique_ptr<PragmaHandler> MSBSSSeg;
190   std::unique_ptr<PragmaHandler> MSConstSeg;
191   std::unique_ptr<PragmaHandler> MSCodeSeg;
192   std::unique_ptr<PragmaHandler> MSSection;
193   std::unique_ptr<PragmaHandler> MSRuntimeChecks;
194   std::unique_ptr<PragmaHandler> MSIntrinsic;
195   std::unique_ptr<PragmaHandler> MSOptimize;
196   std::unique_ptr<PragmaHandler> CUDAForceHostDeviceHandler;
197   std::unique_ptr<PragmaHandler> OptimizeHandler;
198   std::unique_ptr<PragmaHandler> LoopHintHandler;
199   std::unique_ptr<PragmaHandler> UnrollHintHandler;
200   std::unique_ptr<PragmaHandler> NoUnrollHintHandler;
201   std::unique_ptr<PragmaHandler> UnrollAndJamHintHandler;
202   std::unique_ptr<PragmaHandler> NoUnrollAndJamHintHandler;
203   std::unique_ptr<PragmaHandler> FPHandler;
204   std::unique_ptr<PragmaHandler> STDCFENVHandler;
205   std::unique_ptr<PragmaHandler> STDCCXLIMITHandler;
206   std::unique_ptr<PragmaHandler> STDCUnknownHandler;
207   std::unique_ptr<PragmaHandler> AttributePragmaHandler;
208   std::unique_ptr<PragmaHandler> MaxTokensHerePragmaHandler;
209   std::unique_ptr<PragmaHandler> MaxTokensTotalPragmaHandler;
210
211   std::unique_ptr<CommentHandler> CommentSemaHandler;
212
213   /// Whether the '>' token acts as an operator or not. This will be
214   /// true except when we are parsing an expression within a C++
215   /// template argument list, where the '>' closes the template
216   /// argument list.
217   bool GreaterThanIsOperator;
218
219   /// ColonIsSacred - When this is false, we aggressively try to recover from
220   /// code like "foo : bar" as if it were a typo for "foo :: bar".  This is not
221   /// safe in case statements and a few other things.  This is managed by the
222   /// ColonProtectionRAIIObject RAII object.
223   bool ColonIsSacred;
224
225   /// Parsing OpenMP directive mode.
226   bool OpenMPDirectiveParsing = false;
227
228   /// When true, we are directly inside an Objective-C message
229   /// send expression.
230   ///
231   /// This is managed by the \c InMessageExpressionRAIIObject class, and
232   /// should not be set directly.
233   bool InMessageExpression;
234
235   /// Gets set to true after calling ProduceSignatureHelp, it is for a
236   /// workaround to make sure ProduceSignatureHelp is only called at the deepest
237   /// function call.
238   bool CalledSignatureHelp = false;
239
240   /// The "depth" of the template parameters currently being parsed.
241   unsigned TemplateParameterDepth;
242
243   /// RAII class that manages the template parameter depth.
244   class TemplateParameterDepthRAII {
245     unsigned &Depth;
246     unsigned AddedLevels;
247   public:
248     explicit TemplateParameterDepthRAII(unsigned &Depth)
249       : Depth(Depth), AddedLevels(0) {}
250
251     ~TemplateParameterDepthRAII() {
252       Depth -= AddedLevels;
253     }
254
255     void operator++() {
256       ++Depth;
257       ++AddedLevels;
258     }
259     void addDepth(unsigned D) {
260       Depth += D;
261       AddedLevels += D;
262     }
263     void setAddedDepth(unsigned D) {
264       Depth = Depth - AddedLevels + D;
265       AddedLevels = D;
266     }
267
268     unsigned getDepth() const { return Depth; }
269     unsigned getOriginalDepth() const { return Depth - AddedLevels; }
270   };
271
272   /// Factory object for creating ParsedAttr objects.
273   AttributeFactory AttrFactory;
274
275   /// Gathers and cleans up TemplateIdAnnotations when parsing of a
276   /// top-level declaration is finished.
277   SmallVector<TemplateIdAnnotation *, 16> TemplateIds;
278
279   /// Identifiers which have been declared within a tentative parse.
280   SmallVector<IdentifierInfo *, 8> TentativelyDeclaredIdentifiers;
281
282   /// Tracker for '<' tokens that might have been intended to be treated as an
283   /// angle bracket instead of a less-than comparison.
284   ///
285   /// This happens when the user intends to form a template-id, but typoes the
286   /// template-name or forgets a 'template' keyword for a dependent template
287   /// name.
288   ///
289   /// We track these locations from the point where we see a '<' with a
290   /// name-like expression on its left until we see a '>' or '>>' that might
291   /// match it.
292   struct AngleBracketTracker {
293     /// Flags used to rank candidate template names when there is more than one
294     /// '<' in a scope.
295     enum Priority : unsigned short {
296       /// A non-dependent name that is a potential typo for a template name.
297       PotentialTypo = 0x0,
298       /// A dependent name that might instantiate to a template-name.
299       DependentName = 0x2,
300
301       /// A space appears before the '<' token.
302       SpaceBeforeLess = 0x0,
303       /// No space before the '<' token
304       NoSpaceBeforeLess = 0x1,
305
306       LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue*/ DependentName)
307     };
308
309     struct Loc {
310       Expr *TemplateName;
311       SourceLocation LessLoc;
312       AngleBracketTracker::Priority Priority;
313       unsigned short ParenCount, BracketCount, BraceCount;
314
315       bool isActive(Parser &P) const {
316         return P.ParenCount == ParenCount && P.BracketCount == BracketCount &&
317                P.BraceCount == BraceCount;
318       }
319
320       bool isActiveOrNested(Parser &P) const {
321         return isActive(P) || P.ParenCount > ParenCount ||
322                P.BracketCount > BracketCount || P.BraceCount > BraceCount;
323       }
324     };
325
326     SmallVector<Loc, 8> Locs;
327
328     /// Add an expression that might have been intended to be a template name.
329     /// In the case of ambiguity, we arbitrarily select the innermost such
330     /// expression, for example in 'foo < bar < baz', 'bar' is the current
331     /// candidate. No attempt is made to track that 'foo' is also a candidate
332     /// for the case where we see a second suspicious '>' token.
333     void add(Parser &P, Expr *TemplateName, SourceLocation LessLoc,
334              Priority Prio) {
335       if (!Locs.empty() && Locs.back().isActive(P)) {
336         if (Locs.back().Priority <= Prio) {
337           Locs.back().TemplateName = TemplateName;
338           Locs.back().LessLoc = LessLoc;
339           Locs.back().Priority = Prio;
340         }
341       } else {
342         Locs.push_back({TemplateName, LessLoc, Prio,
343                         P.ParenCount, P.BracketCount, P.BraceCount});
344       }
345     }
346
347     /// Mark the current potential missing template location as having been
348     /// handled (this happens if we pass a "corresponding" '>' or '>>' token
349     /// or leave a bracket scope).
350     void clear(Parser &P) {
351       while (!Locs.empty() && Locs.back().isActiveOrNested(P))
352         Locs.pop_back();
353     }
354
355     /// Get the current enclosing expression that might hve been intended to be
356     /// a template name.
357     Loc *getCurrent(Parser &P) {
358       if (!Locs.empty() && Locs.back().isActive(P))
359         return &Locs.back();
360       return nullptr;
361     }
362   };
363
364   AngleBracketTracker AngleBrackets;
365
366   IdentifierInfo *getSEHExceptKeyword();
367
368   /// True if we are within an Objective-C container while parsing C-like decls.
369   ///
370   /// This is necessary because Sema thinks we have left the container
371   /// to parse the C-like decls, meaning Actions.getObjCDeclContext() will
372   /// be NULL.
373   bool ParsingInObjCContainer;
374
375   /// Whether to skip parsing of function bodies.
376   ///
377   /// This option can be used, for example, to speed up searches for
378   /// declarations/definitions when indexing.
379   bool SkipFunctionBodies;
380
381   /// The location of the expression statement that is being parsed right now.
382   /// Used to determine if an expression that is being parsed is a statement or
383   /// just a regular sub-expression.
384   SourceLocation ExprStatementTokLoc;
385
386   /// Flags describing a context in which we're parsing a statement.
387   enum class ParsedStmtContext {
388     /// This context permits declarations in language modes where declarations
389     /// are not statements.
390     AllowDeclarationsInC = 0x1,
391     /// This context permits standalone OpenMP directives.
392     AllowStandaloneOpenMPDirectives = 0x2,
393     /// This context is at the top level of a GNU statement expression.
394     InStmtExpr = 0x4,
395
396     /// The context of a regular substatement.
397     SubStmt = 0,
398     /// The context of a compound-statement.
399     Compound = AllowDeclarationsInC | AllowStandaloneOpenMPDirectives,
400
401     LLVM_MARK_AS_BITMASK_ENUM(InStmtExpr)
402   };
403
404   /// Act on an expression statement that might be the last statement in a
405   /// GNU statement expression. Checks whether we are actually at the end of
406   /// a statement expression and builds a suitable expression statement.
407   StmtResult handleExprStmt(ExprResult E, ParsedStmtContext StmtCtx);
408
409 public:
410   Parser(Preprocessor &PP, Sema &Actions, bool SkipFunctionBodies);
411   ~Parser() override;
412
413   const LangOptions &getLangOpts() const { return PP.getLangOpts(); }
414   const TargetInfo &getTargetInfo() const { return PP.getTargetInfo(); }
415   Preprocessor &getPreprocessor() const { return PP; }
416   Sema &getActions() const { return Actions; }
417   AttributeFactory &getAttrFactory() { return AttrFactory; }
418
419   const Token &getCurToken() const { return Tok; }
420   Scope *getCurScope() const { return Actions.getCurScope(); }
421   void incrementMSManglingNumber() const {
422     return Actions.incrementMSManglingNumber();
423   }
424
425   Decl  *getObjCDeclContext() const { return Actions.getObjCDeclContext(); }
426
427   // Type forwarding.  All of these are statically 'void*', but they may all be
428   // different actual classes based on the actions in place.
429   typedef OpaquePtr<DeclGroupRef> DeclGroupPtrTy;
430   typedef OpaquePtr<TemplateName> TemplateTy;
431
432   typedef SmallVector<TemplateParameterList *, 4> TemplateParameterLists;
433
434   typedef Sema::FullExprArg FullExprArg;
435
436   // Parsing methods.
437
438   /// Initialize - Warm up the parser.
439   ///
440   void Initialize();
441
442   /// Parse the first top-level declaration in a translation unit.
443   bool ParseFirstTopLevelDecl(DeclGroupPtrTy &Result);
444
445   /// ParseTopLevelDecl - Parse one top-level declaration. Returns true if
446   /// the EOF was encountered.
447   bool ParseTopLevelDecl(DeclGroupPtrTy &Result, bool IsFirstDecl = false);
448   bool ParseTopLevelDecl() {
449     DeclGroupPtrTy Result;
450     return ParseTopLevelDecl(Result);
451   }
452
453   /// ConsumeToken - Consume the current 'peek token' and lex the next one.
454   /// This does not work with special tokens: string literals, code completion,
455   /// annotation tokens and balanced tokens must be handled using the specific
456   /// consume methods.
457   /// Returns the location of the consumed token.
458   SourceLocation ConsumeToken() {
459     assert(!isTokenSpecial() &&
460            "Should consume special tokens with Consume*Token");
461     PrevTokLocation = Tok.getLocation();
462     PP.Lex(Tok);
463     return PrevTokLocation;
464   }
465
466   bool TryConsumeToken(tok::TokenKind Expected) {
467     if (Tok.isNot(Expected))
468       return false;
469     assert(!isTokenSpecial() &&
470            "Should consume special tokens with Consume*Token");
471     PrevTokLocation = Tok.getLocation();
472     PP.Lex(Tok);
473     return true;
474   }
475
476   bool TryConsumeToken(tok::TokenKind Expected, SourceLocation &Loc) {
477     if (!TryConsumeToken(Expected))
478       return false;
479     Loc = PrevTokLocation;
480     return true;
481   }
482
483   /// ConsumeAnyToken - Dispatch to the right Consume* method based on the
484   /// current token type.  This should only be used in cases where the type of
485   /// the token really isn't known, e.g. in error recovery.
486   SourceLocation ConsumeAnyToken(bool ConsumeCodeCompletionTok = false) {
487     if (isTokenParen())
488       return ConsumeParen();
489     if (isTokenBracket())
490       return ConsumeBracket();
491     if (isTokenBrace())
492       return ConsumeBrace();
493     if (isTokenStringLiteral())
494       return ConsumeStringToken();
495     if (Tok.is(tok::code_completion))
496       return ConsumeCodeCompletionTok ? ConsumeCodeCompletionToken()
497                                       : handleUnexpectedCodeCompletionToken();
498     if (Tok.isAnnotation())
499       return ConsumeAnnotationToken();
500     return ConsumeToken();
501   }
502
503
504   SourceLocation getEndOfPreviousToken() {
505     return PP.getLocForEndOfToken(PrevTokLocation);
506   }
507
508   /// Retrieve the underscored keyword (_Nonnull, _Nullable) that corresponds
509   /// to the given nullability kind.
510   IdentifierInfo *getNullabilityKeyword(NullabilityKind nullability) {
511     return Actions.getNullabilityKeyword(nullability);
512   }
513
514 private:
515   //===--------------------------------------------------------------------===//
516   // Low-Level token peeking and consumption methods.
517   //
518
519   /// isTokenParen - Return true if the cur token is '(' or ')'.
520   bool isTokenParen() const {
521     return Tok.isOneOf(tok::l_paren, tok::r_paren);
522   }
523   /// isTokenBracket - Return true if the cur token is '[' or ']'.
524   bool isTokenBracket() const {
525     return Tok.isOneOf(tok::l_square, tok::r_square);
526   }
527   /// isTokenBrace - Return true if the cur token is '{' or '}'.
528   bool isTokenBrace() const {
529     return Tok.isOneOf(tok::l_brace, tok::r_brace);
530   }
531   /// isTokenStringLiteral - True if this token is a string-literal.
532   bool isTokenStringLiteral() const {
533     return tok::isStringLiteral(Tok.getKind());
534   }
535   /// isTokenSpecial - True if this token requires special consumption methods.
536   bool isTokenSpecial() const {
537     return isTokenStringLiteral() || isTokenParen() || isTokenBracket() ||
538            isTokenBrace() || Tok.is(tok::code_completion) || Tok.isAnnotation();
539   }
540
541   /// Returns true if the current token is '=' or is a type of '='.
542   /// For typos, give a fixit to '='
543   bool isTokenEqualOrEqualTypo();
544
545   /// Return the current token to the token stream and make the given
546   /// token the current token.
547   void UnconsumeToken(Token &Consumed) {
548       Token Next = Tok;
549       PP.EnterToken(Consumed, /*IsReinject*/true);
550       PP.Lex(Tok);
551       PP.EnterToken(Next, /*IsReinject*/true);
552   }
553
554   SourceLocation ConsumeAnnotationToken() {
555     assert(Tok.isAnnotation() && "wrong consume method");
556     SourceLocation Loc = Tok.getLocation();
557     PrevTokLocation = Tok.getAnnotationEndLoc();
558     PP.Lex(Tok);
559     return Loc;
560   }
561
562   /// ConsumeParen - This consume method keeps the paren count up-to-date.
563   ///
564   SourceLocation ConsumeParen() {
565     assert(isTokenParen() && "wrong consume method");
566     if (Tok.getKind() == tok::l_paren)
567       ++ParenCount;
568     else if (ParenCount) {
569       AngleBrackets.clear(*this);
570       --ParenCount;       // Don't let unbalanced )'s drive the count negative.
571     }
572     PrevTokLocation = Tok.getLocation();
573     PP.Lex(Tok);
574     return PrevTokLocation;
575   }
576
577   /// ConsumeBracket - This consume method keeps the bracket count up-to-date.
578   ///
579   SourceLocation ConsumeBracket() {
580     assert(isTokenBracket() && "wrong consume method");
581     if (Tok.getKind() == tok::l_square)
582       ++BracketCount;
583     else if (BracketCount) {
584       AngleBrackets.clear(*this);
585       --BracketCount;     // Don't let unbalanced ]'s drive the count negative.
586     }
587
588     PrevTokLocation = Tok.getLocation();
589     PP.Lex(Tok);
590     return PrevTokLocation;
591   }
592
593   /// ConsumeBrace - This consume method keeps the brace count up-to-date.
594   ///
595   SourceLocation ConsumeBrace() {
596     assert(isTokenBrace() && "wrong consume method");
597     if (Tok.getKind() == tok::l_brace)
598       ++BraceCount;
599     else if (BraceCount) {
600       AngleBrackets.clear(*this);
601       --BraceCount;     // Don't let unbalanced }'s drive the count negative.
602     }
603
604     PrevTokLocation = Tok.getLocation();
605     PP.Lex(Tok);
606     return PrevTokLocation;
607   }
608
609   /// ConsumeStringToken - Consume the current 'peek token', lexing a new one
610   /// and returning the token kind.  This method is specific to strings, as it
611   /// handles string literal concatenation, as per C99 5.1.1.2, translation
612   /// phase #6.
613   SourceLocation ConsumeStringToken() {
614     assert(isTokenStringLiteral() &&
615            "Should only consume string literals with this method");
616     PrevTokLocation = Tok.getLocation();
617     PP.Lex(Tok);
618     return PrevTokLocation;
619   }
620
621   /// Consume the current code-completion token.
622   ///
623   /// This routine can be called to consume the code-completion token and
624   /// continue processing in special cases where \c cutOffParsing() isn't
625   /// desired, such as token caching or completion with lookahead.
626   SourceLocation ConsumeCodeCompletionToken() {
627     assert(Tok.is(tok::code_completion));
628     PrevTokLocation = Tok.getLocation();
629     PP.Lex(Tok);
630     return PrevTokLocation;
631   }
632
633   ///\ brief When we are consuming a code-completion token without having
634   /// matched specific position in the grammar, provide code-completion results
635   /// based on context.
636   ///
637   /// \returns the source location of the code-completion token.
638   SourceLocation handleUnexpectedCodeCompletionToken();
639
640   /// Abruptly cut off parsing; mainly used when we have reached the
641   /// code-completion point.
642   void cutOffParsing() {
643     if (PP.isCodeCompletionEnabled())
644       PP.setCodeCompletionReached();
645     // Cut off parsing by acting as if we reached the end-of-file.
646     Tok.setKind(tok::eof);
647   }
648
649   /// Determine if we're at the end of the file or at a transition
650   /// between modules.
651   bool isEofOrEom() {
652     tok::TokenKind Kind = Tok.getKind();
653     return Kind == tok::eof || Kind == tok::annot_module_begin ||
654            Kind == tok::annot_module_end || Kind == tok::annot_module_include;
655   }
656
657   /// Checks if the \p Level is valid for use in a fold expression.
658   bool isFoldOperator(prec::Level Level) const;
659
660   /// Checks if the \p Kind is a valid operator for fold expressions.
661   bool isFoldOperator(tok::TokenKind Kind) const;
662
663   /// Initialize all pragma handlers.
664   void initializePragmaHandlers();
665
666   /// Destroy and reset all pragma handlers.
667   void resetPragmaHandlers();
668
669   /// Handle the annotation token produced for #pragma unused(...)
670   void HandlePragmaUnused();
671
672   /// Handle the annotation token produced for
673   /// #pragma GCC visibility...
674   void HandlePragmaVisibility();
675
676   /// Handle the annotation token produced for
677   /// #pragma pack...
678   void HandlePragmaPack();
679
680   /// Handle the annotation token produced for
681   /// #pragma ms_struct...
682   void HandlePragmaMSStruct();
683
684   /// Handle the annotation token produced for
685   /// #pragma comment...
686   void HandlePragmaMSComment();
687
688   void HandlePragmaMSPointersToMembers();
689
690   void HandlePragmaMSVtorDisp();
691
692   void HandlePragmaMSPragma();
693   bool HandlePragmaMSSection(StringRef PragmaName,
694                              SourceLocation PragmaLocation);
695   bool HandlePragmaMSSegment(StringRef PragmaName,
696                              SourceLocation PragmaLocation);
697   bool HandlePragmaMSInitSeg(StringRef PragmaName,
698                              SourceLocation PragmaLocation);
699
700   /// Handle the annotation token produced for
701   /// #pragma align...
702   void HandlePragmaAlign();
703
704   /// Handle the annotation token produced for
705   /// #pragma clang __debug dump...
706   void HandlePragmaDump();
707
708   /// Handle the annotation token produced for
709   /// #pragma weak id...
710   void HandlePragmaWeak();
711
712   /// Handle the annotation token produced for
713   /// #pragma weak id = id...
714   void HandlePragmaWeakAlias();
715
716   /// Handle the annotation token produced for
717   /// #pragma redefine_extname...
718   void HandlePragmaRedefineExtname();
719
720   /// Handle the annotation token produced for
721   /// #pragma STDC FP_CONTRACT...
722   void HandlePragmaFPContract();
723
724   /// Handle the annotation token produced for
725   /// #pragma STDC FENV_ACCESS...
726   void HandlePragmaFEnvAccess();
727
728   /// \brief Handle the annotation token produced for
729   /// #pragma clang fp ...
730   void HandlePragmaFP();
731
732   /// Handle the annotation token produced for
733   /// #pragma OPENCL EXTENSION...
734   void HandlePragmaOpenCLExtension();
735
736   /// Handle the annotation token produced for
737   /// #pragma clang __debug captured
738   StmtResult HandlePragmaCaptured();
739
740   /// Handle the annotation token produced for
741   /// #pragma clang loop and #pragma unroll.
742   bool HandlePragmaLoopHint(LoopHint &Hint);
743
744   bool ParsePragmaAttributeSubjectMatchRuleSet(
745       attr::ParsedSubjectMatchRuleSet &SubjectMatchRules,
746       SourceLocation &AnyLoc, SourceLocation &LastMatchRuleEndLoc);
747
748   void HandlePragmaAttribute();
749
750   /// GetLookAheadToken - This peeks ahead N tokens and returns that token
751   /// without consuming any tokens.  LookAhead(0) returns 'Tok', LookAhead(1)
752   /// returns the token after Tok, etc.
753   ///
754   /// Note that this differs from the Preprocessor's LookAhead method, because
755   /// the Parser always has one token lexed that the preprocessor doesn't.
756   ///
757   const Token &GetLookAheadToken(unsigned N) {
758     if (N == 0 || Tok.is(tok::eof)) return Tok;
759     return PP.LookAhead(N-1);
760   }
761
762 public:
763   /// NextToken - This peeks ahead one token and returns it without
764   /// consuming it.
765   const Token &NextToken() {
766     return PP.LookAhead(0);
767   }
768
769   /// getTypeAnnotation - Read a parsed type out of an annotation token.
770   static TypeResult getTypeAnnotation(const Token &Tok) {
771     if (!Tok.getAnnotationValue())
772       return TypeError();
773     return ParsedType::getFromOpaquePtr(Tok.getAnnotationValue());
774   }
775
776 private:
777   static void setTypeAnnotation(Token &Tok, TypeResult T) {
778     assert((T.isInvalid() || T.get()) &&
779            "produced a valid-but-null type annotation?");
780     Tok.setAnnotationValue(T.isInvalid() ? nullptr : T.get().getAsOpaquePtr());
781   }
782
783   static NamedDecl *getNonTypeAnnotation(const Token &Tok) {
784     return static_cast<NamedDecl*>(Tok.getAnnotationValue());
785   }
786
787   static void setNonTypeAnnotation(Token &Tok, NamedDecl *ND) {
788     Tok.setAnnotationValue(ND);
789   }
790
791   static IdentifierInfo *getIdentifierAnnotation(const Token &Tok) {
792     return static_cast<IdentifierInfo*>(Tok.getAnnotationValue());
793   }
794
795   static void setIdentifierAnnotation(Token &Tok, IdentifierInfo *ND) {
796     Tok.setAnnotationValue(ND);
797   }
798
799   /// Read an already-translated primary expression out of an annotation
800   /// token.
801   static ExprResult getExprAnnotation(const Token &Tok) {
802     return ExprResult::getFromOpaquePointer(Tok.getAnnotationValue());
803   }
804
805   /// Set the primary expression corresponding to the given annotation
806   /// token.
807   static void setExprAnnotation(Token &Tok, ExprResult ER) {
808     Tok.setAnnotationValue(ER.getAsOpaquePointer());
809   }
810
811 public:
812   // If NeedType is true, then TryAnnotateTypeOrScopeToken will try harder to
813   // find a type name by attempting typo correction.
814   bool TryAnnotateTypeOrScopeToken();
815   bool TryAnnotateTypeOrScopeTokenAfterScopeSpec(CXXScopeSpec &SS,
816                                                  bool IsNewScope);
817   bool TryAnnotateCXXScopeToken(bool EnteringContext = false);
818
819   bool MightBeCXXScopeToken() {
820     return Tok.is(tok::identifier) || Tok.is(tok::coloncolon) ||
821            (Tok.is(tok::annot_template_id) &&
822             NextToken().is(tok::coloncolon)) ||
823            Tok.is(tok::kw_decltype) || Tok.is(tok::kw___super);
824   }
825   bool TryAnnotateOptionalCXXScopeToken(bool EnteringContext = false) {
826     return MightBeCXXScopeToken() && TryAnnotateCXXScopeToken(EnteringContext);
827   }
828
829 private:
830   enum AnnotatedNameKind {
831     /// Annotation has failed and emitted an error.
832     ANK_Error,
833     /// The identifier is a tentatively-declared name.
834     ANK_TentativeDecl,
835     /// The identifier is a template name. FIXME: Add an annotation for that.
836     ANK_TemplateName,
837     /// The identifier can't be resolved.
838     ANK_Unresolved,
839     /// Annotation was successful.
840     ANK_Success
841   };
842   AnnotatedNameKind TryAnnotateName(CorrectionCandidateCallback *CCC = nullptr);
843
844   /// Push a tok::annot_cxxscope token onto the token stream.
845   void AnnotateScopeToken(CXXScopeSpec &SS, bool IsNewAnnotation);
846
847   /// TryAltiVecToken - Check for context-sensitive AltiVec identifier tokens,
848   /// replacing them with the non-context-sensitive keywords.  This returns
849   /// true if the token was replaced.
850   bool TryAltiVecToken(DeclSpec &DS, SourceLocation Loc,
851                        const char *&PrevSpec, unsigned &DiagID,
852                        bool &isInvalid) {
853     if (!getLangOpts().AltiVec && !getLangOpts().ZVector)
854       return false;
855
856     if (Tok.getIdentifierInfo() != Ident_vector &&
857         Tok.getIdentifierInfo() != Ident_bool &&
858         (!getLangOpts().AltiVec || Tok.getIdentifierInfo() != Ident_pixel))
859       return false;
860
861     return TryAltiVecTokenOutOfLine(DS, Loc, PrevSpec, DiagID, isInvalid);
862   }
863
864   /// TryAltiVecVectorToken - Check for context-sensitive AltiVec vector
865   /// identifier token, replacing it with the non-context-sensitive __vector.
866   /// This returns true if the token was replaced.
867   bool TryAltiVecVectorToken() {
868     if ((!getLangOpts().AltiVec && !getLangOpts().ZVector) ||
869         Tok.getIdentifierInfo() != Ident_vector) return false;
870     return TryAltiVecVectorTokenOutOfLine();
871   }
872
873   bool TryAltiVecVectorTokenOutOfLine();
874   bool TryAltiVecTokenOutOfLine(DeclSpec &DS, SourceLocation Loc,
875                                 const char *&PrevSpec, unsigned &DiagID,
876                                 bool &isInvalid);
877
878   /// Returns true if the current token is the identifier 'instancetype'.
879   ///
880   /// Should only be used in Objective-C language modes.
881   bool isObjCInstancetype() {
882     assert(getLangOpts().ObjC);
883     if (Tok.isAnnotation())
884       return false;
885     if (!Ident_instancetype)
886       Ident_instancetype = PP.getIdentifierInfo("instancetype");
887     return Tok.getIdentifierInfo() == Ident_instancetype;
888   }
889
890   /// TryKeywordIdentFallback - For compatibility with system headers using
891   /// keywords as identifiers, attempt to convert the current token to an
892   /// identifier and optionally disable the keyword for the remainder of the
893   /// translation unit. This returns false if the token was not replaced,
894   /// otherwise emits a diagnostic and returns true.
895   bool TryKeywordIdentFallback(bool DisableKeyword);
896
897   /// Get the TemplateIdAnnotation from the token.
898   TemplateIdAnnotation *takeTemplateIdAnnotation(const Token &tok);
899
900   /// TentativeParsingAction - An object that is used as a kind of "tentative
901   /// parsing transaction". It gets instantiated to mark the token position and
902   /// after the token consumption is done, Commit() or Revert() is called to
903   /// either "commit the consumed tokens" or revert to the previously marked
904   /// token position. Example:
905   ///
906   ///   TentativeParsingAction TPA(*this);
907   ///   ConsumeToken();
908   ///   ....
909   ///   TPA.Revert();
910   ///
911   class TentativeParsingAction {
912     Parser &P;
913     PreferredTypeBuilder PrevPreferredType;
914     Token PrevTok;
915     size_t PrevTentativelyDeclaredIdentifierCount;
916     unsigned short PrevParenCount, PrevBracketCount, PrevBraceCount;
917     bool isActive;
918
919   public:
920     explicit TentativeParsingAction(Parser& p) : P(p) {
921       PrevPreferredType = P.PreferredType;
922       PrevTok = P.Tok;
923       PrevTentativelyDeclaredIdentifierCount =
924           P.TentativelyDeclaredIdentifiers.size();
925       PrevParenCount = P.ParenCount;
926       PrevBracketCount = P.BracketCount;
927       PrevBraceCount = P.BraceCount;
928       P.PP.EnableBacktrackAtThisPos();
929       isActive = true;
930     }
931     void Commit() {
932       assert(isActive && "Parsing action was finished!");
933       P.TentativelyDeclaredIdentifiers.resize(
934           PrevTentativelyDeclaredIdentifierCount);
935       P.PP.CommitBacktrackedTokens();
936       isActive = false;
937     }
938     void Revert() {
939       assert(isActive && "Parsing action was finished!");
940       P.PP.Backtrack();
941       P.PreferredType = PrevPreferredType;
942       P.Tok = PrevTok;
943       P.TentativelyDeclaredIdentifiers.resize(
944           PrevTentativelyDeclaredIdentifierCount);
945       P.ParenCount = PrevParenCount;
946       P.BracketCount = PrevBracketCount;
947       P.BraceCount = PrevBraceCount;
948       isActive = false;
949     }
950     ~TentativeParsingAction() {
951       assert(!isActive && "Forgot to call Commit or Revert!");
952     }
953   };
954   /// A TentativeParsingAction that automatically reverts in its destructor.
955   /// Useful for disambiguation parses that will always be reverted.
956   class RevertingTentativeParsingAction
957       : private Parser::TentativeParsingAction {
958   public:
959     RevertingTentativeParsingAction(Parser &P)
960         : Parser::TentativeParsingAction(P) {}
961     ~RevertingTentativeParsingAction() { Revert(); }
962   };
963
964   class UnannotatedTentativeParsingAction;
965
966   /// ObjCDeclContextSwitch - An object used to switch context from
967   /// an objective-c decl context to its enclosing decl context and
968   /// back.
969   class ObjCDeclContextSwitch {
970     Parser &P;
971     Decl *DC;
972     SaveAndRestore<bool> WithinObjCContainer;
973   public:
974     explicit ObjCDeclContextSwitch(Parser &p)
975       : P(p), DC(p.getObjCDeclContext()),
976         WithinObjCContainer(P.ParsingInObjCContainer, DC != nullptr) {
977       if (DC)
978         P.Actions.ActOnObjCTemporaryExitContainerContext(cast<DeclContext>(DC));
979     }
980     ~ObjCDeclContextSwitch() {
981       if (DC)
982         P.Actions.ActOnObjCReenterContainerContext(cast<DeclContext>(DC));
983     }
984   };
985
986   /// ExpectAndConsume - The parser expects that 'ExpectedTok' is next in the
987   /// input.  If so, it is consumed and false is returned.
988   ///
989   /// If a trivial punctuator misspelling is encountered, a FixIt error
990   /// diagnostic is issued and false is returned after recovery.
991   ///
992   /// If the input is malformed, this emits the specified diagnostic and true is
993   /// returned.
994   bool ExpectAndConsume(tok::TokenKind ExpectedTok,
995                         unsigned Diag = diag::err_expected,
996                         StringRef DiagMsg = "");
997
998   /// The parser expects a semicolon and, if present, will consume it.
999   ///
1000   /// If the next token is not a semicolon, this emits the specified diagnostic,
1001   /// or, if there's just some closing-delimiter noise (e.g., ')' or ']') prior
1002   /// to the semicolon, consumes that extra token.
1003   bool ExpectAndConsumeSemi(unsigned DiagID);
1004
1005   /// The kind of extra semi diagnostic to emit.
1006   enum ExtraSemiKind {
1007     OutsideFunction = 0,
1008     InsideStruct = 1,
1009     InstanceVariableList = 2,
1010     AfterMemberFunctionDefinition = 3
1011   };
1012
1013   /// Consume any extra semi-colons until the end of the line.
1014   void ConsumeExtraSemi(ExtraSemiKind Kind, DeclSpec::TST T = TST_unspecified);
1015
1016   /// Return false if the next token is an identifier. An 'expected identifier'
1017   /// error is emitted otherwise.
1018   ///
1019   /// The parser tries to recover from the error by checking if the next token
1020   /// is a C++ keyword when parsing Objective-C++. Return false if the recovery
1021   /// was successful.
1022   bool expectIdentifier();
1023
1024 public:
1025   //===--------------------------------------------------------------------===//
1026   // Scope manipulation
1027
1028   /// ParseScope - Introduces a new scope for parsing. The kind of
1029   /// scope is determined by ScopeFlags. Objects of this type should
1030   /// be created on the stack to coincide with the position where the
1031   /// parser enters the new scope, and this object's constructor will
1032   /// create that new scope. Similarly, once the object is destroyed
1033   /// the parser will exit the scope.
1034   class ParseScope {
1035     Parser *Self;
1036     ParseScope(const ParseScope &) = delete;
1037     void operator=(const ParseScope &) = delete;
1038
1039   public:
1040     // ParseScope - Construct a new object to manage a scope in the
1041     // parser Self where the new Scope is created with the flags
1042     // ScopeFlags, but only when we aren't about to enter a compound statement.
1043     ParseScope(Parser *Self, unsigned ScopeFlags, bool EnteredScope = true,
1044                bool BeforeCompoundStmt = false)
1045       : Self(Self) {
1046       if (EnteredScope && !BeforeCompoundStmt)
1047         Self->EnterScope(ScopeFlags);
1048       else {
1049         if (BeforeCompoundStmt)
1050           Self->incrementMSManglingNumber();
1051
1052         this->Self = nullptr;
1053       }
1054     }
1055
1056     // Exit - Exit the scope associated with this object now, rather
1057     // than waiting until the object is destroyed.
1058     void Exit() {
1059       if (Self) {
1060         Self->ExitScope();
1061         Self = nullptr;
1062       }
1063     }
1064
1065     ~ParseScope() {
1066       Exit();
1067     }
1068   };
1069
1070   /// EnterScope - Start a new scope.
1071   void EnterScope(unsigned ScopeFlags);
1072
1073   /// ExitScope - Pop a scope off the scope stack.
1074   void ExitScope();
1075
1076 private:
1077   /// RAII object used to modify the scope flags for the current scope.
1078   class ParseScopeFlags {
1079     Scope *CurScope;
1080     unsigned OldFlags;
1081     ParseScopeFlags(const ParseScopeFlags &) = delete;
1082     void operator=(const ParseScopeFlags &) = delete;
1083
1084   public:
1085     ParseScopeFlags(Parser *Self, unsigned ScopeFlags, bool ManageFlags = true);
1086     ~ParseScopeFlags();
1087   };
1088
1089   //===--------------------------------------------------------------------===//
1090   // Diagnostic Emission and Error recovery.
1091
1092 public:
1093   DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID);
1094   DiagnosticBuilder Diag(const Token &Tok, unsigned DiagID);
1095   DiagnosticBuilder Diag(unsigned DiagID) {
1096     return Diag(Tok, DiagID);
1097   }
1098
1099 private:
1100   void SuggestParentheses(SourceLocation Loc, unsigned DK,
1101                           SourceRange ParenRange);
1102   void CheckNestedObjCContexts(SourceLocation AtLoc);
1103
1104 public:
1105
1106   /// Control flags for SkipUntil functions.
1107   enum SkipUntilFlags {
1108     StopAtSemi = 1 << 0,  ///< Stop skipping at semicolon
1109     /// Stop skipping at specified token, but don't skip the token itself
1110     StopBeforeMatch = 1 << 1,
1111     StopAtCodeCompletion = 1 << 2 ///< Stop at code completion
1112   };
1113
1114   friend constexpr SkipUntilFlags operator|(SkipUntilFlags L,
1115                                             SkipUntilFlags R) {
1116     return static_cast<SkipUntilFlags>(static_cast<unsigned>(L) |
1117                                        static_cast<unsigned>(R));
1118   }
1119
1120   /// SkipUntil - Read tokens until we get to the specified token, then consume
1121   /// it (unless StopBeforeMatch is specified).  Because we cannot guarantee
1122   /// that the token will ever occur, this skips to the next token, or to some
1123   /// likely good stopping point.  If Flags has StopAtSemi flag, skipping will
1124   /// stop at a ';' character. Balances (), [], and {} delimiter tokens while
1125   /// skipping.
1126   ///
1127   /// If SkipUntil finds the specified token, it returns true, otherwise it
1128   /// returns false.
1129   bool SkipUntil(tok::TokenKind T,
1130                  SkipUntilFlags Flags = static_cast<SkipUntilFlags>(0)) {
1131     return SkipUntil(llvm::makeArrayRef(T), Flags);
1132   }
1133   bool SkipUntil(tok::TokenKind T1, tok::TokenKind T2,
1134                  SkipUntilFlags Flags = static_cast<SkipUntilFlags>(0)) {
1135     tok::TokenKind TokArray[] = {T1, T2};
1136     return SkipUntil(TokArray, Flags);
1137   }
1138   bool SkipUntil(tok::TokenKind T1, tok::TokenKind T2, tok::TokenKind T3,
1139                  SkipUntilFlags Flags = static_cast<SkipUntilFlags>(0)) {
1140     tok::TokenKind TokArray[] = {T1, T2, T3};
1141     return SkipUntil(TokArray, Flags);
1142   }
1143   bool SkipUntil(ArrayRef<tok::TokenKind> Toks,
1144                  SkipUntilFlags Flags = static_cast<SkipUntilFlags>(0));
1145
1146   /// SkipMalformedDecl - Read tokens until we get to some likely good stopping
1147   /// point for skipping past a simple-declaration.
1148   void SkipMalformedDecl();
1149
1150   /// The location of the first statement inside an else that might
1151   /// have a missleading indentation. If there is no
1152   /// MisleadingIndentationChecker on an else active, this location is invalid.
1153   SourceLocation MisleadingIndentationElseLoc;
1154
1155 private:
1156   //===--------------------------------------------------------------------===//
1157   // Lexing and parsing of C++ inline methods.
1158
1159   struct ParsingClass;
1160
1161   /// [class.mem]p1: "... the class is regarded as complete within
1162   /// - function bodies
1163   /// - default arguments
1164   /// - exception-specifications (TODO: C++0x)
1165   /// - and brace-or-equal-initializers for non-static data members
1166   /// (including such things in nested classes)."
1167   /// LateParsedDeclarations build the tree of those elements so they can
1168   /// be parsed after parsing the top-level class.
1169   class LateParsedDeclaration {
1170   public:
1171     virtual ~LateParsedDeclaration();
1172
1173     virtual void ParseLexedMethodDeclarations();
1174     virtual void ParseLexedMemberInitializers();
1175     virtual void ParseLexedMethodDefs();
1176     virtual void ParseLexedAttributes();
1177     virtual void ParseLexedPragmas();
1178   };
1179
1180   /// Inner node of the LateParsedDeclaration tree that parses
1181   /// all its members recursively.
1182   class LateParsedClass : public LateParsedDeclaration {
1183   public:
1184     LateParsedClass(Parser *P, ParsingClass *C);
1185     ~LateParsedClass() override;
1186
1187     void ParseLexedMethodDeclarations() override;
1188     void ParseLexedMemberInitializers() override;
1189     void ParseLexedMethodDefs() override;
1190     void ParseLexedAttributes() override;
1191     void ParseLexedPragmas() override;
1192
1193   private:
1194     Parser *Self;
1195     ParsingClass *Class;
1196   };
1197
1198   /// Contains the lexed tokens of an attribute with arguments that
1199   /// may reference member variables and so need to be parsed at the
1200   /// end of the class declaration after parsing all other member
1201   /// member declarations.
1202   /// FIXME: Perhaps we should change the name of LateParsedDeclaration to
1203   /// LateParsedTokens.
1204   struct LateParsedAttribute : public LateParsedDeclaration {
1205     Parser *Self;
1206     CachedTokens Toks;
1207     IdentifierInfo &AttrName;
1208     IdentifierInfo *MacroII = nullptr;
1209     SourceLocation AttrNameLoc;
1210     SmallVector<Decl*, 2> Decls;
1211
1212     explicit LateParsedAttribute(Parser *P, IdentifierInfo &Name,
1213                                  SourceLocation Loc)
1214       : Self(P), AttrName(Name), AttrNameLoc(Loc) {}
1215
1216     void ParseLexedAttributes() override;
1217
1218     void addDecl(Decl *D) { Decls.push_back(D); }
1219   };
1220
1221   /// Contains the lexed tokens of a pragma with arguments that
1222   /// may reference member variables and so need to be parsed at the
1223   /// end of the class declaration after parsing all other member
1224   /// member declarations.
1225   class LateParsedPragma : public LateParsedDeclaration {
1226     Parser *Self = nullptr;
1227     AccessSpecifier AS = AS_none;
1228     CachedTokens Toks;
1229
1230   public:
1231     explicit LateParsedPragma(Parser *P, AccessSpecifier AS)
1232         : Self(P), AS(AS) {}
1233
1234     void takeToks(CachedTokens &Cached) { Toks.swap(Cached); }
1235     const CachedTokens &toks() const { return Toks; }
1236     AccessSpecifier getAccessSpecifier() const { return AS; }
1237
1238     void ParseLexedPragmas() override;
1239   };
1240
1241   // A list of late-parsed attributes.  Used by ParseGNUAttributes.
1242   class LateParsedAttrList: public SmallVector<LateParsedAttribute *, 2> {
1243   public:
1244     LateParsedAttrList(bool PSoon = false) : ParseSoon(PSoon) { }
1245
1246     bool parseSoon() { return ParseSoon; }
1247
1248   private:
1249     bool ParseSoon;  // Are we planning to parse these shortly after creation?
1250   };
1251
1252   /// Contains the lexed tokens of a member function definition
1253   /// which needs to be parsed at the end of the class declaration
1254   /// after parsing all other member declarations.
1255   struct LexedMethod : public LateParsedDeclaration {
1256     Parser *Self;
1257     Decl *D;
1258     CachedTokens Toks;
1259
1260     /// Whether this member function had an associated template
1261     /// scope. When true, D is a template declaration.
1262     /// otherwise, it is a member function declaration.
1263     bool TemplateScope;
1264
1265     explicit LexedMethod(Parser* P, Decl *MD)
1266       : Self(P), D(MD), TemplateScope(false) {}
1267
1268     void ParseLexedMethodDefs() override;
1269   };
1270
1271   /// LateParsedDefaultArgument - Keeps track of a parameter that may
1272   /// have a default argument that cannot be parsed yet because it
1273   /// occurs within a member function declaration inside the class
1274   /// (C++ [class.mem]p2).
1275   struct LateParsedDefaultArgument {
1276     explicit LateParsedDefaultArgument(Decl *P,
1277                                        std::unique_ptr<CachedTokens> Toks = nullptr)
1278       : Param(P), Toks(std::move(Toks)) { }
1279
1280     /// Param - The parameter declaration for this parameter.
1281     Decl *Param;
1282
1283     /// Toks - The sequence of tokens that comprises the default
1284     /// argument expression, not including the '=' or the terminating
1285     /// ')' or ','. This will be NULL for parameters that have no
1286     /// default argument.
1287     std::unique_ptr<CachedTokens> Toks;
1288   };
1289
1290   /// LateParsedMethodDeclaration - A method declaration inside a class that
1291   /// contains at least one entity whose parsing needs to be delayed
1292   /// until the class itself is completely-defined, such as a default
1293   /// argument (C++ [class.mem]p2).
1294   struct LateParsedMethodDeclaration : public LateParsedDeclaration {
1295     explicit LateParsedMethodDeclaration(Parser *P, Decl *M)
1296       : Self(P), Method(M), TemplateScope(false),
1297         ExceptionSpecTokens(nullptr) {}
1298
1299     void ParseLexedMethodDeclarations() override;
1300
1301     Parser* Self;
1302
1303     /// Method - The method declaration.
1304     Decl *Method;
1305
1306     /// Whether this member function had an associated template
1307     /// scope. When true, D is a template declaration.
1308     /// otherwise, it is a member function declaration.
1309     bool TemplateScope;
1310
1311     /// DefaultArgs - Contains the parameters of the function and
1312     /// their default arguments. At least one of the parameters will
1313     /// have a default argument, but all of the parameters of the
1314     /// method will be stored so that they can be reintroduced into
1315     /// scope at the appropriate times.
1316     SmallVector<LateParsedDefaultArgument, 8> DefaultArgs;
1317
1318     /// The set of tokens that make up an exception-specification that
1319     /// has not yet been parsed.
1320     CachedTokens *ExceptionSpecTokens;
1321   };
1322
1323   /// LateParsedMemberInitializer - An initializer for a non-static class data
1324   /// member whose parsing must to be delayed until the class is completely
1325   /// defined (C++11 [class.mem]p2).
1326   struct LateParsedMemberInitializer : public LateParsedDeclaration {
1327     LateParsedMemberInitializer(Parser *P, Decl *FD)
1328       : Self(P), Field(FD) { }
1329
1330     void ParseLexedMemberInitializers() override;
1331
1332     Parser *Self;
1333
1334     /// Field - The field declaration.
1335     Decl *Field;
1336
1337     /// CachedTokens - The sequence of tokens that comprises the initializer,
1338     /// including any leading '='.
1339     CachedTokens Toks;
1340   };
1341
1342   /// LateParsedDeclarationsContainer - During parsing of a top (non-nested)
1343   /// C++ class, its method declarations that contain parts that won't be
1344   /// parsed until after the definition is completed (C++ [class.mem]p2),
1345   /// the method declarations and possibly attached inline definitions
1346   /// will be stored here with the tokens that will be parsed to create those
1347   /// entities.
1348   typedef SmallVector<LateParsedDeclaration*,2> LateParsedDeclarationsContainer;
1349
1350   /// Representation of a class that has been parsed, including
1351   /// any member function declarations or definitions that need to be
1352   /// parsed after the corresponding top-level class is complete.
1353   struct ParsingClass {
1354     ParsingClass(Decl *TagOrTemplate, bool TopLevelClass, bool IsInterface)
1355       : TopLevelClass(TopLevelClass), TemplateScope(false),
1356         IsInterface(IsInterface), TagOrTemplate(TagOrTemplate) { }
1357
1358     /// Whether this is a "top-level" class, meaning that it is
1359     /// not nested within another class.
1360     bool TopLevelClass : 1;
1361
1362     /// Whether this class had an associated template
1363     /// scope. When true, TagOrTemplate is a template declaration;
1364     /// otherwise, it is a tag declaration.
1365     bool TemplateScope : 1;
1366
1367     /// Whether this class is an __interface.
1368     bool IsInterface : 1;
1369
1370     /// The class or class template whose definition we are parsing.
1371     Decl *TagOrTemplate;
1372
1373     /// LateParsedDeclarations - Method declarations, inline definitions and
1374     /// nested classes that contain pieces whose parsing will be delayed until
1375     /// the top-level class is fully defined.
1376     LateParsedDeclarationsContainer LateParsedDeclarations;
1377   };
1378
1379   /// The stack of classes that is currently being
1380   /// parsed. Nested and local classes will be pushed onto this stack
1381   /// when they are parsed, and removed afterward.
1382   std::stack<ParsingClass *> ClassStack;
1383
1384   ParsingClass &getCurrentClass() {
1385     assert(!ClassStack.empty() && "No lexed method stacks!");
1386     return *ClassStack.top();
1387   }
1388
1389   /// RAII object used to manage the parsing of a class definition.
1390   class ParsingClassDefinition {
1391     Parser &P;
1392     bool Popped;
1393     Sema::ParsingClassState State;
1394
1395   public:
1396     ParsingClassDefinition(Parser &P, Decl *TagOrTemplate, bool TopLevelClass,
1397                            bool IsInterface)
1398       : P(P), Popped(false),
1399         State(P.PushParsingClass(TagOrTemplate, TopLevelClass, IsInterface)) {
1400     }
1401
1402     /// Pop this class of the stack.
1403     void Pop() {
1404       assert(!Popped && "Nested class has already been popped");
1405       Popped = true;
1406       P.PopParsingClass(State);
1407     }
1408
1409     ~ParsingClassDefinition() {
1410       if (!Popped)
1411         P.PopParsingClass(State);
1412     }
1413   };
1414
1415   /// Contains information about any template-specific
1416   /// information that has been parsed prior to parsing declaration
1417   /// specifiers.
1418   struct ParsedTemplateInfo {
1419     ParsedTemplateInfo()
1420       : Kind(NonTemplate), TemplateParams(nullptr), TemplateLoc() { }
1421
1422     ParsedTemplateInfo(TemplateParameterLists *TemplateParams,
1423                        bool isSpecialization,
1424                        bool lastParameterListWasEmpty = false)
1425       : Kind(isSpecialization? ExplicitSpecialization : Template),
1426         TemplateParams(TemplateParams),
1427         LastParameterListWasEmpty(lastParameterListWasEmpty) { }
1428
1429     explicit ParsedTemplateInfo(SourceLocation ExternLoc,
1430                                 SourceLocation TemplateLoc)
1431       : Kind(ExplicitInstantiation), TemplateParams(nullptr),
1432         ExternLoc(ExternLoc), TemplateLoc(TemplateLoc),
1433         LastParameterListWasEmpty(false){ }
1434
1435     /// The kind of template we are parsing.
1436     enum {
1437       /// We are not parsing a template at all.
1438       NonTemplate = 0,
1439       /// We are parsing a template declaration.
1440       Template,
1441       /// We are parsing an explicit specialization.
1442       ExplicitSpecialization,
1443       /// We are parsing an explicit instantiation.
1444       ExplicitInstantiation
1445     } Kind;
1446
1447     /// The template parameter lists, for template declarations
1448     /// and explicit specializations.
1449     TemplateParameterLists *TemplateParams;
1450
1451     /// The location of the 'extern' keyword, if any, for an explicit
1452     /// instantiation
1453     SourceLocation ExternLoc;
1454
1455     /// The location of the 'template' keyword, for an explicit
1456     /// instantiation.
1457     SourceLocation TemplateLoc;
1458
1459     /// Whether the last template parameter list was empty.
1460     bool LastParameterListWasEmpty;
1461
1462     SourceRange getSourceRange() const LLVM_READONLY;
1463   };
1464
1465   void LexTemplateFunctionForLateParsing(CachedTokens &Toks);
1466   void ParseLateTemplatedFuncDef(LateParsedTemplate &LPT);
1467
1468   static void LateTemplateParserCallback(void *P, LateParsedTemplate &LPT);
1469   static void LateTemplateParserCleanupCallback(void *P);
1470
1471   Sema::ParsingClassState
1472   PushParsingClass(Decl *TagOrTemplate, bool TopLevelClass, bool IsInterface);
1473   void DeallocateParsedClasses(ParsingClass *Class);
1474   void PopParsingClass(Sema::ParsingClassState);
1475
1476   enum CachedInitKind {
1477     CIK_DefaultArgument,
1478     CIK_DefaultInitializer
1479   };
1480
1481   NamedDecl *ParseCXXInlineMethodDef(AccessSpecifier AS,
1482                                      ParsedAttributes &AccessAttrs,
1483                                      ParsingDeclarator &D,
1484                                      const ParsedTemplateInfo &TemplateInfo,
1485                                      const VirtSpecifiers &VS,
1486                                      SourceLocation PureSpecLoc);
1487   void ParseCXXNonStaticMemberInitializer(Decl *VarD);
1488   void ParseLexedAttributes(ParsingClass &Class);
1489   void ParseLexedAttributeList(LateParsedAttrList &LAs, Decl *D,
1490                                bool EnterScope, bool OnDefinition);
1491   void ParseLexedAttribute(LateParsedAttribute &LA,
1492                            bool EnterScope, bool OnDefinition);
1493   void ParseLexedMethodDeclarations(ParsingClass &Class);
1494   void ParseLexedMethodDeclaration(LateParsedMethodDeclaration &LM);
1495   void ParseLexedMethodDefs(ParsingClass &Class);
1496   void ParseLexedMethodDef(LexedMethod &LM);
1497   void ParseLexedMemberInitializers(ParsingClass &Class);
1498   void ParseLexedMemberInitializer(LateParsedMemberInitializer &MI);
1499   void ParseLexedObjCMethodDefs(LexedMethod &LM, bool parseMethod);
1500   void ParseLexedPragmas(ParsingClass &Class);
1501   void ParseLexedPragma(LateParsedPragma &LP);
1502   bool ConsumeAndStoreFunctionPrologue(CachedTokens &Toks);
1503   bool ConsumeAndStoreInitializer(CachedTokens &Toks, CachedInitKind CIK);
1504   bool ConsumeAndStoreConditional(CachedTokens &Toks);
1505   bool ConsumeAndStoreUntil(tok::TokenKind T1,
1506                             CachedTokens &Toks,
1507                             bool StopAtSemi = true,
1508                             bool ConsumeFinalToken = true) {
1509     return ConsumeAndStoreUntil(T1, T1, Toks, StopAtSemi, ConsumeFinalToken);
1510   }
1511   bool ConsumeAndStoreUntil(tok::TokenKind T1, tok::TokenKind T2,
1512                             CachedTokens &Toks,
1513                             bool StopAtSemi = true,
1514                             bool ConsumeFinalToken = true);
1515
1516   //===--------------------------------------------------------------------===//
1517   // C99 6.9: External Definitions.
1518   struct ParsedAttributesWithRange : ParsedAttributes {
1519     ParsedAttributesWithRange(AttributeFactory &factory)
1520       : ParsedAttributes(factory) {}
1521
1522     void clear() {
1523       ParsedAttributes::clear();
1524       Range = SourceRange();
1525     }
1526
1527     SourceRange Range;
1528   };
1529   struct ParsedAttributesViewWithRange : ParsedAttributesView {
1530     ParsedAttributesViewWithRange() : ParsedAttributesView() {}
1531     void clearListOnly() {
1532       ParsedAttributesView::clearListOnly();
1533       Range = SourceRange();
1534     }
1535
1536     SourceRange Range;
1537   };
1538
1539   DeclGroupPtrTy ParseExternalDeclaration(ParsedAttributesWithRange &attrs,
1540                                           ParsingDeclSpec *DS = nullptr);
1541   bool isDeclarationAfterDeclarator();
1542   bool isStartOfFunctionDefinition(const ParsingDeclarator &Declarator);
1543   DeclGroupPtrTy ParseDeclarationOrFunctionDefinition(
1544                                                   ParsedAttributesWithRange &attrs,
1545                                                   ParsingDeclSpec *DS = nullptr,
1546                                                   AccessSpecifier AS = AS_none);
1547   DeclGroupPtrTy ParseDeclOrFunctionDefInternal(ParsedAttributesWithRange &attrs,
1548                                                 ParsingDeclSpec &DS,
1549                                                 AccessSpecifier AS);
1550
1551   void SkipFunctionBody();
1552   Decl *ParseFunctionDefinition(ParsingDeclarator &D,
1553                  const ParsedTemplateInfo &TemplateInfo = ParsedTemplateInfo(),
1554                  LateParsedAttrList *LateParsedAttrs = nullptr);
1555   void ParseKNRParamDeclarations(Declarator &D);
1556   // EndLoc is filled with the location of the last token of the simple-asm.
1557   ExprResult ParseSimpleAsm(bool ForAsmLabel, SourceLocation *EndLoc);
1558   ExprResult ParseAsmStringLiteral(bool ForAsmLabel);
1559
1560   // Objective-C External Declarations
1561   void MaybeSkipAttributes(tok::ObjCKeywordKind Kind);
1562   DeclGroupPtrTy ParseObjCAtDirectives(ParsedAttributesWithRange &Attrs);
1563   DeclGroupPtrTy ParseObjCAtClassDeclaration(SourceLocation atLoc);
1564   Decl *ParseObjCAtInterfaceDeclaration(SourceLocation AtLoc,
1565                                         ParsedAttributes &prefixAttrs);
1566   class ObjCTypeParamListScope;
1567   ObjCTypeParamList *parseObjCTypeParamList();
1568   ObjCTypeParamList *parseObjCTypeParamListOrProtocolRefs(
1569       ObjCTypeParamListScope &Scope, SourceLocation &lAngleLoc,
1570       SmallVectorImpl<IdentifierLocPair> &protocolIdents,
1571       SourceLocation &rAngleLoc, bool mayBeProtocolList = true);
1572
1573   void HelperActionsForIvarDeclarations(Decl *interfaceDecl, SourceLocation atLoc,
1574                                         BalancedDelimiterTracker &T,
1575                                         SmallVectorImpl<Decl *> &AllIvarDecls,
1576                                         bool RBraceMissing);
1577   void ParseObjCClassInstanceVariables(Decl *interfaceDecl,
1578                                        tok::ObjCKeywordKind visibility,
1579                                        SourceLocation atLoc);
1580   bool ParseObjCProtocolReferences(SmallVectorImpl<Decl *> &P,
1581                                    SmallVectorImpl<SourceLocation> &PLocs,
1582                                    bool WarnOnDeclarations,
1583                                    bool ForObjCContainer,
1584                                    SourceLocation &LAngleLoc,
1585                                    SourceLocation &EndProtoLoc,
1586                                    bool consumeLastToken);
1587
1588   /// Parse the first angle-bracket-delimited clause for an
1589   /// Objective-C object or object pointer type, which may be either
1590   /// type arguments or protocol qualifiers.
1591   void parseObjCTypeArgsOrProtocolQualifiers(
1592          ParsedType baseType,
1593          SourceLocation &typeArgsLAngleLoc,
1594          SmallVectorImpl<ParsedType> &typeArgs,
1595          SourceLocation &typeArgsRAngleLoc,
1596          SourceLocation &protocolLAngleLoc,
1597          SmallVectorImpl<Decl *> &protocols,
1598          SmallVectorImpl<SourceLocation> &protocolLocs,
1599          SourceLocation &protocolRAngleLoc,
1600          bool consumeLastToken,
1601          bool warnOnIncompleteProtocols);
1602
1603   /// Parse either Objective-C type arguments or protocol qualifiers; if the
1604   /// former, also parse protocol qualifiers afterward.
1605   void parseObjCTypeArgsAndProtocolQualifiers(
1606          ParsedType baseType,
1607          SourceLocation &typeArgsLAngleLoc,
1608          SmallVectorImpl<ParsedType> &typeArgs,
1609          SourceLocation &typeArgsRAngleLoc,
1610          SourceLocation &protocolLAngleLoc,
1611          SmallVectorImpl<Decl *> &protocols,
1612          SmallVectorImpl<SourceLocation> &protocolLocs,
1613          SourceLocation &protocolRAngleLoc,
1614          bool consumeLastToken);
1615
1616   /// Parse a protocol qualifier type such as '<NSCopying>', which is
1617   /// an anachronistic way of writing 'id<NSCopying>'.
1618   TypeResult parseObjCProtocolQualifierType(SourceLocation &rAngleLoc);
1619
1620   /// Parse Objective-C type arguments and protocol qualifiers, extending the
1621   /// current type with the parsed result.
1622   TypeResult parseObjCTypeArgsAndProtocolQualifiers(SourceLocation loc,
1623                                                     ParsedType type,
1624                                                     bool consumeLastToken,
1625                                                     SourceLocation &endLoc);
1626
1627   void ParseObjCInterfaceDeclList(tok::ObjCKeywordKind contextKey,
1628                                   Decl *CDecl);
1629   DeclGroupPtrTy ParseObjCAtProtocolDeclaration(SourceLocation atLoc,
1630                                                 ParsedAttributes &prefixAttrs);
1631
1632   struct ObjCImplParsingDataRAII {
1633     Parser &P;
1634     Decl *Dcl;
1635     bool HasCFunction;
1636     typedef SmallVector<LexedMethod*, 8> LateParsedObjCMethodContainer;
1637     LateParsedObjCMethodContainer LateParsedObjCMethods;
1638
1639     ObjCImplParsingDataRAII(Parser &parser, Decl *D)
1640       : P(parser), Dcl(D), HasCFunction(false) {
1641       P.CurParsedObjCImpl = this;
1642       Finished = false;
1643     }
1644     ~ObjCImplParsingDataRAII();
1645
1646     void finish(SourceRange AtEnd);
1647     bool isFinished() const { return Finished; }
1648
1649   private:
1650     bool Finished;
1651   };
1652   ObjCImplParsingDataRAII *CurParsedObjCImpl;
1653   void StashAwayMethodOrFunctionBodyTokens(Decl *MDecl);
1654
1655   DeclGroupPtrTy ParseObjCAtImplementationDeclaration(SourceLocation AtLoc,
1656                                                       ParsedAttributes &Attrs);
1657   DeclGroupPtrTy ParseObjCAtEndDeclaration(SourceRange atEnd);
1658   Decl *ParseObjCAtAliasDeclaration(SourceLocation atLoc);
1659   Decl *ParseObjCPropertySynthesize(SourceLocation atLoc);
1660   Decl *ParseObjCPropertyDynamic(SourceLocation atLoc);
1661
1662   IdentifierInfo *ParseObjCSelectorPiece(SourceLocation &MethodLocation);
1663   // Definitions for Objective-c context sensitive keywords recognition.
1664   enum ObjCTypeQual {
1665     objc_in=0, objc_out, objc_inout, objc_oneway, objc_bycopy, objc_byref,
1666     objc_nonnull, objc_nullable, objc_null_unspecified,
1667     objc_NumQuals
1668   };
1669   IdentifierInfo *ObjCTypeQuals[objc_NumQuals];
1670
1671   bool isTokIdentifier_in() const;
1672
1673   ParsedType ParseObjCTypeName(ObjCDeclSpec &DS, DeclaratorContext Ctx,
1674                                ParsedAttributes *ParamAttrs);
1675   void ParseObjCMethodRequirement();
1676   Decl *ParseObjCMethodPrototype(
1677             tok::ObjCKeywordKind MethodImplKind = tok::objc_not_keyword,
1678             bool MethodDefinition = true);
1679   Decl *ParseObjCMethodDecl(SourceLocation mLoc, tok::TokenKind mType,
1680             tok::ObjCKeywordKind MethodImplKind = tok::objc_not_keyword,
1681             bool MethodDefinition=true);
1682   void ParseObjCPropertyAttribute(ObjCDeclSpec &DS);
1683
1684   Decl *ParseObjCMethodDefinition();
1685
1686 public:
1687   //===--------------------------------------------------------------------===//
1688   // C99 6.5: Expressions.
1689
1690   /// TypeCastState - State whether an expression is or may be a type cast.
1691   enum TypeCastState {
1692     NotTypeCast = 0,
1693     MaybeTypeCast,
1694     IsTypeCast
1695   };
1696
1697   ExprResult ParseExpression(TypeCastState isTypeCast = NotTypeCast);
1698   ExprResult ParseConstantExpressionInExprEvalContext(
1699       TypeCastState isTypeCast = NotTypeCast);
1700   ExprResult ParseConstantExpression(TypeCastState isTypeCast = NotTypeCast);
1701   ExprResult ParseCaseExpression(SourceLocation CaseLoc);
1702   ExprResult ParseConstraintExpression();
1703   ExprResult
1704   ParseConstraintLogicalAndExpression(bool IsTrailingRequiresClause);
1705   ExprResult ParseConstraintLogicalOrExpression(bool IsTrailingRequiresClause);
1706   // Expr that doesn't include commas.
1707   ExprResult ParseAssignmentExpression(TypeCastState isTypeCast = NotTypeCast);
1708
1709   ExprResult ParseMSAsmIdentifier(llvm::SmallVectorImpl<Token> &LineToks,
1710                                   unsigned &NumLineToksConsumed,
1711                                   bool IsUnevaluated);
1712
1713   ExprResult ParseStringLiteralExpression(bool AllowUserDefinedLiteral = false);
1714
1715 private:
1716   ExprResult ParseExpressionWithLeadingAt(SourceLocation AtLoc);
1717
1718   ExprResult ParseExpressionWithLeadingExtension(SourceLocation ExtLoc);
1719
1720   ExprResult ParseRHSOfBinaryExpression(ExprResult LHS,
1721                                         prec::Level MinPrec);
1722   /// Control what ParseCastExpression will parse.
1723   enum CastParseKind {
1724     AnyCastExpr = 0,
1725     UnaryExprOnly,
1726     PrimaryExprOnly
1727   };
1728   ExprResult ParseCastExpression(CastParseKind ParseKind,
1729                                  bool isAddressOfOperand,
1730                                  bool &NotCastExpr,
1731                                  TypeCastState isTypeCast,
1732                                  bool isVectorLiteral = false,
1733                                  bool *NotPrimaryExpression = nullptr);
1734   ExprResult ParseCastExpression(CastParseKind ParseKind,
1735                                  bool isAddressOfOperand = false,
1736                                  TypeCastState isTypeCast = NotTypeCast,
1737                                  bool isVectorLiteral = false,
1738                                  bool *NotPrimaryExpression = nullptr);
1739
1740   /// Returns true if the next token cannot start an expression.
1741   bool isNotExpressionStart();
1742
1743   /// Returns true if the next token would start a postfix-expression
1744   /// suffix.
1745   bool isPostfixExpressionSuffixStart() {
1746     tok::TokenKind K = Tok.getKind();
1747     return (K == tok::l_square || K == tok::l_paren ||
1748             K == tok::period || K == tok::arrow ||
1749             K == tok::plusplus || K == tok::minusminus);
1750   }
1751
1752   bool diagnoseUnknownTemplateId(ExprResult TemplateName, SourceLocation Less);
1753   void checkPotentialAngleBracket(ExprResult &PotentialTemplateName);
1754   bool checkPotentialAngleBracketDelimiter(const AngleBracketTracker::Loc &,
1755                                            const Token &OpToken);
1756   bool checkPotentialAngleBracketDelimiter(const Token &OpToken) {
1757     if (auto *Info = AngleBrackets.getCurrent(*this))
1758       return checkPotentialAngleBracketDelimiter(*Info, OpToken);
1759     return false;
1760   }
1761
1762   ExprResult ParsePostfixExpressionSuffix(ExprResult LHS);
1763   ExprResult ParseUnaryExprOrTypeTraitExpression();
1764   ExprResult ParseBuiltinPrimaryExpression();
1765   ExprResult ParseUniqueStableNameExpression();
1766
1767   ExprResult ParseExprAfterUnaryExprOrTypeTrait(const Token &OpTok,
1768                                                      bool &isCastExpr,
1769                                                      ParsedType &CastTy,
1770                                                      SourceRange &CastRange);
1771
1772   typedef SmallVector<Expr*, 20> ExprListTy;
1773   typedef SmallVector<SourceLocation, 20> CommaLocsTy;
1774
1775   /// ParseExpressionList - Used for C/C++ (argument-)expression-list.
1776   bool ParseExpressionList(SmallVectorImpl<Expr *> &Exprs,
1777                            SmallVectorImpl<SourceLocation> &CommaLocs,
1778                            llvm::function_ref<void()> ExpressionStarts =
1779                                llvm::function_ref<void()>());
1780
1781   /// ParseSimpleExpressionList - A simple comma-separated list of expressions,
1782   /// used for misc language extensions.
1783   bool ParseSimpleExpressionList(SmallVectorImpl<Expr*> &Exprs,
1784                                  SmallVectorImpl<SourceLocation> &CommaLocs);
1785
1786
1787   /// ParenParseOption - Control what ParseParenExpression will parse.
1788   enum ParenParseOption {
1789     SimpleExpr,      // Only parse '(' expression ')'
1790     FoldExpr,        // Also allow fold-expression <anything>
1791     CompoundStmt,    // Also allow '(' compound-statement ')'
1792     CompoundLiteral, // Also allow '(' type-name ')' '{' ... '}'
1793     CastExpr         // Also allow '(' type-name ')' <anything>
1794   };
1795   ExprResult ParseParenExpression(ParenParseOption &ExprType,
1796                                         bool stopIfCastExpr,
1797                                         bool isTypeCast,
1798                                         ParsedType &CastTy,
1799                                         SourceLocation &RParenLoc);
1800
1801   ExprResult ParseCXXAmbiguousParenExpression(
1802       ParenParseOption &ExprType, ParsedType &CastTy,
1803       BalancedDelimiterTracker &Tracker, ColonProtectionRAIIObject &ColonProt);
1804   ExprResult ParseCompoundLiteralExpression(ParsedType Ty,
1805                                                   SourceLocation LParenLoc,
1806                                                   SourceLocation RParenLoc);
1807
1808   ExprResult ParseGenericSelectionExpression();
1809
1810   ExprResult ParseObjCBoolLiteral();
1811
1812   ExprResult ParseFoldExpression(ExprResult LHS, BalancedDelimiterTracker &T);
1813
1814   //===--------------------------------------------------------------------===//
1815   // C++ Expressions
1816   ExprResult tryParseCXXIdExpression(CXXScopeSpec &SS, bool isAddressOfOperand,
1817                                      Token &Replacement);
1818   ExprResult ParseCXXIdExpression(bool isAddressOfOperand = false);
1819
1820   bool areTokensAdjacent(const Token &A, const Token &B);
1821
1822   void CheckForTemplateAndDigraph(Token &Next, ParsedType ObjectTypePtr,
1823                                   bool EnteringContext, IdentifierInfo &II,
1824                                   CXXScopeSpec &SS);
1825
1826   bool ParseOptionalCXXScopeSpecifier(CXXScopeSpec &SS,
1827                                       ParsedType ObjectType,
1828                                       bool ObjectHasErrors,
1829                                       bool EnteringContext,
1830                                       bool *MayBePseudoDestructor = nullptr,
1831                                       bool IsTypename = false,
1832                                       IdentifierInfo **LastII = nullptr,
1833                                       bool OnlyNamespace = false,
1834                                       bool InUsingDeclaration = false);
1835
1836   //===--------------------------------------------------------------------===//
1837   // C++11 5.1.2: Lambda expressions
1838
1839   /// Result of tentatively parsing a lambda-introducer.
1840   enum class LambdaIntroducerTentativeParse {
1841     /// This appears to be a lambda-introducer, which has been fully parsed.
1842     Success,
1843     /// This is a lambda-introducer, but has not been fully parsed, and this
1844     /// function needs to be called again to parse it.
1845     Incomplete,
1846     /// This is definitely an Objective-C message send expression, rather than
1847     /// a lambda-introducer, attribute-specifier, or array designator.
1848     MessageSend,
1849     /// This is not a lambda-introducer.
1850     Invalid,
1851   };
1852
1853   // [...] () -> type {...}
1854   ExprResult ParseLambdaExpression();
1855   ExprResult TryParseLambdaExpression();
1856   bool
1857   ParseLambdaIntroducer(LambdaIntroducer &Intro,
1858                         LambdaIntroducerTentativeParse *Tentative = nullptr);
1859   ExprResult ParseLambdaExpressionAfterIntroducer(LambdaIntroducer &Intro);
1860
1861   //===--------------------------------------------------------------------===//
1862   // C++ 5.2p1: C++ Casts
1863   ExprResult ParseCXXCasts();
1864
1865   /// Parse a __builtin_bit_cast(T, E), used to implement C++2a std::bit_cast.
1866   ExprResult ParseBuiltinBitCast();
1867
1868   //===--------------------------------------------------------------------===//
1869   // C++ 5.2p1: C++ Type Identification
1870   ExprResult ParseCXXTypeid();
1871
1872   //===--------------------------------------------------------------------===//
1873   //  C++ : Microsoft __uuidof Expression
1874   ExprResult ParseCXXUuidof();
1875
1876   //===--------------------------------------------------------------------===//
1877   // C++ 5.2.4: C++ Pseudo-Destructor Expressions
1878   ExprResult ParseCXXPseudoDestructor(Expr *Base, SourceLocation OpLoc,
1879                                             tok::TokenKind OpKind,
1880                                             CXXScopeSpec &SS,
1881                                             ParsedType ObjectType);
1882
1883   //===--------------------------------------------------------------------===//
1884   // C++ 9.3.2: C++ 'this' pointer
1885   ExprResult ParseCXXThis();
1886
1887   //===--------------------------------------------------------------------===//
1888   // C++ 15: C++ Throw Expression
1889   ExprResult ParseThrowExpression();
1890
1891   ExceptionSpecificationType tryParseExceptionSpecification(
1892                     bool Delayed,
1893                     SourceRange &SpecificationRange,
1894                     SmallVectorImpl<ParsedType> &DynamicExceptions,
1895                     SmallVectorImpl<SourceRange> &DynamicExceptionRanges,
1896                     ExprResult &NoexceptExpr,
1897                     CachedTokens *&ExceptionSpecTokens);
1898
1899   // EndLoc is filled with the location of the last token of the specification.
1900   ExceptionSpecificationType ParseDynamicExceptionSpecification(
1901                                   SourceRange &SpecificationRange,
1902                                   SmallVectorImpl<ParsedType> &Exceptions,
1903                                   SmallVectorImpl<SourceRange> &Ranges);
1904
1905   //===--------------------------------------------------------------------===//
1906   // C++0x 8: Function declaration trailing-return-type
1907   TypeResult ParseTrailingReturnType(SourceRange &Range,
1908                                      bool MayBeFollowedByDirectInit);
1909
1910   //===--------------------------------------------------------------------===//
1911   // C++ 2.13.5: C++ Boolean Literals
1912   ExprResult ParseCXXBoolLiteral();
1913
1914   //===--------------------------------------------------------------------===//
1915   // C++ 5.2.3: Explicit type conversion (functional notation)
1916   ExprResult ParseCXXTypeConstructExpression(const DeclSpec &DS);
1917
1918   /// ParseCXXSimpleTypeSpecifier - [C++ 7.1.5.2] Simple type specifiers.
1919   /// This should only be called when the current token is known to be part of
1920   /// simple-type-specifier.
1921   void ParseCXXSimpleTypeSpecifier(DeclSpec &DS);
1922
1923   bool ParseCXXTypeSpecifierSeq(DeclSpec &DS);
1924
1925   //===--------------------------------------------------------------------===//
1926   // C++ 5.3.4 and 5.3.5: C++ new and delete
1927   bool ParseExpressionListOrTypeId(SmallVectorImpl<Expr*> &Exprs,
1928                                    Declarator &D);
1929   void ParseDirectNewDeclarator(Declarator &D);
1930   ExprResult ParseCXXNewExpression(bool UseGlobal, SourceLocation Start);
1931   ExprResult ParseCXXDeleteExpression(bool UseGlobal,
1932                                             SourceLocation Start);
1933
1934   //===--------------------------------------------------------------------===//
1935   // C++ if/switch/while/for condition expression.
1936   struct ForRangeInfo;
1937   Sema::ConditionResult ParseCXXCondition(StmtResult *InitStmt,
1938                                           SourceLocation Loc,
1939                                           Sema::ConditionKind CK,
1940                                           ForRangeInfo *FRI = nullptr);
1941
1942   //===--------------------------------------------------------------------===//
1943   // C++ Coroutines
1944
1945   ExprResult ParseCoyieldExpression();
1946
1947   //===--------------------------------------------------------------------===//
1948   // C++ Concepts
1949
1950   ExprResult ParseRequiresExpression();
1951   void ParseTrailingRequiresClause(Declarator &D);
1952
1953   //===--------------------------------------------------------------------===//
1954   // C99 6.7.8: Initialization.
1955
1956   /// ParseInitializer
1957   ///       initializer: [C99 6.7.8]
1958   ///         assignment-expression
1959   ///         '{' ...
1960   ExprResult ParseInitializer() {
1961     if (Tok.isNot(tok::l_brace))
1962       return ParseAssignmentExpression();
1963     return ParseBraceInitializer();
1964   }
1965   bool MayBeDesignationStart();
1966   ExprResult ParseBraceInitializer();
1967   ExprResult ParseInitializerWithPotentialDesignator(
1968       llvm::function_ref<void(const Designation &)> CodeCompleteCB);
1969
1970   //===--------------------------------------------------------------------===//
1971   // clang Expressions
1972
1973   ExprResult ParseBlockLiteralExpression();  // ^{...}
1974
1975   //===--------------------------------------------------------------------===//
1976   // Objective-C Expressions
1977   ExprResult ParseObjCAtExpression(SourceLocation AtLocation);
1978   ExprResult ParseObjCStringLiteral(SourceLocation AtLoc);
1979   ExprResult ParseObjCCharacterLiteral(SourceLocation AtLoc);
1980   ExprResult ParseObjCNumericLiteral(SourceLocation AtLoc);
1981   ExprResult ParseObjCBooleanLiteral(SourceLocation AtLoc, bool ArgValue);
1982   ExprResult ParseObjCArrayLiteral(SourceLocation AtLoc);
1983   ExprResult ParseObjCDictionaryLiteral(SourceLocation AtLoc);
1984   ExprResult ParseObjCBoxedExpr(SourceLocation AtLoc);
1985   ExprResult ParseObjCEncodeExpression(SourceLocation AtLoc);
1986   ExprResult ParseObjCSelectorExpression(SourceLocation AtLoc);
1987   ExprResult ParseObjCProtocolExpression(SourceLocation AtLoc);
1988   bool isSimpleObjCMessageExpression();
1989   ExprResult ParseObjCMessageExpression();
1990   ExprResult ParseObjCMessageExpressionBody(SourceLocation LBracloc,
1991                                             SourceLocation SuperLoc,
1992                                             ParsedType ReceiverType,
1993                                             Expr *ReceiverExpr);
1994   ExprResult ParseAssignmentExprWithObjCMessageExprStart(
1995       SourceLocation LBracloc, SourceLocation SuperLoc,
1996       ParsedType ReceiverType, Expr *ReceiverExpr);
1997   bool ParseObjCXXMessageReceiver(bool &IsExpr, void *&TypeOrExpr);
1998
1999   //===--------------------------------------------------------------------===//
2000   // C99 6.8: Statements and Blocks.
2001
2002   /// A SmallVector of statements, with stack size 32 (as that is the only one
2003   /// used.)
2004   typedef SmallVector<Stmt*, 32> StmtVector;
2005   /// A SmallVector of expressions, with stack size 12 (the maximum used.)
2006   typedef SmallVector<Expr*, 12> ExprVector;
2007   /// A SmallVector of types.
2008   typedef SmallVector<ParsedType, 12> TypeVector;
2009
2010   StmtResult
2011   ParseStatement(SourceLocation *TrailingElseLoc = nullptr,
2012                  ParsedStmtContext StmtCtx = ParsedStmtContext::SubStmt);
2013   StmtResult ParseStatementOrDeclaration(
2014       StmtVector &Stmts, ParsedStmtContext StmtCtx,
2015       SourceLocation *TrailingElseLoc = nullptr);
2016   StmtResult ParseStatementOrDeclarationAfterAttributes(
2017                                          StmtVector &Stmts,
2018                                          ParsedStmtContext StmtCtx,
2019                                          SourceLocation *TrailingElseLoc,
2020                                          ParsedAttributesWithRange &Attrs);
2021   StmtResult ParseExprStatement(ParsedStmtContext StmtCtx);
2022   StmtResult ParseLabeledStatement(ParsedAttributesWithRange &attrs,
2023                                    ParsedStmtContext StmtCtx);
2024   StmtResult ParseCaseStatement(ParsedStmtContext StmtCtx,
2025                                 bool MissingCase = false,
2026                                 ExprResult Expr = ExprResult());
2027   StmtResult ParseDefaultStatement(ParsedStmtContext StmtCtx);
2028   StmtResult ParseCompoundStatement(bool isStmtExpr = false);
2029   StmtResult ParseCompoundStatement(bool isStmtExpr,
2030                                     unsigned ScopeFlags);
2031   void ParseCompoundStatementLeadingPragmas();
2032   bool ConsumeNullStmt(StmtVector &Stmts);
2033   StmtResult ParseCompoundStatementBody(bool isStmtExpr = false);
2034   bool ParseParenExprOrCondition(StmtResult *InitStmt,
2035                                  Sema::ConditionResult &CondResult,
2036                                  SourceLocation Loc,
2037                                  Sema::ConditionKind CK);
2038   StmtResult ParseIfStatement(SourceLocation *TrailingElseLoc);
2039   StmtResult ParseSwitchStatement(SourceLocation *TrailingElseLoc);
2040   StmtResult ParseWhileStatement(SourceLocation *TrailingElseLoc);
2041   StmtResult ParseDoStatement();
2042   StmtResult ParseForStatement(SourceLocation *TrailingElseLoc);
2043   StmtResult ParseGotoStatement();
2044   StmtResult ParseContinueStatement();
2045   StmtResult ParseBreakStatement();
2046   StmtResult ParseReturnStatement();
2047   StmtResult ParseAsmStatement(bool &msAsm);
2048   StmtResult ParseMicrosoftAsmStatement(SourceLocation AsmLoc);
2049   StmtResult ParsePragmaLoopHint(StmtVector &Stmts,
2050                                  ParsedStmtContext StmtCtx,
2051                                  SourceLocation *TrailingElseLoc,
2052                                  ParsedAttributesWithRange &Attrs);
2053
2054   /// Describes the behavior that should be taken for an __if_exists
2055   /// block.
2056   enum IfExistsBehavior {
2057     /// Parse the block; this code is always used.
2058     IEB_Parse,
2059     /// Skip the block entirely; this code is never used.
2060     IEB_Skip,
2061     /// Parse the block as a dependent block, which may be used in
2062     /// some template instantiations but not others.
2063     IEB_Dependent
2064   };
2065
2066   /// Describes the condition of a Microsoft __if_exists or
2067   /// __if_not_exists block.
2068   struct IfExistsCondition {
2069     /// The location of the initial keyword.
2070     SourceLocation KeywordLoc;
2071     /// Whether this is an __if_exists block (rather than an
2072     /// __if_not_exists block).
2073     bool IsIfExists;
2074
2075     /// Nested-name-specifier preceding the name.
2076     CXXScopeSpec SS;
2077
2078     /// The name we're looking for.
2079     UnqualifiedId Name;
2080
2081     /// The behavior of this __if_exists or __if_not_exists block
2082     /// should.
2083     IfExistsBehavior Behavior;
2084   };
2085
2086   bool ParseMicrosoftIfExistsCondition(IfExistsCondition& Result);
2087   void ParseMicrosoftIfExistsStatement(StmtVector &Stmts);
2088   void ParseMicrosoftIfExistsExternalDeclaration();
2089   void ParseMicrosoftIfExistsClassDeclaration(DeclSpec::TST TagType,
2090                                               ParsedAttributes &AccessAttrs,
2091                                               AccessSpecifier &CurAS);
2092   bool ParseMicrosoftIfExistsBraceInitializer(ExprVector &InitExprs,
2093                                               bool &InitExprsOk);
2094   bool ParseAsmOperandsOpt(SmallVectorImpl<IdentifierInfo *> &Names,
2095                            SmallVectorImpl<Expr *> &Constraints,
2096                            SmallVectorImpl<Expr *> &Exprs);
2097
2098   //===--------------------------------------------------------------------===//
2099   // C++ 6: Statements and Blocks
2100
2101   StmtResult ParseCXXTryBlock();
2102   StmtResult ParseCXXTryBlockCommon(SourceLocation TryLoc, bool FnTry = false);
2103   StmtResult ParseCXXCatchBlock(bool FnCatch = false);
2104
2105   //===--------------------------------------------------------------------===//
2106   // MS: SEH Statements and Blocks
2107
2108   StmtResult ParseSEHTryBlock();
2109   StmtResult ParseSEHExceptBlock(SourceLocation Loc);
2110   StmtResult ParseSEHFinallyBlock(SourceLocation Loc);
2111   StmtResult ParseSEHLeaveStatement();
2112
2113   //===--------------------------------------------------------------------===//
2114   // Objective-C Statements
2115
2116   StmtResult ParseObjCAtStatement(SourceLocation atLoc,
2117                                   ParsedStmtContext StmtCtx);
2118   StmtResult ParseObjCTryStmt(SourceLocation atLoc);
2119   StmtResult ParseObjCThrowStmt(SourceLocation atLoc);
2120   StmtResult ParseObjCSynchronizedStmt(SourceLocation atLoc);
2121   StmtResult ParseObjCAutoreleasePoolStmt(SourceLocation atLoc);
2122
2123
2124   //===--------------------------------------------------------------------===//
2125   // C99 6.7: Declarations.
2126
2127   /// A context for parsing declaration specifiers.  TODO: flesh this
2128   /// out, there are other significant restrictions on specifiers than
2129   /// would be best implemented in the parser.
2130   enum class DeclSpecContext {
2131     DSC_normal, // normal context
2132     DSC_class,  // class context, enables 'friend'
2133     DSC_type_specifier, // C++ type-specifier-seq or C specifier-qualifier-list
2134     DSC_trailing, // C++11 trailing-type-specifier in a trailing return type
2135     DSC_alias_declaration, // C++11 type-specifier-seq in an alias-declaration
2136     DSC_top_level, // top-level/namespace declaration context
2137     DSC_template_param, // template parameter context
2138     DSC_template_type_arg, // template type argument context
2139     DSC_objc_method_result, // ObjC method result context, enables 'instancetype'
2140     DSC_condition // condition declaration context
2141   };
2142
2143   /// Is this a context in which we are parsing just a type-specifier (or
2144   /// trailing-type-specifier)?
2145   static bool isTypeSpecifier(DeclSpecContext DSC) {
2146     switch (DSC) {
2147     case DeclSpecContext::DSC_normal:
2148     case DeclSpecContext::DSC_template_param:
2149     case DeclSpecContext::DSC_class:
2150     case DeclSpecContext::DSC_top_level:
2151     case DeclSpecContext::DSC_objc_method_result:
2152     case DeclSpecContext::DSC_condition:
2153       return false;
2154
2155     case DeclSpecContext::DSC_template_type_arg:
2156     case DeclSpecContext::DSC_type_specifier:
2157     case DeclSpecContext::DSC_trailing:
2158     case DeclSpecContext::DSC_alias_declaration:
2159       return true;
2160     }
2161     llvm_unreachable("Missing DeclSpecContext case");
2162   }
2163
2164   /// Is this a context in which we can perform class template argument
2165   /// deduction?
2166   static bool isClassTemplateDeductionContext(DeclSpecContext DSC) {
2167     switch (DSC) {
2168     case DeclSpecContext::DSC_normal:
2169     case DeclSpecContext::DSC_template_param:
2170     case DeclSpecContext::DSC_class:
2171     case DeclSpecContext::DSC_top_level:
2172     case DeclSpecContext::DSC_condition:
2173     case DeclSpecContext::DSC_type_specifier:
2174       return true;
2175
2176     case DeclSpecContext::DSC_objc_method_result:
2177     case DeclSpecContext::DSC_template_type_arg:
2178     case DeclSpecContext::DSC_trailing:
2179     case DeclSpecContext::DSC_alias_declaration:
2180       return false;
2181     }
2182     llvm_unreachable("Missing DeclSpecContext case");
2183   }
2184
2185   /// Information on a C++0x for-range-initializer found while parsing a
2186   /// declaration which turns out to be a for-range-declaration.
2187   struct ForRangeInit {
2188     SourceLocation ColonLoc;
2189     ExprResult RangeExpr;
2190
2191     bool ParsedForRangeDecl() { return !ColonLoc.isInvalid(); }
2192   };
2193   struct ForRangeInfo : ForRangeInit {
2194     StmtResult LoopVar;
2195   };
2196
2197   DeclGroupPtrTy ParseDeclaration(DeclaratorContext Context,
2198                                   SourceLocation &DeclEnd,
2199                                   ParsedAttributesWithRange &attrs,
2200                                   SourceLocation *DeclSpecStart = nullptr);
2201   DeclGroupPtrTy
2202   ParseSimpleDeclaration(DeclaratorContext Context, SourceLocation &DeclEnd,
2203                          ParsedAttributesWithRange &attrs, bool RequireSemi,
2204                          ForRangeInit *FRI = nullptr,
2205                          SourceLocation *DeclSpecStart = nullptr);
2206   bool MightBeDeclarator(DeclaratorContext Context);
2207   DeclGroupPtrTy ParseDeclGroup(ParsingDeclSpec &DS, DeclaratorContext Context,
2208                                 SourceLocation *DeclEnd = nullptr,
2209                                 ForRangeInit *FRI = nullptr);
2210   Decl *ParseDeclarationAfterDeclarator(Declarator &D,
2211                const ParsedTemplateInfo &TemplateInfo = ParsedTemplateInfo());
2212   bool ParseAsmAttributesAfterDeclarator(Declarator &D);
2213   Decl *ParseDeclarationAfterDeclaratorAndAttributes(
2214       Declarator &D,
2215       const ParsedTemplateInfo &TemplateInfo = ParsedTemplateInfo(),
2216       ForRangeInit *FRI = nullptr);
2217   Decl *ParseFunctionStatementBody(Decl *Decl, ParseScope &BodyScope);
2218   Decl *ParseFunctionTryBlock(Decl *Decl, ParseScope &BodyScope);
2219
2220   /// When in code-completion, skip parsing of the function/method body
2221   /// unless the body contains the code-completion point.
2222   ///
2223   /// \returns true if the function body was skipped.
2224   bool trySkippingFunctionBody();
2225
2226   bool ParseImplicitInt(DeclSpec &DS, CXXScopeSpec *SS,
2227                         const ParsedTemplateInfo &TemplateInfo,
2228                         AccessSpecifier AS, DeclSpecContext DSC,
2229                         ParsedAttributesWithRange &Attrs);
2230   DeclSpecContext
2231   getDeclSpecContextFromDeclaratorContext(DeclaratorContext Context);
2232   void ParseDeclarationSpecifiers(
2233       DeclSpec &DS,
2234       const ParsedTemplateInfo &TemplateInfo = ParsedTemplateInfo(),
2235       AccessSpecifier AS = AS_none,
2236       DeclSpecContext DSC = DeclSpecContext::DSC_normal,
2237       LateParsedAttrList *LateAttrs = nullptr);
2238   bool DiagnoseMissingSemiAfterTagDefinition(
2239       DeclSpec &DS, AccessSpecifier AS, DeclSpecContext DSContext,
2240       LateParsedAttrList *LateAttrs = nullptr);
2241
2242   void ParseSpecifierQualifierList(
2243       DeclSpec &DS, AccessSpecifier AS = AS_none,
2244       DeclSpecContext DSC = DeclSpecContext::DSC_normal);
2245
2246   void ParseObjCTypeQualifierList(ObjCDeclSpec &DS,
2247                                   DeclaratorContext Context);
2248
2249   void ParseEnumSpecifier(SourceLocation TagLoc, DeclSpec &DS,
2250                           const ParsedTemplateInfo &TemplateInfo,
2251                           AccessSpecifier AS, DeclSpecContext DSC);
2252   void ParseEnumBody(SourceLocation StartLoc, Decl *TagDecl);
2253   void ParseStructUnionBody(SourceLocation StartLoc, DeclSpec::TST TagType,
2254                             Decl *TagDecl);
2255
2256   void ParseStructDeclaration(
2257       ParsingDeclSpec &DS,
2258       llvm::function_ref<void(ParsingFieldDeclarator &)> FieldsCallback);
2259
2260   bool isDeclarationSpecifier(bool DisambiguatingWithExpression = false);
2261   bool isTypeSpecifierQualifier();
2262
2263   /// isKnownToBeTypeSpecifier - Return true if we know that the specified token
2264   /// is definitely a type-specifier.  Return false if it isn't part of a type
2265   /// specifier or if we're not sure.
2266   bool isKnownToBeTypeSpecifier(const Token &Tok) const;
2267
2268   /// Return true if we know that we are definitely looking at a
2269   /// decl-specifier, and isn't part of an expression such as a function-style
2270   /// cast. Return false if it's no a decl-specifier, or we're not sure.
2271   bool isKnownToBeDeclarationSpecifier() {
2272     if (getLangOpts().CPlusPlus)
2273       return isCXXDeclarationSpecifier() == TPResult::True;
2274     return isDeclarationSpecifier(true);
2275   }
2276
2277   /// isDeclarationStatement - Disambiguates between a declaration or an
2278   /// expression statement, when parsing function bodies.
2279   /// Returns true for declaration, false for expression.
2280   bool isDeclarationStatement() {
2281     if (getLangOpts().CPlusPlus)
2282       return isCXXDeclarationStatement();
2283     return isDeclarationSpecifier(true);
2284   }
2285
2286   /// isForInitDeclaration - Disambiguates between a declaration or an
2287   /// expression in the context of the C 'clause-1' or the C++
2288   // 'for-init-statement' part of a 'for' statement.
2289   /// Returns true for declaration, false for expression.
2290   bool isForInitDeclaration() {
2291     if (getLangOpts().OpenMP)
2292       Actions.startOpenMPLoop();
2293     if (getLangOpts().CPlusPlus)
2294       return isCXXSimpleDeclaration(/*AllowForRangeDecl=*/true);
2295     return isDeclarationSpecifier(true);
2296   }
2297
2298   /// Determine whether this is a C++1z for-range-identifier.
2299   bool isForRangeIdentifier();
2300
2301   /// Determine whether we are currently at the start of an Objective-C
2302   /// class message that appears to be missing the open bracket '['.
2303   bool isStartOfObjCClassMessageMissingOpenBracket();
2304
2305   /// Starting with a scope specifier, identifier, or
2306   /// template-id that refers to the current class, determine whether
2307   /// this is a constructor declarator.
2308   bool isConstructorDeclarator(bool Unqualified, bool DeductionGuide = false);
2309
2310   /// Specifies the context in which type-id/expression
2311   /// disambiguation will occur.
2312   enum TentativeCXXTypeIdContext {
2313     TypeIdInParens,
2314     TypeIdUnambiguous,
2315     TypeIdAsTemplateArgument
2316   };
2317
2318
2319   /// isTypeIdInParens - Assumes that a '(' was parsed and now we want to know
2320   /// whether the parens contain an expression or a type-id.
2321   /// Returns true for a type-id and false for an expression.
2322   bool isTypeIdInParens(bool &isAmbiguous) {
2323     if (getLangOpts().CPlusPlus)
2324       return isCXXTypeId(TypeIdInParens, isAmbiguous);
2325     isAmbiguous = false;
2326     return isTypeSpecifierQualifier();
2327   }
2328   bool isTypeIdInParens() {
2329     bool isAmbiguous;
2330     return isTypeIdInParens(isAmbiguous);
2331   }
2332
2333   /// Checks if the current tokens form type-id or expression.
2334   /// It is similar to isTypeIdInParens but does not suppose that type-id
2335   /// is in parenthesis.
2336   bool isTypeIdUnambiguously() {
2337     bool IsAmbiguous;
2338     if (getLangOpts().CPlusPlus)
2339       return isCXXTypeId(TypeIdUnambiguous, IsAmbiguous);
2340     return isTypeSpecifierQualifier();
2341   }
2342
2343   /// isCXXDeclarationStatement - C++-specialized function that disambiguates
2344   /// between a declaration or an expression statement, when parsing function
2345   /// bodies. Returns true for declaration, false for expression.
2346   bool isCXXDeclarationStatement();
2347
2348   /// isCXXSimpleDeclaration - C++-specialized function that disambiguates
2349   /// between a simple-declaration or an expression-statement.
2350   /// If during the disambiguation process a parsing error is encountered,
2351   /// the function returns true to let the declaration parsing code handle it.
2352   /// Returns false if the statement is disambiguated as expression.
2353   bool isCXXSimpleDeclaration(bool AllowForRangeDecl);
2354
2355   /// isCXXFunctionDeclarator - Disambiguates between a function declarator or
2356   /// a constructor-style initializer, when parsing declaration statements.
2357   /// Returns true for function declarator and false for constructor-style
2358   /// initializer. Sets 'IsAmbiguous' to true to indicate that this declaration
2359   /// might be a constructor-style initializer.
2360   /// If during the disambiguation process a parsing error is encountered,
2361   /// the function returns true to let the declaration parsing code handle it.
2362   bool isCXXFunctionDeclarator(bool *IsAmbiguous = nullptr);
2363
2364   struct ConditionDeclarationOrInitStatementState;
2365   enum class ConditionOrInitStatement {
2366     Expression,    ///< Disambiguated as an expression (either kind).
2367     ConditionDecl, ///< Disambiguated as the declaration form of condition.
2368     InitStmtDecl,  ///< Disambiguated as a simple-declaration init-statement.
2369     ForRangeDecl,  ///< Disambiguated as a for-range declaration.
2370     Error          ///< Can't be any of the above!
2371   };
2372   /// Disambiguates between the different kinds of things that can happen
2373   /// after 'if (' or 'switch ('. This could be one of two different kinds of
2374   /// declaration (depending on whether there is a ';' later) or an expression.
2375   ConditionOrInitStatement
2376   isCXXConditionDeclarationOrInitStatement(bool CanBeInitStmt,
2377                                            bool CanBeForRangeDecl);
2378
2379   bool isCXXTypeId(TentativeCXXTypeIdContext Context, bool &isAmbiguous);
2380   bool isCXXTypeId(TentativeCXXTypeIdContext Context) {
2381     bool isAmbiguous;
2382     return isCXXTypeId(Context, isAmbiguous);
2383   }
2384
2385   /// TPResult - Used as the result value for functions whose purpose is to
2386   /// disambiguate C++ constructs by "tentatively parsing" them.
2387   enum class TPResult {
2388     True, False, Ambiguous, Error
2389   };
2390
2391   /// Based only on the given token kind, determine whether we know that
2392   /// we're at the start of an expression or a type-specifier-seq (which may
2393   /// be an expression, in C++).
2394   ///
2395   /// This routine does not attempt to resolve any of the trick cases, e.g.,
2396   /// those involving lookup of identifiers.
2397   ///
2398   /// \returns \c TPR_true if this token starts an expression, \c TPR_false if
2399   /// this token starts a type-specifier-seq, or \c TPR_ambiguous if it cannot
2400   /// tell.
2401   TPResult isExpressionOrTypeSpecifierSimple(tok::TokenKind Kind);
2402
2403   /// isCXXDeclarationSpecifier - Returns TPResult::True if it is a
2404   /// declaration specifier, TPResult::False if it is not,
2405   /// TPResult::Ambiguous if it could be either a decl-specifier or a
2406   /// function-style cast, and TPResult::Error if a parsing error was
2407   /// encountered. If it could be a braced C++11 function-style cast, returns
2408   /// BracedCastResult.
2409   /// Doesn't consume tokens.
2410   TPResult
2411   isCXXDeclarationSpecifier(TPResult BracedCastResult = TPResult::False,
2412                             bool *InvalidAsDeclSpec = nullptr);
2413
2414   /// Given that isCXXDeclarationSpecifier returns \c TPResult::True or
2415   /// \c TPResult::Ambiguous, determine whether the decl-specifier would be
2416   /// a type-specifier other than a cv-qualifier.
2417   bool isCXXDeclarationSpecifierAType();
2418
2419   /// Determine whether the current token sequence might be
2420   ///   '<' template-argument-list '>'
2421   /// rather than a less-than expression.
2422   TPResult isTemplateArgumentList(unsigned TokensToSkip);
2423
2424   /// Determine whether an '(' after an 'explicit' keyword is part of a C++20
2425   /// 'explicit(bool)' declaration, in earlier language modes where that is an
2426   /// extension.
2427   TPResult isExplicitBool();
2428
2429   /// Determine whether an identifier has been tentatively declared as a
2430   /// non-type. Such tentative declarations should not be found to name a type
2431   /// during a tentative parse, but also should not be annotated as a non-type.
2432   bool isTentativelyDeclared(IdentifierInfo *II);
2433
2434   // "Tentative parsing" functions, used for disambiguation. If a parsing error
2435   // is encountered they will return TPResult::Error.
2436   // Returning TPResult::True/False indicates that the ambiguity was
2437   // resolved and tentative parsing may stop. TPResult::Ambiguous indicates
2438   // that more tentative parsing is necessary for disambiguation.
2439   // They all consume tokens, so backtracking should be used after calling them.
2440
2441   TPResult TryParseSimpleDeclaration(bool AllowForRangeDecl);
2442   TPResult TryParseTypeofSpecifier();
2443   TPResult TryParseProtocolQualifiers();
2444   TPResult TryParsePtrOperatorSeq();
2445   TPResult TryParseOperatorId();
2446   TPResult TryParseInitDeclaratorList();
2447   TPResult TryParseDeclarator(bool mayBeAbstract, bool mayHaveIdentifier = true,
2448                               bool mayHaveDirectInit = false);
2449   TPResult
2450   TryParseParameterDeclarationClause(bool *InvalidAsDeclaration = nullptr,
2451                                      bool VersusTemplateArg = false);
2452   TPResult TryParseFunctionDeclarator();
2453   TPResult TryParseBracketDeclarator();
2454   TPResult TryConsumeDeclarationSpecifier();
2455
2456   /// Try to skip a possibly empty sequence of 'attribute-specifier's without
2457   /// full validation of the syntactic structure of attributes.
2458   bool TrySkipAttributes();
2459
2460 public:
2461   TypeResult ParseTypeName(SourceRange *Range = nullptr,
2462                            DeclaratorContext Context
2463                              = DeclaratorContext::TypeNameContext,
2464                            AccessSpecifier AS = AS_none,
2465                            Decl **OwnedType = nullptr,
2466                            ParsedAttributes *Attrs = nullptr);
2467
2468 private:
2469   void ParseBlockId(SourceLocation CaretLoc);
2470
2471   /// Are [[]] attributes enabled?
2472   bool standardAttributesAllowed() const {
2473     const LangOptions &LO = getLangOpts();
2474     return LO.DoubleSquareBracketAttributes;
2475   }
2476
2477   // Check for the start of an attribute-specifier-seq in a context where an
2478   // attribute is not allowed.
2479   bool CheckProhibitedCXX11Attribute() {
2480     assert(Tok.is(tok::l_square));
2481     if (!standardAttributesAllowed() || NextToken().isNot(tok::l_square))
2482       return false;
2483     return DiagnoseProhibitedCXX11Attribute();
2484   }
2485
2486   bool DiagnoseProhibitedCXX11Attribute();
2487   void CheckMisplacedCXX11Attribute(ParsedAttributesWithRange &Attrs,
2488                                     SourceLocation CorrectLocation) {
2489     if (!standardAttributesAllowed())
2490       return;
2491     if ((Tok.isNot(tok::l_square) || NextToken().isNot(tok::l_square)) &&
2492         Tok.isNot(tok::kw_alignas))
2493       return;
2494     DiagnoseMisplacedCXX11Attribute(Attrs, CorrectLocation);
2495   }
2496   void DiagnoseMisplacedCXX11Attribute(ParsedAttributesWithRange &Attrs,
2497                                        SourceLocation CorrectLocation);
2498
2499   void stripTypeAttributesOffDeclSpec(ParsedAttributesWithRange &Attrs,
2500                                       DeclSpec &DS, Sema::TagUseKind TUK);
2501
2502   // FixItLoc = possible correct location for the attributes
2503   void ProhibitAttributes(ParsedAttributesWithRange &Attrs,
2504                           SourceLocation FixItLoc = SourceLocation()) {
2505     if (Attrs.Range.isInvalid())
2506       return;
2507     DiagnoseProhibitedAttributes(Attrs.Range, FixItLoc);
2508     Attrs.clear();
2509   }
2510
2511   void ProhibitAttributes(ParsedAttributesViewWithRange &Attrs,
2512                           SourceLocation FixItLoc = SourceLocation()) {
2513     if (Attrs.Range.isInvalid())
2514       return;
2515     DiagnoseProhibitedAttributes(Attrs.Range, FixItLoc);
2516     Attrs.clearListOnly();
2517   }
2518   void DiagnoseProhibitedAttributes(const SourceRange &Range,
2519                                     SourceLocation FixItLoc);
2520
2521   // Forbid C++11 and C2x attributes that appear on certain syntactic locations
2522   // which standard permits but we don't supported yet, for example, attributes
2523   // appertain to decl specifiers.
2524   void ProhibitCXX11Attributes(ParsedAttributesWithRange &Attrs,
2525                                unsigned DiagID);
2526
2527   /// Skip C++11 and C2x attributes and return the end location of the
2528   /// last one.
2529   /// \returns SourceLocation() if there are no attributes.
2530   SourceLocation SkipCXX11Attributes();
2531
2532   /// Diagnose and skip C++11 and C2x attributes that appear in syntactic
2533   /// locations where attributes are not allowed.
2534   void DiagnoseAndSkipCXX11Attributes();
2535
2536   /// Parses syntax-generic attribute arguments for attributes which are
2537   /// known to the implementation, and adds them to the given ParsedAttributes
2538   /// list with the given attribute syntax. Returns the number of arguments
2539   /// parsed for the attribute.
2540   unsigned
2541   ParseAttributeArgsCommon(IdentifierInfo *AttrName, SourceLocation AttrNameLoc,
2542                            ParsedAttributes &Attrs, SourceLocation *EndLoc,
2543                            IdentifierInfo *ScopeName, SourceLocation ScopeLoc,
2544                            ParsedAttr::Syntax Syntax);
2545
2546   void MaybeParseGNUAttributes(Declarator &D,
2547                                LateParsedAttrList *LateAttrs = nullptr) {
2548     if (Tok.is(tok::kw___attribute)) {
2549       ParsedAttributes attrs(AttrFactory);
2550       SourceLocation endLoc;
2551       ParseGNUAttributes(attrs, &endLoc, LateAttrs, &D);
2552       D.takeAttributes(attrs, endLoc);
2553     }
2554   }
2555   void MaybeParseGNUAttributes(ParsedAttributes &attrs,
2556                                SourceLocation *endLoc = nullptr,
2557                                LateParsedAttrList *LateAttrs = nullptr) {
2558     if (Tok.is(tok::kw___attribute))
2559       ParseGNUAttributes(attrs, endLoc, LateAttrs);
2560   }
2561   void ParseGNUAttributes(ParsedAttributes &attrs,
2562                           SourceLocation *endLoc = nullptr,
2563                           LateParsedAttrList *LateAttrs = nullptr,
2564                           Declarator *D = nullptr);
2565   void ParseGNUAttributeArgs(IdentifierInfo *AttrName,
2566                              SourceLocation AttrNameLoc,
2567                              ParsedAttributes &Attrs, SourceLocation *EndLoc,
2568                              IdentifierInfo *ScopeName, SourceLocation ScopeLoc,
2569                              ParsedAttr::Syntax Syntax, Declarator *D);
2570   IdentifierLoc *ParseIdentifierLoc();
2571
2572   unsigned
2573   ParseClangAttributeArgs(IdentifierInfo *AttrName, SourceLocation AttrNameLoc,
2574                           ParsedAttributes &Attrs, SourceLocation *EndLoc,
2575                           IdentifierInfo *ScopeName, SourceLocation ScopeLoc,
2576                           ParsedAttr::Syntax Syntax);
2577
2578   void MaybeParseCXX11Attributes(Declarator &D) {
2579     if (standardAttributesAllowed() && isCXX11AttributeSpecifier()) {
2580       ParsedAttributesWithRange attrs(AttrFactory);
2581       SourceLocation endLoc;
2582       ParseCXX11Attributes(attrs, &endLoc);
2583       D.takeAttributes(attrs, endLoc);
2584     }
2585   }
2586   void MaybeParseCXX11Attributes(ParsedAttributes &attrs,
2587                                  SourceLocation *endLoc = nullptr) {
2588     if (standardAttributesAllowed() && isCXX11AttributeSpecifier()) {
2589       ParsedAttributesWithRange attrsWithRange(AttrFactory);
2590       ParseCXX11Attributes(attrsWithRange, endLoc);
2591       attrs.takeAllFrom(attrsWithRange);
2592     }
2593   }
2594   void MaybeParseCXX11Attributes(ParsedAttributesWithRange &attrs,
2595                                  SourceLocation *endLoc = nullptr,
2596                                  bool OuterMightBeMessageSend = false) {
2597     if (standardAttributesAllowed() &&
2598       isCXX11AttributeSpecifier(false, OuterMightBeMessageSend))
2599       ParseCXX11Attributes(attrs, endLoc);
2600   }
2601
2602   void ParseCXX11AttributeSpecifier(ParsedAttributes &attrs,
2603                                     SourceLocation *EndLoc = nullptr);
2604   void ParseCXX11Attributes(ParsedAttributesWithRange &attrs,
2605                             SourceLocation *EndLoc = nullptr);
2606   /// Parses a C++11 (or C2x)-style attribute argument list. Returns true
2607   /// if this results in adding an attribute to the ParsedAttributes list.
2608   bool ParseCXX11AttributeArgs(IdentifierInfo *AttrName,
2609                                SourceLocation AttrNameLoc,
2610                                ParsedAttributes &Attrs, SourceLocation *EndLoc,
2611                                IdentifierInfo *ScopeName,
2612                                SourceLocation ScopeLoc);
2613
2614   IdentifierInfo *TryParseCXX11AttributeIdentifier(SourceLocation &Loc);
2615
2616   void MaybeParseMicrosoftAttributes(ParsedAttributes &attrs,
2617                                      SourceLocation *endLoc = nullptr) {
2618     if (getLangOpts().MicrosoftExt && Tok.is(tok::l_square))
2619       ParseMicrosoftAttributes(attrs, endLoc);
2620   }
2621   void ParseMicrosoftUuidAttributeArgs(ParsedAttributes &Attrs);
2622   void ParseMicrosoftAttributes(ParsedAttributes &attrs,
2623                                 SourceLocation *endLoc = nullptr);
2624   void MaybeParseMicrosoftDeclSpecs(ParsedAttributes &Attrs,
2625                                     SourceLocation *End = nullptr) {
2626     const auto &LO = getLangOpts();
2627     if (LO.DeclSpecKeyword && Tok.is(tok::kw___declspec))
2628       ParseMicrosoftDeclSpecs(Attrs, End);
2629   }
2630   void ParseMicrosoftDeclSpecs(ParsedAttributes &Attrs,
2631                                SourceLocation *End = nullptr);
2632   bool ParseMicrosoftDeclSpecArgs(IdentifierInfo *AttrName,
2633                                   SourceLocation AttrNameLoc,
2634                                   ParsedAttributes &Attrs);
2635   void ParseMicrosoftTypeAttributes(ParsedAttributes &attrs);
2636   void DiagnoseAndSkipExtendedMicrosoftTypeAttributes();
2637   SourceLocation SkipExtendedMicrosoftTypeAttributes();
2638   void ParseMicrosoftInheritanceClassAttributes(ParsedAttributes &attrs);
2639   void ParseBorlandTypeAttributes(ParsedAttributes &attrs);
2640   void ParseOpenCLKernelAttributes(ParsedAttributes &attrs);
2641   void ParseOpenCLQualifiers(ParsedAttributes &Attrs);
2642   /// Parses opencl_unroll_hint attribute if language is OpenCL v2.0
2643   /// or higher.
2644   /// \return false if error happens.
2645   bool MaybeParseOpenCLUnrollHintAttribute(ParsedAttributes &Attrs) {
2646     if (getLangOpts().OpenCL)
2647       return ParseOpenCLUnrollHintAttribute(Attrs);
2648     return true;
2649   }
2650   /// Parses opencl_unroll_hint attribute.
2651   /// \return false if error happens.
2652   bool ParseOpenCLUnrollHintAttribute(ParsedAttributes &Attrs);
2653   void ParseNullabilityTypeSpecifiers(ParsedAttributes &attrs);
2654
2655   VersionTuple ParseVersionTuple(SourceRange &Range);
2656   void ParseAvailabilityAttribute(IdentifierInfo &Availability,
2657                                   SourceLocation AvailabilityLoc,
2658                                   ParsedAttributes &attrs,
2659                                   SourceLocation *endLoc,
2660                                   IdentifierInfo *ScopeName,
2661                                   SourceLocation ScopeLoc,
2662                                   ParsedAttr::Syntax Syntax);
2663
2664   Optional<AvailabilitySpec> ParseAvailabilitySpec();
2665   ExprResult ParseAvailabilityCheckExpr(SourceLocation StartLoc);
2666
2667   void ParseExternalSourceSymbolAttribute(IdentifierInfo &ExternalSourceSymbol,
2668                                           SourceLocation Loc,
2669                                           ParsedAttributes &Attrs,
2670                                           SourceLocation *EndLoc,
2671                                           IdentifierInfo *ScopeName,
2672                                           SourceLocation ScopeLoc,
2673                                           ParsedAttr::Syntax Syntax);
2674
2675   void ParseObjCBridgeRelatedAttribute(IdentifierInfo &ObjCBridgeRelated,
2676                                        SourceLocation ObjCBridgeRelatedLoc,
2677                                        ParsedAttributes &attrs,
2678                                        SourceLocation *endLoc,
2679                                        IdentifierInfo *ScopeName,
2680                                        SourceLocation ScopeLoc,
2681                                        ParsedAttr::Syntax Syntax);
2682
2683   void ParseTypeTagForDatatypeAttribute(IdentifierInfo &AttrName,
2684                                         SourceLocation AttrNameLoc,
2685                                         ParsedAttributes &Attrs,
2686                                         SourceLocation *EndLoc,
2687                                         IdentifierInfo *ScopeName,
2688                                         SourceLocation ScopeLoc,
2689                                         ParsedAttr::Syntax Syntax);
2690
2691   void
2692   ParseAttributeWithTypeArg(IdentifierInfo &AttrName,
2693                             SourceLocation AttrNameLoc, ParsedAttributes &Attrs,
2694                             SourceLocation *EndLoc, IdentifierInfo *ScopeName,
2695                             SourceLocation ScopeLoc, ParsedAttr::Syntax Syntax);
2696
2697   void ParseTypeofSpecifier(DeclSpec &DS);
2698   SourceLocation ParseDecltypeSpecifier(DeclSpec &DS);
2699   void AnnotateExistingDecltypeSpecifier(const DeclSpec &DS,
2700                                          SourceLocation StartLoc,
2701                                          SourceLocation EndLoc);
2702   void ParseUnderlyingTypeSpecifier(DeclSpec &DS);
2703   void ParseAtomicSpecifier(DeclSpec &DS);
2704
2705   ExprResult ParseAlignArgument(SourceLocation Start,
2706                                 SourceLocation &EllipsisLoc);
2707   void ParseAlignmentSpecifier(ParsedAttributes &Attrs,
2708                                SourceLocation *endLoc = nullptr);
2709
2710   VirtSpecifiers::Specifier isCXX11VirtSpecifier(const Token &Tok) const;
2711   VirtSpecifiers::Specifier isCXX11VirtSpecifier() const {
2712     return isCXX11VirtSpecifier(Tok);
2713   }
2714   void ParseOptionalCXX11VirtSpecifierSeq(VirtSpecifiers &VS, bool IsInterface,
2715                                           SourceLocation FriendLoc);
2716
2717   bool isCXX11FinalKeyword() const;
2718
2719   /// DeclaratorScopeObj - RAII object used in Parser::ParseDirectDeclarator to
2720   /// enter a new C++ declarator scope and exit it when the function is
2721   /// finished.
2722   class DeclaratorScopeObj {
2723     Parser &P;
2724     CXXScopeSpec &SS;
2725     bool EnteredScope;
2726     bool CreatedScope;
2727   public:
2728     DeclaratorScopeObj(Parser &p, CXXScopeSpec &ss)
2729       : P(p), SS(ss), EnteredScope(false), CreatedScope(false) {}
2730
2731     void EnterDeclaratorScope() {
2732       assert(!EnteredScope && "Already entered the scope!");
2733       assert(SS.isSet() && "C++ scope was not set!");
2734
2735       CreatedScope = true;
2736       P.EnterScope(0); // Not a decl scope.
2737
2738       if (!P.Actions.ActOnCXXEnterDeclaratorScope(P.getCurScope(), SS))
2739         EnteredScope = true;
2740     }
2741
2742     ~DeclaratorScopeObj() {
2743       if (EnteredScope) {
2744         assert(SS.isSet() && "C++ scope was cleared ?");
2745         P.Actions.ActOnCXXExitDeclaratorScope(P.getCurScope(), SS);
2746       }
2747       if (CreatedScope)
2748         P.ExitScope();
2749     }
2750   };
2751
2752   /// ParseDeclarator - Parse and verify a newly-initialized declarator.
2753   void ParseDeclarator(Declarator &D);
2754   /// A function that parses a variant of direct-declarator.
2755   typedef void (Parser::*DirectDeclParseFunction)(Declarator&);
2756   void ParseDeclaratorInternal(Declarator &D,
2757                                DirectDeclParseFunction DirectDeclParser);
2758
2759   enum AttrRequirements {
2760     AR_NoAttributesParsed = 0, ///< No attributes are diagnosed.
2761     AR_GNUAttributesParsedAndRejected = 1 << 0, ///< Diagnose GNU attributes.
2762     AR_GNUAttributesParsed = 1 << 1,
2763     AR_CXX11AttributesParsed = 1 << 2,
2764     AR_DeclspecAttributesParsed = 1 << 3,
2765     AR_AllAttributesParsed = AR_GNUAttributesParsed |
2766                              AR_CXX11AttributesParsed |
2767                              AR_DeclspecAttributesParsed,
2768     AR_VendorAttributesParsed = AR_GNUAttributesParsed |
2769                                 AR_DeclspecAttributesParsed
2770   };
2771
2772   void ParseTypeQualifierListOpt(
2773       DeclSpec &DS, unsigned AttrReqs = AR_AllAttributesParsed,
2774       bool AtomicAllowed = true, bool IdentifierRequired = false,
2775       Optional<llvm::function_ref<void()>> CodeCompletionHandler = None);
2776   void ParseDirectDeclarator(Declarator &D);
2777   void ParseDecompositionDeclarator(Declarator &D);
2778   void ParseParenDeclarator(Declarator &D);
2779   void ParseFunctionDeclarator(Declarator &D,
2780                                ParsedAttributes &attrs,
2781                                BalancedDelimiterTracker &Tracker,
2782                                bool IsAmbiguous,
2783                                bool RequiresArg = false);
2784   void InitCXXThisScopeForDeclaratorIfRelevant(
2785       const Declarator &D, const DeclSpec &DS,
2786       llvm::Optional<Sema::CXXThisScopeRAII> &ThisScope);
2787   bool ParseRefQualifier(bool &RefQualifierIsLValueRef,
2788                          SourceLocation &RefQualifierLoc);
2789   bool isFunctionDeclaratorIdentifierList();
2790   void ParseFunctionDeclaratorIdentifierList(
2791          Declarator &D,
2792          SmallVectorImpl<DeclaratorChunk::ParamInfo> &ParamInfo);
2793   void ParseParameterDeclarationClause(
2794          DeclaratorContext DeclaratorContext,
2795          ParsedAttributes &attrs,
2796          SmallVectorImpl<DeclaratorChunk::ParamInfo> &ParamInfo,
2797          SourceLocation &EllipsisLoc);
2798   void ParseBracketDeclarator(Declarator &D);
2799   void ParseMisplacedBracketDeclarator(Declarator &D);
2800
2801   //===--------------------------------------------------------------------===//
2802   // C++ 7: Declarations [dcl.dcl]
2803
2804   /// The kind of attribute specifier we have found.
2805   enum CXX11AttributeKind {
2806     /// This is not an attribute specifier.
2807     CAK_NotAttributeSpecifier,
2808     /// This should be treated as an attribute-specifier.
2809     CAK_AttributeSpecifier,
2810     /// The next tokens are '[[', but this is not an attribute-specifier. This
2811     /// is ill-formed by C++11 [dcl.attr.grammar]p6.
2812     CAK_InvalidAttributeSpecifier
2813   };
2814   CXX11AttributeKind
2815   isCXX11AttributeSpecifier(bool Disambiguate = false,
2816                             bool OuterMightBeMessageSend = false);
2817
2818   void DiagnoseUnexpectedNamespace(NamedDecl *Context);
2819
2820   DeclGroupPtrTy ParseNamespace(DeclaratorContext Context,
2821                                 SourceLocation &DeclEnd,
2822                                 SourceLocation InlineLoc = SourceLocation());
2823
2824   struct InnerNamespaceInfo {
2825     SourceLocation NamespaceLoc;
2826     SourceLocation InlineLoc;
2827     SourceLocation IdentLoc;
2828     IdentifierInfo *Ident;
2829   };
2830   using InnerNamespaceInfoList = llvm::SmallVector<InnerNamespaceInfo, 4>;
2831
2832   void ParseInnerNamespace(const InnerNamespaceInfoList &InnerNSs,
2833                            unsigned int index, SourceLocation &InlineLoc,
2834                            ParsedAttributes &attrs,
2835                            BalancedDelimiterTracker &Tracker);
2836   Decl *ParseLinkage(ParsingDeclSpec &DS, DeclaratorContext Context);
2837   Decl *ParseExportDeclaration();
2838   DeclGroupPtrTy ParseUsingDirectiveOrDeclaration(
2839       DeclaratorContext Context, const ParsedTemplateInfo &TemplateInfo,
2840       SourceLocation &DeclEnd, ParsedAttributesWithRange &attrs);
2841   Decl *ParseUsingDirective(DeclaratorContext Context,
2842                             SourceLocation UsingLoc,
2843                             SourceLocation &DeclEnd,
2844                             ParsedAttributes &attrs);
2845
2846   struct UsingDeclarator {
2847     SourceLocation TypenameLoc;
2848     CXXScopeSpec SS;
2849     UnqualifiedId Name;
2850     SourceLocation EllipsisLoc;
2851
2852     void clear() {
2853       TypenameLoc = EllipsisLoc = SourceLocation();
2854       SS.clear();
2855       Name.clear();
2856     }
2857   };
2858
2859   bool ParseUsingDeclarator(DeclaratorContext Context, UsingDeclarator &D);
2860   DeclGroupPtrTy ParseUsingDeclaration(DeclaratorContext Context,
2861                                        const ParsedTemplateInfo &TemplateInfo,
2862                                        SourceLocation UsingLoc,
2863                                        SourceLocation &DeclEnd,
2864                                        AccessSpecifier AS = AS_none);
2865   Decl *ParseAliasDeclarationAfterDeclarator(
2866       const ParsedTemplateInfo &TemplateInfo, SourceLocation UsingLoc,
2867       UsingDeclarator &D, SourceLocation &DeclEnd, AccessSpecifier AS,
2868       ParsedAttributes &Attrs, Decl **OwnedType = nullptr);
2869
2870   Decl *ParseStaticAssertDeclaration(SourceLocation &DeclEnd);
2871   Decl *ParseNamespaceAlias(SourceLocation NamespaceLoc,
2872                             SourceLocation AliasLoc, IdentifierInfo *Alias,
2873                             SourceLocation &DeclEnd);
2874
2875   //===--------------------------------------------------------------------===//
2876   // C++ 9: classes [class] and C structs/unions.
2877   bool isValidAfterTypeSpecifier(bool CouldBeBitfield);
2878   void ParseClassSpecifier(tok::TokenKind TagTokKind, SourceLocation TagLoc,
2879                            DeclSpec &DS, const ParsedTemplateInfo &TemplateInfo,
2880                            AccessSpecifier AS, bool EnteringContext,
2881                            DeclSpecContext DSC,
2882                            ParsedAttributesWithRange &Attributes);
2883   void SkipCXXMemberSpecification(SourceLocation StartLoc,
2884                                   SourceLocation AttrFixitLoc,
2885                                   unsigned TagType,
2886                                   Decl *TagDecl);
2887   void ParseCXXMemberSpecification(SourceLocation StartLoc,
2888                                    SourceLocation AttrFixitLoc,
2889                                    ParsedAttributesWithRange &Attrs,
2890                                    unsigned TagType,
2891                                    Decl *TagDecl);
2892   ExprResult ParseCXXMemberInitializer(Decl *D, bool IsFunction,
2893                                        SourceLocation &EqualLoc);
2894   bool
2895   ParseCXXMemberDeclaratorBeforeInitializer(Declarator &DeclaratorInfo,
2896                                             VirtSpecifiers &VS,
2897                                             ExprResult &BitfieldSize,
2898                                             LateParsedAttrList &LateAttrs);
2899   void MaybeParseAndDiagnoseDeclSpecAfterCXX11VirtSpecifierSeq(Declarator &D,
2900                                                                VirtSpecifiers &VS);
2901   DeclGroupPtrTy ParseCXXClassMemberDeclaration(
2902       AccessSpecifier AS, ParsedAttributes &Attr,
2903       const ParsedTemplateInfo &TemplateInfo = ParsedTemplateInfo(),
2904       ParsingDeclRAIIObject *DiagsFromTParams = nullptr);
2905   DeclGroupPtrTy ParseCXXClassMemberDeclarationWithPragmas(
2906       AccessSpecifier &AS, ParsedAttributesWithRange &AccessAttrs,
2907       DeclSpec::TST TagType, Decl *Tag);
2908   void ParseConstructorInitializer(Decl *ConstructorDecl);
2909   MemInitResult ParseMemInitializer(Decl *ConstructorDecl);
2910   void HandleMemberFunctionDeclDelays(Declarator& DeclaratorInfo,
2911                                       Decl *ThisDecl);
2912
2913   //===--------------------------------------------------------------------===//
2914   // C++ 10: Derived classes [class.derived]
2915   TypeResult ParseBaseTypeSpecifier(SourceLocation &BaseLoc,
2916                                     SourceLocation &EndLocation);
2917   void ParseBaseClause(Decl *ClassDecl);
2918   BaseResult ParseBaseSpecifier(Decl *ClassDecl);
2919   AccessSpecifier getAccessSpecifierIfPresent() const;
2920
2921   bool ParseUnqualifiedIdTemplateId(CXXScopeSpec &SS,
2922                                     ParsedType ObjectType,
2923                                     bool ObjectHadErrors,
2924                                     SourceLocation TemplateKWLoc,
2925                                     IdentifierInfo *Name,
2926                                     SourceLocation NameLoc,
2927                                     bool EnteringContext,
2928                                     UnqualifiedId &Id,
2929                                     bool AssumeTemplateId);
2930   bool ParseUnqualifiedIdOperator(CXXScopeSpec &SS, bool EnteringContext,
2931                                   ParsedType ObjectType,
2932                                   UnqualifiedId &Result);
2933
2934   //===--------------------------------------------------------------------===//
2935   // OpenMP: Directives and clauses.
2936   /// Parse clauses for '#pragma omp declare simd'.
2937   DeclGroupPtrTy ParseOMPDeclareSimdClauses(DeclGroupPtrTy Ptr,
2938                                             CachedTokens &Toks,
2939                                             SourceLocation Loc);
2940
2941   /// Parse a property kind into \p TIProperty for the selector set \p Set and
2942   /// selector \p Selector.
2943   void parseOMPTraitPropertyKind(OMPTraitProperty &TIProperty,
2944                                  llvm::omp::TraitSet Set,
2945                                  llvm::omp::TraitSelector Selector,
2946                                  llvm::StringMap<SourceLocation> &Seen);
2947
2948   /// Parse a selector kind into \p TISelector for the selector set \p Set.
2949   void parseOMPTraitSelectorKind(OMPTraitSelector &TISelector,
2950                                  llvm::omp::TraitSet Set,
2951                                  llvm::StringMap<SourceLocation> &Seen);
2952
2953   /// Parse a selector set kind into \p TISet.
2954   void parseOMPTraitSetKind(OMPTraitSet &TISet,
2955                             llvm::StringMap<SourceLocation> &Seen);
2956
2957   /// Parses an OpenMP context property.
2958   void parseOMPContextProperty(OMPTraitSelector &TISelector,
2959                                llvm::omp::TraitSet Set,
2960                                llvm::StringMap<SourceLocation> &Seen);
2961
2962   /// Parses an OpenMP context selector.
2963   void parseOMPContextSelector(OMPTraitSelector &TISelector,
2964                                llvm::omp::TraitSet Set,
2965                                llvm::StringMap<SourceLocation> &SeenSelectors);
2966
2967   /// Parses an OpenMP context selector set.
2968   void parseOMPContextSelectorSet(OMPTraitSet &TISet,
2969                                   llvm::StringMap<SourceLocation> &SeenSets);
2970
2971   /// Parses OpenMP context selectors.
2972   bool parseOMPContextSelectors(SourceLocation Loc, OMPTraitInfo &TI);
2973
2974   /// Parse a `match` clause for an '#pragma omp declare variant'. Return true
2975   /// if there was an error.
2976   bool parseOMPDeclareVariantMatchClause(SourceLocation Loc, OMPTraitInfo &TI);
2977
2978   /// Parse clauses for '#pragma omp declare variant'.
2979   void ParseOMPDeclareVariantClauses(DeclGroupPtrTy Ptr, CachedTokens &Toks,
2980                                      SourceLocation Loc);
2981
2982   /// Parse clauses for '#pragma omp declare target'.
2983   DeclGroupPtrTy ParseOMPDeclareTargetClauses();
2984   /// Parse '#pragma omp end declare target'.
2985   void ParseOMPEndDeclareTargetDirective(OpenMPDirectiveKind DKind,
2986                                          SourceLocation Loc);
2987
2988   /// Skip tokens until a `annot_pragma_openmp_end` was found. Emit a warning if
2989   /// it is not the current token.
2990   void skipUntilPragmaOpenMPEnd(OpenMPDirectiveKind DKind);
2991
2992   /// Check the \p FoundKind against the \p ExpectedKind, if not issue an error
2993   /// that the "end" matching the "begin" directive of kind \p BeginKind was not
2994   /// found. Finally, if the expected kind was found or if \p SkipUntilOpenMPEnd
2995   /// is set, skip ahead using the helper `skipUntilPragmaOpenMPEnd`.
2996   void parseOMPEndDirective(OpenMPDirectiveKind BeginKind,
2997                             OpenMPDirectiveKind ExpectedKind,
2998                             OpenMPDirectiveKind FoundKind,
2999                             SourceLocation MatchingLoc,
3000                             SourceLocation FoundLoc,
3001                             bool SkipUntilOpenMPEnd);
3002
3003   /// Parses declarative OpenMP directives.
3004   DeclGroupPtrTy ParseOpenMPDeclarativeDirectiveWithExtDecl(
3005       AccessSpecifier &AS, ParsedAttributesWithRange &Attrs,
3006       bool Delayed = false, DeclSpec::TST TagType = DeclSpec::TST_unspecified,
3007       Decl *TagDecl = nullptr);
3008   /// Parse 'omp declare reduction' construct.
3009   DeclGroupPtrTy ParseOpenMPDeclareReductionDirective(AccessSpecifier AS);
3010   /// Parses initializer for provided omp_priv declaration inside the reduction
3011   /// initializer.
3012   void ParseOpenMPReductionInitializerForDecl(VarDecl *OmpPrivParm);
3013
3014   /// Parses 'omp declare mapper' directive.
3015   DeclGroupPtrTy ParseOpenMPDeclareMapperDirective(AccessSpecifier AS);
3016   /// Parses variable declaration in 'omp declare mapper' directive.
3017   TypeResult parseOpenMPDeclareMapperVarDecl(SourceRange &Range,
3018                                              DeclarationName &Name,
3019                                              AccessSpecifier AS = AS_none);
3020
3021   /// Tries to parse cast part of OpenMP array shaping operation:
3022   /// '[' expression ']' { '[' expression ']' } ')'.
3023   bool tryParseOpenMPArrayShapingCastPart();
3024
3025   /// Parses simple list of variables.
3026   ///
3027   /// \param Kind Kind of the directive.
3028   /// \param Callback Callback function to be called for the list elements.
3029   /// \param AllowScopeSpecifier true, if the variables can have fully
3030   /// qualified names.
3031   ///
3032   bool ParseOpenMPSimpleVarList(
3033       OpenMPDirectiveKind Kind,
3034       const llvm::function_ref<void(CXXScopeSpec &, DeclarationNameInfo)> &
3035           Callback,
3036       bool AllowScopeSpecifier);
3037   /// Parses declarative or executable directive.
3038   ///
3039   /// \param StmtCtx The context in which we're parsing the directive.
3040   StmtResult
3041   ParseOpenMPDeclarativeOrExecutableDirective(ParsedStmtContext StmtCtx);
3042   /// Parses clause of kind \a CKind for directive of a kind \a Kind.
3043   ///
3044   /// \param DKind Kind of current directive.
3045   /// \param CKind Kind of current clause.
3046   /// \param FirstClause true, if this is the first clause of a kind \a CKind
3047   /// in current directive.
3048   ///
3049   OMPClause *ParseOpenMPClause(OpenMPDirectiveKind DKind,
3050                                OpenMPClauseKind CKind, bool FirstClause);
3051   /// Parses clause with a single expression of a kind \a Kind.
3052   ///
3053   /// \param Kind Kind of current clause.
3054   /// \param ParseOnly true to skip the clause's semantic actions and return
3055   /// nullptr.
3056   ///
3057   OMPClause *ParseOpenMPSingleExprClause(OpenMPClauseKind Kind,
3058                                          bool ParseOnly);
3059   /// Parses simple clause of a kind \a Kind.
3060   ///
3061   /// \param Kind Kind of current clause.
3062   /// \param ParseOnly true to skip the clause's semantic actions and return
3063   /// nullptr.
3064   ///
3065   OMPClause *ParseOpenMPSimpleClause(OpenMPClauseKind Kind, bool ParseOnly);
3066   /// Parses clause with a single expression and an additional argument
3067   /// of a kind \a Kind.
3068   ///
3069   /// \param DKind Directive kind.
3070   /// \param Kind Kind of current clause.
3071   /// \param ParseOnly true to skip the clause's semantic actions and return
3072   /// nullptr.
3073   ///
3074   OMPClause *ParseOpenMPSingleExprWithArgClause(OpenMPDirectiveKind DKind,
3075                                                 OpenMPClauseKind Kind,
3076                                                 bool ParseOnly);
3077   /// Parses clause without any additional arguments.
3078   ///
3079   /// \param Kind Kind of current clause.
3080   /// \param ParseOnly true to skip the clause's semantic actions and return
3081   /// nullptr.
3082   ///
3083   OMPClause *ParseOpenMPClause(OpenMPClauseKind Kind, bool ParseOnly = false);
3084   /// Parses clause with the list of variables of a kind \a Kind.
3085   ///
3086   /// \param Kind Kind of current clause.
3087   /// \param ParseOnly true to skip the clause's semantic actions and return
3088   /// nullptr.
3089   ///
3090   OMPClause *ParseOpenMPVarListClause(OpenMPDirectiveKind DKind,
3091                                       OpenMPClauseKind Kind, bool ParseOnly);
3092
3093   /// Parses and creates OpenMP 5.0 iterators expression:
3094   /// <iterators> = 'iterator' '(' { [ <iterator-type> ] identifier =
3095   /// <range-specification> }+ ')'
3096   ExprResult ParseOpenMPIteratorsExpr();
3097
3098 public:
3099   /// Parses simple expression in parens for single-expression clauses of OpenMP
3100   /// constructs.
3101   /// \param RLoc Returned location of right paren.
3102   ExprResult ParseOpenMPParensExpr(StringRef ClauseName, SourceLocation &RLoc,
3103                                    bool IsAddressOfOperand = false);
3104
3105   /// Data used for parsing list of variables in OpenMP clauses.
3106   struct OpenMPVarListDataTy {
3107     Expr *DepModOrTailExpr = nullptr;
3108     SourceLocation ColonLoc;
3109     SourceLocation RLoc;
3110     CXXScopeSpec ReductionOrMapperIdScopeSpec;
3111     DeclarationNameInfo ReductionOrMapperId;
3112     int ExtraModifier = -1; ///< Additional modifier for linear, map, depend or
3113                             ///< lastprivate clause.
3114     SmallVector<OpenMPMapModifierKind, NumberOfOMPMapClauseModifiers>
3115     MapTypeModifiers;
3116     SmallVector<SourceLocation, NumberOfOMPMapClauseModifiers>
3117     MapTypeModifiersLoc;
3118     bool IsMapTypeImplicit = false;
3119     SourceLocation ExtraModifierLoc;
3120   };
3121
3122   /// Parses clauses with list.
3123   bool ParseOpenMPVarList(OpenMPDirectiveKind DKind, OpenMPClauseKind Kind,
3124                           SmallVectorImpl<Expr *> &Vars,
3125                           OpenMPVarListDataTy &Data);
3126   bool ParseUnqualifiedId(CXXScopeSpec &SS, ParsedType ObjectType,
3127                           bool ObjectHadErrors, bool EnteringContext,
3128                           bool AllowDestructorName, bool AllowConstructorName,
3129                           bool AllowDeductionGuide,
3130                           SourceLocation *TemplateKWLoc, UnqualifiedId &Result);
3131
3132   /// Parses the mapper modifier in map, to, and from clauses.
3133   bool parseMapperModifier(OpenMPVarListDataTy &Data);
3134   /// Parses map-type-modifiers in map clause.
3135   /// map([ [map-type-modifier[,] [map-type-modifier[,] ...] map-type : ] list)
3136   /// where, map-type-modifier ::= always | close | mapper(mapper-identifier)
3137   bool parseMapTypeModifiers(OpenMPVarListDataTy &Data);
3138
3139 private:
3140   //===--------------------------------------------------------------------===//
3141   // C++ 14: Templates [temp]
3142
3143   // C++ 14.1: Template Parameters [temp.param]
3144   Decl *ParseDeclarationStartingWithTemplate(DeclaratorContext Context,
3145                                              SourceLocation &DeclEnd,
3146                                              ParsedAttributes &AccessAttrs,
3147                                              AccessSpecifier AS = AS_none);
3148   Decl *ParseTemplateDeclarationOrSpecialization(DeclaratorContext Context,
3149                                                  SourceLocation &DeclEnd,
3150                                                  ParsedAttributes &AccessAttrs,
3151                                                  AccessSpecifier AS);
3152   Decl *ParseSingleDeclarationAfterTemplate(
3153       DeclaratorContext Context, const ParsedTemplateInfo &TemplateInfo,
3154       ParsingDeclRAIIObject &DiagsFromParams, SourceLocation &DeclEnd,
3155       ParsedAttributes &AccessAttrs, AccessSpecifier AS = AS_none);
3156   bool ParseTemplateParameters(unsigned Depth,
3157                                SmallVectorImpl<NamedDecl *> &TemplateParams,
3158                                SourceLocation &LAngleLoc,
3159                                SourceLocation &RAngleLoc);
3160   bool ParseTemplateParameterList(unsigned Depth,
3161                                   SmallVectorImpl<NamedDecl*> &TemplateParams);
3162   TPResult isStartOfTemplateTypeParameter();
3163   NamedDecl *ParseTemplateParameter(unsigned Depth, unsigned Position);
3164   NamedDecl *ParseTypeParameter(unsigned Depth, unsigned Position);
3165   NamedDecl *ParseTemplateTemplateParameter(unsigned Depth, unsigned Position);
3166   NamedDecl *ParseNonTypeTemplateParameter(unsigned Depth, unsigned Position);
3167   bool isTypeConstraintAnnotation();
3168   bool TryAnnotateTypeConstraint();
3169   NamedDecl *
3170   ParseConstrainedTemplateTypeParameter(unsigned Depth, unsigned Position);
3171   void DiagnoseMisplacedEllipsis(SourceLocation EllipsisLoc,
3172                                  SourceLocation CorrectLoc,
3173                                  bool AlreadyHasEllipsis,
3174                                  bool IdentifierHasName);
3175   void DiagnoseMisplacedEllipsisInDeclarator(SourceLocation EllipsisLoc,
3176                                              Declarator &D);
3177   // C++ 14.3: Template arguments [temp.arg]
3178   typedef SmallVector<ParsedTemplateArgument, 16> TemplateArgList;
3179
3180   bool ParseGreaterThanInTemplateList(SourceLocation LAngleLoc,
3181                                       SourceLocation &RAngleLoc,
3182                                       bool ConsumeLastToken,
3183                                       bool ObjCGenericList);
3184   bool ParseTemplateIdAfterTemplateName(bool ConsumeLastToken,
3185                                         SourceLocation &LAngleLoc,
3186                                         TemplateArgList &TemplateArgs,
3187                                         SourceLocation &RAngleLoc);
3188
3189   bool AnnotateTemplateIdToken(TemplateTy Template, TemplateNameKind TNK,
3190                                CXXScopeSpec &SS,
3191                                SourceLocation TemplateKWLoc,
3192                                UnqualifiedId &TemplateName,
3193                                bool AllowTypeAnnotation = true,
3194                                bool TypeConstraint = false);
3195   void AnnotateTemplateIdTokenAsType(CXXScopeSpec &SS,
3196                                      bool IsClassName = false);
3197   bool ParseTemplateArgumentList(TemplateArgList &TemplateArgs);
3198   ParsedTemplateArgument ParseTemplateTemplateArgument();
3199   ParsedTemplateArgument ParseTemplateArgument();
3200   Decl *ParseExplicitInstantiation(DeclaratorContext Context,
3201                                    SourceLocation ExternLoc,
3202                                    SourceLocation TemplateLoc,
3203                                    SourceLocation &DeclEnd,
3204                                    ParsedAttributes &AccessAttrs,
3205                                    AccessSpecifier AS = AS_none);
3206   // C++2a: Template, concept definition [temp]
3207   Decl *
3208   ParseConceptDefinition(const ParsedTemplateInfo &TemplateInfo,
3209                          SourceLocation &DeclEnd);
3210
3211   //===--------------------------------------------------------------------===//
3212   // Modules
3213   DeclGroupPtrTy ParseModuleDecl(bool IsFirstDecl);
3214   Decl *ParseModuleImport(SourceLocation AtLoc);
3215   bool parseMisplacedModuleImport();
3216   bool tryParseMisplacedModuleImport() {
3217     tok::TokenKind Kind = Tok.getKind();
3218     if (Kind == tok::annot_module_begin || Kind == tok::annot_module_end ||
3219         Kind == tok::annot_module_include)
3220       return parseMisplacedModuleImport();
3221     return false;
3222   }
3223
3224   bool ParseModuleName(
3225       SourceLocation UseLoc,
3226       SmallVectorImpl<std::pair<IdentifierInfo *, SourceLocation>> &Path,
3227       bool IsImport);
3228
3229   //===--------------------------------------------------------------------===//
3230   // C++11/G++: Type Traits [Type-Traits.html in the GCC manual]
3231   ExprResult ParseTypeTrait();
3232
3233   //===--------------------------------------------------------------------===//
3234   // Embarcadero: Arary and Expression Traits
3235   ExprResult ParseArrayTypeTrait();
3236   ExprResult ParseExpressionTrait();
3237
3238   //===--------------------------------------------------------------------===//
3239   // Preprocessor code-completion pass-through
3240   void CodeCompleteDirective(bool InConditional) override;
3241   void CodeCompleteInConditionalExclusion() override;
3242   void CodeCompleteMacroName(bool IsDefinition) override;
3243   void CodeCompletePreprocessorExpression() override;
3244   void CodeCompleteMacroArgument(IdentifierInfo *Macro, MacroInfo *MacroInfo,
3245                                  unsigned ArgumentIndex) override;
3246   void CodeCompleteIncludedFile(llvm::StringRef Dir, bool IsAngled) override;
3247   void CodeCompleteNaturalLanguage() override;
3248
3249   class GNUAsmQualifiers {
3250     unsigned Qualifiers = AQ_unspecified;
3251
3252   public:
3253     enum AQ {
3254       AQ_unspecified = 0,
3255       AQ_volatile    = 1,
3256       AQ_inline      = 2,
3257       AQ_goto        = 4,
3258     };
3259     static const char *getQualifierName(AQ Qualifier);
3260     bool setAsmQualifier(AQ Qualifier);
3261     inline bool isVolatile() const { return Qualifiers & AQ_volatile; };
3262     inline bool isInline() const { return Qualifiers & AQ_inline; };
3263     inline bool isGoto() const { return Qualifiers & AQ_goto; }
3264   };
3265   bool isGCCAsmStatement(const Token &TokAfterAsm) const;
3266   bool isGNUAsmQualifier(const Token &TokAfterAsm) const;
3267   GNUAsmQualifiers::AQ getGNUAsmQualifier(const Token &Tok) const;
3268   bool parseGNUAsmQualifierListOpt(GNUAsmQualifiers &AQ);
3269 };
3270
3271 }  // end namespace clang
3272
3273 #endif