xref: /freebsd/contrib/llvm-project/clang/lib/Parse/ParseTentative.cpp (revision ec0ea6efa1ad229d75c394c1a9b9cac33af2b1d3)
1 //===--- ParseTentative.cpp - Ambiguity Resolution Parsing ----------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 //  This file implements the tentative parsing portions of the Parser
10 //  interfaces, for ambiguity resolution.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "clang/Parse/Parser.h"
15 #include "clang/Parse/ParseDiagnostic.h"
16 #include "clang/Sema/ParsedTemplate.h"
17 using namespace clang;
18 
19 /// isCXXDeclarationStatement - C++-specialized function that disambiguates
20 /// between a declaration or an expression statement, when parsing function
21 /// bodies. Returns true for declaration, false for expression.
22 ///
23 ///         declaration-statement:
24 ///           block-declaration
25 ///
26 ///         block-declaration:
27 ///           simple-declaration
28 ///           asm-definition
29 ///           namespace-alias-definition
30 ///           using-declaration
31 ///           using-directive
32 /// [C++0x]   static_assert-declaration
33 ///
34 ///         asm-definition:
35 ///           'asm' '(' string-literal ')' ';'
36 ///
37 ///         namespace-alias-definition:
38 ///           'namespace' identifier = qualified-namespace-specifier ';'
39 ///
40 ///         using-declaration:
41 ///           'using' typename[opt] '::'[opt] nested-name-specifier
42 ///                 unqualified-id ';'
43 ///           'using' '::' unqualified-id ;
44 ///
45 ///         using-directive:
46 ///           'using' 'namespace' '::'[opt] nested-name-specifier[opt]
47 ///                 namespace-name ';'
48 ///
49 bool Parser::isCXXDeclarationStatement() {
50   switch (Tok.getKind()) {
51     // asm-definition
52   case tok::kw_asm:
53     // namespace-alias-definition
54   case tok::kw_namespace:
55     // using-declaration
56     // using-directive
57   case tok::kw_using:
58     // static_assert-declaration
59   case tok::kw_static_assert:
60   case tok::kw__Static_assert:
61     return true;
62     // simple-declaration
63   default:
64     return isCXXSimpleDeclaration(/*AllowForRangeDecl=*/false);
65   }
66 }
67 
68 /// isCXXSimpleDeclaration - C++-specialized function that disambiguates
69 /// between a simple-declaration or an expression-statement.
70 /// If during the disambiguation process a parsing error is encountered,
71 /// the function returns true to let the declaration parsing code handle it.
72 /// Returns false if the statement is disambiguated as expression.
73 ///
74 /// simple-declaration:
75 ///   decl-specifier-seq init-declarator-list[opt] ';'
76 ///   decl-specifier-seq ref-qualifier[opt] '[' identifier-list ']'
77 ///                      brace-or-equal-initializer ';'    [C++17]
78 ///
79 /// (if AllowForRangeDecl specified)
80 /// for ( for-range-declaration : for-range-initializer ) statement
81 ///
82 /// for-range-declaration:
83 ///    decl-specifier-seq declarator
84 ///    decl-specifier-seq ref-qualifier[opt] '[' identifier-list ']'
85 ///
86 /// In any of the above cases there can be a preceding attribute-specifier-seq,
87 /// but the caller is expected to handle that.
88 bool Parser::isCXXSimpleDeclaration(bool AllowForRangeDecl) {
89   // C++ 6.8p1:
90   // There is an ambiguity in the grammar involving expression-statements and
91   // declarations: An expression-statement with a function-style explicit type
92   // conversion (5.2.3) as its leftmost subexpression can be indistinguishable
93   // from a declaration where the first declarator starts with a '('. In those
94   // cases the statement is a declaration. [Note: To disambiguate, the whole
95   // statement might have to be examined to determine if it is an
96   // expression-statement or a declaration].
97 
98   // C++ 6.8p3:
99   // The disambiguation is purely syntactic; that is, the meaning of the names
100   // occurring in such a statement, beyond whether they are type-names or not,
101   // is not generally used in or changed by the disambiguation. Class
102   // templates are instantiated as necessary to determine if a qualified name
103   // is a type-name. Disambiguation precedes parsing, and a statement
104   // disambiguated as a declaration may be an ill-formed declaration.
105 
106   // We don't have to parse all of the decl-specifier-seq part. There's only
107   // an ambiguity if the first decl-specifier is
108   // simple-type-specifier/typename-specifier followed by a '(', which may
109   // indicate a function-style cast expression.
110   // isCXXDeclarationSpecifier will return TPResult::Ambiguous only in such
111   // a case.
112 
113   bool InvalidAsDeclaration = false;
114   TPResult TPR = isCXXDeclarationSpecifier(TPResult::False,
115                                            &InvalidAsDeclaration);
116   if (TPR != TPResult::Ambiguous)
117     return TPR != TPResult::False; // Returns true for TPResult::True or
118                                    // TPResult::Error.
119 
120   // FIXME: TryParseSimpleDeclaration doesn't look past the first initializer,
121   // and so gets some cases wrong. We can't carry on if we've already seen
122   // something which makes this statement invalid as a declaration in this case,
123   // since it can cause us to misparse valid code. Revisit this once
124   // TryParseInitDeclaratorList is fixed.
125   if (InvalidAsDeclaration)
126     return false;
127 
128   // FIXME: Add statistics about the number of ambiguous statements encountered
129   // and how they were resolved (number of declarations+number of expressions).
130 
131   // Ok, we have a simple-type-specifier/typename-specifier followed by a '(',
132   // or an identifier which doesn't resolve as anything. We need tentative
133   // parsing...
134 
135   {
136     RevertingTentativeParsingAction PA(*this);
137     TPR = TryParseSimpleDeclaration(AllowForRangeDecl);
138   }
139 
140   // In case of an error, let the declaration parsing code handle it.
141   if (TPR == TPResult::Error)
142     return true;
143 
144   // Declarations take precedence over expressions.
145   if (TPR == TPResult::Ambiguous)
146     TPR = TPResult::True;
147 
148   assert(TPR == TPResult::True || TPR == TPResult::False);
149   return TPR == TPResult::True;
150 }
151 
152 /// Try to consume a token sequence that we've already identified as
153 /// (potentially) starting a decl-specifier.
154 Parser::TPResult Parser::TryConsumeDeclarationSpecifier() {
155   switch (Tok.getKind()) {
156   case tok::kw__Atomic:
157     if (NextToken().isNot(tok::l_paren)) {
158       ConsumeToken();
159       break;
160     }
161     LLVM_FALLTHROUGH;
162   case tok::kw_typeof:
163   case tok::kw___attribute:
164   case tok::kw___underlying_type: {
165     ConsumeToken();
166     if (Tok.isNot(tok::l_paren))
167       return TPResult::Error;
168     ConsumeParen();
169     if (!SkipUntil(tok::r_paren))
170       return TPResult::Error;
171     break;
172   }
173 
174   case tok::kw_class:
175   case tok::kw_struct:
176   case tok::kw_union:
177   case tok::kw___interface:
178   case tok::kw_enum:
179     // elaborated-type-specifier:
180     //     class-key attribute-specifier-seq[opt]
181     //         nested-name-specifier[opt] identifier
182     //     class-key nested-name-specifier[opt] template[opt] simple-template-id
183     //     enum nested-name-specifier[opt] identifier
184     //
185     // FIXME: We don't support class-specifiers nor enum-specifiers here.
186     ConsumeToken();
187 
188     // Skip attributes.
189     if (!TrySkipAttributes())
190       return TPResult::Error;
191 
192     if (TryAnnotateOptionalCXXScopeToken())
193       return TPResult::Error;
194     if (Tok.is(tok::annot_cxxscope))
195       ConsumeAnnotationToken();
196     if (Tok.is(tok::identifier))
197       ConsumeToken();
198     else if (Tok.is(tok::annot_template_id))
199       ConsumeAnnotationToken();
200     else
201       return TPResult::Error;
202     break;
203 
204   case tok::annot_cxxscope:
205     ConsumeAnnotationToken();
206     LLVM_FALLTHROUGH;
207   default:
208     ConsumeAnyToken();
209 
210     if (getLangOpts().ObjC && Tok.is(tok::less))
211       return TryParseProtocolQualifiers();
212     break;
213   }
214 
215   return TPResult::Ambiguous;
216 }
217 
218 /// simple-declaration:
219 ///   decl-specifier-seq init-declarator-list[opt] ';'
220 ///
221 /// (if AllowForRangeDecl specified)
222 /// for ( for-range-declaration : for-range-initializer ) statement
223 /// for-range-declaration:
224 ///    attribute-specifier-seqopt type-specifier-seq declarator
225 ///
226 Parser::TPResult Parser::TryParseSimpleDeclaration(bool AllowForRangeDecl) {
227   if (TryConsumeDeclarationSpecifier() == TPResult::Error)
228     return TPResult::Error;
229 
230   // Two decl-specifiers in a row conclusively disambiguate this as being a
231   // simple-declaration. Don't bother calling isCXXDeclarationSpecifier in the
232   // overwhelmingly common case that the next token is a '('.
233   if (Tok.isNot(tok::l_paren)) {
234     TPResult TPR = isCXXDeclarationSpecifier();
235     if (TPR == TPResult::Ambiguous)
236       return TPResult::True;
237     if (TPR == TPResult::True || TPR == TPResult::Error)
238       return TPR;
239     assert(TPR == TPResult::False);
240   }
241 
242   TPResult TPR = TryParseInitDeclaratorList();
243   if (TPR != TPResult::Ambiguous)
244     return TPR;
245 
246   if (Tok.isNot(tok::semi) && (!AllowForRangeDecl || Tok.isNot(tok::colon)))
247     return TPResult::False;
248 
249   return TPResult::Ambiguous;
250 }
251 
252 /// Tentatively parse an init-declarator-list in order to disambiguate it from
253 /// an expression.
254 ///
255 ///       init-declarator-list:
256 ///         init-declarator
257 ///         init-declarator-list ',' init-declarator
258 ///
259 ///       init-declarator:
260 ///         declarator initializer[opt]
261 /// [GNU]   declarator simple-asm-expr[opt] attributes[opt] initializer[opt]
262 ///
263 ///       initializer:
264 ///         brace-or-equal-initializer
265 ///         '(' expression-list ')'
266 ///
267 ///       brace-or-equal-initializer:
268 ///         '=' initializer-clause
269 /// [C++11] braced-init-list
270 ///
271 ///       initializer-clause:
272 ///         assignment-expression
273 ///         braced-init-list
274 ///
275 ///       braced-init-list:
276 ///         '{' initializer-list ','[opt] '}'
277 ///         '{' '}'
278 ///
279 Parser::TPResult Parser::TryParseInitDeclaratorList() {
280   while (1) {
281     // declarator
282     TPResult TPR = TryParseDeclarator(false/*mayBeAbstract*/);
283     if (TPR != TPResult::Ambiguous)
284       return TPR;
285 
286     // [GNU] simple-asm-expr[opt] attributes[opt]
287     if (Tok.isOneOf(tok::kw_asm, tok::kw___attribute))
288       return TPResult::True;
289 
290     // initializer[opt]
291     if (Tok.is(tok::l_paren)) {
292       // Parse through the parens.
293       ConsumeParen();
294       if (!SkipUntil(tok::r_paren, StopAtSemi))
295         return TPResult::Error;
296     } else if (Tok.is(tok::l_brace)) {
297       // A left-brace here is sufficient to disambiguate the parse; an
298       // expression can never be followed directly by a braced-init-list.
299       return TPResult::True;
300     } else if (Tok.is(tok::equal) || isTokIdentifier_in()) {
301       // MSVC and g++ won't examine the rest of declarators if '=' is
302       // encountered; they just conclude that we have a declaration.
303       // EDG parses the initializer completely, which is the proper behavior
304       // for this case.
305       //
306       // At present, Clang follows MSVC and g++, since the parser does not have
307       // the ability to parse an expression fully without recording the
308       // results of that parse.
309       // FIXME: Handle this case correctly.
310       //
311       // Also allow 'in' after an Objective-C declaration as in:
312       // for (int (^b)(void) in array). Ideally this should be done in the
313       // context of parsing for-init-statement of a foreach statement only. But,
314       // in any other context 'in' is invalid after a declaration and parser
315       // issues the error regardless of outcome of this decision.
316       // FIXME: Change if above assumption does not hold.
317       return TPResult::True;
318     }
319 
320     if (!TryConsumeToken(tok::comma))
321       break;
322   }
323 
324   return TPResult::Ambiguous;
325 }
326 
327 struct Parser::ConditionDeclarationOrInitStatementState {
328   Parser &P;
329   bool CanBeExpression = true;
330   bool CanBeCondition = true;
331   bool CanBeInitStatement;
332   bool CanBeForRangeDecl;
333 
334   ConditionDeclarationOrInitStatementState(Parser &P, bool CanBeInitStatement,
335                                            bool CanBeForRangeDecl)
336       : P(P), CanBeInitStatement(CanBeInitStatement),
337         CanBeForRangeDecl(CanBeForRangeDecl) {}
338 
339   bool resolved() {
340     return CanBeExpression + CanBeCondition + CanBeInitStatement +
341                CanBeForRangeDecl < 2;
342   }
343 
344   void markNotExpression() {
345     CanBeExpression = false;
346 
347     if (!resolved()) {
348       // FIXME: Unify the parsing codepaths for condition variables and
349       // simple-declarations so that we don't need to eagerly figure out which
350       // kind we have here. (Just parse init-declarators until we reach a
351       // semicolon or right paren.)
352       RevertingTentativeParsingAction PA(P);
353       if (CanBeForRangeDecl) {
354         // Skip until we hit a ')', ';', or a ':' with no matching '?'.
355         // The final case is a for range declaration, the rest are not.
356         unsigned QuestionColonDepth = 0;
357         while (true) {
358           P.SkipUntil({tok::r_paren, tok::semi, tok::question, tok::colon},
359                       StopBeforeMatch);
360           if (P.Tok.is(tok::question))
361             ++QuestionColonDepth;
362           else if (P.Tok.is(tok::colon)) {
363             if (QuestionColonDepth)
364               --QuestionColonDepth;
365             else {
366               CanBeCondition = CanBeInitStatement = false;
367               return;
368             }
369           } else {
370             CanBeForRangeDecl = false;
371             break;
372           }
373           P.ConsumeToken();
374         }
375       } else {
376         // Just skip until we hit a ')' or ';'.
377         P.SkipUntil(tok::r_paren, tok::semi, StopBeforeMatch);
378       }
379       if (P.Tok.isNot(tok::r_paren))
380         CanBeCondition = CanBeForRangeDecl = false;
381       if (P.Tok.isNot(tok::semi))
382         CanBeInitStatement = false;
383     }
384   }
385 
386   bool markNotCondition() {
387     CanBeCondition = false;
388     return resolved();
389   }
390 
391   bool markNotForRangeDecl() {
392     CanBeForRangeDecl = false;
393     return resolved();
394   }
395 
396   bool update(TPResult IsDecl) {
397     switch (IsDecl) {
398     case TPResult::True:
399       markNotExpression();
400       assert(resolved() && "can't continue after tentative parsing bails out");
401       break;
402     case TPResult::False:
403       CanBeCondition = CanBeInitStatement = CanBeForRangeDecl = false;
404       break;
405     case TPResult::Ambiguous:
406       break;
407     case TPResult::Error:
408       CanBeExpression = CanBeCondition = CanBeInitStatement =
409           CanBeForRangeDecl = false;
410       break;
411     }
412     return resolved();
413   }
414 
415   ConditionOrInitStatement result() const {
416     assert(CanBeExpression + CanBeCondition + CanBeInitStatement +
417                    CanBeForRangeDecl < 2 &&
418            "result called but not yet resolved");
419     if (CanBeExpression)
420       return ConditionOrInitStatement::Expression;
421     if (CanBeCondition)
422       return ConditionOrInitStatement::ConditionDecl;
423     if (CanBeInitStatement)
424       return ConditionOrInitStatement::InitStmtDecl;
425     if (CanBeForRangeDecl)
426       return ConditionOrInitStatement::ForRangeDecl;
427     return ConditionOrInitStatement::Error;
428   }
429 };
430 
431 bool Parser::isEnumBase(bool AllowSemi) {
432   assert(Tok.is(tok::colon) && "should be looking at the ':'");
433 
434   RevertingTentativeParsingAction PA(*this);
435   // ':'
436   ConsumeToken();
437 
438   // type-specifier-seq
439   bool InvalidAsDeclSpec = false;
440   // FIXME: We could disallow non-type decl-specifiers here, but it makes no
441   // difference: those specifiers are ill-formed regardless of the
442   // interpretation.
443   TPResult R = isCXXDeclarationSpecifier(/*BracedCastResult*/ TPResult::True,
444                                          &InvalidAsDeclSpec);
445   if (R == TPResult::Ambiguous) {
446     // We either have a decl-specifier followed by '(' or an undeclared
447     // identifier.
448     if (TryConsumeDeclarationSpecifier() == TPResult::Error)
449       return true;
450 
451     // If we get to the end of the enum-base, we hit either a '{' or a ';'.
452     // Don't bother checking the enumerator-list.
453     if (Tok.is(tok::l_brace) || (AllowSemi && Tok.is(tok::semi)))
454       return true;
455 
456     // A second decl-specifier unambiguously indicatges an enum-base.
457     R = isCXXDeclarationSpecifier(TPResult::True, &InvalidAsDeclSpec);
458   }
459 
460   return R != TPResult::False;
461 }
462 
463 /// Disambiguates between a declaration in a condition, a
464 /// simple-declaration in an init-statement, and an expression for
465 /// a condition of a if/switch statement.
466 ///
467 ///       condition:
468 ///         expression
469 ///         type-specifier-seq declarator '=' assignment-expression
470 /// [C++11] type-specifier-seq declarator '=' initializer-clause
471 /// [C++11] type-specifier-seq declarator braced-init-list
472 /// [GNU]   type-specifier-seq declarator simple-asm-expr[opt] attributes[opt]
473 ///             '=' assignment-expression
474 ///       simple-declaration:
475 ///         decl-specifier-seq init-declarator-list[opt] ';'
476 ///
477 /// Note that, unlike isCXXSimpleDeclaration, we must disambiguate all the way
478 /// to the ';' to disambiguate cases like 'int(x))' (an expression) from
479 /// 'int(x);' (a simple-declaration in an init-statement).
480 Parser::ConditionOrInitStatement
481 Parser::isCXXConditionDeclarationOrInitStatement(bool CanBeInitStatement,
482                                                  bool CanBeForRangeDecl) {
483   ConditionDeclarationOrInitStatementState State(*this, CanBeInitStatement,
484                                                  CanBeForRangeDecl);
485 
486   if (State.update(isCXXDeclarationSpecifier()))
487     return State.result();
488 
489   // It might be a declaration; we need tentative parsing.
490   RevertingTentativeParsingAction PA(*this);
491 
492   // FIXME: A tag definition unambiguously tells us this is an init-statement.
493   if (State.update(TryConsumeDeclarationSpecifier()))
494     return State.result();
495   assert(Tok.is(tok::l_paren) && "Expected '('");
496 
497   while (true) {
498     // Consume a declarator.
499     if (State.update(TryParseDeclarator(false/*mayBeAbstract*/)))
500       return State.result();
501 
502     // Attributes, asm label, or an initializer imply this is not an expression.
503     // FIXME: Disambiguate properly after an = instead of assuming that it's a
504     // valid declaration.
505     if (Tok.isOneOf(tok::equal, tok::kw_asm, tok::kw___attribute) ||
506         (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace))) {
507       State.markNotExpression();
508       return State.result();
509     }
510 
511     // A colon here identifies a for-range declaration.
512     if (State.CanBeForRangeDecl && Tok.is(tok::colon))
513       return ConditionOrInitStatement::ForRangeDecl;
514 
515     // At this point, it can't be a condition any more, because a condition
516     // must have a brace-or-equal-initializer.
517     if (State.markNotCondition())
518       return State.result();
519 
520     // Likewise, it can't be a for-range declaration any more.
521     if (State.markNotForRangeDecl())
522       return State.result();
523 
524     // A parenthesized initializer could be part of an expression or a
525     // simple-declaration.
526     if (Tok.is(tok::l_paren)) {
527       ConsumeParen();
528       SkipUntil(tok::r_paren, StopAtSemi);
529     }
530 
531     if (!TryConsumeToken(tok::comma))
532       break;
533   }
534 
535   // We reached the end. If it can now be some kind of decl, then it is.
536   if (State.CanBeCondition && Tok.is(tok::r_paren))
537     return ConditionOrInitStatement::ConditionDecl;
538   else if (State.CanBeInitStatement && Tok.is(tok::semi))
539     return ConditionOrInitStatement::InitStmtDecl;
540   else
541     return ConditionOrInitStatement::Expression;
542 }
543 
544   /// Determine whether the next set of tokens contains a type-id.
545   ///
546   /// The context parameter states what context we're parsing right
547   /// now, which affects how this routine copes with the token
548   /// following the type-id. If the context is TypeIdInParens, we have
549   /// already parsed the '(' and we will cease lookahead when we hit
550   /// the corresponding ')'. If the context is
551   /// TypeIdAsTemplateArgument, we've already parsed the '<' or ','
552   /// before this template argument, and will cease lookahead when we
553   /// hit a '>', '>>' (in C++0x), or ','; or, in C++0x, an ellipsis immediately
554   /// preceding such. Returns true for a type-id and false for an expression.
555   /// If during the disambiguation process a parsing error is encountered,
556   /// the function returns true to let the declaration parsing code handle it.
557   ///
558   /// type-id:
559   ///   type-specifier-seq abstract-declarator[opt]
560   ///
561 bool Parser::isCXXTypeId(TentativeCXXTypeIdContext Context, bool &isAmbiguous) {
562 
563   isAmbiguous = false;
564 
565   // C++ 8.2p2:
566   // The ambiguity arising from the similarity between a function-style cast and
567   // a type-id can occur in different contexts. The ambiguity appears as a
568   // choice between a function-style cast expression and a declaration of a
569   // type. The resolution is that any construct that could possibly be a type-id
570   // in its syntactic context shall be considered a type-id.
571 
572   TPResult TPR = isCXXDeclarationSpecifier();
573   if (TPR != TPResult::Ambiguous)
574     return TPR != TPResult::False; // Returns true for TPResult::True or
575                                      // TPResult::Error.
576 
577   // FIXME: Add statistics about the number of ambiguous statements encountered
578   // and how they were resolved (number of declarations+number of expressions).
579 
580   // Ok, we have a simple-type-specifier/typename-specifier followed by a '('.
581   // We need tentative parsing...
582 
583   RevertingTentativeParsingAction PA(*this);
584 
585   // type-specifier-seq
586   TryConsumeDeclarationSpecifier();
587   assert(Tok.is(tok::l_paren) && "Expected '('");
588 
589   // declarator
590   TPR = TryParseDeclarator(true/*mayBeAbstract*/, false/*mayHaveIdentifier*/);
591 
592   // In case of an error, let the declaration parsing code handle it.
593   if (TPR == TPResult::Error)
594     TPR = TPResult::True;
595 
596   if (TPR == TPResult::Ambiguous) {
597     // We are supposed to be inside parens, so if after the abstract declarator
598     // we encounter a ')' this is a type-id, otherwise it's an expression.
599     if (Context == TypeIdInParens && Tok.is(tok::r_paren)) {
600       TPR = TPResult::True;
601       isAmbiguous = true;
602 
603     // We are supposed to be inside a template argument, so if after
604     // the abstract declarator we encounter a '>', '>>' (in C++0x), or
605     // ','; or, in C++0x, an ellipsis immediately preceding such, this
606     // is a type-id. Otherwise, it's an expression.
607     } else if (Context == TypeIdAsTemplateArgument &&
608                (Tok.isOneOf(tok::greater, tok::comma) ||
609                 (getLangOpts().CPlusPlus11 &&
610                  (Tok.isOneOf(tok::greatergreater,
611                               tok::greatergreatergreater) ||
612                   (Tok.is(tok::ellipsis) &&
613                    NextToken().isOneOf(tok::greater, tok::greatergreater,
614                                        tok::greatergreatergreater,
615                                        tok::comma)))))) {
616       TPR = TPResult::True;
617       isAmbiguous = true;
618 
619     } else
620       TPR = TPResult::False;
621   }
622 
623   assert(TPR == TPResult::True || TPR == TPResult::False);
624   return TPR == TPResult::True;
625 }
626 
627 /// Returns true if this is a C++11 attribute-specifier. Per
628 /// C++11 [dcl.attr.grammar]p6, two consecutive left square bracket tokens
629 /// always introduce an attribute. In Objective-C++11, this rule does not
630 /// apply if either '[' begins a message-send.
631 ///
632 /// If Disambiguate is true, we try harder to determine whether a '[[' starts
633 /// an attribute-specifier, and return CAK_InvalidAttributeSpecifier if not.
634 ///
635 /// If OuterMightBeMessageSend is true, we assume the outer '[' is either an
636 /// Obj-C message send or the start of an attribute. Otherwise, we assume it
637 /// is not an Obj-C message send.
638 ///
639 /// C++11 [dcl.attr.grammar]:
640 ///
641 ///     attribute-specifier:
642 ///         '[' '[' attribute-list ']' ']'
643 ///         alignment-specifier
644 ///
645 ///     attribute-list:
646 ///         attribute[opt]
647 ///         attribute-list ',' attribute[opt]
648 ///         attribute '...'
649 ///         attribute-list ',' attribute '...'
650 ///
651 ///     attribute:
652 ///         attribute-token attribute-argument-clause[opt]
653 ///
654 ///     attribute-token:
655 ///         identifier
656 ///         identifier '::' identifier
657 ///
658 ///     attribute-argument-clause:
659 ///         '(' balanced-token-seq ')'
660 Parser::CXX11AttributeKind
661 Parser::isCXX11AttributeSpecifier(bool Disambiguate,
662                                   bool OuterMightBeMessageSend) {
663   if (Tok.is(tok::kw_alignas))
664     return CAK_AttributeSpecifier;
665 
666   if (Tok.isNot(tok::l_square) || NextToken().isNot(tok::l_square))
667     return CAK_NotAttributeSpecifier;
668 
669   // No tentative parsing if we don't need to look for ']]' or a lambda.
670   if (!Disambiguate && !getLangOpts().ObjC)
671     return CAK_AttributeSpecifier;
672 
673   // '[[using ns: ...]]' is an attribute.
674   if (GetLookAheadToken(2).is(tok::kw_using))
675     return CAK_AttributeSpecifier;
676 
677   RevertingTentativeParsingAction PA(*this);
678 
679   // Opening brackets were checked for above.
680   ConsumeBracket();
681 
682   if (!getLangOpts().ObjC) {
683     ConsumeBracket();
684 
685     bool IsAttribute = SkipUntil(tok::r_square);
686     IsAttribute &= Tok.is(tok::r_square);
687 
688     return IsAttribute ? CAK_AttributeSpecifier : CAK_InvalidAttributeSpecifier;
689   }
690 
691   // In Obj-C++11, we need to distinguish four situations:
692   //  1a) int x[[attr]];                     C++11 attribute.
693   //  1b) [[attr]];                          C++11 statement attribute.
694   //   2) int x[[obj](){ return 1; }()];     Lambda in array size/index.
695   //  3a) int x[[obj get]];                  Message send in array size/index.
696   //  3b) [[Class alloc] init];              Message send in message send.
697   //   4) [[obj]{ return self; }() doStuff]; Lambda in message send.
698   // (1) is an attribute, (2) is ill-formed, and (3) and (4) are accepted.
699 
700   // Check to see if this is a lambda-expression.
701   // FIXME: If this disambiguation is too slow, fold the tentative lambda parse
702   // into the tentative attribute parse below.
703   {
704     RevertingTentativeParsingAction LambdaTPA(*this);
705     LambdaIntroducer Intro;
706     LambdaIntroducerTentativeParse Tentative;
707     if (ParseLambdaIntroducer(Intro, &Tentative)) {
708       // We hit a hard error after deciding this was not an attribute.
709       // FIXME: Don't parse and annotate expressions when disambiguating
710       // against an attribute.
711       return CAK_NotAttributeSpecifier;
712     }
713 
714     switch (Tentative) {
715     case LambdaIntroducerTentativeParse::MessageSend:
716       // Case 3: The inner construct is definitely a message send, so the
717       // outer construct is definitely not an attribute.
718       return CAK_NotAttributeSpecifier;
719 
720     case LambdaIntroducerTentativeParse::Success:
721     case LambdaIntroducerTentativeParse::Incomplete:
722       // This is a lambda-introducer or attribute-specifier.
723       if (Tok.is(tok::r_square))
724         // Case 1: C++11 attribute.
725         return CAK_AttributeSpecifier;
726 
727       if (OuterMightBeMessageSend)
728         // Case 4: Lambda in message send.
729         return CAK_NotAttributeSpecifier;
730 
731       // Case 2: Lambda in array size / index.
732       return CAK_InvalidAttributeSpecifier;
733 
734     case LambdaIntroducerTentativeParse::Invalid:
735       // No idea what this is; we couldn't parse it as a lambda-introducer.
736       // Might still be an attribute-specifier or a message send.
737       break;
738     }
739   }
740 
741   ConsumeBracket();
742 
743   // If we don't have a lambda-introducer, then we have an attribute or a
744   // message-send.
745   bool IsAttribute = true;
746   while (Tok.isNot(tok::r_square)) {
747     if (Tok.is(tok::comma)) {
748       // Case 1: Stray commas can only occur in attributes.
749       return CAK_AttributeSpecifier;
750     }
751 
752     // Parse the attribute-token, if present.
753     // C++11 [dcl.attr.grammar]:
754     //   If a keyword or an alternative token that satisfies the syntactic
755     //   requirements of an identifier is contained in an attribute-token,
756     //   it is considered an identifier.
757     SourceLocation Loc;
758     if (!TryParseCXX11AttributeIdentifier(Loc)) {
759       IsAttribute = false;
760       break;
761     }
762     if (Tok.is(tok::coloncolon)) {
763       ConsumeToken();
764       if (!TryParseCXX11AttributeIdentifier(Loc)) {
765         IsAttribute = false;
766         break;
767       }
768     }
769 
770     // Parse the attribute-argument-clause, if present.
771     if (Tok.is(tok::l_paren)) {
772       ConsumeParen();
773       if (!SkipUntil(tok::r_paren)) {
774         IsAttribute = false;
775         break;
776       }
777     }
778 
779     TryConsumeToken(tok::ellipsis);
780 
781     if (!TryConsumeToken(tok::comma))
782       break;
783   }
784 
785   // An attribute must end ']]'.
786   if (IsAttribute) {
787     if (Tok.is(tok::r_square)) {
788       ConsumeBracket();
789       IsAttribute = Tok.is(tok::r_square);
790     } else {
791       IsAttribute = false;
792     }
793   }
794 
795   if (IsAttribute)
796     // Case 1: C++11 statement attribute.
797     return CAK_AttributeSpecifier;
798 
799   // Case 3: Message send.
800   return CAK_NotAttributeSpecifier;
801 }
802 
803 bool Parser::TrySkipAttributes() {
804   while (Tok.isOneOf(tok::l_square, tok::kw___attribute, tok::kw___declspec,
805                      tok::kw_alignas)) {
806     if (Tok.is(tok::l_square)) {
807       ConsumeBracket();
808       if (Tok.isNot(tok::l_square))
809         return false;
810       ConsumeBracket();
811       if (!SkipUntil(tok::r_square) || Tok.isNot(tok::r_square))
812         return false;
813       // Note that explicitly checking for `[[` and `]]` allows to fail as
814       // expected in the case of the Objective-C message send syntax.
815       ConsumeBracket();
816     } else {
817       ConsumeToken();
818       if (Tok.isNot(tok::l_paren))
819         return false;
820       ConsumeParen();
821       if (!SkipUntil(tok::r_paren))
822         return false;
823     }
824   }
825 
826   return true;
827 }
828 
829 Parser::TPResult Parser::TryParsePtrOperatorSeq() {
830   while (true) {
831     if (TryAnnotateOptionalCXXScopeToken(true))
832       return TPResult::Error;
833 
834     if (Tok.isOneOf(tok::star, tok::amp, tok::caret, tok::ampamp) ||
835         (Tok.is(tok::annot_cxxscope) && NextToken().is(tok::star))) {
836       // ptr-operator
837       ConsumeAnyToken();
838 
839       // Skip attributes.
840       if (!TrySkipAttributes())
841         return TPResult::Error;
842 
843       while (Tok.isOneOf(tok::kw_const, tok::kw_volatile, tok::kw_restrict,
844                          tok::kw__Nonnull, tok::kw__Nullable,
845                          tok::kw__Nullable_result, tok::kw__Null_unspecified,
846                          tok::kw__Atomic))
847         ConsumeToken();
848     } else {
849       return TPResult::True;
850     }
851   }
852 }
853 
854 ///         operator-function-id:
855 ///           'operator' operator
856 ///
857 ///         operator: one of
858 ///           new  delete  new[]  delete[]  +  -  *  /  %  ^  [...]
859 ///
860 ///         conversion-function-id:
861 ///           'operator' conversion-type-id
862 ///
863 ///         conversion-type-id:
864 ///           type-specifier-seq conversion-declarator[opt]
865 ///
866 ///         conversion-declarator:
867 ///           ptr-operator conversion-declarator[opt]
868 ///
869 ///         literal-operator-id:
870 ///           'operator' string-literal identifier
871 ///           'operator' user-defined-string-literal
872 Parser::TPResult Parser::TryParseOperatorId() {
873   assert(Tok.is(tok::kw_operator));
874   ConsumeToken();
875 
876   // Maybe this is an operator-function-id.
877   switch (Tok.getKind()) {
878   case tok::kw_new: case tok::kw_delete:
879     ConsumeToken();
880     if (Tok.is(tok::l_square) && NextToken().is(tok::r_square)) {
881       ConsumeBracket();
882       ConsumeBracket();
883     }
884     return TPResult::True;
885 
886 #define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemOnly) \
887   case tok::Token:
888 #define OVERLOADED_OPERATOR_MULTI(Name, Spelling, Unary, Binary, MemOnly)
889 #include "clang/Basic/OperatorKinds.def"
890     ConsumeToken();
891     return TPResult::True;
892 
893   case tok::l_square:
894     if (NextToken().is(tok::r_square)) {
895       ConsumeBracket();
896       ConsumeBracket();
897       return TPResult::True;
898     }
899     break;
900 
901   case tok::l_paren:
902     if (NextToken().is(tok::r_paren)) {
903       ConsumeParen();
904       ConsumeParen();
905       return TPResult::True;
906     }
907     break;
908 
909   default:
910     break;
911   }
912 
913   // Maybe this is a literal-operator-id.
914   if (getLangOpts().CPlusPlus11 && isTokenStringLiteral()) {
915     bool FoundUDSuffix = false;
916     do {
917       FoundUDSuffix |= Tok.hasUDSuffix();
918       ConsumeStringToken();
919     } while (isTokenStringLiteral());
920 
921     if (!FoundUDSuffix) {
922       if (Tok.is(tok::identifier))
923         ConsumeToken();
924       else
925         return TPResult::Error;
926     }
927     return TPResult::True;
928   }
929 
930   // Maybe this is a conversion-function-id.
931   bool AnyDeclSpecifiers = false;
932   while (true) {
933     TPResult TPR = isCXXDeclarationSpecifier();
934     if (TPR == TPResult::Error)
935       return TPR;
936     if (TPR == TPResult::False) {
937       if (!AnyDeclSpecifiers)
938         return TPResult::Error;
939       break;
940     }
941     if (TryConsumeDeclarationSpecifier() == TPResult::Error)
942       return TPResult::Error;
943     AnyDeclSpecifiers = true;
944   }
945   return TryParsePtrOperatorSeq();
946 }
947 
948 ///         declarator:
949 ///           direct-declarator
950 ///           ptr-operator declarator
951 ///
952 ///         direct-declarator:
953 ///           declarator-id
954 ///           direct-declarator '(' parameter-declaration-clause ')'
955 ///                 cv-qualifier-seq[opt] exception-specification[opt]
956 ///           direct-declarator '[' constant-expression[opt] ']'
957 ///           '(' declarator ')'
958 /// [GNU]     '(' attributes declarator ')'
959 ///
960 ///         abstract-declarator:
961 ///           ptr-operator abstract-declarator[opt]
962 ///           direct-abstract-declarator
963 ///
964 ///         direct-abstract-declarator:
965 ///           direct-abstract-declarator[opt]
966 ///                 '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
967 ///                 exception-specification[opt]
968 ///           direct-abstract-declarator[opt] '[' constant-expression[opt] ']'
969 ///           '(' abstract-declarator ')'
970 /// [C++0x]   ...
971 ///
972 ///         ptr-operator:
973 ///           '*' cv-qualifier-seq[opt]
974 ///           '&'
975 /// [C++0x]   '&&'                                                        [TODO]
976 ///           '::'[opt] nested-name-specifier '*' cv-qualifier-seq[opt]
977 ///
978 ///         cv-qualifier-seq:
979 ///           cv-qualifier cv-qualifier-seq[opt]
980 ///
981 ///         cv-qualifier:
982 ///           'const'
983 ///           'volatile'
984 ///
985 ///         declarator-id:
986 ///           '...'[opt] id-expression
987 ///
988 ///         id-expression:
989 ///           unqualified-id
990 ///           qualified-id                                                [TODO]
991 ///
992 ///         unqualified-id:
993 ///           identifier
994 ///           operator-function-id
995 ///           conversion-function-id
996 ///           literal-operator-id
997 ///           '~' class-name                                              [TODO]
998 ///           '~' decltype-specifier                                      [TODO]
999 ///           template-id                                                 [TODO]
1000 ///
1001 Parser::TPResult Parser::TryParseDeclarator(bool mayBeAbstract,
1002                                             bool mayHaveIdentifier,
1003                                             bool mayHaveDirectInit) {
1004   // declarator:
1005   //   direct-declarator
1006   //   ptr-operator declarator
1007   if (TryParsePtrOperatorSeq() == TPResult::Error)
1008     return TPResult::Error;
1009 
1010   // direct-declarator:
1011   // direct-abstract-declarator:
1012   if (Tok.is(tok::ellipsis))
1013     ConsumeToken();
1014 
1015   if ((Tok.isOneOf(tok::identifier, tok::kw_operator) ||
1016        (Tok.is(tok::annot_cxxscope) && (NextToken().is(tok::identifier) ||
1017                                         NextToken().is(tok::kw_operator)))) &&
1018       mayHaveIdentifier) {
1019     // declarator-id
1020     if (Tok.is(tok::annot_cxxscope)) {
1021       CXXScopeSpec SS;
1022       Actions.RestoreNestedNameSpecifierAnnotation(
1023           Tok.getAnnotationValue(), Tok.getAnnotationRange(), SS);
1024       if (SS.isInvalid())
1025         return TPResult::Error;
1026       ConsumeAnnotationToken();
1027     } else if (Tok.is(tok::identifier)) {
1028       TentativelyDeclaredIdentifiers.push_back(Tok.getIdentifierInfo());
1029     }
1030     if (Tok.is(tok::kw_operator)) {
1031       if (TryParseOperatorId() == TPResult::Error)
1032         return TPResult::Error;
1033     } else
1034       ConsumeToken();
1035   } else if (Tok.is(tok::l_paren)) {
1036     ConsumeParen();
1037     if (mayBeAbstract &&
1038         (Tok.is(tok::r_paren) ||       // 'int()' is a function.
1039          // 'int(...)' is a function.
1040          (Tok.is(tok::ellipsis) && NextToken().is(tok::r_paren)) ||
1041          isDeclarationSpecifier())) {   // 'int(int)' is a function.
1042       // '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
1043       //        exception-specification[opt]
1044       TPResult TPR = TryParseFunctionDeclarator();
1045       if (TPR != TPResult::Ambiguous)
1046         return TPR;
1047     } else {
1048       // '(' declarator ')'
1049       // '(' attributes declarator ')'
1050       // '(' abstract-declarator ')'
1051       if (Tok.isOneOf(tok::kw___attribute, tok::kw___declspec, tok::kw___cdecl,
1052                       tok::kw___stdcall, tok::kw___fastcall, tok::kw___thiscall,
1053                       tok::kw___regcall, tok::kw___vectorcall))
1054         return TPResult::True; // attributes indicate declaration
1055       TPResult TPR = TryParseDeclarator(mayBeAbstract, mayHaveIdentifier);
1056       if (TPR != TPResult::Ambiguous)
1057         return TPR;
1058       if (Tok.isNot(tok::r_paren))
1059         return TPResult::False;
1060       ConsumeParen();
1061     }
1062   } else if (!mayBeAbstract) {
1063     return TPResult::False;
1064   }
1065 
1066   if (mayHaveDirectInit)
1067     return TPResult::Ambiguous;
1068 
1069   while (1) {
1070     TPResult TPR(TPResult::Ambiguous);
1071 
1072     if (Tok.is(tok::l_paren)) {
1073       // Check whether we have a function declarator or a possible ctor-style
1074       // initializer that follows the declarator. Note that ctor-style
1075       // initializers are not possible in contexts where abstract declarators
1076       // are allowed.
1077       if (!mayBeAbstract && !isCXXFunctionDeclarator())
1078         break;
1079 
1080       // direct-declarator '(' parameter-declaration-clause ')'
1081       //        cv-qualifier-seq[opt] exception-specification[opt]
1082       ConsumeParen();
1083       TPR = TryParseFunctionDeclarator();
1084     } else if (Tok.is(tok::l_square)) {
1085       // direct-declarator '[' constant-expression[opt] ']'
1086       // direct-abstract-declarator[opt] '[' constant-expression[opt] ']'
1087       TPR = TryParseBracketDeclarator();
1088     } else if (Tok.is(tok::kw_requires)) {
1089       // declarator requires-clause
1090       // A requires clause indicates a function declaration.
1091       TPR = TPResult::True;
1092     } else {
1093       break;
1094     }
1095 
1096     if (TPR != TPResult::Ambiguous)
1097       return TPR;
1098   }
1099 
1100   return TPResult::Ambiguous;
1101 }
1102 
1103 bool Parser::isTentativelyDeclared(IdentifierInfo *II) {
1104   return std::find(TentativelyDeclaredIdentifiers.begin(),
1105                    TentativelyDeclaredIdentifiers.end(), II)
1106       != TentativelyDeclaredIdentifiers.end();
1107 }
1108 
1109 namespace {
1110 class TentativeParseCCC final : public CorrectionCandidateCallback {
1111 public:
1112   TentativeParseCCC(const Token &Next) {
1113     WantRemainingKeywords = false;
1114     WantTypeSpecifiers =
1115         Next.isOneOf(tok::l_paren, tok::r_paren, tok::greater, tok::l_brace,
1116                      tok::identifier, tok::comma);
1117   }
1118 
1119   bool ValidateCandidate(const TypoCorrection &Candidate) override {
1120     // Reject any candidate that only resolves to instance members since they
1121     // aren't viable as standalone identifiers instead of member references.
1122     if (Candidate.isResolved() && !Candidate.isKeyword() &&
1123         llvm::all_of(Candidate,
1124                      [](NamedDecl *ND) { return ND->isCXXInstanceMember(); }))
1125       return false;
1126 
1127     return CorrectionCandidateCallback::ValidateCandidate(Candidate);
1128   }
1129 
1130   std::unique_ptr<CorrectionCandidateCallback> clone() override {
1131     return std::make_unique<TentativeParseCCC>(*this);
1132   }
1133 };
1134 }
1135 /// isCXXDeclarationSpecifier - Returns TPResult::True if it is a declaration
1136 /// specifier, TPResult::False if it is not, TPResult::Ambiguous if it could
1137 /// be either a decl-specifier or a function-style cast, and TPResult::Error
1138 /// if a parsing error was found and reported.
1139 ///
1140 /// If InvalidAsDeclSpec is not null, some cases that would be ill-formed as
1141 /// declaration specifiers but possibly valid as some other kind of construct
1142 /// return TPResult::Ambiguous instead of TPResult::False. When this happens,
1143 /// the intent is to keep trying to disambiguate, on the basis that we might
1144 /// find a better reason to treat this construct as a declaration later on.
1145 /// When this happens and the name could possibly be valid in some other
1146 /// syntactic context, *InvalidAsDeclSpec is set to 'true'. The current cases
1147 /// that trigger this are:
1148 ///
1149 ///   * When parsing X::Y (with no 'typename') where X is dependent
1150 ///   * When parsing X<Y> where X is undeclared
1151 ///
1152 ///         decl-specifier:
1153 ///           storage-class-specifier
1154 ///           type-specifier
1155 ///           function-specifier
1156 ///           'friend'
1157 ///           'typedef'
1158 /// [C++11]   'constexpr'
1159 /// [C++20]   'consteval'
1160 /// [GNU]     attributes declaration-specifiers[opt]
1161 ///
1162 ///         storage-class-specifier:
1163 ///           'register'
1164 ///           'static'
1165 ///           'extern'
1166 ///           'mutable'
1167 ///           'auto'
1168 /// [GNU]     '__thread'
1169 /// [C++11]   'thread_local'
1170 /// [C11]     '_Thread_local'
1171 ///
1172 ///         function-specifier:
1173 ///           'inline'
1174 ///           'virtual'
1175 ///           'explicit'
1176 ///
1177 ///         typedef-name:
1178 ///           identifier
1179 ///
1180 ///         type-specifier:
1181 ///           simple-type-specifier
1182 ///           class-specifier
1183 ///           enum-specifier
1184 ///           elaborated-type-specifier
1185 ///           typename-specifier
1186 ///           cv-qualifier
1187 ///
1188 ///         simple-type-specifier:
1189 ///           '::'[opt] nested-name-specifier[opt] type-name
1190 ///           '::'[opt] nested-name-specifier 'template'
1191 ///                 simple-template-id                              [TODO]
1192 ///           'char'
1193 ///           'wchar_t'
1194 ///           'bool'
1195 ///           'short'
1196 ///           'int'
1197 ///           'long'
1198 ///           'signed'
1199 ///           'unsigned'
1200 ///           'float'
1201 ///           'double'
1202 ///           'void'
1203 /// [GNU]     typeof-specifier
1204 /// [GNU]     '_Complex'
1205 /// [C++11]   'auto'
1206 /// [GNU]     '__auto_type'
1207 /// [C++11]   'decltype' ( expression )
1208 /// [C++1y]   'decltype' ( 'auto' )
1209 ///
1210 ///         type-name:
1211 ///           class-name
1212 ///           enum-name
1213 ///           typedef-name
1214 ///
1215 ///         elaborated-type-specifier:
1216 ///           class-key '::'[opt] nested-name-specifier[opt] identifier
1217 ///           class-key '::'[opt] nested-name-specifier[opt] 'template'[opt]
1218 ///               simple-template-id
1219 ///           'enum' '::'[opt] nested-name-specifier[opt] identifier
1220 ///
1221 ///         enum-name:
1222 ///           identifier
1223 ///
1224 ///         enum-specifier:
1225 ///           'enum' identifier[opt] '{' enumerator-list[opt] '}'
1226 ///           'enum' identifier[opt] '{' enumerator-list ',' '}'
1227 ///
1228 ///         class-specifier:
1229 ///           class-head '{' member-specification[opt] '}'
1230 ///
1231 ///         class-head:
1232 ///           class-key identifier[opt] base-clause[opt]
1233 ///           class-key nested-name-specifier identifier base-clause[opt]
1234 ///           class-key nested-name-specifier[opt] simple-template-id
1235 ///               base-clause[opt]
1236 ///
1237 ///         class-key:
1238 ///           'class'
1239 ///           'struct'
1240 ///           'union'
1241 ///
1242 ///         cv-qualifier:
1243 ///           'const'
1244 ///           'volatile'
1245 /// [GNU]     restrict
1246 ///
1247 Parser::TPResult
1248 Parser::isCXXDeclarationSpecifier(Parser::TPResult BracedCastResult,
1249                                   bool *InvalidAsDeclSpec) {
1250   auto IsPlaceholderSpecifier = [&] (TemplateIdAnnotation *TemplateId,
1251                                      int Lookahead) {
1252     // We have a placeholder-constraint (we check for 'auto' or 'decltype' to
1253     // distinguish 'C<int>;' from 'C<int> auto c = 1;')
1254     return TemplateId->Kind == TNK_Concept_template &&
1255         GetLookAheadToken(Lookahead + 1).isOneOf(tok::kw_auto, tok::kw_decltype,
1256             // If we have an identifier here, the user probably forgot the
1257             // 'auto' in the placeholder constraint, e.g. 'C<int> x = 2;'
1258             // This will be diagnosed nicely later, so disambiguate as a
1259             // declaration.
1260             tok::identifier);
1261   };
1262   switch (Tok.getKind()) {
1263   case tok::identifier: {
1264     // Check for need to substitute AltiVec __vector keyword
1265     // for "vector" identifier.
1266     if (TryAltiVecVectorToken())
1267       return TPResult::True;
1268 
1269     const Token &Next = NextToken();
1270     // In 'foo bar', 'foo' is always a type name outside of Objective-C.
1271     if (!getLangOpts().ObjC && Next.is(tok::identifier))
1272       return TPResult::True;
1273 
1274     if (Next.isNot(tok::coloncolon) && Next.isNot(tok::less)) {
1275       // Determine whether this is a valid expression. If not, we will hit
1276       // a parse error one way or another. In that case, tell the caller that
1277       // this is ambiguous. Typo-correct to type and expression keywords and
1278       // to types and identifiers, in order to try to recover from errors.
1279       TentativeParseCCC CCC(Next);
1280       switch (TryAnnotateName(&CCC)) {
1281       case ANK_Error:
1282         return TPResult::Error;
1283       case ANK_TentativeDecl:
1284         return TPResult::False;
1285       case ANK_TemplateName:
1286         // In C++17, this could be a type template for class template argument
1287         // deduction. Try to form a type annotation for it. If we're in a
1288         // template template argument, we'll undo this when checking the
1289         // validity of the argument.
1290         if (getLangOpts().CPlusPlus17) {
1291           if (TryAnnotateTypeOrScopeToken())
1292             return TPResult::Error;
1293           if (Tok.isNot(tok::identifier))
1294             break;
1295         }
1296 
1297         // A bare type template-name which can't be a template template
1298         // argument is an error, and was probably intended to be a type.
1299         return GreaterThanIsOperator ? TPResult::True : TPResult::False;
1300       case ANK_Unresolved:
1301         return InvalidAsDeclSpec ? TPResult::Ambiguous : TPResult::False;
1302       case ANK_Success:
1303         break;
1304       }
1305       assert(Tok.isNot(tok::identifier) &&
1306              "TryAnnotateName succeeded without producing an annotation");
1307     } else {
1308       // This might possibly be a type with a dependent scope specifier and
1309       // a missing 'typename' keyword. Don't use TryAnnotateName in this case,
1310       // since it will annotate as a primary expression, and we want to use the
1311       // "missing 'typename'" logic.
1312       if (TryAnnotateTypeOrScopeToken())
1313         return TPResult::Error;
1314       // If annotation failed, assume it's a non-type.
1315       // FIXME: If this happens due to an undeclared identifier, treat it as
1316       // ambiguous.
1317       if (Tok.is(tok::identifier))
1318         return TPResult::False;
1319     }
1320 
1321     // We annotated this token as something. Recurse to handle whatever we got.
1322     return isCXXDeclarationSpecifier(BracedCastResult, InvalidAsDeclSpec);
1323   }
1324 
1325   case tok::kw_typename:  // typename T::type
1326     // Annotate typenames and C++ scope specifiers.  If we get one, just
1327     // recurse to handle whatever we get.
1328     if (TryAnnotateTypeOrScopeToken())
1329       return TPResult::Error;
1330     return isCXXDeclarationSpecifier(BracedCastResult, InvalidAsDeclSpec);
1331 
1332   case tok::coloncolon: {    // ::foo::bar
1333     const Token &Next = NextToken();
1334     if (Next.isOneOf(tok::kw_new,       // ::new
1335                      tok::kw_delete))   // ::delete
1336       return TPResult::False;
1337     LLVM_FALLTHROUGH;
1338   }
1339   case tok::kw___super:
1340   case tok::kw_decltype:
1341     // Annotate typenames and C++ scope specifiers.  If we get one, just
1342     // recurse to handle whatever we get.
1343     if (TryAnnotateTypeOrScopeToken())
1344       return TPResult::Error;
1345     return isCXXDeclarationSpecifier(BracedCastResult, InvalidAsDeclSpec);
1346 
1347     // decl-specifier:
1348     //   storage-class-specifier
1349     //   type-specifier
1350     //   function-specifier
1351     //   'friend'
1352     //   'typedef'
1353     //   'constexpr'
1354   case tok::kw_friend:
1355   case tok::kw_typedef:
1356   case tok::kw_constexpr:
1357   case tok::kw_consteval:
1358   case tok::kw_constinit:
1359     // storage-class-specifier
1360   case tok::kw_register:
1361   case tok::kw_static:
1362   case tok::kw_extern:
1363   case tok::kw_mutable:
1364   case tok::kw_auto:
1365   case tok::kw___thread:
1366   case tok::kw_thread_local:
1367   case tok::kw__Thread_local:
1368     // function-specifier
1369   case tok::kw_inline:
1370   case tok::kw_virtual:
1371   case tok::kw_explicit:
1372 
1373     // Modules
1374   case tok::kw___module_private__:
1375 
1376     // Debugger support
1377   case tok::kw___unknown_anytype:
1378 
1379     // type-specifier:
1380     //   simple-type-specifier
1381     //   class-specifier
1382     //   enum-specifier
1383     //   elaborated-type-specifier
1384     //   typename-specifier
1385     //   cv-qualifier
1386 
1387     // class-specifier
1388     // elaborated-type-specifier
1389   case tok::kw_class:
1390   case tok::kw_struct:
1391   case tok::kw_union:
1392   case tok::kw___interface:
1393     // enum-specifier
1394   case tok::kw_enum:
1395     // cv-qualifier
1396   case tok::kw_const:
1397   case tok::kw_volatile:
1398     return TPResult::True;
1399 
1400     // OpenCL address space qualifiers
1401   case tok::kw_private:
1402     if (!getLangOpts().OpenCL)
1403       return TPResult::False;
1404     LLVM_FALLTHROUGH;
1405   case tok::kw___private:
1406   case tok::kw___local:
1407   case tok::kw___global:
1408   case tok::kw___constant:
1409   case tok::kw___generic:
1410     // OpenCL access qualifiers
1411   case tok::kw___read_only:
1412   case tok::kw___write_only:
1413   case tok::kw___read_write:
1414     // OpenCL pipe
1415   case tok::kw_pipe:
1416 
1417     // GNU
1418   case tok::kw_restrict:
1419   case tok::kw__Complex:
1420   case tok::kw___attribute:
1421   case tok::kw___auto_type:
1422     return TPResult::True;
1423 
1424     // Microsoft
1425   case tok::kw___declspec:
1426   case tok::kw___cdecl:
1427   case tok::kw___stdcall:
1428   case tok::kw___fastcall:
1429   case tok::kw___thiscall:
1430   case tok::kw___regcall:
1431   case tok::kw___vectorcall:
1432   case tok::kw___w64:
1433   case tok::kw___sptr:
1434   case tok::kw___uptr:
1435   case tok::kw___ptr64:
1436   case tok::kw___ptr32:
1437   case tok::kw___forceinline:
1438   case tok::kw___unaligned:
1439   case tok::kw__Nonnull:
1440   case tok::kw__Nullable:
1441   case tok::kw__Nullable_result:
1442   case tok::kw__Null_unspecified:
1443   case tok::kw___kindof:
1444     return TPResult::True;
1445 
1446     // Borland
1447   case tok::kw___pascal:
1448     return TPResult::True;
1449 
1450     // AltiVec
1451   case tok::kw___vector:
1452     return TPResult::True;
1453 
1454   case tok::annot_template_id: {
1455     TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
1456     // If lookup for the template-name found nothing, don't assume we have a
1457     // definitive disambiguation result yet.
1458     if ((TemplateId->hasInvalidName() ||
1459          TemplateId->Kind == TNK_Undeclared_template) &&
1460         InvalidAsDeclSpec) {
1461       // 'template-id(' can be a valid expression but not a valid decl spec if
1462       // the template-name is not declared, but we don't consider this to be a
1463       // definitive disambiguation. In any other context, it's an error either
1464       // way.
1465       *InvalidAsDeclSpec = NextToken().is(tok::l_paren);
1466       return TPResult::Ambiguous;
1467     }
1468     if (TemplateId->hasInvalidName())
1469       return TPResult::Error;
1470     if (IsPlaceholderSpecifier(TemplateId, /*Lookahead=*/0))
1471       return TPResult::True;
1472     if (TemplateId->Kind != TNK_Type_template)
1473       return TPResult::False;
1474     CXXScopeSpec SS;
1475     AnnotateTemplateIdTokenAsType(SS);
1476     assert(Tok.is(tok::annot_typename));
1477     goto case_typename;
1478   }
1479 
1480   case tok::annot_cxxscope: // foo::bar or ::foo::bar, but already parsed
1481     // We've already annotated a scope; try to annotate a type.
1482     if (TryAnnotateTypeOrScopeToken())
1483       return TPResult::Error;
1484     if (!Tok.is(tok::annot_typename)) {
1485       if (Tok.is(tok::annot_cxxscope) &&
1486           NextToken().is(tok::annot_template_id)) {
1487         TemplateIdAnnotation *TemplateId =
1488             takeTemplateIdAnnotation(NextToken());
1489         if (TemplateId->hasInvalidName()) {
1490           if (InvalidAsDeclSpec) {
1491             *InvalidAsDeclSpec = NextToken().is(tok::l_paren);
1492             return TPResult::Ambiguous;
1493           }
1494           return TPResult::Error;
1495         }
1496         if (IsPlaceholderSpecifier(TemplateId, /*Lookahead=*/1))
1497           return TPResult::True;
1498       }
1499       // If the next token is an identifier or a type qualifier, then this
1500       // can't possibly be a valid expression either.
1501       if (Tok.is(tok::annot_cxxscope) && NextToken().is(tok::identifier)) {
1502         CXXScopeSpec SS;
1503         Actions.RestoreNestedNameSpecifierAnnotation(Tok.getAnnotationValue(),
1504                                                      Tok.getAnnotationRange(),
1505                                                      SS);
1506         if (SS.getScopeRep() && SS.getScopeRep()->isDependent()) {
1507           RevertingTentativeParsingAction PA(*this);
1508           ConsumeAnnotationToken();
1509           ConsumeToken();
1510           bool isIdentifier = Tok.is(tok::identifier);
1511           TPResult TPR = TPResult::False;
1512           if (!isIdentifier)
1513             TPR = isCXXDeclarationSpecifier(BracedCastResult,
1514                                             InvalidAsDeclSpec);
1515 
1516           if (isIdentifier ||
1517               TPR == TPResult::True || TPR == TPResult::Error)
1518             return TPResult::Error;
1519 
1520           if (InvalidAsDeclSpec) {
1521             // We can't tell whether this is a missing 'typename' or a valid
1522             // expression.
1523             *InvalidAsDeclSpec = true;
1524             return TPResult::Ambiguous;
1525           } else {
1526             // In MS mode, if InvalidAsDeclSpec is not provided, and the tokens
1527             // are or the form *) or &) *> or &> &&>, this can't be an expression.
1528             // The typename must be missing.
1529             if (getLangOpts().MSVCCompat) {
1530               if (((Tok.is(tok::amp) || Tok.is(tok::star)) &&
1531                    (NextToken().is(tok::r_paren) ||
1532                     NextToken().is(tok::greater))) ||
1533                   (Tok.is(tok::ampamp) && NextToken().is(tok::greater)))
1534                 return TPResult::True;
1535             }
1536           }
1537         } else {
1538           // Try to resolve the name. If it doesn't exist, assume it was
1539           // intended to name a type and keep disambiguating.
1540           switch (TryAnnotateName()) {
1541           case ANK_Error:
1542             return TPResult::Error;
1543           case ANK_TentativeDecl:
1544             return TPResult::False;
1545           case ANK_TemplateName:
1546             // In C++17, this could be a type template for class template
1547             // argument deduction.
1548             if (getLangOpts().CPlusPlus17) {
1549               if (TryAnnotateTypeOrScopeToken())
1550                 return TPResult::Error;
1551               if (Tok.isNot(tok::identifier))
1552                 break;
1553             }
1554 
1555             // A bare type template-name which can't be a template template
1556             // argument is an error, and was probably intended to be a type.
1557             // In C++17, this could be class template argument deduction.
1558             return (getLangOpts().CPlusPlus17 || GreaterThanIsOperator)
1559                        ? TPResult::True
1560                        : TPResult::False;
1561           case ANK_Unresolved:
1562             return InvalidAsDeclSpec ? TPResult::Ambiguous : TPResult::False;
1563           case ANK_Success:
1564             break;
1565           }
1566 
1567           // Annotated it, check again.
1568           assert(Tok.isNot(tok::annot_cxxscope) ||
1569                  NextToken().isNot(tok::identifier));
1570           return isCXXDeclarationSpecifier(BracedCastResult, InvalidAsDeclSpec);
1571         }
1572       }
1573       return TPResult::False;
1574     }
1575     // If that succeeded, fallthrough into the generic simple-type-id case.
1576     LLVM_FALLTHROUGH;
1577 
1578     // The ambiguity resides in a simple-type-specifier/typename-specifier
1579     // followed by a '('. The '(' could either be the start of:
1580     //
1581     //   direct-declarator:
1582     //     '(' declarator ')'
1583     //
1584     //   direct-abstract-declarator:
1585     //     '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
1586     //              exception-specification[opt]
1587     //     '(' abstract-declarator ')'
1588     //
1589     // or part of a function-style cast expression:
1590     //
1591     //     simple-type-specifier '(' expression-list[opt] ')'
1592     //
1593 
1594     // simple-type-specifier:
1595 
1596   case tok::annot_typename:
1597   case_typename:
1598     // In Objective-C, we might have a protocol-qualified type.
1599     if (getLangOpts().ObjC && NextToken().is(tok::less)) {
1600       // Tentatively parse the protocol qualifiers.
1601       RevertingTentativeParsingAction PA(*this);
1602       ConsumeAnyToken(); // The type token
1603 
1604       TPResult TPR = TryParseProtocolQualifiers();
1605       bool isFollowedByParen = Tok.is(tok::l_paren);
1606       bool isFollowedByBrace = Tok.is(tok::l_brace);
1607 
1608       if (TPR == TPResult::Error)
1609         return TPResult::Error;
1610 
1611       if (isFollowedByParen)
1612         return TPResult::Ambiguous;
1613 
1614       if (getLangOpts().CPlusPlus11 && isFollowedByBrace)
1615         return BracedCastResult;
1616 
1617       return TPResult::True;
1618     }
1619     LLVM_FALLTHROUGH;
1620 
1621   case tok::kw_char:
1622   case tok::kw_wchar_t:
1623   case tok::kw_char8_t:
1624   case tok::kw_char16_t:
1625   case tok::kw_char32_t:
1626   case tok::kw_bool:
1627   case tok::kw_short:
1628   case tok::kw_int:
1629   case tok::kw_long:
1630   case tok::kw___int64:
1631   case tok::kw___int128:
1632   case tok::kw_signed:
1633   case tok::kw_unsigned:
1634   case tok::kw_half:
1635   case tok::kw_float:
1636   case tok::kw_double:
1637   case tok::kw___bf16:
1638   case tok::kw__Float16:
1639   case tok::kw___float128:
1640   case tok::kw_void:
1641   case tok::annot_decltype:
1642 #define GENERIC_IMAGE_TYPE(ImgType, Id) case tok::kw_##ImgType##_t:
1643 #include "clang/Basic/OpenCLImageTypes.def"
1644     if (NextToken().is(tok::l_paren))
1645       return TPResult::Ambiguous;
1646 
1647     // This is a function-style cast in all cases we disambiguate other than
1648     // one:
1649     //   struct S {
1650     //     enum E : int { a = 4 }; // enum
1651     //     enum E : int { 4 };     // bit-field
1652     //   };
1653     if (getLangOpts().CPlusPlus11 && NextToken().is(tok::l_brace))
1654       return BracedCastResult;
1655 
1656     if (isStartOfObjCClassMessageMissingOpenBracket())
1657       return TPResult::False;
1658 
1659     return TPResult::True;
1660 
1661   // GNU typeof support.
1662   case tok::kw_typeof: {
1663     if (NextToken().isNot(tok::l_paren))
1664       return TPResult::True;
1665 
1666     RevertingTentativeParsingAction PA(*this);
1667 
1668     TPResult TPR = TryParseTypeofSpecifier();
1669     bool isFollowedByParen = Tok.is(tok::l_paren);
1670     bool isFollowedByBrace = Tok.is(tok::l_brace);
1671 
1672     if (TPR == TPResult::Error)
1673       return TPResult::Error;
1674 
1675     if (isFollowedByParen)
1676       return TPResult::Ambiguous;
1677 
1678     if (getLangOpts().CPlusPlus11 && isFollowedByBrace)
1679       return BracedCastResult;
1680 
1681     return TPResult::True;
1682   }
1683 
1684   // C++0x type traits support
1685   case tok::kw___underlying_type:
1686     return TPResult::True;
1687 
1688   // C11 _Atomic
1689   case tok::kw__Atomic:
1690     return TPResult::True;
1691 
1692   case tok::kw__ExtInt: {
1693     if (NextToken().isNot(tok::l_paren))
1694       return TPResult::Error;
1695     RevertingTentativeParsingAction PA(*this);
1696     ConsumeToken();
1697     ConsumeParen();
1698 
1699     if (!SkipUntil(tok::r_paren, StopAtSemi))
1700       return TPResult::Error;
1701 
1702     if (Tok.is(tok::l_paren))
1703       return TPResult::Ambiguous;
1704 
1705     if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace))
1706       return BracedCastResult;
1707 
1708     return TPResult::True;
1709   }
1710   default:
1711     return TPResult::False;
1712   }
1713 }
1714 
1715 bool Parser::isCXXDeclarationSpecifierAType() {
1716   switch (Tok.getKind()) {
1717     // typename-specifier
1718   case tok::annot_decltype:
1719   case tok::annot_template_id:
1720   case tok::annot_typename:
1721   case tok::kw_typeof:
1722   case tok::kw___underlying_type:
1723     return true;
1724 
1725     // elaborated-type-specifier
1726   case tok::kw_class:
1727   case tok::kw_struct:
1728   case tok::kw_union:
1729   case tok::kw___interface:
1730   case tok::kw_enum:
1731     return true;
1732 
1733     // simple-type-specifier
1734   case tok::kw_char:
1735   case tok::kw_wchar_t:
1736   case tok::kw_char8_t:
1737   case tok::kw_char16_t:
1738   case tok::kw_char32_t:
1739   case tok::kw_bool:
1740   case tok::kw_short:
1741   case tok::kw_int:
1742   case tok::kw__ExtInt:
1743   case tok::kw_long:
1744   case tok::kw___int64:
1745   case tok::kw___int128:
1746   case tok::kw_signed:
1747   case tok::kw_unsigned:
1748   case tok::kw_half:
1749   case tok::kw_float:
1750   case tok::kw_double:
1751   case tok::kw___bf16:
1752   case tok::kw__Float16:
1753   case tok::kw___float128:
1754   case tok::kw_void:
1755   case tok::kw___unknown_anytype:
1756   case tok::kw___auto_type:
1757 #define GENERIC_IMAGE_TYPE(ImgType, Id) case tok::kw_##ImgType##_t:
1758 #include "clang/Basic/OpenCLImageTypes.def"
1759     return true;
1760 
1761   case tok::kw_auto:
1762     return getLangOpts().CPlusPlus11;
1763 
1764   case tok::kw__Atomic:
1765     // "_Atomic foo"
1766     return NextToken().is(tok::l_paren);
1767 
1768   default:
1769     return false;
1770   }
1771 }
1772 
1773 /// [GNU] typeof-specifier:
1774 ///         'typeof' '(' expressions ')'
1775 ///         'typeof' '(' type-name ')'
1776 ///
1777 Parser::TPResult Parser::TryParseTypeofSpecifier() {
1778   assert(Tok.is(tok::kw_typeof) && "Expected 'typeof'!");
1779   ConsumeToken();
1780 
1781   assert(Tok.is(tok::l_paren) && "Expected '('");
1782   // Parse through the parens after 'typeof'.
1783   ConsumeParen();
1784   if (!SkipUntil(tok::r_paren, StopAtSemi))
1785     return TPResult::Error;
1786 
1787   return TPResult::Ambiguous;
1788 }
1789 
1790 /// [ObjC] protocol-qualifiers:
1791 ////         '<' identifier-list '>'
1792 Parser::TPResult Parser::TryParseProtocolQualifiers() {
1793   assert(Tok.is(tok::less) && "Expected '<' for qualifier list");
1794   ConsumeToken();
1795   do {
1796     if (Tok.isNot(tok::identifier))
1797       return TPResult::Error;
1798     ConsumeToken();
1799 
1800     if (Tok.is(tok::comma)) {
1801       ConsumeToken();
1802       continue;
1803     }
1804 
1805     if (Tok.is(tok::greater)) {
1806       ConsumeToken();
1807       return TPResult::Ambiguous;
1808     }
1809   } while (false);
1810 
1811   return TPResult::Error;
1812 }
1813 
1814 /// isCXXFunctionDeclarator - Disambiguates between a function declarator or
1815 /// a constructor-style initializer, when parsing declaration statements.
1816 /// Returns true for function declarator and false for constructor-style
1817 /// initializer.
1818 /// If during the disambiguation process a parsing error is encountered,
1819 /// the function returns true to let the declaration parsing code handle it.
1820 ///
1821 /// '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
1822 ///         exception-specification[opt]
1823 ///
1824 bool Parser::isCXXFunctionDeclarator(bool *IsAmbiguous) {
1825 
1826   // C++ 8.2p1:
1827   // The ambiguity arising from the similarity between a function-style cast and
1828   // a declaration mentioned in 6.8 can also occur in the context of a
1829   // declaration. In that context, the choice is between a function declaration
1830   // with a redundant set of parentheses around a parameter name and an object
1831   // declaration with a function-style cast as the initializer. Just as for the
1832   // ambiguities mentioned in 6.8, the resolution is to consider any construct
1833   // that could possibly be a declaration a declaration.
1834 
1835   RevertingTentativeParsingAction PA(*this);
1836 
1837   ConsumeParen();
1838   bool InvalidAsDeclaration = false;
1839   TPResult TPR = TryParseParameterDeclarationClause(&InvalidAsDeclaration);
1840   if (TPR == TPResult::Ambiguous) {
1841     if (Tok.isNot(tok::r_paren))
1842       TPR = TPResult::False;
1843     else {
1844       const Token &Next = NextToken();
1845       if (Next.isOneOf(tok::amp, tok::ampamp, tok::kw_const, tok::kw_volatile,
1846                        tok::kw_throw, tok::kw_noexcept, tok::l_square,
1847                        tok::l_brace, tok::kw_try, tok::equal, tok::arrow) ||
1848           isCXX11VirtSpecifier(Next))
1849         // The next token cannot appear after a constructor-style initializer,
1850         // and can appear next in a function definition. This must be a function
1851         // declarator.
1852         TPR = TPResult::True;
1853       else if (InvalidAsDeclaration)
1854         // Use the absence of 'typename' as a tie-breaker.
1855         TPR = TPResult::False;
1856     }
1857   }
1858 
1859   if (IsAmbiguous && TPR == TPResult::Ambiguous)
1860     *IsAmbiguous = true;
1861 
1862   // In case of an error, let the declaration parsing code handle it.
1863   return TPR != TPResult::False;
1864 }
1865 
1866 /// parameter-declaration-clause:
1867 ///   parameter-declaration-list[opt] '...'[opt]
1868 ///   parameter-declaration-list ',' '...'
1869 ///
1870 /// parameter-declaration-list:
1871 ///   parameter-declaration
1872 ///   parameter-declaration-list ',' parameter-declaration
1873 ///
1874 /// parameter-declaration:
1875 ///   attribute-specifier-seq[opt] decl-specifier-seq declarator attributes[opt]
1876 ///   attribute-specifier-seq[opt] decl-specifier-seq declarator attributes[opt]
1877 ///     '=' assignment-expression
1878 ///   attribute-specifier-seq[opt] decl-specifier-seq abstract-declarator[opt]
1879 ///     attributes[opt]
1880 ///   attribute-specifier-seq[opt] decl-specifier-seq abstract-declarator[opt]
1881 ///     attributes[opt] '=' assignment-expression
1882 ///
1883 Parser::TPResult
1884 Parser::TryParseParameterDeclarationClause(bool *InvalidAsDeclaration,
1885                                            bool VersusTemplateArgument) {
1886 
1887   if (Tok.is(tok::r_paren))
1888     return TPResult::Ambiguous;
1889 
1890   //   parameter-declaration-list[opt] '...'[opt]
1891   //   parameter-declaration-list ',' '...'
1892   //
1893   // parameter-declaration-list:
1894   //   parameter-declaration
1895   //   parameter-declaration-list ',' parameter-declaration
1896   //
1897   while (1) {
1898     // '...'[opt]
1899     if (Tok.is(tok::ellipsis)) {
1900       ConsumeToken();
1901       if (Tok.is(tok::r_paren))
1902         return TPResult::True; // '...)' is a sign of a function declarator.
1903       else
1904         return TPResult::False;
1905     }
1906 
1907     // An attribute-specifier-seq here is a sign of a function declarator.
1908     if (isCXX11AttributeSpecifier(/*Disambiguate*/false,
1909                                   /*OuterMightBeMessageSend*/true))
1910       return TPResult::True;
1911 
1912     ParsedAttributes attrs(AttrFactory);
1913     MaybeParseMicrosoftAttributes(attrs);
1914 
1915     // decl-specifier-seq
1916     // A parameter-declaration's initializer must be preceded by an '=', so
1917     // decl-specifier-seq '{' is not a parameter in C++11.
1918     TPResult TPR = isCXXDeclarationSpecifier(TPResult::False,
1919                                              InvalidAsDeclaration);
1920     // A declaration-specifier (not followed by '(' or '{') means this can't be
1921     // an expression, but it could still be a template argument.
1922     if (TPR != TPResult::Ambiguous &&
1923         !(VersusTemplateArgument && TPR == TPResult::True))
1924       return TPR;
1925 
1926     bool SeenType = false;
1927     do {
1928       SeenType |= isCXXDeclarationSpecifierAType();
1929       if (TryConsumeDeclarationSpecifier() == TPResult::Error)
1930         return TPResult::Error;
1931 
1932       // If we see a parameter name, this can't be a template argument.
1933       if (SeenType && Tok.is(tok::identifier))
1934         return TPResult::True;
1935 
1936       TPR = isCXXDeclarationSpecifier(TPResult::False,
1937                                       InvalidAsDeclaration);
1938       if (TPR == TPResult::Error)
1939         return TPR;
1940 
1941       // Two declaration-specifiers means this can't be an expression.
1942       if (TPR == TPResult::True && !VersusTemplateArgument)
1943         return TPR;
1944     } while (TPR != TPResult::False);
1945 
1946     // declarator
1947     // abstract-declarator[opt]
1948     TPR = TryParseDeclarator(true/*mayBeAbstract*/);
1949     if (TPR != TPResult::Ambiguous)
1950       return TPR;
1951 
1952     // [GNU] attributes[opt]
1953     if (Tok.is(tok::kw___attribute))
1954       return TPResult::True;
1955 
1956     // If we're disambiguating a template argument in a default argument in
1957     // a class definition versus a parameter declaration, an '=' here
1958     // disambiguates the parse one way or the other.
1959     // If this is a parameter, it must have a default argument because
1960     //   (a) the previous parameter did, and
1961     //   (b) this must be the first declaration of the function, so we can't
1962     //       inherit any default arguments from elsewhere.
1963     // FIXME: If we reach a ')' without consuming any '>'s, then this must
1964     // also be a function parameter (that's missing its default argument).
1965     if (VersusTemplateArgument)
1966       return Tok.is(tok::equal) ? TPResult::True : TPResult::False;
1967 
1968     if (Tok.is(tok::equal)) {
1969       // '=' assignment-expression
1970       // Parse through assignment-expression.
1971       if (!SkipUntil(tok::comma, tok::r_paren, StopAtSemi | StopBeforeMatch))
1972         return TPResult::Error;
1973     }
1974 
1975     if (Tok.is(tok::ellipsis)) {
1976       ConsumeToken();
1977       if (Tok.is(tok::r_paren))
1978         return TPResult::True; // '...)' is a sign of a function declarator.
1979       else
1980         return TPResult::False;
1981     }
1982 
1983     if (!TryConsumeToken(tok::comma))
1984       break;
1985   }
1986 
1987   return TPResult::Ambiguous;
1988 }
1989 
1990 /// TryParseFunctionDeclarator - We parsed a '(' and we want to try to continue
1991 /// parsing as a function declarator.
1992 /// If TryParseFunctionDeclarator fully parsed the function declarator, it will
1993 /// return TPResult::Ambiguous, otherwise it will return either False() or
1994 /// Error().
1995 ///
1996 /// '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
1997 ///         exception-specification[opt]
1998 ///
1999 /// exception-specification:
2000 ///   'throw' '(' type-id-list[opt] ')'
2001 ///
2002 Parser::TPResult Parser::TryParseFunctionDeclarator() {
2003   // The '(' is already parsed.
2004 
2005   TPResult TPR = TryParseParameterDeclarationClause();
2006   if (TPR == TPResult::Ambiguous && Tok.isNot(tok::r_paren))
2007     TPR = TPResult::False;
2008 
2009   if (TPR == TPResult::False || TPR == TPResult::Error)
2010     return TPR;
2011 
2012   // Parse through the parens.
2013   if (!SkipUntil(tok::r_paren, StopAtSemi))
2014     return TPResult::Error;
2015 
2016   // cv-qualifier-seq
2017   while (Tok.isOneOf(tok::kw_const, tok::kw_volatile, tok::kw___unaligned,
2018                      tok::kw_restrict))
2019     ConsumeToken();
2020 
2021   // ref-qualifier[opt]
2022   if (Tok.isOneOf(tok::amp, tok::ampamp))
2023     ConsumeToken();
2024 
2025   // exception-specification
2026   if (Tok.is(tok::kw_throw)) {
2027     ConsumeToken();
2028     if (Tok.isNot(tok::l_paren))
2029       return TPResult::Error;
2030 
2031     // Parse through the parens after 'throw'.
2032     ConsumeParen();
2033     if (!SkipUntil(tok::r_paren, StopAtSemi))
2034       return TPResult::Error;
2035   }
2036   if (Tok.is(tok::kw_noexcept)) {
2037     ConsumeToken();
2038     // Possibly an expression as well.
2039     if (Tok.is(tok::l_paren)) {
2040       // Find the matching rparen.
2041       ConsumeParen();
2042       if (!SkipUntil(tok::r_paren, StopAtSemi))
2043         return TPResult::Error;
2044     }
2045   }
2046 
2047   return TPResult::Ambiguous;
2048 }
2049 
2050 /// '[' constant-expression[opt] ']'
2051 ///
2052 Parser::TPResult Parser::TryParseBracketDeclarator() {
2053   ConsumeBracket();
2054 
2055   // A constant-expression cannot begin with a '{', but the
2056   // expr-or-braced-init-list of a postfix-expression can.
2057   if (Tok.is(tok::l_brace))
2058     return TPResult::False;
2059 
2060   if (!SkipUntil(tok::r_square, tok::comma, StopAtSemi | StopBeforeMatch))
2061     return TPResult::Error;
2062 
2063   // If we hit a comma before the ']', this is not a constant-expression,
2064   // but might still be the expr-or-braced-init-list of a postfix-expression.
2065   if (Tok.isNot(tok::r_square))
2066     return TPResult::False;
2067 
2068   ConsumeBracket();
2069   return TPResult::Ambiguous;
2070 }
2071 
2072 /// Determine whether we might be looking at the '<' template-argument-list '>'
2073 /// of a template-id or simple-template-id, rather than a less-than comparison.
2074 /// This will often fail and produce an ambiguity, but should never be wrong
2075 /// if it returns True or False.
2076 Parser::TPResult Parser::isTemplateArgumentList(unsigned TokensToSkip) {
2077   if (!TokensToSkip) {
2078     if (Tok.isNot(tok::less))
2079       return TPResult::False;
2080     if (NextToken().is(tok::greater))
2081       return TPResult::True;
2082   }
2083 
2084   RevertingTentativeParsingAction PA(*this);
2085 
2086   while (TokensToSkip) {
2087     ConsumeAnyToken();
2088     --TokensToSkip;
2089   }
2090 
2091   if (!TryConsumeToken(tok::less))
2092     return TPResult::False;
2093 
2094   // We can't do much to tell an expression apart from a template-argument,
2095   // but one good distinguishing factor is that a "decl-specifier" not
2096   // followed by '(' or '{' can't appear in an expression.
2097   bool InvalidAsTemplateArgumentList = false;
2098   if (isCXXDeclarationSpecifier(TPResult::False,
2099                                        &InvalidAsTemplateArgumentList) ==
2100              TPResult::True)
2101     return TPResult::True;
2102   if (InvalidAsTemplateArgumentList)
2103     return TPResult::False;
2104 
2105   // FIXME: In many contexts, X<thing1, Type> can only be a
2106   // template-argument-list. But that's not true in general:
2107   //
2108   // using b = int;
2109   // void f() {
2110   //   int a = A<B, b, c = C>D; // OK, declares b, not a template-id.
2111   //
2112   // X<Y<0, int> // ', int>' might be end of X's template argument list
2113   //
2114   // We might be able to disambiguate a few more cases if we're careful.
2115 
2116   // A template-argument-list must be terminated by a '>'.
2117   if (SkipUntil({tok::greater, tok::greatergreater, tok::greatergreatergreater},
2118                 StopAtSemi | StopBeforeMatch))
2119     return TPResult::Ambiguous;
2120   return TPResult::False;
2121 }
2122 
2123 /// Determine whether we might be looking at the '(' of a C++20 explicit(bool)
2124 /// in an earlier language mode.
2125 Parser::TPResult Parser::isExplicitBool() {
2126   assert(Tok.is(tok::l_paren) && "expected to be looking at a '(' token");
2127 
2128   RevertingTentativeParsingAction PA(*this);
2129   ConsumeParen();
2130 
2131   // We can only have 'explicit' on a constructor, conversion function, or
2132   // deduction guide. The declarator of a deduction guide cannot be
2133   // parenthesized, so we know this isn't a deduction guide. So the only
2134   // thing we need to check for is some number of parens followed by either
2135   // the current class name or 'operator'.
2136   while (Tok.is(tok::l_paren))
2137     ConsumeParen();
2138 
2139   if (TryAnnotateOptionalCXXScopeToken())
2140     return TPResult::Error;
2141 
2142   // Class-scope constructor and conversion function names can't really be
2143   // qualified, but we get better diagnostics if we assume they can be.
2144   CXXScopeSpec SS;
2145   if (Tok.is(tok::annot_cxxscope)) {
2146     Actions.RestoreNestedNameSpecifierAnnotation(Tok.getAnnotationValue(),
2147                                                  Tok.getAnnotationRange(),
2148                                                  SS);
2149     ConsumeAnnotationToken();
2150   }
2151 
2152   // 'explicit(operator' might be explicit(bool) or the declaration of a
2153   // conversion function, but it's probably a conversion function.
2154   if (Tok.is(tok::kw_operator))
2155     return TPResult::Ambiguous;
2156 
2157   // If this can't be a constructor name, it can only be explicit(bool).
2158   if (Tok.isNot(tok::identifier) && Tok.isNot(tok::annot_template_id))
2159     return TPResult::True;
2160   if (!Actions.isCurrentClassName(Tok.is(tok::identifier)
2161                                       ? *Tok.getIdentifierInfo()
2162                                       : *takeTemplateIdAnnotation(Tok)->Name,
2163                                   getCurScope(), &SS))
2164     return TPResult::True;
2165   // Formally, we must have a right-paren after the constructor name to match
2166   // the grammar for a constructor. But clang permits a parenthesized
2167   // constructor declarator, so also allow a constructor declarator to follow
2168   // with no ')' token after the constructor name.
2169   if (!NextToken().is(tok::r_paren) &&
2170       !isConstructorDeclarator(/*Unqualified=*/SS.isEmpty(),
2171                                /*DeductionGuide=*/false))
2172     return TPResult::True;
2173 
2174   // Might be explicit(bool) or a parenthesized constructor name.
2175   return TPResult::Ambiguous;
2176 }
2177