xref: /freebsd/contrib/llvm-project/clang/lib/Parse/ParseExprCXX.cpp (revision e1e636193db45630c7881246d25902e57c43d24e)
1 //===--- ParseExprCXX.cpp - C++ Expression 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 Expression parsing implementation for C++.
10 //
11 //===----------------------------------------------------------------------===//
12 #include "clang/AST/ASTContext.h"
13 #include "clang/AST/Decl.h"
14 #include "clang/AST/DeclTemplate.h"
15 #include "clang/AST/ExprCXX.h"
16 #include "clang/Basic/PrettyStackTrace.h"
17 #include "clang/Basic/TokenKinds.h"
18 #include "clang/Lex/LiteralSupport.h"
19 #include "clang/Parse/ParseDiagnostic.h"
20 #include "clang/Parse/Parser.h"
21 #include "clang/Parse/RAIIObjectsForParser.h"
22 #include "clang/Sema/DeclSpec.h"
23 #include "clang/Sema/EnterExpressionEvaluationContext.h"
24 #include "clang/Sema/ParsedTemplate.h"
25 #include "clang/Sema/Scope.h"
26 #include "llvm/Support/Compiler.h"
27 #include "llvm/Support/ErrorHandling.h"
28 #include <numeric>
29 
30 using namespace clang;
31 
32 static int SelectDigraphErrorMessage(tok::TokenKind Kind) {
33   switch (Kind) {
34     // template name
35     case tok::unknown:             return 0;
36     // casts
37     case tok::kw_addrspace_cast:   return 1;
38     case tok::kw_const_cast:       return 2;
39     case tok::kw_dynamic_cast:     return 3;
40     case tok::kw_reinterpret_cast: return 4;
41     case tok::kw_static_cast:      return 5;
42     default:
43       llvm_unreachable("Unknown type for digraph error message.");
44   }
45 }
46 
47 // Are the two tokens adjacent in the same source file?
48 bool Parser::areTokensAdjacent(const Token &First, const Token &Second) {
49   SourceManager &SM = PP.getSourceManager();
50   SourceLocation FirstLoc = SM.getSpellingLoc(First.getLocation());
51   SourceLocation FirstEnd = FirstLoc.getLocWithOffset(First.getLength());
52   return FirstEnd == SM.getSpellingLoc(Second.getLocation());
53 }
54 
55 // Suggest fixit for "<::" after a cast.
56 static void FixDigraph(Parser &P, Preprocessor &PP, Token &DigraphToken,
57                        Token &ColonToken, tok::TokenKind Kind, bool AtDigraph) {
58   // Pull '<:' and ':' off token stream.
59   if (!AtDigraph)
60     PP.Lex(DigraphToken);
61   PP.Lex(ColonToken);
62 
63   SourceRange Range;
64   Range.setBegin(DigraphToken.getLocation());
65   Range.setEnd(ColonToken.getLocation());
66   P.Diag(DigraphToken.getLocation(), diag::err_missing_whitespace_digraph)
67       << SelectDigraphErrorMessage(Kind)
68       << FixItHint::CreateReplacement(Range, "< ::");
69 
70   // Update token information to reflect their change in token type.
71   ColonToken.setKind(tok::coloncolon);
72   ColonToken.setLocation(ColonToken.getLocation().getLocWithOffset(-1));
73   ColonToken.setLength(2);
74   DigraphToken.setKind(tok::less);
75   DigraphToken.setLength(1);
76 
77   // Push new tokens back to token stream.
78   PP.EnterToken(ColonToken, /*IsReinject*/ true);
79   if (!AtDigraph)
80     PP.EnterToken(DigraphToken, /*IsReinject*/ true);
81 }
82 
83 // Check for '<::' which should be '< ::' instead of '[:' when following
84 // a template name.
85 void Parser::CheckForTemplateAndDigraph(Token &Next, ParsedType ObjectType,
86                                         bool EnteringContext,
87                                         IdentifierInfo &II, CXXScopeSpec &SS) {
88   if (!Next.is(tok::l_square) || Next.getLength() != 2)
89     return;
90 
91   Token SecondToken = GetLookAheadToken(2);
92   if (!SecondToken.is(tok::colon) || !areTokensAdjacent(Next, SecondToken))
93     return;
94 
95   TemplateTy Template;
96   UnqualifiedId TemplateName;
97   TemplateName.setIdentifier(&II, Tok.getLocation());
98   bool MemberOfUnknownSpecialization;
99   if (!Actions.isTemplateName(getCurScope(), SS, /*hasTemplateKeyword=*/false,
100                               TemplateName, ObjectType, EnteringContext,
101                               Template, MemberOfUnknownSpecialization))
102     return;
103 
104   FixDigraph(*this, PP, Next, SecondToken, tok::unknown,
105              /*AtDigraph*/false);
106 }
107 
108 /// Parse global scope or nested-name-specifier if present.
109 ///
110 /// Parses a C++ global scope specifier ('::') or nested-name-specifier (which
111 /// may be preceded by '::'). Note that this routine will not parse ::new or
112 /// ::delete; it will just leave them in the token stream.
113 ///
114 ///       '::'[opt] nested-name-specifier
115 ///       '::'
116 ///
117 ///       nested-name-specifier:
118 ///         type-name '::'
119 ///         namespace-name '::'
120 ///         nested-name-specifier identifier '::'
121 ///         nested-name-specifier 'template'[opt] simple-template-id '::'
122 ///
123 ///
124 /// \param SS the scope specifier that will be set to the parsed
125 /// nested-name-specifier (or empty)
126 ///
127 /// \param ObjectType if this nested-name-specifier is being parsed following
128 /// the "." or "->" of a member access expression, this parameter provides the
129 /// type of the object whose members are being accessed.
130 ///
131 /// \param ObjectHadErrors if this unqualified-id occurs within a member access
132 /// expression, indicates whether the original subexpressions had any errors.
133 /// When true, diagnostics for missing 'template' keyword will be supressed.
134 ///
135 /// \param EnteringContext whether we will be entering into the context of
136 /// the nested-name-specifier after parsing it.
137 ///
138 /// \param MayBePseudoDestructor When non-NULL, points to a flag that
139 /// indicates whether this nested-name-specifier may be part of a
140 /// pseudo-destructor name. In this case, the flag will be set false
141 /// if we don't actually end up parsing a destructor name. Moreover,
142 /// if we do end up determining that we are parsing a destructor name,
143 /// the last component of the nested-name-specifier is not parsed as
144 /// part of the scope specifier.
145 ///
146 /// \param IsTypename If \c true, this nested-name-specifier is known to be
147 /// part of a type name. This is used to improve error recovery.
148 ///
149 /// \param LastII When non-NULL, points to an IdentifierInfo* that will be
150 /// filled in with the leading identifier in the last component of the
151 /// nested-name-specifier, if any.
152 ///
153 /// \param OnlyNamespace If true, only considers namespaces in lookup.
154 ///
155 ///
156 /// \returns true if there was an error parsing a scope specifier
157 bool Parser::ParseOptionalCXXScopeSpecifier(
158     CXXScopeSpec &SS, ParsedType ObjectType, bool ObjectHadErrors,
159     bool EnteringContext, bool *MayBePseudoDestructor, bool IsTypename,
160     IdentifierInfo **LastII, bool OnlyNamespace, bool InUsingDeclaration) {
161   assert(getLangOpts().CPlusPlus &&
162          "Call sites of this function should be guarded by checking for C++");
163 
164   if (Tok.is(tok::annot_cxxscope)) {
165     assert(!LastII && "want last identifier but have already annotated scope");
166     assert(!MayBePseudoDestructor && "unexpected annot_cxxscope");
167     Actions.RestoreNestedNameSpecifierAnnotation(Tok.getAnnotationValue(),
168                                                  Tok.getAnnotationRange(),
169                                                  SS);
170     ConsumeAnnotationToken();
171     return false;
172   }
173 
174   // Has to happen before any "return false"s in this function.
175   bool CheckForDestructor = false;
176   if (MayBePseudoDestructor && *MayBePseudoDestructor) {
177     CheckForDestructor = true;
178     *MayBePseudoDestructor = false;
179   }
180 
181   if (LastII)
182     *LastII = nullptr;
183 
184   bool HasScopeSpecifier = false;
185 
186   if (Tok.is(tok::coloncolon)) {
187     // ::new and ::delete aren't nested-name-specifiers.
188     tok::TokenKind NextKind = NextToken().getKind();
189     if (NextKind == tok::kw_new || NextKind == tok::kw_delete)
190       return false;
191 
192     if (NextKind == tok::l_brace) {
193       // It is invalid to have :: {, consume the scope qualifier and pretend
194       // like we never saw it.
195       Diag(ConsumeToken(), diag::err_expected) << tok::identifier;
196     } else {
197       // '::' - Global scope qualifier.
198       if (Actions.ActOnCXXGlobalScopeSpecifier(ConsumeToken(), SS))
199         return true;
200 
201       HasScopeSpecifier = true;
202     }
203   }
204 
205   if (Tok.is(tok::kw___super)) {
206     SourceLocation SuperLoc = ConsumeToken();
207     if (!Tok.is(tok::coloncolon)) {
208       Diag(Tok.getLocation(), diag::err_expected_coloncolon_after_super);
209       return true;
210     }
211 
212     return Actions.ActOnSuperScopeSpecifier(SuperLoc, ConsumeToken(), SS);
213   }
214 
215   if (!HasScopeSpecifier &&
216       Tok.isOneOf(tok::kw_decltype, tok::annot_decltype)) {
217     DeclSpec DS(AttrFactory);
218     SourceLocation DeclLoc = Tok.getLocation();
219     SourceLocation EndLoc  = ParseDecltypeSpecifier(DS);
220 
221     SourceLocation CCLoc;
222     // Work around a standard defect: 'decltype(auto)::' is not a
223     // nested-name-specifier.
224     if (DS.getTypeSpecType() == DeclSpec::TST_decltype_auto ||
225         !TryConsumeToken(tok::coloncolon, CCLoc)) {
226       AnnotateExistingDecltypeSpecifier(DS, DeclLoc, EndLoc);
227       return false;
228     }
229 
230     if (Actions.ActOnCXXNestedNameSpecifierDecltype(SS, DS, CCLoc))
231       SS.SetInvalid(SourceRange(DeclLoc, CCLoc));
232 
233     HasScopeSpecifier = true;
234   }
235 
236   // Preferred type might change when parsing qualifiers, we need the original.
237   auto SavedType = PreferredType;
238   while (true) {
239     if (HasScopeSpecifier) {
240       if (Tok.is(tok::code_completion)) {
241         cutOffParsing();
242         // Code completion for a nested-name-specifier, where the code
243         // completion token follows the '::'.
244         Actions.CodeCompleteQualifiedId(getCurScope(), SS, EnteringContext,
245                                         InUsingDeclaration, ObjectType.get(),
246                                         SavedType.get(SS.getBeginLoc()));
247         // Include code completion token into the range of the scope otherwise
248         // when we try to annotate the scope tokens the dangling code completion
249         // token will cause assertion in
250         // Preprocessor::AnnotatePreviousCachedTokens.
251         SS.setEndLoc(Tok.getLocation());
252         return true;
253       }
254 
255       // C++ [basic.lookup.classref]p5:
256       //   If the qualified-id has the form
257       //
258       //       ::class-name-or-namespace-name::...
259       //
260       //   the class-name-or-namespace-name is looked up in global scope as a
261       //   class-name or namespace-name.
262       //
263       // To implement this, we clear out the object type as soon as we've
264       // seen a leading '::' or part of a nested-name-specifier.
265       ObjectType = nullptr;
266     }
267 
268     // nested-name-specifier:
269     //   nested-name-specifier 'template'[opt] simple-template-id '::'
270 
271     // Parse the optional 'template' keyword, then make sure we have
272     // 'identifier <' after it.
273     if (Tok.is(tok::kw_template)) {
274       // If we don't have a scope specifier or an object type, this isn't a
275       // nested-name-specifier, since they aren't allowed to start with
276       // 'template'.
277       if (!HasScopeSpecifier && !ObjectType)
278         break;
279 
280       TentativeParsingAction TPA(*this);
281       SourceLocation TemplateKWLoc = ConsumeToken();
282 
283       UnqualifiedId TemplateName;
284       if (Tok.is(tok::identifier)) {
285         // Consume the identifier.
286         TemplateName.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
287         ConsumeToken();
288       } else if (Tok.is(tok::kw_operator)) {
289         // We don't need to actually parse the unqualified-id in this case,
290         // because a simple-template-id cannot start with 'operator', but
291         // go ahead and parse it anyway for consistency with the case where
292         // we already annotated the template-id.
293         if (ParseUnqualifiedIdOperator(SS, EnteringContext, ObjectType,
294                                        TemplateName)) {
295           TPA.Commit();
296           break;
297         }
298 
299         if (TemplateName.getKind() != UnqualifiedIdKind::IK_OperatorFunctionId &&
300             TemplateName.getKind() != UnqualifiedIdKind::IK_LiteralOperatorId) {
301           Diag(TemplateName.getSourceRange().getBegin(),
302                diag::err_id_after_template_in_nested_name_spec)
303             << TemplateName.getSourceRange();
304           TPA.Commit();
305           break;
306         }
307       } else {
308         TPA.Revert();
309         break;
310       }
311 
312       // If the next token is not '<', we have a qualified-id that refers
313       // to a template name, such as T::template apply, but is not a
314       // template-id.
315       if (Tok.isNot(tok::less)) {
316         TPA.Revert();
317         break;
318       }
319 
320       // Commit to parsing the template-id.
321       TPA.Commit();
322       TemplateTy Template;
323       TemplateNameKind TNK = Actions.ActOnTemplateName(
324           getCurScope(), SS, TemplateKWLoc, TemplateName, ObjectType,
325           EnteringContext, Template, /*AllowInjectedClassName*/ true);
326       if (AnnotateTemplateIdToken(Template, TNK, SS, TemplateKWLoc,
327                                   TemplateName, false))
328         return true;
329 
330       continue;
331     }
332 
333     if (Tok.is(tok::annot_template_id) && NextToken().is(tok::coloncolon)) {
334       // We have
335       //
336       //   template-id '::'
337       //
338       // So we need to check whether the template-id is a simple-template-id of
339       // the right kind (it should name a type or be dependent), and then
340       // convert it into a type within the nested-name-specifier.
341       TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
342       if (CheckForDestructor && GetLookAheadToken(2).is(tok::tilde)) {
343         *MayBePseudoDestructor = true;
344         return false;
345       }
346 
347       if (LastII)
348         *LastII = TemplateId->Name;
349 
350       // Consume the template-id token.
351       ConsumeAnnotationToken();
352 
353       assert(Tok.is(tok::coloncolon) && "NextToken() not working properly!");
354       SourceLocation CCLoc = ConsumeToken();
355 
356       HasScopeSpecifier = true;
357 
358       ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
359                                          TemplateId->NumArgs);
360 
361       if (TemplateId->isInvalid() ||
362           Actions.ActOnCXXNestedNameSpecifier(getCurScope(),
363                                               SS,
364                                               TemplateId->TemplateKWLoc,
365                                               TemplateId->Template,
366                                               TemplateId->TemplateNameLoc,
367                                               TemplateId->LAngleLoc,
368                                               TemplateArgsPtr,
369                                               TemplateId->RAngleLoc,
370                                               CCLoc,
371                                               EnteringContext)) {
372         SourceLocation StartLoc
373           = SS.getBeginLoc().isValid()? SS.getBeginLoc()
374                                       : TemplateId->TemplateNameLoc;
375         SS.SetInvalid(SourceRange(StartLoc, CCLoc));
376       }
377 
378       continue;
379     }
380 
381     // The rest of the nested-name-specifier possibilities start with
382     // tok::identifier.
383     if (Tok.isNot(tok::identifier))
384       break;
385 
386     IdentifierInfo &II = *Tok.getIdentifierInfo();
387 
388     // nested-name-specifier:
389     //   type-name '::'
390     //   namespace-name '::'
391     //   nested-name-specifier identifier '::'
392     Token Next = NextToken();
393     Sema::NestedNameSpecInfo IdInfo(&II, Tok.getLocation(), Next.getLocation(),
394                                     ObjectType);
395 
396     // If we get foo:bar, this is almost certainly a typo for foo::bar.  Recover
397     // and emit a fixit hint for it.
398     if (Next.is(tok::colon) && !ColonIsSacred) {
399       if (Actions.IsInvalidUnlessNestedName(getCurScope(), SS, IdInfo,
400                                             EnteringContext) &&
401           // If the token after the colon isn't an identifier, it's still an
402           // error, but they probably meant something else strange so don't
403           // recover like this.
404           PP.LookAhead(1).is(tok::identifier)) {
405         Diag(Next, diag::err_unexpected_colon_in_nested_name_spec)
406           << FixItHint::CreateReplacement(Next.getLocation(), "::");
407         // Recover as if the user wrote '::'.
408         Next.setKind(tok::coloncolon);
409       }
410     }
411 
412     if (Next.is(tok::coloncolon) && GetLookAheadToken(2).is(tok::l_brace)) {
413       // It is invalid to have :: {, consume the scope qualifier and pretend
414       // like we never saw it.
415       Token Identifier = Tok; // Stash away the identifier.
416       ConsumeToken();         // Eat the identifier, current token is now '::'.
417       Diag(PP.getLocForEndOfToken(ConsumeToken()), diag::err_expected)
418           << tok::identifier;
419       UnconsumeToken(Identifier); // Stick the identifier back.
420       Next = NextToken();         // Point Next at the '{' token.
421     }
422 
423     if (Next.is(tok::coloncolon)) {
424       if (CheckForDestructor && GetLookAheadToken(2).is(tok::tilde)) {
425         *MayBePseudoDestructor = true;
426         return false;
427       }
428 
429       if (ColonIsSacred) {
430         const Token &Next2 = GetLookAheadToken(2);
431         if (Next2.is(tok::kw_private) || Next2.is(tok::kw_protected) ||
432             Next2.is(tok::kw_public) || Next2.is(tok::kw_virtual)) {
433           Diag(Next2, diag::err_unexpected_token_in_nested_name_spec)
434               << Next2.getName()
435               << FixItHint::CreateReplacement(Next.getLocation(), ":");
436           Token ColonColon;
437           PP.Lex(ColonColon);
438           ColonColon.setKind(tok::colon);
439           PP.EnterToken(ColonColon, /*IsReinject*/ true);
440           break;
441         }
442       }
443 
444       if (LastII)
445         *LastII = &II;
446 
447       // We have an identifier followed by a '::'. Lookup this name
448       // as the name in a nested-name-specifier.
449       Token Identifier = Tok;
450       SourceLocation IdLoc = ConsumeToken();
451       assert(Tok.isOneOf(tok::coloncolon, tok::colon) &&
452              "NextToken() not working properly!");
453       Token ColonColon = Tok;
454       SourceLocation CCLoc = ConsumeToken();
455 
456       bool IsCorrectedToColon = false;
457       bool *CorrectionFlagPtr = ColonIsSacred ? &IsCorrectedToColon : nullptr;
458       if (Actions.ActOnCXXNestedNameSpecifier(
459               getCurScope(), IdInfo, EnteringContext, SS, CorrectionFlagPtr,
460               OnlyNamespace)) {
461         // Identifier is not recognized as a nested name, but we can have
462         // mistyped '::' instead of ':'.
463         if (CorrectionFlagPtr && IsCorrectedToColon) {
464           ColonColon.setKind(tok::colon);
465           PP.EnterToken(Tok, /*IsReinject*/ true);
466           PP.EnterToken(ColonColon, /*IsReinject*/ true);
467           Tok = Identifier;
468           break;
469         }
470         SS.SetInvalid(SourceRange(IdLoc, CCLoc));
471       }
472       HasScopeSpecifier = true;
473       continue;
474     }
475 
476     CheckForTemplateAndDigraph(Next, ObjectType, EnteringContext, II, SS);
477 
478     // nested-name-specifier:
479     //   type-name '<'
480     if (Next.is(tok::less)) {
481 
482       TemplateTy Template;
483       UnqualifiedId TemplateName;
484       TemplateName.setIdentifier(&II, Tok.getLocation());
485       bool MemberOfUnknownSpecialization;
486       if (TemplateNameKind TNK = Actions.isTemplateName(getCurScope(), SS,
487                                               /*hasTemplateKeyword=*/false,
488                                                         TemplateName,
489                                                         ObjectType,
490                                                         EnteringContext,
491                                                         Template,
492                                               MemberOfUnknownSpecialization)) {
493         // If lookup didn't find anything, we treat the name as a template-name
494         // anyway. C++20 requires this, and in prior language modes it improves
495         // error recovery. But before we commit to this, check that we actually
496         // have something that looks like a template-argument-list next.
497         if (!IsTypename && TNK == TNK_Undeclared_template &&
498             isTemplateArgumentList(1) == TPResult::False)
499           break;
500 
501         // We have found a template name, so annotate this token
502         // with a template-id annotation. We do not permit the
503         // template-id to be translated into a type annotation,
504         // because some clients (e.g., the parsing of class template
505         // specializations) still want to see the original template-id
506         // token, and it might not be a type at all (e.g. a concept name in a
507         // type-constraint).
508         ConsumeToken();
509         if (AnnotateTemplateIdToken(Template, TNK, SS, SourceLocation(),
510                                     TemplateName, false))
511           return true;
512         continue;
513       }
514 
515       if (MemberOfUnknownSpecialization && (ObjectType || SS.isSet()) &&
516           (IsTypename || isTemplateArgumentList(1) == TPResult::True)) {
517         // If we had errors before, ObjectType can be dependent even without any
518         // templates. Do not report missing template keyword in that case.
519         if (!ObjectHadErrors) {
520           // We have something like t::getAs<T>, where getAs is a
521           // member of an unknown specialization. However, this will only
522           // parse correctly as a template, so suggest the keyword 'template'
523           // before 'getAs' and treat this as a dependent template name.
524           unsigned DiagID = diag::err_missing_dependent_template_keyword;
525           if (getLangOpts().MicrosoftExt)
526             DiagID = diag::warn_missing_dependent_template_keyword;
527 
528           Diag(Tok.getLocation(), DiagID)
529               << II.getName()
530               << FixItHint::CreateInsertion(Tok.getLocation(), "template ");
531         }
532 
533         SourceLocation TemplateNameLoc = ConsumeToken();
534 
535         TemplateNameKind TNK = Actions.ActOnTemplateName(
536             getCurScope(), SS, TemplateNameLoc, TemplateName, ObjectType,
537             EnteringContext, Template, /*AllowInjectedClassName*/ true);
538         if (AnnotateTemplateIdToken(Template, TNK, SS, SourceLocation(),
539                                     TemplateName, false))
540           return true;
541 
542         continue;
543       }
544     }
545 
546     // We don't have any tokens that form the beginning of a
547     // nested-name-specifier, so we're done.
548     break;
549   }
550 
551   // Even if we didn't see any pieces of a nested-name-specifier, we
552   // still check whether there is a tilde in this position, which
553   // indicates a potential pseudo-destructor.
554   if (CheckForDestructor && !HasScopeSpecifier && Tok.is(tok::tilde))
555     *MayBePseudoDestructor = true;
556 
557   return false;
558 }
559 
560 ExprResult Parser::tryParseCXXIdExpression(CXXScopeSpec &SS,
561                                            bool isAddressOfOperand,
562                                            Token &Replacement) {
563   ExprResult E;
564 
565   // We may have already annotated this id-expression.
566   switch (Tok.getKind()) {
567   case tok::annot_non_type: {
568     NamedDecl *ND = getNonTypeAnnotation(Tok);
569     SourceLocation Loc = ConsumeAnnotationToken();
570     E = Actions.ActOnNameClassifiedAsNonType(getCurScope(), SS, ND, Loc, Tok);
571     break;
572   }
573 
574   case tok::annot_non_type_dependent: {
575     IdentifierInfo *II = getIdentifierAnnotation(Tok);
576     SourceLocation Loc = ConsumeAnnotationToken();
577 
578     // This is only the direct operand of an & operator if it is not
579     // followed by a postfix-expression suffix.
580     if (isAddressOfOperand && isPostfixExpressionSuffixStart())
581       isAddressOfOperand = false;
582 
583     E = Actions.ActOnNameClassifiedAsDependentNonType(SS, II, Loc,
584                                                       isAddressOfOperand);
585     break;
586   }
587 
588   case tok::annot_non_type_undeclared: {
589     assert(SS.isEmpty() &&
590            "undeclared non-type annotation should be unqualified");
591     IdentifierInfo *II = getIdentifierAnnotation(Tok);
592     SourceLocation Loc = ConsumeAnnotationToken();
593     E = Actions.ActOnNameClassifiedAsUndeclaredNonType(II, Loc);
594     break;
595   }
596 
597   default:
598     SourceLocation TemplateKWLoc;
599     UnqualifiedId Name;
600     if (ParseUnqualifiedId(SS, /*ObjectType=*/nullptr,
601                            /*ObjectHadErrors=*/false,
602                            /*EnteringContext=*/false,
603                            /*AllowDestructorName=*/false,
604                            /*AllowConstructorName=*/false,
605                            /*AllowDeductionGuide=*/false, &TemplateKWLoc, Name))
606       return ExprError();
607 
608     // This is only the direct operand of an & operator if it is not
609     // followed by a postfix-expression suffix.
610     if (isAddressOfOperand && isPostfixExpressionSuffixStart())
611       isAddressOfOperand = false;
612 
613     E = Actions.ActOnIdExpression(
614         getCurScope(), SS, TemplateKWLoc, Name, Tok.is(tok::l_paren),
615         isAddressOfOperand, /*CCC=*/nullptr, /*IsInlineAsmIdentifier=*/false,
616         &Replacement);
617     break;
618   }
619 
620   if (!E.isInvalid() && !E.isUnset() && Tok.is(tok::less))
621     checkPotentialAngleBracket(E);
622   return E;
623 }
624 
625 /// ParseCXXIdExpression - Handle id-expression.
626 ///
627 ///       id-expression:
628 ///         unqualified-id
629 ///         qualified-id
630 ///
631 ///       qualified-id:
632 ///         '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
633 ///         '::' identifier
634 ///         '::' operator-function-id
635 ///         '::' template-id
636 ///
637 /// NOTE: The standard specifies that, for qualified-id, the parser does not
638 /// expect:
639 ///
640 ///   '::' conversion-function-id
641 ///   '::' '~' class-name
642 ///
643 /// This may cause a slight inconsistency on diagnostics:
644 ///
645 /// class C {};
646 /// namespace A {}
647 /// void f() {
648 ///   :: A :: ~ C(); // Some Sema error about using destructor with a
649 ///                  // namespace.
650 ///   :: ~ C(); // Some Parser error like 'unexpected ~'.
651 /// }
652 ///
653 /// We simplify the parser a bit and make it work like:
654 ///
655 ///       qualified-id:
656 ///         '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
657 ///         '::' unqualified-id
658 ///
659 /// That way Sema can handle and report similar errors for namespaces and the
660 /// global scope.
661 ///
662 /// The isAddressOfOperand parameter indicates that this id-expression is a
663 /// direct operand of the address-of operator. This is, besides member contexts,
664 /// the only place where a qualified-id naming a non-static class member may
665 /// appear.
666 ///
667 ExprResult Parser::ParseCXXIdExpression(bool isAddressOfOperand) {
668   // qualified-id:
669   //   '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
670   //   '::' unqualified-id
671   //
672   CXXScopeSpec SS;
673   ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/nullptr,
674                                  /*ObjectHasErrors=*/false,
675                                  /*EnteringContext=*/false);
676 
677   Token Replacement;
678   ExprResult Result =
679       tryParseCXXIdExpression(SS, isAddressOfOperand, Replacement);
680   if (Result.isUnset()) {
681     // If the ExprResult is valid but null, then typo correction suggested a
682     // keyword replacement that needs to be reparsed.
683     UnconsumeToken(Replacement);
684     Result = tryParseCXXIdExpression(SS, isAddressOfOperand, Replacement);
685   }
686   assert(!Result.isUnset() && "Typo correction suggested a keyword replacement "
687                               "for a previous keyword suggestion");
688   return Result;
689 }
690 
691 /// ParseLambdaExpression - Parse a C++11 lambda expression.
692 ///
693 ///       lambda-expression:
694 ///         lambda-introducer lambda-declarator compound-statement
695 ///         lambda-introducer '<' template-parameter-list '>'
696 ///             requires-clause[opt] lambda-declarator compound-statement
697 ///
698 ///       lambda-introducer:
699 ///         '[' lambda-capture[opt] ']'
700 ///
701 ///       lambda-capture:
702 ///         capture-default
703 ///         capture-list
704 ///         capture-default ',' capture-list
705 ///
706 ///       capture-default:
707 ///         '&'
708 ///         '='
709 ///
710 ///       capture-list:
711 ///         capture
712 ///         capture-list ',' capture
713 ///
714 ///       capture:
715 ///         simple-capture
716 ///         init-capture     [C++1y]
717 ///
718 ///       simple-capture:
719 ///         identifier
720 ///         '&' identifier
721 ///         'this'
722 ///
723 ///       init-capture:      [C++1y]
724 ///         identifier initializer
725 ///         '&' identifier initializer
726 ///
727 ///       lambda-declarator:
728 ///         lambda-specifiers     [C++23]
729 ///         '(' parameter-declaration-clause ')' lambda-specifiers
730 ///             requires-clause[opt]
731 ///
732 ///       lambda-specifiers:
733 ///         decl-specifier-seq[opt] noexcept-specifier[opt]
734 ///             attribute-specifier-seq[opt] trailing-return-type[opt]
735 ///
736 ExprResult Parser::ParseLambdaExpression() {
737   // Parse lambda-introducer.
738   LambdaIntroducer Intro;
739   if (ParseLambdaIntroducer(Intro)) {
740     SkipUntil(tok::r_square, StopAtSemi);
741     SkipUntil(tok::l_brace, StopAtSemi);
742     SkipUntil(tok::r_brace, StopAtSemi);
743     return ExprError();
744   }
745 
746   return ParseLambdaExpressionAfterIntroducer(Intro);
747 }
748 
749 /// Use lookahead and potentially tentative parsing to determine if we are
750 /// looking at a C++11 lambda expression, and parse it if we are.
751 ///
752 /// If we are not looking at a lambda expression, returns ExprError().
753 ExprResult Parser::TryParseLambdaExpression() {
754   assert(getLangOpts().CPlusPlus11
755          && Tok.is(tok::l_square)
756          && "Not at the start of a possible lambda expression.");
757 
758   const Token Next = NextToken();
759   if (Next.is(tok::eof)) // Nothing else to lookup here...
760     return ExprEmpty();
761 
762   const Token After = GetLookAheadToken(2);
763   // If lookahead indicates this is a lambda...
764   if (Next.is(tok::r_square) ||     // []
765       Next.is(tok::equal) ||        // [=
766       (Next.is(tok::amp) &&         // [&] or [&,
767        After.isOneOf(tok::r_square, tok::comma)) ||
768       (Next.is(tok::identifier) &&  // [identifier]
769        After.is(tok::r_square)) ||
770       Next.is(tok::ellipsis)) {     // [...
771     return ParseLambdaExpression();
772   }
773 
774   // If lookahead indicates an ObjC message send...
775   // [identifier identifier
776   if (Next.is(tok::identifier) && After.is(tok::identifier))
777     return ExprEmpty();
778 
779   // Here, we're stuck: lambda introducers and Objective-C message sends are
780   // unambiguous, but it requires arbitrary lookhead.  [a,b,c,d,e,f,g] is a
781   // lambda, and [a,b,c,d,e,f,g h] is a Objective-C message send.  Instead of
782   // writing two routines to parse a lambda introducer, just try to parse
783   // a lambda introducer first, and fall back if that fails.
784   LambdaIntroducer Intro;
785   {
786     TentativeParsingAction TPA(*this);
787     LambdaIntroducerTentativeParse Tentative;
788     if (ParseLambdaIntroducer(Intro, &Tentative)) {
789       TPA.Commit();
790       return ExprError();
791     }
792 
793     switch (Tentative) {
794     case LambdaIntroducerTentativeParse::Success:
795       TPA.Commit();
796       break;
797 
798     case LambdaIntroducerTentativeParse::Incomplete:
799       // Didn't fully parse the lambda-introducer, try again with a
800       // non-tentative parse.
801       TPA.Revert();
802       Intro = LambdaIntroducer();
803       if (ParseLambdaIntroducer(Intro))
804         return ExprError();
805       break;
806 
807     case LambdaIntroducerTentativeParse::MessageSend:
808     case LambdaIntroducerTentativeParse::Invalid:
809       // Not a lambda-introducer, might be a message send.
810       TPA.Revert();
811       return ExprEmpty();
812     }
813   }
814 
815   return ParseLambdaExpressionAfterIntroducer(Intro);
816 }
817 
818 /// Parse a lambda introducer.
819 /// \param Intro A LambdaIntroducer filled in with information about the
820 ///        contents of the lambda-introducer.
821 /// \param Tentative If non-null, we are disambiguating between a
822 ///        lambda-introducer and some other construct. In this mode, we do not
823 ///        produce any diagnostics or take any other irreversible action unless
824 ///        we're sure that this is a lambda-expression.
825 /// \return \c true if parsing (or disambiguation) failed with a diagnostic and
826 ///         the caller should bail out / recover.
827 bool Parser::ParseLambdaIntroducer(LambdaIntroducer &Intro,
828                                    LambdaIntroducerTentativeParse *Tentative) {
829   if (Tentative)
830     *Tentative = LambdaIntroducerTentativeParse::Success;
831 
832   assert(Tok.is(tok::l_square) && "Lambda expressions begin with '['.");
833   BalancedDelimiterTracker T(*this, tok::l_square);
834   T.consumeOpen();
835 
836   Intro.Range.setBegin(T.getOpenLocation());
837 
838   bool First = true;
839 
840   // Produce a diagnostic if we're not tentatively parsing; otherwise track
841   // that our parse has failed.
842   auto Invalid = [&](llvm::function_ref<void()> Action) {
843     if (Tentative) {
844       *Tentative = LambdaIntroducerTentativeParse::Invalid;
845       return false;
846     }
847     Action();
848     return true;
849   };
850 
851   // Perform some irreversible action if this is a non-tentative parse;
852   // otherwise note that our actions were incomplete.
853   auto NonTentativeAction = [&](llvm::function_ref<void()> Action) {
854     if (Tentative)
855       *Tentative = LambdaIntroducerTentativeParse::Incomplete;
856     else
857       Action();
858   };
859 
860   // Parse capture-default.
861   if (Tok.is(tok::amp) &&
862       (NextToken().is(tok::comma) || NextToken().is(tok::r_square))) {
863     Intro.Default = LCD_ByRef;
864     Intro.DefaultLoc = ConsumeToken();
865     First = false;
866     if (!Tok.getIdentifierInfo()) {
867       // This can only be a lambda; no need for tentative parsing any more.
868       // '[[and]]' can still be an attribute, though.
869       Tentative = nullptr;
870     }
871   } else if (Tok.is(tok::equal)) {
872     Intro.Default = LCD_ByCopy;
873     Intro.DefaultLoc = ConsumeToken();
874     First = false;
875     Tentative = nullptr;
876   }
877 
878   while (Tok.isNot(tok::r_square)) {
879     if (!First) {
880       if (Tok.isNot(tok::comma)) {
881         // Provide a completion for a lambda introducer here. Except
882         // in Objective-C, where this is Almost Surely meant to be a message
883         // send. In that case, fail here and let the ObjC message
884         // expression parser perform the completion.
885         if (Tok.is(tok::code_completion) &&
886             !(getLangOpts().ObjC && Tentative)) {
887           cutOffParsing();
888           Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro,
889                                                /*AfterAmpersand=*/false);
890           break;
891         }
892 
893         return Invalid([&] {
894           Diag(Tok.getLocation(), diag::err_expected_comma_or_rsquare);
895         });
896       }
897       ConsumeToken();
898     }
899 
900     if (Tok.is(tok::code_completion)) {
901       cutOffParsing();
902       // If we're in Objective-C++ and we have a bare '[', then this is more
903       // likely to be a message receiver.
904       if (getLangOpts().ObjC && Tentative && First)
905         Actions.CodeCompleteObjCMessageReceiver(getCurScope());
906       else
907         Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro,
908                                              /*AfterAmpersand=*/false);
909       break;
910     }
911 
912     First = false;
913 
914     // Parse capture.
915     LambdaCaptureKind Kind = LCK_ByCopy;
916     LambdaCaptureInitKind InitKind = LambdaCaptureInitKind::NoInit;
917     SourceLocation Loc;
918     IdentifierInfo *Id = nullptr;
919     SourceLocation EllipsisLocs[4];
920     ExprResult Init;
921     SourceLocation LocStart = Tok.getLocation();
922 
923     if (Tok.is(tok::star)) {
924       Loc = ConsumeToken();
925       if (Tok.is(tok::kw_this)) {
926         ConsumeToken();
927         Kind = LCK_StarThis;
928       } else {
929         return Invalid([&] {
930           Diag(Tok.getLocation(), diag::err_expected_star_this_capture);
931         });
932       }
933     } else if (Tok.is(tok::kw_this)) {
934       Kind = LCK_This;
935       Loc = ConsumeToken();
936     } else if (Tok.isOneOf(tok::amp, tok::equal) &&
937                NextToken().isOneOf(tok::comma, tok::r_square) &&
938                Intro.Default == LCD_None) {
939       // We have a lone "&" or "=" which is either a misplaced capture-default
940       // or the start of a capture (in the "&" case) with the rest of the
941       // capture missing. Both are an error but a misplaced capture-default
942       // is more likely if we don't already have a capture default.
943       return Invalid(
944           [&] { Diag(Tok.getLocation(), diag::err_capture_default_first); });
945     } else {
946       TryConsumeToken(tok::ellipsis, EllipsisLocs[0]);
947 
948       if (Tok.is(tok::amp)) {
949         Kind = LCK_ByRef;
950         ConsumeToken();
951 
952         if (Tok.is(tok::code_completion)) {
953           cutOffParsing();
954           Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro,
955                                                /*AfterAmpersand=*/true);
956           break;
957         }
958       }
959 
960       TryConsumeToken(tok::ellipsis, EllipsisLocs[1]);
961 
962       if (Tok.is(tok::identifier)) {
963         Id = Tok.getIdentifierInfo();
964         Loc = ConsumeToken();
965       } else if (Tok.is(tok::kw_this)) {
966         return Invalid([&] {
967           // FIXME: Suggest a fixit here.
968           Diag(Tok.getLocation(), diag::err_this_captured_by_reference);
969         });
970       } else {
971         return Invalid([&] {
972           Diag(Tok.getLocation(), diag::err_expected_capture);
973         });
974       }
975 
976       TryConsumeToken(tok::ellipsis, EllipsisLocs[2]);
977 
978       if (Tok.is(tok::l_paren)) {
979         BalancedDelimiterTracker Parens(*this, tok::l_paren);
980         Parens.consumeOpen();
981 
982         InitKind = LambdaCaptureInitKind::DirectInit;
983 
984         ExprVector Exprs;
985         if (Tentative) {
986           Parens.skipToEnd();
987           *Tentative = LambdaIntroducerTentativeParse::Incomplete;
988         } else if (ParseExpressionList(Exprs)) {
989           Parens.skipToEnd();
990           Init = ExprError();
991         } else {
992           Parens.consumeClose();
993           Init = Actions.ActOnParenListExpr(Parens.getOpenLocation(),
994                                             Parens.getCloseLocation(),
995                                             Exprs);
996         }
997       } else if (Tok.isOneOf(tok::l_brace, tok::equal)) {
998         // Each lambda init-capture forms its own full expression, which clears
999         // Actions.MaybeODRUseExprs. So create an expression evaluation context
1000         // to save the necessary state, and restore it later.
1001         EnterExpressionEvaluationContext EC(
1002             Actions, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
1003 
1004         if (TryConsumeToken(tok::equal))
1005           InitKind = LambdaCaptureInitKind::CopyInit;
1006         else
1007           InitKind = LambdaCaptureInitKind::ListInit;
1008 
1009         if (!Tentative) {
1010           Init = ParseInitializer();
1011         } else if (Tok.is(tok::l_brace)) {
1012           BalancedDelimiterTracker Braces(*this, tok::l_brace);
1013           Braces.consumeOpen();
1014           Braces.skipToEnd();
1015           *Tentative = LambdaIntroducerTentativeParse::Incomplete;
1016         } else {
1017           // We're disambiguating this:
1018           //
1019           //   [..., x = expr
1020           //
1021           // We need to find the end of the following expression in order to
1022           // determine whether this is an Obj-C message send's receiver, a
1023           // C99 designator, or a lambda init-capture.
1024           //
1025           // Parse the expression to find where it ends, and annotate it back
1026           // onto the tokens. We would have parsed this expression the same way
1027           // in either case: both the RHS of an init-capture and the RHS of an
1028           // assignment expression are parsed as an initializer-clause, and in
1029           // neither case can anything be added to the scope between the '[' and
1030           // here.
1031           //
1032           // FIXME: This is horrible. Adding a mechanism to skip an expression
1033           // would be much cleaner.
1034           // FIXME: If there is a ',' before the next ']' or ':', we can skip to
1035           // that instead. (And if we see a ':' with no matching '?', we can
1036           // classify this as an Obj-C message send.)
1037           SourceLocation StartLoc = Tok.getLocation();
1038           InMessageExpressionRAIIObject MaybeInMessageExpression(*this, true);
1039           Init = ParseInitializer();
1040           if (!Init.isInvalid())
1041             Init = Actions.CorrectDelayedTyposInExpr(Init.get());
1042 
1043           if (Tok.getLocation() != StartLoc) {
1044             // Back out the lexing of the token after the initializer.
1045             PP.RevertCachedTokens(1);
1046 
1047             // Replace the consumed tokens with an appropriate annotation.
1048             Tok.setLocation(StartLoc);
1049             Tok.setKind(tok::annot_primary_expr);
1050             setExprAnnotation(Tok, Init);
1051             Tok.setAnnotationEndLoc(PP.getLastCachedTokenLocation());
1052             PP.AnnotateCachedTokens(Tok);
1053 
1054             // Consume the annotated initializer.
1055             ConsumeAnnotationToken();
1056           }
1057         }
1058       }
1059 
1060       TryConsumeToken(tok::ellipsis, EllipsisLocs[3]);
1061     }
1062 
1063     // Check if this is a message send before we act on a possible init-capture.
1064     if (Tentative && Tok.is(tok::identifier) &&
1065         NextToken().isOneOf(tok::colon, tok::r_square)) {
1066       // This can only be a message send. We're done with disambiguation.
1067       *Tentative = LambdaIntroducerTentativeParse::MessageSend;
1068       return false;
1069     }
1070 
1071     // Ensure that any ellipsis was in the right place.
1072     SourceLocation EllipsisLoc;
1073     if (llvm::any_of(EllipsisLocs,
1074                      [](SourceLocation Loc) { return Loc.isValid(); })) {
1075       // The '...' should appear before the identifier in an init-capture, and
1076       // after the identifier otherwise.
1077       bool InitCapture = InitKind != LambdaCaptureInitKind::NoInit;
1078       SourceLocation *ExpectedEllipsisLoc =
1079           !InitCapture      ? &EllipsisLocs[2] :
1080           Kind == LCK_ByRef ? &EllipsisLocs[1] :
1081                               &EllipsisLocs[0];
1082       EllipsisLoc = *ExpectedEllipsisLoc;
1083 
1084       unsigned DiagID = 0;
1085       if (EllipsisLoc.isInvalid()) {
1086         DiagID = diag::err_lambda_capture_misplaced_ellipsis;
1087         for (SourceLocation Loc : EllipsisLocs) {
1088           if (Loc.isValid())
1089             EllipsisLoc = Loc;
1090         }
1091       } else {
1092         unsigned NumEllipses = std::accumulate(
1093             std::begin(EllipsisLocs), std::end(EllipsisLocs), 0,
1094             [](int N, SourceLocation Loc) { return N + Loc.isValid(); });
1095         if (NumEllipses > 1)
1096           DiagID = diag::err_lambda_capture_multiple_ellipses;
1097       }
1098       if (DiagID) {
1099         NonTentativeAction([&] {
1100           // Point the diagnostic at the first misplaced ellipsis.
1101           SourceLocation DiagLoc;
1102           for (SourceLocation &Loc : EllipsisLocs) {
1103             if (&Loc != ExpectedEllipsisLoc && Loc.isValid()) {
1104               DiagLoc = Loc;
1105               break;
1106             }
1107           }
1108           assert(DiagLoc.isValid() && "no location for diagnostic");
1109 
1110           // Issue the diagnostic and produce fixits showing where the ellipsis
1111           // should have been written.
1112           auto &&D = Diag(DiagLoc, DiagID);
1113           if (DiagID == diag::err_lambda_capture_misplaced_ellipsis) {
1114             SourceLocation ExpectedLoc =
1115                 InitCapture ? Loc
1116                             : Lexer::getLocForEndOfToken(
1117                                   Loc, 0, PP.getSourceManager(), getLangOpts());
1118             D << InitCapture << FixItHint::CreateInsertion(ExpectedLoc, "...");
1119           }
1120           for (SourceLocation &Loc : EllipsisLocs) {
1121             if (&Loc != ExpectedEllipsisLoc && Loc.isValid())
1122               D << FixItHint::CreateRemoval(Loc);
1123           }
1124         });
1125       }
1126     }
1127 
1128     // Process the init-capture initializers now rather than delaying until we
1129     // form the lambda-expression so that they can be handled in the context
1130     // enclosing the lambda-expression, rather than in the context of the
1131     // lambda-expression itself.
1132     ParsedType InitCaptureType;
1133     if (Init.isUsable())
1134       Init = Actions.CorrectDelayedTyposInExpr(Init.get());
1135     if (Init.isUsable()) {
1136       NonTentativeAction([&] {
1137         // Get the pointer and store it in an lvalue, so we can use it as an
1138         // out argument.
1139         Expr *InitExpr = Init.get();
1140         // This performs any lvalue-to-rvalue conversions if necessary, which
1141         // can affect what gets captured in the containing decl-context.
1142         InitCaptureType = Actions.actOnLambdaInitCaptureInitialization(
1143             Loc, Kind == LCK_ByRef, EllipsisLoc, Id, InitKind, InitExpr);
1144         Init = InitExpr;
1145       });
1146     }
1147 
1148     SourceLocation LocEnd = PrevTokLocation;
1149 
1150     Intro.addCapture(Kind, Loc, Id, EllipsisLoc, InitKind, Init,
1151                      InitCaptureType, SourceRange(LocStart, LocEnd));
1152   }
1153 
1154   T.consumeClose();
1155   Intro.Range.setEnd(T.getCloseLocation());
1156   return false;
1157 }
1158 
1159 static void tryConsumeLambdaSpecifierToken(Parser &P,
1160                                            SourceLocation &MutableLoc,
1161                                            SourceLocation &StaticLoc,
1162                                            SourceLocation &ConstexprLoc,
1163                                            SourceLocation &ConstevalLoc,
1164                                            SourceLocation &DeclEndLoc) {
1165   assert(MutableLoc.isInvalid());
1166   assert(StaticLoc.isInvalid());
1167   assert(ConstexprLoc.isInvalid());
1168   assert(ConstevalLoc.isInvalid());
1169   // Consume constexpr-opt mutable-opt in any sequence, and set the DeclEndLoc
1170   // to the final of those locations. Emit an error if we have multiple
1171   // copies of those keywords and recover.
1172 
1173   auto ConsumeLocation = [&P, &DeclEndLoc](SourceLocation &SpecifierLoc,
1174                                            int DiagIndex) {
1175     if (SpecifierLoc.isValid()) {
1176       P.Diag(P.getCurToken().getLocation(),
1177              diag::err_lambda_decl_specifier_repeated)
1178           << DiagIndex
1179           << FixItHint::CreateRemoval(P.getCurToken().getLocation());
1180     }
1181     SpecifierLoc = P.ConsumeToken();
1182     DeclEndLoc = SpecifierLoc;
1183   };
1184 
1185   while (true) {
1186     switch (P.getCurToken().getKind()) {
1187     case tok::kw_mutable:
1188       ConsumeLocation(MutableLoc, 0);
1189       break;
1190     case tok::kw_static:
1191       ConsumeLocation(StaticLoc, 1);
1192       break;
1193     case tok::kw_constexpr:
1194       ConsumeLocation(ConstexprLoc, 2);
1195       break;
1196     case tok::kw_consteval:
1197       ConsumeLocation(ConstevalLoc, 3);
1198       break;
1199     default:
1200       return;
1201     }
1202   }
1203 }
1204 
1205 static void addStaticToLambdaDeclSpecifier(Parser &P, SourceLocation StaticLoc,
1206                                            DeclSpec &DS) {
1207   if (StaticLoc.isValid()) {
1208     P.Diag(StaticLoc, !P.getLangOpts().CPlusPlus23
1209                           ? diag::err_static_lambda
1210                           : diag::warn_cxx20_compat_static_lambda);
1211     const char *PrevSpec = nullptr;
1212     unsigned DiagID = 0;
1213     DS.SetStorageClassSpec(P.getActions(), DeclSpec::SCS_static, StaticLoc,
1214                            PrevSpec, DiagID,
1215                            P.getActions().getASTContext().getPrintingPolicy());
1216     assert(PrevSpec == nullptr && DiagID == 0 &&
1217            "Static cannot have been set previously!");
1218   }
1219 }
1220 
1221 static void
1222 addConstexprToLambdaDeclSpecifier(Parser &P, SourceLocation ConstexprLoc,
1223                                   DeclSpec &DS) {
1224   if (ConstexprLoc.isValid()) {
1225     P.Diag(ConstexprLoc, !P.getLangOpts().CPlusPlus17
1226                              ? diag::ext_constexpr_on_lambda_cxx17
1227                              : diag::warn_cxx14_compat_constexpr_on_lambda);
1228     const char *PrevSpec = nullptr;
1229     unsigned DiagID = 0;
1230     DS.SetConstexprSpec(ConstexprSpecKind::Constexpr, ConstexprLoc, PrevSpec,
1231                         DiagID);
1232     assert(PrevSpec == nullptr && DiagID == 0 &&
1233            "Constexpr cannot have been set previously!");
1234   }
1235 }
1236 
1237 static void addConstevalToLambdaDeclSpecifier(Parser &P,
1238                                               SourceLocation ConstevalLoc,
1239                                               DeclSpec &DS) {
1240   if (ConstevalLoc.isValid()) {
1241     P.Diag(ConstevalLoc, diag::warn_cxx20_compat_consteval);
1242     const char *PrevSpec = nullptr;
1243     unsigned DiagID = 0;
1244     DS.SetConstexprSpec(ConstexprSpecKind::Consteval, ConstevalLoc, PrevSpec,
1245                         DiagID);
1246     if (DiagID != 0)
1247       P.Diag(ConstevalLoc, DiagID) << PrevSpec;
1248   }
1249 }
1250 
1251 static void DiagnoseStaticSpecifierRestrictions(Parser &P,
1252                                                 SourceLocation StaticLoc,
1253                                                 SourceLocation MutableLoc,
1254                                                 const LambdaIntroducer &Intro) {
1255   if (StaticLoc.isInvalid())
1256     return;
1257 
1258   // [expr.prim.lambda.general] p4
1259   // The lambda-specifier-seq shall not contain both mutable and static.
1260   // If the lambda-specifier-seq contains static, there shall be no
1261   // lambda-capture.
1262   if (MutableLoc.isValid())
1263     P.Diag(StaticLoc, diag::err_static_mutable_lambda);
1264   if (Intro.hasLambdaCapture()) {
1265     P.Diag(StaticLoc, diag::err_static_lambda_captures);
1266   }
1267 }
1268 
1269 /// ParseLambdaExpressionAfterIntroducer - Parse the rest of a lambda
1270 /// expression.
1271 ExprResult Parser::ParseLambdaExpressionAfterIntroducer(
1272                      LambdaIntroducer &Intro) {
1273   SourceLocation LambdaBeginLoc = Intro.Range.getBegin();
1274   Diag(LambdaBeginLoc, diag::warn_cxx98_compat_lambda);
1275 
1276   PrettyStackTraceLoc CrashInfo(PP.getSourceManager(), LambdaBeginLoc,
1277                                 "lambda expression parsing");
1278 
1279   // Parse lambda-declarator[opt].
1280   DeclSpec DS(AttrFactory);
1281   Declarator D(DS, ParsedAttributesView::none(), DeclaratorContext::LambdaExpr);
1282   TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth);
1283 
1284   ParseScope LambdaScope(this, Scope::LambdaScope | Scope::DeclScope |
1285                                    Scope::FunctionDeclarationScope |
1286                                    Scope::FunctionPrototypeScope);
1287 
1288   Actions.PushLambdaScope();
1289   Actions.ActOnLambdaExpressionAfterIntroducer(Intro, getCurScope());
1290 
1291   ParsedAttributes Attributes(AttrFactory);
1292   if (getLangOpts().CUDA) {
1293     // In CUDA code, GNU attributes are allowed to appear immediately after the
1294     // "[...]", even if there is no "(...)" before the lambda body.
1295     //
1296     // Note that we support __noinline__ as a keyword in this mode and thus
1297     // it has to be separately handled.
1298     while (true) {
1299       if (Tok.is(tok::kw___noinline__)) {
1300         IdentifierInfo *AttrName = Tok.getIdentifierInfo();
1301         SourceLocation AttrNameLoc = ConsumeToken();
1302         Attributes.addNew(AttrName, AttrNameLoc, /*ScopeName=*/nullptr,
1303                           AttrNameLoc, /*ArgsUnion=*/nullptr,
1304                           /*numArgs=*/0, tok::kw___noinline__);
1305       } else if (Tok.is(tok::kw___attribute))
1306         ParseGNUAttributes(Attributes, /*LatePArsedAttrList=*/nullptr, &D);
1307       else
1308         break;
1309     }
1310 
1311     D.takeAttributes(Attributes);
1312   }
1313 
1314   MultiParseScope TemplateParamScope(*this);
1315   if (Tok.is(tok::less)) {
1316     Diag(Tok, getLangOpts().CPlusPlus20
1317                   ? diag::warn_cxx17_compat_lambda_template_parameter_list
1318                   : diag::ext_lambda_template_parameter_list);
1319 
1320     SmallVector<NamedDecl*, 4> TemplateParams;
1321     SourceLocation LAngleLoc, RAngleLoc;
1322     if (ParseTemplateParameters(TemplateParamScope,
1323                                 CurTemplateDepthTracker.getDepth(),
1324                                 TemplateParams, LAngleLoc, RAngleLoc)) {
1325       Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope());
1326       return ExprError();
1327     }
1328 
1329     if (TemplateParams.empty()) {
1330       Diag(RAngleLoc,
1331            diag::err_lambda_template_parameter_list_empty);
1332     } else {
1333       ExprResult RequiresClause;
1334       if (TryConsumeToken(tok::kw_requires)) {
1335         RequiresClause =
1336             Actions.ActOnRequiresClause(ParseConstraintLogicalOrExpression(
1337                 /*IsTrailingRequiresClause=*/false));
1338         if (RequiresClause.isInvalid())
1339           SkipUntil({tok::l_brace, tok::l_paren}, StopAtSemi | StopBeforeMatch);
1340       }
1341 
1342       Actions.ActOnLambdaExplicitTemplateParameterList(
1343           Intro, LAngleLoc, TemplateParams, RAngleLoc, RequiresClause);
1344       ++CurTemplateDepthTracker;
1345     }
1346   }
1347 
1348   // Implement WG21 P2173, which allows attributes immediately before the
1349   // lambda declarator and applies them to the corresponding function operator
1350   // or operator template declaration. We accept this as a conforming extension
1351   // in all language modes that support lambdas.
1352   if (isCXX11AttributeSpecifier()) {
1353     Diag(Tok, getLangOpts().CPlusPlus23
1354                   ? diag::warn_cxx20_compat_decl_attrs_on_lambda
1355                   : diag::ext_decl_attrs_on_lambda)
1356         << Tok.getIdentifierInfo() << Tok.isRegularKeywordAttribute();
1357     MaybeParseCXX11Attributes(D);
1358   }
1359 
1360   TypeResult TrailingReturnType;
1361   SourceLocation TrailingReturnTypeLoc;
1362   SourceLocation LParenLoc, RParenLoc;
1363   SourceLocation DeclEndLoc;
1364   bool HasParentheses = false;
1365   bool HasSpecifiers = false;
1366   SourceLocation MutableLoc;
1367 
1368   ParseScope Prototype(this, Scope::FunctionPrototypeScope |
1369                                  Scope::FunctionDeclarationScope |
1370                                  Scope::DeclScope);
1371 
1372   // Parse parameter-declaration-clause.
1373   SmallVector<DeclaratorChunk::ParamInfo, 16> ParamInfo;
1374   SourceLocation EllipsisLoc;
1375 
1376   if (Tok.is(tok::l_paren)) {
1377     BalancedDelimiterTracker T(*this, tok::l_paren);
1378     T.consumeOpen();
1379     LParenLoc = T.getOpenLocation();
1380 
1381     if (Tok.isNot(tok::r_paren)) {
1382       Actions.RecordParsingTemplateParameterDepth(
1383           CurTemplateDepthTracker.getOriginalDepth());
1384 
1385       ParseParameterDeclarationClause(D, Attributes, ParamInfo, EllipsisLoc);
1386       // For a generic lambda, each 'auto' within the parameter declaration
1387       // clause creates a template type parameter, so increment the depth.
1388       // If we've parsed any explicit template parameters, then the depth will
1389       // have already been incremented. So we make sure that at most a single
1390       // depth level is added.
1391       if (Actions.getCurGenericLambda())
1392         CurTemplateDepthTracker.setAddedDepth(1);
1393     }
1394 
1395     T.consumeClose();
1396     DeclEndLoc = RParenLoc = T.getCloseLocation();
1397     HasParentheses = true;
1398   }
1399 
1400   HasSpecifiers =
1401       Tok.isOneOf(tok::kw_mutable, tok::arrow, tok::kw___attribute,
1402                   tok::kw_constexpr, tok::kw_consteval, tok::kw_static,
1403                   tok::kw___private, tok::kw___global, tok::kw___local,
1404                   tok::kw___constant, tok::kw___generic, tok::kw_groupshared,
1405                   tok::kw_requires, tok::kw_noexcept) ||
1406       Tok.isRegularKeywordAttribute() ||
1407       (Tok.is(tok::l_square) && NextToken().is(tok::l_square));
1408 
1409   if (HasSpecifiers && !HasParentheses && !getLangOpts().CPlusPlus23) {
1410     // It's common to forget that one needs '()' before 'mutable', an
1411     // attribute specifier, the result type, or the requires clause. Deal with
1412     // this.
1413     Diag(Tok, diag::ext_lambda_missing_parens)
1414         << FixItHint::CreateInsertion(Tok.getLocation(), "() ");
1415   }
1416 
1417   if (HasParentheses || HasSpecifiers) {
1418     // GNU-style attributes must be parsed before the mutable specifier to
1419     // be compatible with GCC. MSVC-style attributes must be parsed before
1420     // the mutable specifier to be compatible with MSVC.
1421     MaybeParseAttributes(PAKM_GNU | PAKM_Declspec, Attributes);
1422     // Parse mutable-opt and/or constexpr-opt or consteval-opt, and update
1423     // the DeclEndLoc.
1424     SourceLocation ConstexprLoc;
1425     SourceLocation ConstevalLoc;
1426     SourceLocation StaticLoc;
1427 
1428     tryConsumeLambdaSpecifierToken(*this, MutableLoc, StaticLoc, ConstexprLoc,
1429                                    ConstevalLoc, DeclEndLoc);
1430 
1431     DiagnoseStaticSpecifierRestrictions(*this, StaticLoc, MutableLoc, Intro);
1432 
1433     addStaticToLambdaDeclSpecifier(*this, StaticLoc, DS);
1434     addConstexprToLambdaDeclSpecifier(*this, ConstexprLoc, DS);
1435     addConstevalToLambdaDeclSpecifier(*this, ConstevalLoc, DS);
1436   }
1437 
1438   Actions.ActOnLambdaClosureParameters(getCurScope(), ParamInfo);
1439 
1440   if (!HasParentheses)
1441     Actions.ActOnLambdaClosureQualifiers(Intro, MutableLoc);
1442 
1443   if (HasSpecifiers || HasParentheses) {
1444     // Parse exception-specification[opt].
1445     ExceptionSpecificationType ESpecType = EST_None;
1446     SourceRange ESpecRange;
1447     SmallVector<ParsedType, 2> DynamicExceptions;
1448     SmallVector<SourceRange, 2> DynamicExceptionRanges;
1449     ExprResult NoexceptExpr;
1450     CachedTokens *ExceptionSpecTokens;
1451 
1452     ESpecType = tryParseExceptionSpecification(
1453         /*Delayed=*/false, ESpecRange, DynamicExceptions,
1454         DynamicExceptionRanges, NoexceptExpr, ExceptionSpecTokens);
1455 
1456     if (ESpecType != EST_None)
1457       DeclEndLoc = ESpecRange.getEnd();
1458 
1459     // Parse attribute-specifier[opt].
1460     if (MaybeParseCXX11Attributes(Attributes))
1461       DeclEndLoc = Attributes.Range.getEnd();
1462 
1463     // Parse OpenCL addr space attribute.
1464     if (Tok.isOneOf(tok::kw___private, tok::kw___global, tok::kw___local,
1465                     tok::kw___constant, tok::kw___generic)) {
1466       ParseOpenCLQualifiers(DS.getAttributes());
1467       ConsumeToken();
1468     }
1469 
1470     SourceLocation FunLocalRangeEnd = DeclEndLoc;
1471 
1472     // Parse trailing-return-type[opt].
1473     if (Tok.is(tok::arrow)) {
1474       FunLocalRangeEnd = Tok.getLocation();
1475       SourceRange Range;
1476       TrailingReturnType =
1477           ParseTrailingReturnType(Range, /*MayBeFollowedByDirectInit=*/false);
1478       TrailingReturnTypeLoc = Range.getBegin();
1479       if (Range.getEnd().isValid())
1480         DeclEndLoc = Range.getEnd();
1481     }
1482 
1483     SourceLocation NoLoc;
1484     D.AddTypeInfo(DeclaratorChunk::getFunction(
1485                       /*HasProto=*/true,
1486                       /*IsAmbiguous=*/false, LParenLoc, ParamInfo.data(),
1487                       ParamInfo.size(), EllipsisLoc, RParenLoc,
1488                       /*RefQualifierIsLvalueRef=*/true,
1489                       /*RefQualifierLoc=*/NoLoc, MutableLoc, ESpecType,
1490                       ESpecRange, DynamicExceptions.data(),
1491                       DynamicExceptionRanges.data(), DynamicExceptions.size(),
1492                       NoexceptExpr.isUsable() ? NoexceptExpr.get() : nullptr,
1493                       /*ExceptionSpecTokens*/ nullptr,
1494                       /*DeclsInPrototype=*/std::nullopt, LParenLoc,
1495                       FunLocalRangeEnd, D, TrailingReturnType,
1496                       TrailingReturnTypeLoc, &DS),
1497                   std::move(Attributes), DeclEndLoc);
1498 
1499     Actions.ActOnLambdaClosureQualifiers(Intro, MutableLoc);
1500 
1501     if (HasParentheses && Tok.is(tok::kw_requires))
1502       ParseTrailingRequiresClause(D);
1503   }
1504 
1505   // Emit a warning if we see a CUDA host/device/global attribute
1506   // after '(...)'. nvcc doesn't accept this.
1507   if (getLangOpts().CUDA) {
1508     for (const ParsedAttr &A : Attributes)
1509       if (A.getKind() == ParsedAttr::AT_CUDADevice ||
1510           A.getKind() == ParsedAttr::AT_CUDAHost ||
1511           A.getKind() == ParsedAttr::AT_CUDAGlobal)
1512         Diag(A.getLoc(), diag::warn_cuda_attr_lambda_position)
1513             << A.getAttrName()->getName();
1514   }
1515 
1516   Prototype.Exit();
1517 
1518   // FIXME: Rename BlockScope -> ClosureScope if we decide to continue using
1519   // it.
1520   unsigned ScopeFlags = Scope::BlockScope | Scope::FnScope | Scope::DeclScope |
1521                         Scope::CompoundStmtScope;
1522   ParseScope BodyScope(this, ScopeFlags);
1523 
1524   Actions.ActOnStartOfLambdaDefinition(Intro, D, DS);
1525 
1526   // Parse compound-statement.
1527   if (!Tok.is(tok::l_brace)) {
1528     Diag(Tok, diag::err_expected_lambda_body);
1529     Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope());
1530     return ExprError();
1531   }
1532 
1533   StmtResult Stmt(ParseCompoundStatementBody());
1534   BodyScope.Exit();
1535   TemplateParamScope.Exit();
1536   LambdaScope.Exit();
1537 
1538   if (!Stmt.isInvalid() && !TrailingReturnType.isInvalid() &&
1539       !D.isInvalidType())
1540     return Actions.ActOnLambdaExpr(LambdaBeginLoc, Stmt.get());
1541 
1542   Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope());
1543   return ExprError();
1544 }
1545 
1546 /// ParseCXXCasts - This handles the various ways to cast expressions to another
1547 /// type.
1548 ///
1549 ///       postfix-expression: [C++ 5.2p1]
1550 ///         'dynamic_cast' '<' type-name '>' '(' expression ')'
1551 ///         'static_cast' '<' type-name '>' '(' expression ')'
1552 ///         'reinterpret_cast' '<' type-name '>' '(' expression ')'
1553 ///         'const_cast' '<' type-name '>' '(' expression ')'
1554 ///
1555 /// C++ for OpenCL s2.3.1 adds:
1556 ///         'addrspace_cast' '<' type-name '>' '(' expression ')'
1557 ExprResult Parser::ParseCXXCasts() {
1558   tok::TokenKind Kind = Tok.getKind();
1559   const char *CastName = nullptr; // For error messages
1560 
1561   switch (Kind) {
1562   default: llvm_unreachable("Unknown C++ cast!");
1563   case tok::kw_addrspace_cast:   CastName = "addrspace_cast";   break;
1564   case tok::kw_const_cast:       CastName = "const_cast";       break;
1565   case tok::kw_dynamic_cast:     CastName = "dynamic_cast";     break;
1566   case tok::kw_reinterpret_cast: CastName = "reinterpret_cast"; break;
1567   case tok::kw_static_cast:      CastName = "static_cast";      break;
1568   }
1569 
1570   SourceLocation OpLoc = ConsumeToken();
1571   SourceLocation LAngleBracketLoc = Tok.getLocation();
1572 
1573   // Check for "<::" which is parsed as "[:".  If found, fix token stream,
1574   // diagnose error, suggest fix, and recover parsing.
1575   if (Tok.is(tok::l_square) && Tok.getLength() == 2) {
1576     Token Next = NextToken();
1577     if (Next.is(tok::colon) && areTokensAdjacent(Tok, Next))
1578       FixDigraph(*this, PP, Tok, Next, Kind, /*AtDigraph*/true);
1579   }
1580 
1581   if (ExpectAndConsume(tok::less, diag::err_expected_less_after, CastName))
1582     return ExprError();
1583 
1584   // Parse the common declaration-specifiers piece.
1585   DeclSpec DS(AttrFactory);
1586   ParseSpecifierQualifierList(DS, /*AccessSpecifier=*/AS_none,
1587                               DeclSpecContext::DSC_type_specifier);
1588 
1589   // Parse the abstract-declarator, if present.
1590   Declarator DeclaratorInfo(DS, ParsedAttributesView::none(),
1591                             DeclaratorContext::TypeName);
1592   ParseDeclarator(DeclaratorInfo);
1593 
1594   SourceLocation RAngleBracketLoc = Tok.getLocation();
1595 
1596   if (ExpectAndConsume(tok::greater))
1597     return ExprError(Diag(LAngleBracketLoc, diag::note_matching) << tok::less);
1598 
1599   BalancedDelimiterTracker T(*this, tok::l_paren);
1600 
1601   if (T.expectAndConsume(diag::err_expected_lparen_after, CastName))
1602     return ExprError();
1603 
1604   ExprResult Result = ParseExpression();
1605 
1606   // Match the ')'.
1607   T.consumeClose();
1608 
1609   if (!Result.isInvalid() && !DeclaratorInfo.isInvalidType())
1610     Result = Actions.ActOnCXXNamedCast(OpLoc, Kind,
1611                                        LAngleBracketLoc, DeclaratorInfo,
1612                                        RAngleBracketLoc,
1613                                        T.getOpenLocation(), Result.get(),
1614                                        T.getCloseLocation());
1615 
1616   return Result;
1617 }
1618 
1619 /// ParseCXXTypeid - This handles the C++ typeid expression.
1620 ///
1621 ///       postfix-expression: [C++ 5.2p1]
1622 ///         'typeid' '(' expression ')'
1623 ///         'typeid' '(' type-id ')'
1624 ///
1625 ExprResult Parser::ParseCXXTypeid() {
1626   assert(Tok.is(tok::kw_typeid) && "Not 'typeid'!");
1627 
1628   SourceLocation OpLoc = ConsumeToken();
1629   SourceLocation LParenLoc, RParenLoc;
1630   BalancedDelimiterTracker T(*this, tok::l_paren);
1631 
1632   // typeid expressions are always parenthesized.
1633   if (T.expectAndConsume(diag::err_expected_lparen_after, "typeid"))
1634     return ExprError();
1635   LParenLoc = T.getOpenLocation();
1636 
1637   ExprResult Result;
1638 
1639   // C++0x [expr.typeid]p3:
1640   //   When typeid is applied to an expression other than an lvalue of a
1641   //   polymorphic class type [...] The expression is an unevaluated
1642   //   operand (Clause 5).
1643   //
1644   // Note that we can't tell whether the expression is an lvalue of a
1645   // polymorphic class type until after we've parsed the expression; we
1646   // speculatively assume the subexpression is unevaluated, and fix it up
1647   // later.
1648   //
1649   // We enter the unevaluated context before trying to determine whether we
1650   // have a type-id, because the tentative parse logic will try to resolve
1651   // names, and must treat them as unevaluated.
1652   EnterExpressionEvaluationContext Unevaluated(
1653       Actions, Sema::ExpressionEvaluationContext::Unevaluated,
1654       Sema::ReuseLambdaContextDecl);
1655 
1656   if (isTypeIdInParens()) {
1657     TypeResult Ty = ParseTypeName();
1658 
1659     // Match the ')'.
1660     T.consumeClose();
1661     RParenLoc = T.getCloseLocation();
1662     if (Ty.isInvalid() || RParenLoc.isInvalid())
1663       return ExprError();
1664 
1665     Result = Actions.ActOnCXXTypeid(OpLoc, LParenLoc, /*isType=*/true,
1666                                     Ty.get().getAsOpaquePtr(), RParenLoc);
1667   } else {
1668     Result = ParseExpression();
1669 
1670     // Match the ')'.
1671     if (Result.isInvalid())
1672       SkipUntil(tok::r_paren, StopAtSemi);
1673     else {
1674       T.consumeClose();
1675       RParenLoc = T.getCloseLocation();
1676       if (RParenLoc.isInvalid())
1677         return ExprError();
1678 
1679       Result = Actions.ActOnCXXTypeid(OpLoc, LParenLoc, /*isType=*/false,
1680                                       Result.get(), RParenLoc);
1681     }
1682   }
1683 
1684   return Result;
1685 }
1686 
1687 /// ParseCXXUuidof - This handles the Microsoft C++ __uuidof expression.
1688 ///
1689 ///         '__uuidof' '(' expression ')'
1690 ///         '__uuidof' '(' type-id ')'
1691 ///
1692 ExprResult Parser::ParseCXXUuidof() {
1693   assert(Tok.is(tok::kw___uuidof) && "Not '__uuidof'!");
1694 
1695   SourceLocation OpLoc = ConsumeToken();
1696   BalancedDelimiterTracker T(*this, tok::l_paren);
1697 
1698   // __uuidof expressions are always parenthesized.
1699   if (T.expectAndConsume(diag::err_expected_lparen_after, "__uuidof"))
1700     return ExprError();
1701 
1702   ExprResult Result;
1703 
1704   if (isTypeIdInParens()) {
1705     TypeResult Ty = ParseTypeName();
1706 
1707     // Match the ')'.
1708     T.consumeClose();
1709 
1710     if (Ty.isInvalid())
1711       return ExprError();
1712 
1713     Result = Actions.ActOnCXXUuidof(OpLoc, T.getOpenLocation(), /*isType=*/true,
1714                                     Ty.get().getAsOpaquePtr(),
1715                                     T.getCloseLocation());
1716   } else {
1717     EnterExpressionEvaluationContext Unevaluated(
1718         Actions, Sema::ExpressionEvaluationContext::Unevaluated);
1719     Result = ParseExpression();
1720 
1721     // Match the ')'.
1722     if (Result.isInvalid())
1723       SkipUntil(tok::r_paren, StopAtSemi);
1724     else {
1725       T.consumeClose();
1726 
1727       Result = Actions.ActOnCXXUuidof(OpLoc, T.getOpenLocation(),
1728                                       /*isType=*/false,
1729                                       Result.get(), T.getCloseLocation());
1730     }
1731   }
1732 
1733   return Result;
1734 }
1735 
1736 /// Parse a C++ pseudo-destructor expression after the base,
1737 /// . or -> operator, and nested-name-specifier have already been
1738 /// parsed. We're handling this fragment of the grammar:
1739 ///
1740 ///       postfix-expression: [C++2a expr.post]
1741 ///         postfix-expression . template[opt] id-expression
1742 ///         postfix-expression -> template[opt] id-expression
1743 ///
1744 ///       id-expression:
1745 ///         qualified-id
1746 ///         unqualified-id
1747 ///
1748 ///       qualified-id:
1749 ///         nested-name-specifier template[opt] unqualified-id
1750 ///
1751 ///       nested-name-specifier:
1752 ///         type-name ::
1753 ///         decltype-specifier ::    FIXME: not implemented, but probably only
1754 ///                                         allowed in C++ grammar by accident
1755 ///         nested-name-specifier identifier ::
1756 ///         nested-name-specifier template[opt] simple-template-id ::
1757 ///         [...]
1758 ///
1759 ///       unqualified-id:
1760 ///         ~ type-name
1761 ///         ~ decltype-specifier
1762 ///         [...]
1763 ///
1764 /// ... where the all but the last component of the nested-name-specifier
1765 /// has already been parsed, and the base expression is not of a non-dependent
1766 /// class type.
1767 ExprResult
1768 Parser::ParseCXXPseudoDestructor(Expr *Base, SourceLocation OpLoc,
1769                                  tok::TokenKind OpKind,
1770                                  CXXScopeSpec &SS,
1771                                  ParsedType ObjectType) {
1772   // If the last component of the (optional) nested-name-specifier is
1773   // template[opt] simple-template-id, it has already been annotated.
1774   UnqualifiedId FirstTypeName;
1775   SourceLocation CCLoc;
1776   if (Tok.is(tok::identifier)) {
1777     FirstTypeName.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
1778     ConsumeToken();
1779     assert(Tok.is(tok::coloncolon) &&"ParseOptionalCXXScopeSpecifier fail");
1780     CCLoc = ConsumeToken();
1781   } else if (Tok.is(tok::annot_template_id)) {
1782     TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
1783     // FIXME: Carry on and build an AST representation for tooling.
1784     if (TemplateId->isInvalid())
1785       return ExprError();
1786     FirstTypeName.setTemplateId(TemplateId);
1787     ConsumeAnnotationToken();
1788     assert(Tok.is(tok::coloncolon) &&"ParseOptionalCXXScopeSpecifier fail");
1789     CCLoc = ConsumeToken();
1790   } else {
1791     assert(SS.isEmpty() && "missing last component of nested name specifier");
1792     FirstTypeName.setIdentifier(nullptr, SourceLocation());
1793   }
1794 
1795   // Parse the tilde.
1796   assert(Tok.is(tok::tilde) && "ParseOptionalCXXScopeSpecifier fail");
1797   SourceLocation TildeLoc = ConsumeToken();
1798 
1799   if (Tok.is(tok::kw_decltype) && !FirstTypeName.isValid()) {
1800     DeclSpec DS(AttrFactory);
1801     ParseDecltypeSpecifier(DS);
1802     if (DS.getTypeSpecType() == TST_error)
1803       return ExprError();
1804     return Actions.ActOnPseudoDestructorExpr(getCurScope(), Base, OpLoc, OpKind,
1805                                              TildeLoc, DS);
1806   }
1807 
1808   if (!Tok.is(tok::identifier)) {
1809     Diag(Tok, diag::err_destructor_tilde_identifier);
1810     return ExprError();
1811   }
1812 
1813   // Parse the second type.
1814   UnqualifiedId SecondTypeName;
1815   IdentifierInfo *Name = Tok.getIdentifierInfo();
1816   SourceLocation NameLoc = ConsumeToken();
1817   SecondTypeName.setIdentifier(Name, NameLoc);
1818 
1819   // If there is a '<', the second type name is a template-id. Parse
1820   // it as such.
1821   //
1822   // FIXME: This is not a context in which a '<' is assumed to start a template
1823   // argument list. This affects examples such as
1824   //   void f(auto *p) { p->~X<int>(); }
1825   // ... but there's no ambiguity, and nowhere to write 'template' in such an
1826   // example, so we accept it anyway.
1827   if (Tok.is(tok::less) &&
1828       ParseUnqualifiedIdTemplateId(
1829           SS, ObjectType, Base && Base->containsErrors(), SourceLocation(),
1830           Name, NameLoc, false, SecondTypeName,
1831           /*AssumeTemplateId=*/true))
1832     return ExprError();
1833 
1834   return Actions.ActOnPseudoDestructorExpr(getCurScope(), Base, OpLoc, OpKind,
1835                                            SS, FirstTypeName, CCLoc, TildeLoc,
1836                                            SecondTypeName);
1837 }
1838 
1839 /// ParseCXXBoolLiteral - This handles the C++ Boolean literals.
1840 ///
1841 ///       boolean-literal: [C++ 2.13.5]
1842 ///         'true'
1843 ///         'false'
1844 ExprResult Parser::ParseCXXBoolLiteral() {
1845   tok::TokenKind Kind = Tok.getKind();
1846   return Actions.ActOnCXXBoolLiteral(ConsumeToken(), Kind);
1847 }
1848 
1849 /// ParseThrowExpression - This handles the C++ throw expression.
1850 ///
1851 ///       throw-expression: [C++ 15]
1852 ///         'throw' assignment-expression[opt]
1853 ExprResult Parser::ParseThrowExpression() {
1854   assert(Tok.is(tok::kw_throw) && "Not throw!");
1855   SourceLocation ThrowLoc = ConsumeToken();           // Eat the throw token.
1856 
1857   // If the current token isn't the start of an assignment-expression,
1858   // then the expression is not present.  This handles things like:
1859   //   "C ? throw : (void)42", which is crazy but legal.
1860   switch (Tok.getKind()) {  // FIXME: move this predicate somewhere common.
1861   case tok::semi:
1862   case tok::r_paren:
1863   case tok::r_square:
1864   case tok::r_brace:
1865   case tok::colon:
1866   case tok::comma:
1867     return Actions.ActOnCXXThrow(getCurScope(), ThrowLoc, nullptr);
1868 
1869   default:
1870     ExprResult Expr(ParseAssignmentExpression());
1871     if (Expr.isInvalid()) return Expr;
1872     return Actions.ActOnCXXThrow(getCurScope(), ThrowLoc, Expr.get());
1873   }
1874 }
1875 
1876 /// Parse the C++ Coroutines co_yield expression.
1877 ///
1878 ///       co_yield-expression:
1879 ///         'co_yield' assignment-expression[opt]
1880 ExprResult Parser::ParseCoyieldExpression() {
1881   assert(Tok.is(tok::kw_co_yield) && "Not co_yield!");
1882 
1883   SourceLocation Loc = ConsumeToken();
1884   ExprResult Expr = Tok.is(tok::l_brace) ? ParseBraceInitializer()
1885                                          : ParseAssignmentExpression();
1886   if (!Expr.isInvalid())
1887     Expr = Actions.ActOnCoyieldExpr(getCurScope(), Loc, Expr.get());
1888   return Expr;
1889 }
1890 
1891 /// ParseCXXThis - This handles the C++ 'this' pointer.
1892 ///
1893 /// C++ 9.3.2: In the body of a non-static member function, the keyword this is
1894 /// a non-lvalue expression whose value is the address of the object for which
1895 /// the function is called.
1896 ExprResult Parser::ParseCXXThis() {
1897   assert(Tok.is(tok::kw_this) && "Not 'this'!");
1898   SourceLocation ThisLoc = ConsumeToken();
1899   return Actions.ActOnCXXThis(ThisLoc);
1900 }
1901 
1902 /// ParseCXXTypeConstructExpression - Parse construction of a specified type.
1903 /// Can be interpreted either as function-style casting ("int(x)")
1904 /// or class type construction ("ClassType(x,y,z)")
1905 /// or creation of a value-initialized type ("int()").
1906 /// See [C++ 5.2.3].
1907 ///
1908 ///       postfix-expression: [C++ 5.2p1]
1909 ///         simple-type-specifier '(' expression-list[opt] ')'
1910 /// [C++0x] simple-type-specifier braced-init-list
1911 ///         typename-specifier '(' expression-list[opt] ')'
1912 /// [C++0x] typename-specifier braced-init-list
1913 ///
1914 /// In C++1z onwards, the type specifier can also be a template-name.
1915 ExprResult
1916 Parser::ParseCXXTypeConstructExpression(const DeclSpec &DS) {
1917   Declarator DeclaratorInfo(DS, ParsedAttributesView::none(),
1918                             DeclaratorContext::FunctionalCast);
1919   ParsedType TypeRep = Actions.ActOnTypeName(DeclaratorInfo).get();
1920 
1921   assert((Tok.is(tok::l_paren) ||
1922           (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)))
1923          && "Expected '(' or '{'!");
1924 
1925   if (Tok.is(tok::l_brace)) {
1926     PreferredType.enterTypeCast(Tok.getLocation(), TypeRep.get());
1927     ExprResult Init = ParseBraceInitializer();
1928     if (Init.isInvalid())
1929       return Init;
1930     Expr *InitList = Init.get();
1931     return Actions.ActOnCXXTypeConstructExpr(
1932         TypeRep, InitList->getBeginLoc(), MultiExprArg(&InitList, 1),
1933         InitList->getEndLoc(), /*ListInitialization=*/true);
1934   } else {
1935     BalancedDelimiterTracker T(*this, tok::l_paren);
1936     T.consumeOpen();
1937 
1938     PreferredType.enterTypeCast(Tok.getLocation(), TypeRep.get());
1939 
1940     ExprVector Exprs;
1941 
1942     auto RunSignatureHelp = [&]() {
1943       QualType PreferredType;
1944       if (TypeRep)
1945         PreferredType = Actions.ProduceConstructorSignatureHelp(
1946             TypeRep.get()->getCanonicalTypeInternal(), DS.getEndLoc(), Exprs,
1947             T.getOpenLocation(), /*Braced=*/false);
1948       CalledSignatureHelp = true;
1949       return PreferredType;
1950     };
1951 
1952     if (Tok.isNot(tok::r_paren)) {
1953       if (ParseExpressionList(Exprs, [&] {
1954             PreferredType.enterFunctionArgument(Tok.getLocation(),
1955                                                 RunSignatureHelp);
1956           })) {
1957         if (PP.isCodeCompletionReached() && !CalledSignatureHelp)
1958           RunSignatureHelp();
1959         SkipUntil(tok::r_paren, StopAtSemi);
1960         return ExprError();
1961       }
1962     }
1963 
1964     // Match the ')'.
1965     T.consumeClose();
1966 
1967     // TypeRep could be null, if it references an invalid typedef.
1968     if (!TypeRep)
1969       return ExprError();
1970 
1971     return Actions.ActOnCXXTypeConstructExpr(TypeRep, T.getOpenLocation(),
1972                                              Exprs, T.getCloseLocation(),
1973                                              /*ListInitialization=*/false);
1974   }
1975 }
1976 
1977 Parser::DeclGroupPtrTy
1978 Parser::ParseAliasDeclarationInInitStatement(DeclaratorContext Context,
1979                                              ParsedAttributes &Attrs) {
1980   assert(Tok.is(tok::kw_using) && "Expected using");
1981   assert((Context == DeclaratorContext::ForInit ||
1982           Context == DeclaratorContext::SelectionInit) &&
1983          "Unexpected Declarator Context");
1984   DeclGroupPtrTy DG;
1985   SourceLocation DeclStart = ConsumeToken(), DeclEnd;
1986 
1987   DG = ParseUsingDeclaration(Context, {}, DeclStart, DeclEnd, Attrs, AS_none);
1988   if (!DG)
1989     return DG;
1990 
1991   Diag(DeclStart, !getLangOpts().CPlusPlus23
1992                       ? diag::ext_alias_in_init_statement
1993                       : diag::warn_cxx20_alias_in_init_statement)
1994       << SourceRange(DeclStart, DeclEnd);
1995 
1996   return DG;
1997 }
1998 
1999 /// ParseCXXCondition - if/switch/while condition expression.
2000 ///
2001 ///       condition:
2002 ///         expression
2003 ///         type-specifier-seq declarator '=' assignment-expression
2004 /// [C++11] type-specifier-seq declarator '=' initializer-clause
2005 /// [C++11] type-specifier-seq declarator braced-init-list
2006 /// [Clang] type-specifier-seq ref-qualifier[opt] '[' identifier-list ']'
2007 ///             brace-or-equal-initializer
2008 /// [GNU]   type-specifier-seq declarator simple-asm-expr[opt] attributes[opt]
2009 ///             '=' assignment-expression
2010 ///
2011 /// In C++1z, a condition may in some contexts be preceded by an
2012 /// optional init-statement. This function will parse that too.
2013 ///
2014 /// \param InitStmt If non-null, an init-statement is permitted, and if present
2015 /// will be parsed and stored here.
2016 ///
2017 /// \param Loc The location of the start of the statement that requires this
2018 /// condition, e.g., the "for" in a for loop.
2019 ///
2020 /// \param MissingOK Whether an empty condition is acceptable here. Otherwise
2021 /// it is considered an error to be recovered from.
2022 ///
2023 /// \param FRI If non-null, a for range declaration is permitted, and if
2024 /// present will be parsed and stored here, and a null result will be returned.
2025 ///
2026 /// \param EnterForConditionScope If true, enter a continue/break scope at the
2027 /// appropriate moment for a 'for' loop.
2028 ///
2029 /// \returns The parsed condition.
2030 Sema::ConditionResult
2031 Parser::ParseCXXCondition(StmtResult *InitStmt, SourceLocation Loc,
2032                           Sema::ConditionKind CK, bool MissingOK,
2033                           ForRangeInfo *FRI, bool EnterForConditionScope) {
2034   // Helper to ensure we always enter a continue/break scope if requested.
2035   struct ForConditionScopeRAII {
2036     Scope *S;
2037     void enter(bool IsConditionVariable) {
2038       if (S) {
2039         S->AddFlags(Scope::BreakScope | Scope::ContinueScope);
2040         S->setIsConditionVarScope(IsConditionVariable);
2041       }
2042     }
2043     ~ForConditionScopeRAII() {
2044       if (S)
2045         S->setIsConditionVarScope(false);
2046     }
2047   } ForConditionScope{EnterForConditionScope ? getCurScope() : nullptr};
2048 
2049   ParenBraceBracketBalancer BalancerRAIIObj(*this);
2050   PreferredType.enterCondition(Actions, Tok.getLocation());
2051 
2052   if (Tok.is(tok::code_completion)) {
2053     cutOffParsing();
2054     Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Condition);
2055     return Sema::ConditionError();
2056   }
2057 
2058   ParsedAttributes attrs(AttrFactory);
2059   MaybeParseCXX11Attributes(attrs);
2060 
2061   const auto WarnOnInit = [this, &CK] {
2062     Diag(Tok.getLocation(), getLangOpts().CPlusPlus17
2063                                 ? diag::warn_cxx14_compat_init_statement
2064                                 : diag::ext_init_statement)
2065         << (CK == Sema::ConditionKind::Switch);
2066   };
2067 
2068   // Determine what kind of thing we have.
2069   switch (isCXXConditionDeclarationOrInitStatement(InitStmt, FRI)) {
2070   case ConditionOrInitStatement::Expression: {
2071     // If this is a for loop, we're entering its condition.
2072     ForConditionScope.enter(/*IsConditionVariable=*/false);
2073 
2074     ProhibitAttributes(attrs);
2075 
2076     // We can have an empty expression here.
2077     //   if (; true);
2078     if (InitStmt && Tok.is(tok::semi)) {
2079       WarnOnInit();
2080       SourceLocation SemiLoc = Tok.getLocation();
2081       if (!Tok.hasLeadingEmptyMacro() && !SemiLoc.isMacroID()) {
2082         Diag(SemiLoc, diag::warn_empty_init_statement)
2083             << (CK == Sema::ConditionKind::Switch)
2084             << FixItHint::CreateRemoval(SemiLoc);
2085       }
2086       ConsumeToken();
2087       *InitStmt = Actions.ActOnNullStmt(SemiLoc);
2088       return ParseCXXCondition(nullptr, Loc, CK, MissingOK);
2089     }
2090 
2091     // Parse the expression.
2092     ExprResult Expr = ParseExpression(); // expression
2093     if (Expr.isInvalid())
2094       return Sema::ConditionError();
2095 
2096     if (InitStmt && Tok.is(tok::semi)) {
2097       WarnOnInit();
2098       *InitStmt = Actions.ActOnExprStmt(Expr.get());
2099       ConsumeToken();
2100       return ParseCXXCondition(nullptr, Loc, CK, MissingOK);
2101     }
2102 
2103     return Actions.ActOnCondition(getCurScope(), Loc, Expr.get(), CK,
2104                                   MissingOK);
2105   }
2106 
2107   case ConditionOrInitStatement::InitStmtDecl: {
2108     WarnOnInit();
2109     DeclGroupPtrTy DG;
2110     SourceLocation DeclStart = Tok.getLocation(), DeclEnd;
2111     if (Tok.is(tok::kw_using))
2112       DG = ParseAliasDeclarationInInitStatement(
2113           DeclaratorContext::SelectionInit, attrs);
2114     else {
2115       ParsedAttributes DeclSpecAttrs(AttrFactory);
2116       DG = ParseSimpleDeclaration(DeclaratorContext::SelectionInit, DeclEnd,
2117                                   attrs, DeclSpecAttrs, /*RequireSemi=*/true);
2118     }
2119     *InitStmt = Actions.ActOnDeclStmt(DG, DeclStart, DeclEnd);
2120     return ParseCXXCondition(nullptr, Loc, CK, MissingOK);
2121   }
2122 
2123   case ConditionOrInitStatement::ForRangeDecl: {
2124     // This is 'for (init-stmt; for-range-decl : range-expr)'.
2125     // We're not actually in a for loop yet, so 'break' and 'continue' aren't
2126     // permitted here.
2127     assert(FRI && "should not parse a for range declaration here");
2128     SourceLocation DeclStart = Tok.getLocation(), DeclEnd;
2129     ParsedAttributes DeclSpecAttrs(AttrFactory);
2130     DeclGroupPtrTy DG = ParseSimpleDeclaration(
2131         DeclaratorContext::ForInit, DeclEnd, attrs, DeclSpecAttrs, false, FRI);
2132     FRI->LoopVar = Actions.ActOnDeclStmt(DG, DeclStart, Tok.getLocation());
2133     return Sema::ConditionResult();
2134   }
2135 
2136   case ConditionOrInitStatement::ConditionDecl:
2137   case ConditionOrInitStatement::Error:
2138     break;
2139   }
2140 
2141   // If this is a for loop, we're entering its condition.
2142   ForConditionScope.enter(/*IsConditionVariable=*/true);
2143 
2144   // type-specifier-seq
2145   DeclSpec DS(AttrFactory);
2146   ParseSpecifierQualifierList(DS, AS_none, DeclSpecContext::DSC_condition);
2147 
2148   // declarator
2149   Declarator DeclaratorInfo(DS, attrs, DeclaratorContext::Condition);
2150   ParseDeclarator(DeclaratorInfo);
2151 
2152   // simple-asm-expr[opt]
2153   if (Tok.is(tok::kw_asm)) {
2154     SourceLocation Loc;
2155     ExprResult AsmLabel(ParseSimpleAsm(/*ForAsmLabel*/ true, &Loc));
2156     if (AsmLabel.isInvalid()) {
2157       SkipUntil(tok::semi, StopAtSemi);
2158       return Sema::ConditionError();
2159     }
2160     DeclaratorInfo.setAsmLabel(AsmLabel.get());
2161     DeclaratorInfo.SetRangeEnd(Loc);
2162   }
2163 
2164   // If attributes are present, parse them.
2165   MaybeParseGNUAttributes(DeclaratorInfo);
2166 
2167   // Type-check the declaration itself.
2168   DeclResult Dcl = Actions.ActOnCXXConditionDeclaration(getCurScope(),
2169                                                         DeclaratorInfo);
2170   if (Dcl.isInvalid())
2171     return Sema::ConditionError();
2172   Decl *DeclOut = Dcl.get();
2173 
2174   // '=' assignment-expression
2175   // If a '==' or '+=' is found, suggest a fixit to '='.
2176   bool CopyInitialization = isTokenEqualOrEqualTypo();
2177   if (CopyInitialization)
2178     ConsumeToken();
2179 
2180   ExprResult InitExpr = ExprError();
2181   if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
2182     Diag(Tok.getLocation(),
2183          diag::warn_cxx98_compat_generalized_initializer_lists);
2184     InitExpr = ParseBraceInitializer();
2185   } else if (CopyInitialization) {
2186     PreferredType.enterVariableInit(Tok.getLocation(), DeclOut);
2187     InitExpr = ParseAssignmentExpression();
2188   } else if (Tok.is(tok::l_paren)) {
2189     // This was probably an attempt to initialize the variable.
2190     SourceLocation LParen = ConsumeParen(), RParen = LParen;
2191     if (SkipUntil(tok::r_paren, StopAtSemi | StopBeforeMatch))
2192       RParen = ConsumeParen();
2193     Diag(DeclOut->getLocation(),
2194          diag::err_expected_init_in_condition_lparen)
2195       << SourceRange(LParen, RParen);
2196   } else {
2197     Diag(DeclOut->getLocation(), diag::err_expected_init_in_condition);
2198   }
2199 
2200   if (!InitExpr.isInvalid())
2201     Actions.AddInitializerToDecl(DeclOut, InitExpr.get(), !CopyInitialization);
2202   else
2203     Actions.ActOnInitializerError(DeclOut);
2204 
2205   Actions.FinalizeDeclaration(DeclOut);
2206   return Actions.ActOnConditionVariable(DeclOut, Loc, CK);
2207 }
2208 
2209 /// ParseCXXSimpleTypeSpecifier - [C++ 7.1.5.2] Simple type specifiers.
2210 /// This should only be called when the current token is known to be part of
2211 /// simple-type-specifier.
2212 ///
2213 ///       simple-type-specifier:
2214 ///         '::'[opt] nested-name-specifier[opt] type-name
2215 ///         '::'[opt] nested-name-specifier 'template' simple-template-id [TODO]
2216 ///         char
2217 ///         wchar_t
2218 ///         bool
2219 ///         short
2220 ///         int
2221 ///         long
2222 ///         signed
2223 ///         unsigned
2224 ///         float
2225 ///         double
2226 ///         void
2227 /// [GNU]   typeof-specifier
2228 /// [C++0x] auto               [TODO]
2229 ///
2230 ///       type-name:
2231 ///         class-name
2232 ///         enum-name
2233 ///         typedef-name
2234 ///
2235 void Parser::ParseCXXSimpleTypeSpecifier(DeclSpec &DS) {
2236   DS.SetRangeStart(Tok.getLocation());
2237   const char *PrevSpec;
2238   unsigned DiagID;
2239   SourceLocation Loc = Tok.getLocation();
2240   const clang::PrintingPolicy &Policy =
2241       Actions.getASTContext().getPrintingPolicy();
2242 
2243   switch (Tok.getKind()) {
2244   case tok::identifier:   // foo::bar
2245   case tok::coloncolon:   // ::foo::bar
2246     llvm_unreachable("Annotation token should already be formed!");
2247   default:
2248     llvm_unreachable("Not a simple-type-specifier token!");
2249 
2250   // type-name
2251   case tok::annot_typename: {
2252     DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, DiagID,
2253                        getTypeAnnotation(Tok), Policy);
2254     DS.SetRangeEnd(Tok.getAnnotationEndLoc());
2255     ConsumeAnnotationToken();
2256 
2257     DS.Finish(Actions, Policy);
2258     return;
2259   }
2260 
2261   case tok::kw__ExtInt:
2262   case tok::kw__BitInt: {
2263     DiagnoseBitIntUse(Tok);
2264     ExprResult ER = ParseExtIntegerArgument();
2265     if (ER.isInvalid())
2266       DS.SetTypeSpecError();
2267     else
2268       DS.SetBitIntType(Loc, ER.get(), PrevSpec, DiagID, Policy);
2269 
2270     // Do this here because we have already consumed the close paren.
2271     DS.SetRangeEnd(PrevTokLocation);
2272     DS.Finish(Actions, Policy);
2273     return;
2274   }
2275 
2276   // builtin types
2277   case tok::kw_short:
2278     DS.SetTypeSpecWidth(TypeSpecifierWidth::Short, Loc, PrevSpec, DiagID,
2279                         Policy);
2280     break;
2281   case tok::kw_long:
2282     DS.SetTypeSpecWidth(TypeSpecifierWidth::Long, Loc, PrevSpec, DiagID,
2283                         Policy);
2284     break;
2285   case tok::kw___int64:
2286     DS.SetTypeSpecWidth(TypeSpecifierWidth::LongLong, Loc, PrevSpec, DiagID,
2287                         Policy);
2288     break;
2289   case tok::kw_signed:
2290     DS.SetTypeSpecSign(TypeSpecifierSign::Signed, Loc, PrevSpec, DiagID);
2291     break;
2292   case tok::kw_unsigned:
2293     DS.SetTypeSpecSign(TypeSpecifierSign::Unsigned, Loc, PrevSpec, DiagID);
2294     break;
2295   case tok::kw_void:
2296     DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec, DiagID, Policy);
2297     break;
2298   case tok::kw_auto:
2299     DS.SetTypeSpecType(DeclSpec::TST_auto, Loc, PrevSpec, DiagID, Policy);
2300     break;
2301   case tok::kw_char:
2302     DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec, DiagID, Policy);
2303     break;
2304   case tok::kw_int:
2305     DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec, DiagID, Policy);
2306     break;
2307   case tok::kw___int128:
2308     DS.SetTypeSpecType(DeclSpec::TST_int128, Loc, PrevSpec, DiagID, Policy);
2309     break;
2310   case tok::kw___bf16:
2311     DS.SetTypeSpecType(DeclSpec::TST_BFloat16, Loc, PrevSpec, DiagID, Policy);
2312     break;
2313   case tok::kw_half:
2314     DS.SetTypeSpecType(DeclSpec::TST_half, Loc, PrevSpec, DiagID, Policy);
2315     break;
2316   case tok::kw_float:
2317     DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec, DiagID, Policy);
2318     break;
2319   case tok::kw_double:
2320     DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec, DiagID, Policy);
2321     break;
2322   case tok::kw__Float16:
2323     DS.SetTypeSpecType(DeclSpec::TST_float16, Loc, PrevSpec, DiagID, Policy);
2324     break;
2325   case tok::kw___float128:
2326     DS.SetTypeSpecType(DeclSpec::TST_float128, Loc, PrevSpec, DiagID, Policy);
2327     break;
2328   case tok::kw___ibm128:
2329     DS.SetTypeSpecType(DeclSpec::TST_ibm128, Loc, PrevSpec, DiagID, Policy);
2330     break;
2331   case tok::kw_wchar_t:
2332     DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec, DiagID, Policy);
2333     break;
2334   case tok::kw_char8_t:
2335     DS.SetTypeSpecType(DeclSpec::TST_char8, Loc, PrevSpec, DiagID, Policy);
2336     break;
2337   case tok::kw_char16_t:
2338     DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec, DiagID, Policy);
2339     break;
2340   case tok::kw_char32_t:
2341     DS.SetTypeSpecType(DeclSpec::TST_char32, Loc, PrevSpec, DiagID, Policy);
2342     break;
2343   case tok::kw_bool:
2344     DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec, DiagID, Policy);
2345     break;
2346   case tok::kw__Accum:
2347     DS.SetTypeSpecType(DeclSpec::TST_accum, Loc, PrevSpec, DiagID, Policy);
2348     break;
2349   case tok::kw__Fract:
2350     DS.SetTypeSpecType(DeclSpec::TST_fract, Loc, PrevSpec, DiagID, Policy);
2351     break;
2352   case tok::kw__Sat:
2353     DS.SetTypeSpecSat(Loc, PrevSpec, DiagID);
2354     break;
2355 #define GENERIC_IMAGE_TYPE(ImgType, Id)                                        \
2356   case tok::kw_##ImgType##_t:                                                  \
2357     DS.SetTypeSpecType(DeclSpec::TST_##ImgType##_t, Loc, PrevSpec, DiagID,     \
2358                        Policy);                                                \
2359     break;
2360 #include "clang/Basic/OpenCLImageTypes.def"
2361 
2362   case tok::annot_decltype:
2363   case tok::kw_decltype:
2364     DS.SetRangeEnd(ParseDecltypeSpecifier(DS));
2365     return DS.Finish(Actions, Policy);
2366 
2367   // GNU typeof support.
2368   case tok::kw_typeof:
2369     ParseTypeofSpecifier(DS);
2370     DS.Finish(Actions, Policy);
2371     return;
2372   }
2373   ConsumeAnyToken();
2374   DS.SetRangeEnd(PrevTokLocation);
2375   DS.Finish(Actions, Policy);
2376 }
2377 
2378 /// ParseCXXTypeSpecifierSeq - Parse a C++ type-specifier-seq (C++
2379 /// [dcl.name]), which is a non-empty sequence of type-specifiers,
2380 /// e.g., "const short int". Note that the DeclSpec is *not* finished
2381 /// by parsing the type-specifier-seq, because these sequences are
2382 /// typically followed by some form of declarator. Returns true and
2383 /// emits diagnostics if this is not a type-specifier-seq, false
2384 /// otherwise.
2385 ///
2386 ///   type-specifier-seq: [C++ 8.1]
2387 ///     type-specifier type-specifier-seq[opt]
2388 ///
2389 bool Parser::ParseCXXTypeSpecifierSeq(DeclSpec &DS, DeclaratorContext Context) {
2390   ParseSpecifierQualifierList(DS, AS_none,
2391                               getDeclSpecContextFromDeclaratorContext(Context));
2392   DS.Finish(Actions, Actions.getASTContext().getPrintingPolicy());
2393   return false;
2394 }
2395 
2396 /// Finish parsing a C++ unqualified-id that is a template-id of
2397 /// some form.
2398 ///
2399 /// This routine is invoked when a '<' is encountered after an identifier or
2400 /// operator-function-id is parsed by \c ParseUnqualifiedId() to determine
2401 /// whether the unqualified-id is actually a template-id. This routine will
2402 /// then parse the template arguments and form the appropriate template-id to
2403 /// return to the caller.
2404 ///
2405 /// \param SS the nested-name-specifier that precedes this template-id, if
2406 /// we're actually parsing a qualified-id.
2407 ///
2408 /// \param ObjectType if this unqualified-id occurs within a member access
2409 /// expression, the type of the base object whose member is being accessed.
2410 ///
2411 /// \param ObjectHadErrors this unqualified-id occurs within a member access
2412 /// expression, indicates whether the original subexpressions had any errors.
2413 ///
2414 /// \param Name for constructor and destructor names, this is the actual
2415 /// identifier that may be a template-name.
2416 ///
2417 /// \param NameLoc the location of the class-name in a constructor or
2418 /// destructor.
2419 ///
2420 /// \param EnteringContext whether we're entering the scope of the
2421 /// nested-name-specifier.
2422 ///
2423 /// \param Id as input, describes the template-name or operator-function-id
2424 /// that precedes the '<'. If template arguments were parsed successfully,
2425 /// will be updated with the template-id.
2426 ///
2427 /// \param AssumeTemplateId When true, this routine will assume that the name
2428 /// refers to a template without performing name lookup to verify.
2429 ///
2430 /// \returns true if a parse error occurred, false otherwise.
2431 bool Parser::ParseUnqualifiedIdTemplateId(
2432     CXXScopeSpec &SS, ParsedType ObjectType, bool ObjectHadErrors,
2433     SourceLocation TemplateKWLoc, IdentifierInfo *Name, SourceLocation NameLoc,
2434     bool EnteringContext, UnqualifiedId &Id, bool AssumeTemplateId) {
2435   assert(Tok.is(tok::less) && "Expected '<' to finish parsing a template-id");
2436 
2437   TemplateTy Template;
2438   TemplateNameKind TNK = TNK_Non_template;
2439   switch (Id.getKind()) {
2440   case UnqualifiedIdKind::IK_Identifier:
2441   case UnqualifiedIdKind::IK_OperatorFunctionId:
2442   case UnqualifiedIdKind::IK_LiteralOperatorId:
2443     if (AssumeTemplateId) {
2444       // We defer the injected-class-name checks until we've found whether
2445       // this template-id is used to form a nested-name-specifier or not.
2446       TNK = Actions.ActOnTemplateName(getCurScope(), SS, TemplateKWLoc, Id,
2447                                       ObjectType, EnteringContext, Template,
2448                                       /*AllowInjectedClassName*/ true);
2449     } else {
2450       bool MemberOfUnknownSpecialization;
2451       TNK = Actions.isTemplateName(getCurScope(), SS,
2452                                    TemplateKWLoc.isValid(), Id,
2453                                    ObjectType, EnteringContext, Template,
2454                                    MemberOfUnknownSpecialization);
2455       // If lookup found nothing but we're assuming that this is a template
2456       // name, double-check that makes sense syntactically before committing
2457       // to it.
2458       if (TNK == TNK_Undeclared_template &&
2459           isTemplateArgumentList(0) == TPResult::False)
2460         return false;
2461 
2462       if (TNK == TNK_Non_template && MemberOfUnknownSpecialization &&
2463           ObjectType && isTemplateArgumentList(0) == TPResult::True) {
2464         // If we had errors before, ObjectType can be dependent even without any
2465         // templates, do not report missing template keyword in that case.
2466         if (!ObjectHadErrors) {
2467           // We have something like t->getAs<T>(), where getAs is a
2468           // member of an unknown specialization. However, this will only
2469           // parse correctly as a template, so suggest the keyword 'template'
2470           // before 'getAs' and treat this as a dependent template name.
2471           std::string Name;
2472           if (Id.getKind() == UnqualifiedIdKind::IK_Identifier)
2473             Name = std::string(Id.Identifier->getName());
2474           else {
2475             Name = "operator ";
2476             if (Id.getKind() == UnqualifiedIdKind::IK_OperatorFunctionId)
2477               Name += getOperatorSpelling(Id.OperatorFunctionId.Operator);
2478             else
2479               Name += Id.Identifier->getName();
2480           }
2481           Diag(Id.StartLocation, diag::err_missing_dependent_template_keyword)
2482               << Name
2483               << FixItHint::CreateInsertion(Id.StartLocation, "template ");
2484         }
2485         TNK = Actions.ActOnTemplateName(
2486             getCurScope(), SS, TemplateKWLoc, Id, ObjectType, EnteringContext,
2487             Template, /*AllowInjectedClassName*/ true);
2488       } else if (TNK == TNK_Non_template) {
2489         return false;
2490       }
2491     }
2492     break;
2493 
2494   case UnqualifiedIdKind::IK_ConstructorName: {
2495     UnqualifiedId TemplateName;
2496     bool MemberOfUnknownSpecialization;
2497     TemplateName.setIdentifier(Name, NameLoc);
2498     TNK = Actions.isTemplateName(getCurScope(), SS, TemplateKWLoc.isValid(),
2499                                  TemplateName, ObjectType,
2500                                  EnteringContext, Template,
2501                                  MemberOfUnknownSpecialization);
2502     if (TNK == TNK_Non_template)
2503       return false;
2504     break;
2505   }
2506 
2507   case UnqualifiedIdKind::IK_DestructorName: {
2508     UnqualifiedId TemplateName;
2509     bool MemberOfUnknownSpecialization;
2510     TemplateName.setIdentifier(Name, NameLoc);
2511     if (ObjectType) {
2512       TNK = Actions.ActOnTemplateName(
2513           getCurScope(), SS, TemplateKWLoc, TemplateName, ObjectType,
2514           EnteringContext, Template, /*AllowInjectedClassName*/ true);
2515     } else {
2516       TNK = Actions.isTemplateName(getCurScope(), SS, TemplateKWLoc.isValid(),
2517                                    TemplateName, ObjectType,
2518                                    EnteringContext, Template,
2519                                    MemberOfUnknownSpecialization);
2520 
2521       if (TNK == TNK_Non_template && !Id.DestructorName.get()) {
2522         Diag(NameLoc, diag::err_destructor_template_id)
2523           << Name << SS.getRange();
2524         // Carry on to parse the template arguments before bailing out.
2525       }
2526     }
2527     break;
2528   }
2529 
2530   default:
2531     return false;
2532   }
2533 
2534   // Parse the enclosed template argument list.
2535   SourceLocation LAngleLoc, RAngleLoc;
2536   TemplateArgList TemplateArgs;
2537   if (ParseTemplateIdAfterTemplateName(true, LAngleLoc, TemplateArgs, RAngleLoc,
2538                                        Template))
2539     return true;
2540 
2541   // If this is a non-template, we already issued a diagnostic.
2542   if (TNK == TNK_Non_template)
2543     return true;
2544 
2545   if (Id.getKind() == UnqualifiedIdKind::IK_Identifier ||
2546       Id.getKind() == UnqualifiedIdKind::IK_OperatorFunctionId ||
2547       Id.getKind() == UnqualifiedIdKind::IK_LiteralOperatorId) {
2548     // Form a parsed representation of the template-id to be stored in the
2549     // UnqualifiedId.
2550 
2551     // FIXME: Store name for literal operator too.
2552     IdentifierInfo *TemplateII =
2553         Id.getKind() == UnqualifiedIdKind::IK_Identifier ? Id.Identifier
2554                                                          : nullptr;
2555     OverloadedOperatorKind OpKind =
2556         Id.getKind() == UnqualifiedIdKind::IK_Identifier
2557             ? OO_None
2558             : Id.OperatorFunctionId.Operator;
2559 
2560     TemplateIdAnnotation *TemplateId = TemplateIdAnnotation::Create(
2561         TemplateKWLoc, Id.StartLocation, TemplateII, OpKind, Template, TNK,
2562         LAngleLoc, RAngleLoc, TemplateArgs, /*ArgsInvalid*/false, TemplateIds);
2563 
2564     Id.setTemplateId(TemplateId);
2565     return false;
2566   }
2567 
2568   // Bundle the template arguments together.
2569   ASTTemplateArgsPtr TemplateArgsPtr(TemplateArgs);
2570 
2571   // Constructor and destructor names.
2572   TypeResult Type = Actions.ActOnTemplateIdType(
2573       getCurScope(), SS, TemplateKWLoc, Template, Name, NameLoc, LAngleLoc,
2574       TemplateArgsPtr, RAngleLoc, /*IsCtorOrDtorName=*/true);
2575   if (Type.isInvalid())
2576     return true;
2577 
2578   if (Id.getKind() == UnqualifiedIdKind::IK_ConstructorName)
2579     Id.setConstructorName(Type.get(), NameLoc, RAngleLoc);
2580   else
2581     Id.setDestructorName(Id.StartLocation, Type.get(), RAngleLoc);
2582 
2583   return false;
2584 }
2585 
2586 /// Parse an operator-function-id or conversion-function-id as part
2587 /// of a C++ unqualified-id.
2588 ///
2589 /// This routine is responsible only for parsing the operator-function-id or
2590 /// conversion-function-id; it does not handle template arguments in any way.
2591 ///
2592 /// \code
2593 ///       operator-function-id: [C++ 13.5]
2594 ///         'operator' operator
2595 ///
2596 ///       operator: one of
2597 ///            new   delete  new[]   delete[]
2598 ///            +     -    *  /    %  ^    &   |   ~
2599 ///            !     =    <  >    += -=   *=  /=  %=
2600 ///            ^=    &=   |= <<   >> >>= <<=  ==  !=
2601 ///            <=    >=   && ||   ++ --   ,   ->* ->
2602 ///            ()    []   <=>
2603 ///
2604 ///       conversion-function-id: [C++ 12.3.2]
2605 ///         operator conversion-type-id
2606 ///
2607 ///       conversion-type-id:
2608 ///         type-specifier-seq conversion-declarator[opt]
2609 ///
2610 ///       conversion-declarator:
2611 ///         ptr-operator conversion-declarator[opt]
2612 /// \endcode
2613 ///
2614 /// \param SS The nested-name-specifier that preceded this unqualified-id. If
2615 /// non-empty, then we are parsing the unqualified-id of a qualified-id.
2616 ///
2617 /// \param EnteringContext whether we are entering the scope of the
2618 /// nested-name-specifier.
2619 ///
2620 /// \param ObjectType if this unqualified-id occurs within a member access
2621 /// expression, the type of the base object whose member is being accessed.
2622 ///
2623 /// \param Result on a successful parse, contains the parsed unqualified-id.
2624 ///
2625 /// \returns true if parsing fails, false otherwise.
2626 bool Parser::ParseUnqualifiedIdOperator(CXXScopeSpec &SS, bool EnteringContext,
2627                                         ParsedType ObjectType,
2628                                         UnqualifiedId &Result) {
2629   assert(Tok.is(tok::kw_operator) && "Expected 'operator' keyword");
2630 
2631   // Consume the 'operator' keyword.
2632   SourceLocation KeywordLoc = ConsumeToken();
2633 
2634   // Determine what kind of operator name we have.
2635   unsigned SymbolIdx = 0;
2636   SourceLocation SymbolLocations[3];
2637   OverloadedOperatorKind Op = OO_None;
2638   switch (Tok.getKind()) {
2639     case tok::kw_new:
2640     case tok::kw_delete: {
2641       bool isNew = Tok.getKind() == tok::kw_new;
2642       // Consume the 'new' or 'delete'.
2643       SymbolLocations[SymbolIdx++] = ConsumeToken();
2644       // Check for array new/delete.
2645       if (Tok.is(tok::l_square) &&
2646           (!getLangOpts().CPlusPlus11 || NextToken().isNot(tok::l_square))) {
2647         // Consume the '[' and ']'.
2648         BalancedDelimiterTracker T(*this, tok::l_square);
2649         T.consumeOpen();
2650         T.consumeClose();
2651         if (T.getCloseLocation().isInvalid())
2652           return true;
2653 
2654         SymbolLocations[SymbolIdx++] = T.getOpenLocation();
2655         SymbolLocations[SymbolIdx++] = T.getCloseLocation();
2656         Op = isNew? OO_Array_New : OO_Array_Delete;
2657       } else {
2658         Op = isNew? OO_New : OO_Delete;
2659       }
2660       break;
2661     }
2662 
2663 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
2664     case tok::Token:                                                     \
2665       SymbolLocations[SymbolIdx++] = ConsumeToken();                     \
2666       Op = OO_##Name;                                                    \
2667       break;
2668 #define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
2669 #include "clang/Basic/OperatorKinds.def"
2670 
2671     case tok::l_paren: {
2672       // Consume the '(' and ')'.
2673       BalancedDelimiterTracker T(*this, tok::l_paren);
2674       T.consumeOpen();
2675       T.consumeClose();
2676       if (T.getCloseLocation().isInvalid())
2677         return true;
2678 
2679       SymbolLocations[SymbolIdx++] = T.getOpenLocation();
2680       SymbolLocations[SymbolIdx++] = T.getCloseLocation();
2681       Op = OO_Call;
2682       break;
2683     }
2684 
2685     case tok::l_square: {
2686       // Consume the '[' and ']'.
2687       BalancedDelimiterTracker T(*this, tok::l_square);
2688       T.consumeOpen();
2689       T.consumeClose();
2690       if (T.getCloseLocation().isInvalid())
2691         return true;
2692 
2693       SymbolLocations[SymbolIdx++] = T.getOpenLocation();
2694       SymbolLocations[SymbolIdx++] = T.getCloseLocation();
2695       Op = OO_Subscript;
2696       break;
2697     }
2698 
2699     case tok::code_completion: {
2700       // Don't try to parse any further.
2701       cutOffParsing();
2702       // Code completion for the operator name.
2703       Actions.CodeCompleteOperatorName(getCurScope());
2704       return true;
2705     }
2706 
2707     default:
2708       break;
2709   }
2710 
2711   if (Op != OO_None) {
2712     // We have parsed an operator-function-id.
2713     Result.setOperatorFunctionId(KeywordLoc, Op, SymbolLocations);
2714     return false;
2715   }
2716 
2717   // Parse a literal-operator-id.
2718   //
2719   //   literal-operator-id: C++11 [over.literal]
2720   //     operator string-literal identifier
2721   //     operator user-defined-string-literal
2722 
2723   if (getLangOpts().CPlusPlus11 && isTokenStringLiteral()) {
2724     Diag(Tok.getLocation(), diag::warn_cxx98_compat_literal_operator);
2725 
2726     SourceLocation DiagLoc;
2727     unsigned DiagId = 0;
2728 
2729     // We're past translation phase 6, so perform string literal concatenation
2730     // before checking for "".
2731     SmallVector<Token, 4> Toks;
2732     SmallVector<SourceLocation, 4> TokLocs;
2733     while (isTokenStringLiteral()) {
2734       if (!Tok.is(tok::string_literal) && !DiagId) {
2735         // C++11 [over.literal]p1:
2736         //   The string-literal or user-defined-string-literal in a
2737         //   literal-operator-id shall have no encoding-prefix [...].
2738         DiagLoc = Tok.getLocation();
2739         DiagId = diag::err_literal_operator_string_prefix;
2740       }
2741       Toks.push_back(Tok);
2742       TokLocs.push_back(ConsumeStringToken());
2743     }
2744 
2745     StringLiteralParser Literal(Toks, PP);
2746     if (Literal.hadError)
2747       return true;
2748 
2749     // Grab the literal operator's suffix, which will be either the next token
2750     // or a ud-suffix from the string literal.
2751     bool IsUDSuffix = !Literal.getUDSuffix().empty();
2752     IdentifierInfo *II = nullptr;
2753     SourceLocation SuffixLoc;
2754     if (IsUDSuffix) {
2755       II = &PP.getIdentifierTable().get(Literal.getUDSuffix());
2756       SuffixLoc =
2757         Lexer::AdvanceToTokenCharacter(TokLocs[Literal.getUDSuffixToken()],
2758                                        Literal.getUDSuffixOffset(),
2759                                        PP.getSourceManager(), getLangOpts());
2760     } else if (Tok.is(tok::identifier)) {
2761       II = Tok.getIdentifierInfo();
2762       SuffixLoc = ConsumeToken();
2763       TokLocs.push_back(SuffixLoc);
2764     } else {
2765       Diag(Tok.getLocation(), diag::err_expected) << tok::identifier;
2766       return true;
2767     }
2768 
2769     // The string literal must be empty.
2770     if (!Literal.GetString().empty() || Literal.Pascal) {
2771       // C++11 [over.literal]p1:
2772       //   The string-literal or user-defined-string-literal in a
2773       //   literal-operator-id shall [...] contain no characters
2774       //   other than the implicit terminating '\0'.
2775       DiagLoc = TokLocs.front();
2776       DiagId = diag::err_literal_operator_string_not_empty;
2777     }
2778 
2779     if (DiagId) {
2780       // This isn't a valid literal-operator-id, but we think we know
2781       // what the user meant. Tell them what they should have written.
2782       SmallString<32> Str;
2783       Str += "\"\"";
2784       Str += II->getName();
2785       Diag(DiagLoc, DiagId) << FixItHint::CreateReplacement(
2786           SourceRange(TokLocs.front(), TokLocs.back()), Str);
2787     }
2788 
2789     Result.setLiteralOperatorId(II, KeywordLoc, SuffixLoc);
2790 
2791     return Actions.checkLiteralOperatorId(SS, Result, IsUDSuffix);
2792   }
2793 
2794   // Parse a conversion-function-id.
2795   //
2796   //   conversion-function-id: [C++ 12.3.2]
2797   //     operator conversion-type-id
2798   //
2799   //   conversion-type-id:
2800   //     type-specifier-seq conversion-declarator[opt]
2801   //
2802   //   conversion-declarator:
2803   //     ptr-operator conversion-declarator[opt]
2804 
2805   // Parse the type-specifier-seq.
2806   DeclSpec DS(AttrFactory);
2807   if (ParseCXXTypeSpecifierSeq(
2808           DS, DeclaratorContext::ConversionId)) // FIXME: ObjectType?
2809     return true;
2810 
2811   // Parse the conversion-declarator, which is merely a sequence of
2812   // ptr-operators.
2813   Declarator D(DS, ParsedAttributesView::none(),
2814                DeclaratorContext::ConversionId);
2815   ParseDeclaratorInternal(D, /*DirectDeclParser=*/nullptr);
2816 
2817   // Finish up the type.
2818   TypeResult Ty = Actions.ActOnTypeName(D);
2819   if (Ty.isInvalid())
2820     return true;
2821 
2822   // Note that this is a conversion-function-id.
2823   Result.setConversionFunctionId(KeywordLoc, Ty.get(),
2824                                  D.getSourceRange().getEnd());
2825   return false;
2826 }
2827 
2828 /// Parse a C++ unqualified-id (or a C identifier), which describes the
2829 /// name of an entity.
2830 ///
2831 /// \code
2832 ///       unqualified-id: [C++ expr.prim.general]
2833 ///         identifier
2834 ///         operator-function-id
2835 ///         conversion-function-id
2836 /// [C++0x] literal-operator-id [TODO]
2837 ///         ~ class-name
2838 ///         template-id
2839 ///
2840 /// \endcode
2841 ///
2842 /// \param SS The nested-name-specifier that preceded this unqualified-id. If
2843 /// non-empty, then we are parsing the unqualified-id of a qualified-id.
2844 ///
2845 /// \param ObjectType if this unqualified-id occurs within a member access
2846 /// expression, the type of the base object whose member is being accessed.
2847 ///
2848 /// \param ObjectHadErrors if this unqualified-id occurs within a member access
2849 /// expression, indicates whether the original subexpressions had any errors.
2850 /// When true, diagnostics for missing 'template' keyword will be supressed.
2851 ///
2852 /// \param EnteringContext whether we are entering the scope of the
2853 /// nested-name-specifier.
2854 ///
2855 /// \param AllowDestructorName whether we allow parsing of a destructor name.
2856 ///
2857 /// \param AllowConstructorName whether we allow parsing a constructor name.
2858 ///
2859 /// \param AllowDeductionGuide whether we allow parsing a deduction guide name.
2860 ///
2861 /// \param Result on a successful parse, contains the parsed unqualified-id.
2862 ///
2863 /// \returns true if parsing fails, false otherwise.
2864 bool Parser::ParseUnqualifiedId(CXXScopeSpec &SS, ParsedType ObjectType,
2865                                 bool ObjectHadErrors, bool EnteringContext,
2866                                 bool AllowDestructorName,
2867                                 bool AllowConstructorName,
2868                                 bool AllowDeductionGuide,
2869                                 SourceLocation *TemplateKWLoc,
2870                                 UnqualifiedId &Result) {
2871   if (TemplateKWLoc)
2872     *TemplateKWLoc = SourceLocation();
2873 
2874   // Handle 'A::template B'. This is for template-ids which have not
2875   // already been annotated by ParseOptionalCXXScopeSpecifier().
2876   bool TemplateSpecified = false;
2877   if (Tok.is(tok::kw_template)) {
2878     if (TemplateKWLoc && (ObjectType || SS.isSet())) {
2879       TemplateSpecified = true;
2880       *TemplateKWLoc = ConsumeToken();
2881     } else {
2882       SourceLocation TemplateLoc = ConsumeToken();
2883       Diag(TemplateLoc, diag::err_unexpected_template_in_unqualified_id)
2884         << FixItHint::CreateRemoval(TemplateLoc);
2885     }
2886   }
2887 
2888   // unqualified-id:
2889   //   identifier
2890   //   template-id (when it hasn't already been annotated)
2891   if (Tok.is(tok::identifier)) {
2892   ParseIdentifier:
2893     // Consume the identifier.
2894     IdentifierInfo *Id = Tok.getIdentifierInfo();
2895     SourceLocation IdLoc = ConsumeToken();
2896 
2897     if (!getLangOpts().CPlusPlus) {
2898       // If we're not in C++, only identifiers matter. Record the
2899       // identifier and return.
2900       Result.setIdentifier(Id, IdLoc);
2901       return false;
2902     }
2903 
2904     ParsedTemplateTy TemplateName;
2905     if (AllowConstructorName &&
2906         Actions.isCurrentClassName(*Id, getCurScope(), &SS)) {
2907       // We have parsed a constructor name.
2908       ParsedType Ty = Actions.getConstructorName(*Id, IdLoc, getCurScope(), SS,
2909                                                  EnteringContext);
2910       if (!Ty)
2911         return true;
2912       Result.setConstructorName(Ty, IdLoc, IdLoc);
2913     } else if (getLangOpts().CPlusPlus17 && AllowDeductionGuide &&
2914                SS.isEmpty() &&
2915                Actions.isDeductionGuideName(getCurScope(), *Id, IdLoc, SS,
2916                                             &TemplateName)) {
2917       // We have parsed a template-name naming a deduction guide.
2918       Result.setDeductionGuideName(TemplateName, IdLoc);
2919     } else {
2920       // We have parsed an identifier.
2921       Result.setIdentifier(Id, IdLoc);
2922     }
2923 
2924     // If the next token is a '<', we may have a template.
2925     TemplateTy Template;
2926     if (Tok.is(tok::less))
2927       return ParseUnqualifiedIdTemplateId(
2928           SS, ObjectType, ObjectHadErrors,
2929           TemplateKWLoc ? *TemplateKWLoc : SourceLocation(), Id, IdLoc,
2930           EnteringContext, Result, TemplateSpecified);
2931     else if (TemplateSpecified &&
2932              Actions.ActOnTemplateName(
2933                  getCurScope(), SS, *TemplateKWLoc, Result, ObjectType,
2934                  EnteringContext, Template,
2935                  /*AllowInjectedClassName*/ true) == TNK_Non_template)
2936       return true;
2937 
2938     return false;
2939   }
2940 
2941   // unqualified-id:
2942   //   template-id (already parsed and annotated)
2943   if (Tok.is(tok::annot_template_id)) {
2944     TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
2945 
2946     // FIXME: Consider passing invalid template-ids on to callers; they may
2947     // be able to recover better than we can.
2948     if (TemplateId->isInvalid()) {
2949       ConsumeAnnotationToken();
2950       return true;
2951     }
2952 
2953     // If the template-name names the current class, then this is a constructor
2954     if (AllowConstructorName && TemplateId->Name &&
2955         Actions.isCurrentClassName(*TemplateId->Name, getCurScope(), &SS)) {
2956       if (SS.isSet()) {
2957         // C++ [class.qual]p2 specifies that a qualified template-name
2958         // is taken as the constructor name where a constructor can be
2959         // declared. Thus, the template arguments are extraneous, so
2960         // complain about them and remove them entirely.
2961         Diag(TemplateId->TemplateNameLoc,
2962              diag::err_out_of_line_constructor_template_id)
2963           << TemplateId->Name
2964           << FixItHint::CreateRemoval(
2965                     SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc));
2966         ParsedType Ty = Actions.getConstructorName(
2967             *TemplateId->Name, TemplateId->TemplateNameLoc, getCurScope(), SS,
2968             EnteringContext);
2969         if (!Ty)
2970           return true;
2971         Result.setConstructorName(Ty, TemplateId->TemplateNameLoc,
2972                                   TemplateId->RAngleLoc);
2973         ConsumeAnnotationToken();
2974         return false;
2975       }
2976 
2977       Result.setConstructorTemplateId(TemplateId);
2978       ConsumeAnnotationToken();
2979       return false;
2980     }
2981 
2982     // We have already parsed a template-id; consume the annotation token as
2983     // our unqualified-id.
2984     Result.setTemplateId(TemplateId);
2985     SourceLocation TemplateLoc = TemplateId->TemplateKWLoc;
2986     if (TemplateLoc.isValid()) {
2987       if (TemplateKWLoc && (ObjectType || SS.isSet()))
2988         *TemplateKWLoc = TemplateLoc;
2989       else
2990         Diag(TemplateLoc, diag::err_unexpected_template_in_unqualified_id)
2991             << FixItHint::CreateRemoval(TemplateLoc);
2992     }
2993     ConsumeAnnotationToken();
2994     return false;
2995   }
2996 
2997   // unqualified-id:
2998   //   operator-function-id
2999   //   conversion-function-id
3000   if (Tok.is(tok::kw_operator)) {
3001     if (ParseUnqualifiedIdOperator(SS, EnteringContext, ObjectType, Result))
3002       return true;
3003 
3004     // If we have an operator-function-id or a literal-operator-id and the next
3005     // token is a '<', we may have a
3006     //
3007     //   template-id:
3008     //     operator-function-id < template-argument-list[opt] >
3009     TemplateTy Template;
3010     if ((Result.getKind() == UnqualifiedIdKind::IK_OperatorFunctionId ||
3011          Result.getKind() == UnqualifiedIdKind::IK_LiteralOperatorId) &&
3012         Tok.is(tok::less))
3013       return ParseUnqualifiedIdTemplateId(
3014           SS, ObjectType, ObjectHadErrors,
3015           TemplateKWLoc ? *TemplateKWLoc : SourceLocation(), nullptr,
3016           SourceLocation(), EnteringContext, Result, TemplateSpecified);
3017     else if (TemplateSpecified &&
3018              Actions.ActOnTemplateName(
3019                  getCurScope(), SS, *TemplateKWLoc, Result, ObjectType,
3020                  EnteringContext, Template,
3021                  /*AllowInjectedClassName*/ true) == TNK_Non_template)
3022       return true;
3023 
3024     return false;
3025   }
3026 
3027   if (getLangOpts().CPlusPlus &&
3028       (AllowDestructorName || SS.isSet()) && Tok.is(tok::tilde)) {
3029     // C++ [expr.unary.op]p10:
3030     //   There is an ambiguity in the unary-expression ~X(), where X is a
3031     //   class-name. The ambiguity is resolved in favor of treating ~ as a
3032     //    unary complement rather than treating ~X as referring to a destructor.
3033 
3034     // Parse the '~'.
3035     SourceLocation TildeLoc = ConsumeToken();
3036 
3037     if (TemplateSpecified) {
3038       // C++ [temp.names]p3:
3039       //   A name prefixed by the keyword template shall be a template-id [...]
3040       //
3041       // A template-id cannot begin with a '~' token. This would never work
3042       // anyway: x.~A<int>() would specify that the destructor is a template,
3043       // not that 'A' is a template.
3044       //
3045       // FIXME: Suggest replacing the attempted destructor name with a correct
3046       // destructor name and recover. (This is not trivial if this would become
3047       // a pseudo-destructor name).
3048       Diag(*TemplateKWLoc, diag::err_unexpected_template_in_destructor_name)
3049         << Tok.getLocation();
3050       return true;
3051     }
3052 
3053     if (SS.isEmpty() && Tok.is(tok::kw_decltype)) {
3054       DeclSpec DS(AttrFactory);
3055       SourceLocation EndLoc = ParseDecltypeSpecifier(DS);
3056       if (ParsedType Type =
3057               Actions.getDestructorTypeForDecltype(DS, ObjectType)) {
3058         Result.setDestructorName(TildeLoc, Type, EndLoc);
3059         return false;
3060       }
3061       return true;
3062     }
3063 
3064     // Parse the class-name.
3065     if (Tok.isNot(tok::identifier)) {
3066       Diag(Tok, diag::err_destructor_tilde_identifier);
3067       return true;
3068     }
3069 
3070     // If the user wrote ~T::T, correct it to T::~T.
3071     DeclaratorScopeObj DeclScopeObj(*this, SS);
3072     if (NextToken().is(tok::coloncolon)) {
3073       // Don't let ParseOptionalCXXScopeSpecifier() "correct"
3074       // `int A; struct { ~A::A(); };` to `int A; struct { ~A:A(); };`,
3075       // it will confuse this recovery logic.
3076       ColonProtectionRAIIObject ColonRAII(*this, false);
3077 
3078       if (SS.isSet()) {
3079         AnnotateScopeToken(SS, /*NewAnnotation*/true);
3080         SS.clear();
3081       }
3082       if (ParseOptionalCXXScopeSpecifier(SS, ObjectType, ObjectHadErrors,
3083                                          EnteringContext))
3084         return true;
3085       if (SS.isNotEmpty())
3086         ObjectType = nullptr;
3087       if (Tok.isNot(tok::identifier) || NextToken().is(tok::coloncolon) ||
3088           !SS.isSet()) {
3089         Diag(TildeLoc, diag::err_destructor_tilde_scope);
3090         return true;
3091       }
3092 
3093       // Recover as if the tilde had been written before the identifier.
3094       Diag(TildeLoc, diag::err_destructor_tilde_scope)
3095         << FixItHint::CreateRemoval(TildeLoc)
3096         << FixItHint::CreateInsertion(Tok.getLocation(), "~");
3097 
3098       // Temporarily enter the scope for the rest of this function.
3099       if (Actions.ShouldEnterDeclaratorScope(getCurScope(), SS))
3100         DeclScopeObj.EnterDeclaratorScope();
3101     }
3102 
3103     // Parse the class-name (or template-name in a simple-template-id).
3104     IdentifierInfo *ClassName = Tok.getIdentifierInfo();
3105     SourceLocation ClassNameLoc = ConsumeToken();
3106 
3107     if (Tok.is(tok::less)) {
3108       Result.setDestructorName(TildeLoc, nullptr, ClassNameLoc);
3109       return ParseUnqualifiedIdTemplateId(
3110           SS, ObjectType, ObjectHadErrors,
3111           TemplateKWLoc ? *TemplateKWLoc : SourceLocation(), ClassName,
3112           ClassNameLoc, EnteringContext, Result, TemplateSpecified);
3113     }
3114 
3115     // Note that this is a destructor name.
3116     ParsedType Ty =
3117         Actions.getDestructorName(*ClassName, ClassNameLoc, getCurScope(), SS,
3118                                   ObjectType, EnteringContext);
3119     if (!Ty)
3120       return true;
3121 
3122     Result.setDestructorName(TildeLoc, Ty, ClassNameLoc);
3123     return false;
3124   }
3125 
3126   switch (Tok.getKind()) {
3127 #define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) case tok::kw___##Trait:
3128 #include "clang/Basic/TransformTypeTraits.def"
3129     if (!NextToken().is(tok::l_paren)) {
3130       Tok.setKind(tok::identifier);
3131       Diag(Tok, diag::ext_keyword_as_ident)
3132           << Tok.getIdentifierInfo()->getName() << 0;
3133       goto ParseIdentifier;
3134     }
3135     [[fallthrough]];
3136   default:
3137     Diag(Tok, diag::err_expected_unqualified_id) << getLangOpts().CPlusPlus;
3138     return true;
3139   }
3140 }
3141 
3142 /// ParseCXXNewExpression - Parse a C++ new-expression. New is used to allocate
3143 /// memory in a typesafe manner and call constructors.
3144 ///
3145 /// This method is called to parse the new expression after the optional :: has
3146 /// been already parsed.  If the :: was present, "UseGlobal" is true and "Start"
3147 /// is its location.  Otherwise, "Start" is the location of the 'new' token.
3148 ///
3149 ///        new-expression:
3150 ///                   '::'[opt] 'new' new-placement[opt] new-type-id
3151 ///                                     new-initializer[opt]
3152 ///                   '::'[opt] 'new' new-placement[opt] '(' type-id ')'
3153 ///                                     new-initializer[opt]
3154 ///
3155 ///        new-placement:
3156 ///                   '(' expression-list ')'
3157 ///
3158 ///        new-type-id:
3159 ///                   type-specifier-seq new-declarator[opt]
3160 /// [GNU]             attributes type-specifier-seq new-declarator[opt]
3161 ///
3162 ///        new-declarator:
3163 ///                   ptr-operator new-declarator[opt]
3164 ///                   direct-new-declarator
3165 ///
3166 ///        new-initializer:
3167 ///                   '(' expression-list[opt] ')'
3168 /// [C++0x]           braced-init-list
3169 ///
3170 ExprResult
3171 Parser::ParseCXXNewExpression(bool UseGlobal, SourceLocation Start) {
3172   assert(Tok.is(tok::kw_new) && "expected 'new' token");
3173   ConsumeToken();   // Consume 'new'
3174 
3175   // A '(' now can be a new-placement or the '(' wrapping the type-id in the
3176   // second form of new-expression. It can't be a new-type-id.
3177 
3178   ExprVector PlacementArgs;
3179   SourceLocation PlacementLParen, PlacementRParen;
3180 
3181   SourceRange TypeIdParens;
3182   DeclSpec DS(AttrFactory);
3183   Declarator DeclaratorInfo(DS, ParsedAttributesView::none(),
3184                             DeclaratorContext::CXXNew);
3185   if (Tok.is(tok::l_paren)) {
3186     // If it turns out to be a placement, we change the type location.
3187     BalancedDelimiterTracker T(*this, tok::l_paren);
3188     T.consumeOpen();
3189     PlacementLParen = T.getOpenLocation();
3190     if (ParseExpressionListOrTypeId(PlacementArgs, DeclaratorInfo)) {
3191       SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
3192       return ExprError();
3193     }
3194 
3195     T.consumeClose();
3196     PlacementRParen = T.getCloseLocation();
3197     if (PlacementRParen.isInvalid()) {
3198       SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
3199       return ExprError();
3200     }
3201 
3202     if (PlacementArgs.empty()) {
3203       // Reset the placement locations. There was no placement.
3204       TypeIdParens = T.getRange();
3205       PlacementLParen = PlacementRParen = SourceLocation();
3206     } else {
3207       // We still need the type.
3208       if (Tok.is(tok::l_paren)) {
3209         BalancedDelimiterTracker T(*this, tok::l_paren);
3210         T.consumeOpen();
3211         MaybeParseGNUAttributes(DeclaratorInfo);
3212         ParseSpecifierQualifierList(DS);
3213         DeclaratorInfo.SetSourceRange(DS.getSourceRange());
3214         ParseDeclarator(DeclaratorInfo);
3215         T.consumeClose();
3216         TypeIdParens = T.getRange();
3217       } else {
3218         MaybeParseGNUAttributes(DeclaratorInfo);
3219         if (ParseCXXTypeSpecifierSeq(DS))
3220           DeclaratorInfo.setInvalidType(true);
3221         else {
3222           DeclaratorInfo.SetSourceRange(DS.getSourceRange());
3223           ParseDeclaratorInternal(DeclaratorInfo,
3224                                   &Parser::ParseDirectNewDeclarator);
3225         }
3226       }
3227     }
3228   } else {
3229     // A new-type-id is a simplified type-id, where essentially the
3230     // direct-declarator is replaced by a direct-new-declarator.
3231     MaybeParseGNUAttributes(DeclaratorInfo);
3232     if (ParseCXXTypeSpecifierSeq(DS, DeclaratorContext::CXXNew))
3233       DeclaratorInfo.setInvalidType(true);
3234     else {
3235       DeclaratorInfo.SetSourceRange(DS.getSourceRange());
3236       ParseDeclaratorInternal(DeclaratorInfo,
3237                               &Parser::ParseDirectNewDeclarator);
3238     }
3239   }
3240   if (DeclaratorInfo.isInvalidType()) {
3241     SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
3242     return ExprError();
3243   }
3244 
3245   ExprResult Initializer;
3246 
3247   if (Tok.is(tok::l_paren)) {
3248     SourceLocation ConstructorLParen, ConstructorRParen;
3249     ExprVector ConstructorArgs;
3250     BalancedDelimiterTracker T(*this, tok::l_paren);
3251     T.consumeOpen();
3252     ConstructorLParen = T.getOpenLocation();
3253     if (Tok.isNot(tok::r_paren)) {
3254       auto RunSignatureHelp = [&]() {
3255         ParsedType TypeRep = Actions.ActOnTypeName(DeclaratorInfo).get();
3256         QualType PreferredType;
3257         // ActOnTypeName might adjust DeclaratorInfo and return a null type even
3258         // the passing DeclaratorInfo is valid, e.g. running SignatureHelp on
3259         // `new decltype(invalid) (^)`.
3260         if (TypeRep)
3261           PreferredType = Actions.ProduceConstructorSignatureHelp(
3262               TypeRep.get()->getCanonicalTypeInternal(),
3263               DeclaratorInfo.getEndLoc(), ConstructorArgs, ConstructorLParen,
3264               /*Braced=*/false);
3265         CalledSignatureHelp = true;
3266         return PreferredType;
3267       };
3268       if (ParseExpressionList(ConstructorArgs, [&] {
3269             PreferredType.enterFunctionArgument(Tok.getLocation(),
3270                                                 RunSignatureHelp);
3271           })) {
3272         if (PP.isCodeCompletionReached() && !CalledSignatureHelp)
3273           RunSignatureHelp();
3274         SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
3275         return ExprError();
3276       }
3277     }
3278     T.consumeClose();
3279     ConstructorRParen = T.getCloseLocation();
3280     if (ConstructorRParen.isInvalid()) {
3281       SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
3282       return ExprError();
3283     }
3284     Initializer = Actions.ActOnParenListExpr(ConstructorLParen,
3285                                              ConstructorRParen,
3286                                              ConstructorArgs);
3287   } else if (Tok.is(tok::l_brace) && getLangOpts().CPlusPlus11) {
3288     Diag(Tok.getLocation(),
3289          diag::warn_cxx98_compat_generalized_initializer_lists);
3290     Initializer = ParseBraceInitializer();
3291   }
3292   if (Initializer.isInvalid())
3293     return Initializer;
3294 
3295   return Actions.ActOnCXXNew(Start, UseGlobal, PlacementLParen,
3296                              PlacementArgs, PlacementRParen,
3297                              TypeIdParens, DeclaratorInfo, Initializer.get());
3298 }
3299 
3300 /// ParseDirectNewDeclarator - Parses a direct-new-declarator. Intended to be
3301 /// passed to ParseDeclaratorInternal.
3302 ///
3303 ///        direct-new-declarator:
3304 ///                   '[' expression[opt] ']'
3305 ///                   direct-new-declarator '[' constant-expression ']'
3306 ///
3307 void Parser::ParseDirectNewDeclarator(Declarator &D) {
3308   // Parse the array dimensions.
3309   bool First = true;
3310   while (Tok.is(tok::l_square)) {
3311     // An array-size expression can't start with a lambda.
3312     if (CheckProhibitedCXX11Attribute())
3313       continue;
3314 
3315     BalancedDelimiterTracker T(*this, tok::l_square);
3316     T.consumeOpen();
3317 
3318     ExprResult Size =
3319         First ? (Tok.is(tok::r_square) ? ExprResult() : ParseExpression())
3320               : ParseConstantExpression();
3321     if (Size.isInvalid()) {
3322       // Recover
3323       SkipUntil(tok::r_square, StopAtSemi);
3324       return;
3325     }
3326     First = false;
3327 
3328     T.consumeClose();
3329 
3330     // Attributes here appertain to the array type. C++11 [expr.new]p5.
3331     ParsedAttributes Attrs(AttrFactory);
3332     MaybeParseCXX11Attributes(Attrs);
3333 
3334     D.AddTypeInfo(DeclaratorChunk::getArray(0,
3335                                             /*isStatic=*/false, /*isStar=*/false,
3336                                             Size.get(), T.getOpenLocation(),
3337                                             T.getCloseLocation()),
3338                   std::move(Attrs), T.getCloseLocation());
3339 
3340     if (T.getCloseLocation().isInvalid())
3341       return;
3342   }
3343 }
3344 
3345 /// ParseExpressionListOrTypeId - Parse either an expression-list or a type-id.
3346 /// This ambiguity appears in the syntax of the C++ new operator.
3347 ///
3348 ///        new-expression:
3349 ///                   '::'[opt] 'new' new-placement[opt] '(' type-id ')'
3350 ///                                     new-initializer[opt]
3351 ///
3352 ///        new-placement:
3353 ///                   '(' expression-list ')'
3354 ///
3355 bool Parser::ParseExpressionListOrTypeId(
3356                                    SmallVectorImpl<Expr*> &PlacementArgs,
3357                                          Declarator &D) {
3358   // The '(' was already consumed.
3359   if (isTypeIdInParens()) {
3360     ParseSpecifierQualifierList(D.getMutableDeclSpec());
3361     D.SetSourceRange(D.getDeclSpec().getSourceRange());
3362     ParseDeclarator(D);
3363     return D.isInvalidType();
3364   }
3365 
3366   // It's not a type, it has to be an expression list.
3367   return ParseExpressionList(PlacementArgs);
3368 }
3369 
3370 /// ParseCXXDeleteExpression - Parse a C++ delete-expression. Delete is used
3371 /// to free memory allocated by new.
3372 ///
3373 /// This method is called to parse the 'delete' expression after the optional
3374 /// '::' has been already parsed.  If the '::' was present, "UseGlobal" is true
3375 /// and "Start" is its location.  Otherwise, "Start" is the location of the
3376 /// 'delete' token.
3377 ///
3378 ///        delete-expression:
3379 ///                   '::'[opt] 'delete' cast-expression
3380 ///                   '::'[opt] 'delete' '[' ']' cast-expression
3381 ExprResult
3382 Parser::ParseCXXDeleteExpression(bool UseGlobal, SourceLocation Start) {
3383   assert(Tok.is(tok::kw_delete) && "Expected 'delete' keyword");
3384   ConsumeToken(); // Consume 'delete'
3385 
3386   // Array delete?
3387   bool ArrayDelete = false;
3388   if (Tok.is(tok::l_square) && NextToken().is(tok::r_square)) {
3389     // C++11 [expr.delete]p1:
3390     //   Whenever the delete keyword is followed by empty square brackets, it
3391     //   shall be interpreted as [array delete].
3392     //   [Footnote: A lambda expression with a lambda-introducer that consists
3393     //              of empty square brackets can follow the delete keyword if
3394     //              the lambda expression is enclosed in parentheses.]
3395 
3396     const Token Next = GetLookAheadToken(2);
3397 
3398     // Basic lookahead to check if we have a lambda expression.
3399     if (Next.isOneOf(tok::l_brace, tok::less) ||
3400         (Next.is(tok::l_paren) &&
3401          (GetLookAheadToken(3).is(tok::r_paren) ||
3402           (GetLookAheadToken(3).is(tok::identifier) &&
3403            GetLookAheadToken(4).is(tok::identifier))))) {
3404       TentativeParsingAction TPA(*this);
3405       SourceLocation LSquareLoc = Tok.getLocation();
3406       SourceLocation RSquareLoc = NextToken().getLocation();
3407 
3408       // SkipUntil can't skip pairs of </*...*/>; don't emit a FixIt in this
3409       // case.
3410       SkipUntil({tok::l_brace, tok::less}, StopBeforeMatch);
3411       SourceLocation RBraceLoc;
3412       bool EmitFixIt = false;
3413       if (Tok.is(tok::l_brace)) {
3414         ConsumeBrace();
3415         SkipUntil(tok::r_brace, StopBeforeMatch);
3416         RBraceLoc = Tok.getLocation();
3417         EmitFixIt = true;
3418       }
3419 
3420       TPA.Revert();
3421 
3422       if (EmitFixIt)
3423         Diag(Start, diag::err_lambda_after_delete)
3424             << SourceRange(Start, RSquareLoc)
3425             << FixItHint::CreateInsertion(LSquareLoc, "(")
3426             << FixItHint::CreateInsertion(
3427                    Lexer::getLocForEndOfToken(
3428                        RBraceLoc, 0, Actions.getSourceManager(), getLangOpts()),
3429                    ")");
3430       else
3431         Diag(Start, diag::err_lambda_after_delete)
3432             << SourceRange(Start, RSquareLoc);
3433 
3434       // Warn that the non-capturing lambda isn't surrounded by parentheses
3435       // to disambiguate it from 'delete[]'.
3436       ExprResult Lambda = ParseLambdaExpression();
3437       if (Lambda.isInvalid())
3438         return ExprError();
3439 
3440       // Evaluate any postfix expressions used on the lambda.
3441       Lambda = ParsePostfixExpressionSuffix(Lambda);
3442       if (Lambda.isInvalid())
3443         return ExprError();
3444       return Actions.ActOnCXXDelete(Start, UseGlobal, /*ArrayForm=*/false,
3445                                     Lambda.get());
3446     }
3447 
3448     ArrayDelete = true;
3449     BalancedDelimiterTracker T(*this, tok::l_square);
3450 
3451     T.consumeOpen();
3452     T.consumeClose();
3453     if (T.getCloseLocation().isInvalid())
3454       return ExprError();
3455   }
3456 
3457   ExprResult Operand(ParseCastExpression(AnyCastExpr));
3458   if (Operand.isInvalid())
3459     return Operand;
3460 
3461   return Actions.ActOnCXXDelete(Start, UseGlobal, ArrayDelete, Operand.get());
3462 }
3463 
3464 /// ParseRequiresExpression - Parse a C++2a requires-expression.
3465 /// C++2a [expr.prim.req]p1
3466 ///     A requires-expression provides a concise way to express requirements on
3467 ///     template arguments. A requirement is one that can be checked by name
3468 ///     lookup (6.4) or by checking properties of types and expressions.
3469 ///
3470 ///     requires-expression:
3471 ///         'requires' requirement-parameter-list[opt] requirement-body
3472 ///
3473 ///     requirement-parameter-list:
3474 ///         '(' parameter-declaration-clause[opt] ')'
3475 ///
3476 ///     requirement-body:
3477 ///         '{' requirement-seq '}'
3478 ///
3479 ///     requirement-seq:
3480 ///         requirement
3481 ///         requirement-seq requirement
3482 ///
3483 ///     requirement:
3484 ///         simple-requirement
3485 ///         type-requirement
3486 ///         compound-requirement
3487 ///         nested-requirement
3488 ExprResult Parser::ParseRequiresExpression() {
3489   assert(Tok.is(tok::kw_requires) && "Expected 'requires' keyword");
3490   SourceLocation RequiresKWLoc = ConsumeToken(); // Consume 'requires'
3491 
3492   llvm::SmallVector<ParmVarDecl *, 2> LocalParameterDecls;
3493   BalancedDelimiterTracker Parens(*this, tok::l_paren);
3494   if (Tok.is(tok::l_paren)) {
3495     // requirement parameter list is present.
3496     ParseScope LocalParametersScope(this, Scope::FunctionPrototypeScope |
3497                                     Scope::DeclScope);
3498     Parens.consumeOpen();
3499     if (!Tok.is(tok::r_paren)) {
3500       ParsedAttributes FirstArgAttrs(getAttrFactory());
3501       SourceLocation EllipsisLoc;
3502       llvm::SmallVector<DeclaratorChunk::ParamInfo, 2> LocalParameters;
3503       ParseParameterDeclarationClause(DeclaratorContext::RequiresExpr,
3504                                       FirstArgAttrs, LocalParameters,
3505                                       EllipsisLoc);
3506       if (EllipsisLoc.isValid())
3507         Diag(EllipsisLoc, diag::err_requires_expr_parameter_list_ellipsis);
3508       for (auto &ParamInfo : LocalParameters)
3509         LocalParameterDecls.push_back(cast<ParmVarDecl>(ParamInfo.Param));
3510     }
3511     Parens.consumeClose();
3512   }
3513 
3514   BalancedDelimiterTracker Braces(*this, tok::l_brace);
3515   if (Braces.expectAndConsume())
3516     return ExprError();
3517 
3518   // Start of requirement list
3519   llvm::SmallVector<concepts::Requirement *, 2> Requirements;
3520 
3521   // C++2a [expr.prim.req]p2
3522   //   Expressions appearing within a requirement-body are unevaluated operands.
3523   EnterExpressionEvaluationContext Ctx(
3524       Actions, Sema::ExpressionEvaluationContext::Unevaluated);
3525 
3526   ParseScope BodyScope(this, Scope::DeclScope);
3527   // Create a separate diagnostic pool for RequiresExprBodyDecl.
3528   // Dependent diagnostics are attached to this Decl and non-depenedent
3529   // diagnostics are surfaced after this parse.
3530   ParsingDeclRAIIObject ParsingBodyDecl(*this, ParsingDeclRAIIObject::NoParent);
3531   RequiresExprBodyDecl *Body = Actions.ActOnStartRequiresExpr(
3532       RequiresKWLoc, LocalParameterDecls, getCurScope());
3533 
3534   if (Tok.is(tok::r_brace)) {
3535     // Grammar does not allow an empty body.
3536     // requirement-body:
3537     //   { requirement-seq }
3538     // requirement-seq:
3539     //   requirement
3540     //   requirement-seq requirement
3541     Diag(Tok, diag::err_empty_requires_expr);
3542     // Continue anyway and produce a requires expr with no requirements.
3543   } else {
3544     while (!Tok.is(tok::r_brace)) {
3545       switch (Tok.getKind()) {
3546       case tok::l_brace: {
3547         // Compound requirement
3548         // C++ [expr.prim.req.compound]
3549         //     compound-requirement:
3550         //         '{' expression '}' 'noexcept'[opt]
3551         //             return-type-requirement[opt] ';'
3552         //     return-type-requirement:
3553         //         trailing-return-type
3554         //         '->' cv-qualifier-seq[opt] constrained-parameter
3555         //             cv-qualifier-seq[opt] abstract-declarator[opt]
3556         BalancedDelimiterTracker ExprBraces(*this, tok::l_brace);
3557         ExprBraces.consumeOpen();
3558         ExprResult Expression =
3559             Actions.CorrectDelayedTyposInExpr(ParseExpression());
3560         if (!Expression.isUsable()) {
3561           ExprBraces.skipToEnd();
3562           SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch);
3563           break;
3564         }
3565         if (ExprBraces.consumeClose())
3566           ExprBraces.skipToEnd();
3567 
3568         concepts::Requirement *Req = nullptr;
3569         SourceLocation NoexceptLoc;
3570         TryConsumeToken(tok::kw_noexcept, NoexceptLoc);
3571         if (Tok.is(tok::semi)) {
3572           Req = Actions.ActOnCompoundRequirement(Expression.get(), NoexceptLoc);
3573           if (Req)
3574             Requirements.push_back(Req);
3575           break;
3576         }
3577         if (!TryConsumeToken(tok::arrow))
3578           // User probably forgot the arrow, remind them and try to continue.
3579           Diag(Tok, diag::err_requires_expr_missing_arrow)
3580               << FixItHint::CreateInsertion(Tok.getLocation(), "->");
3581         // Try to parse a 'type-constraint'
3582         if (TryAnnotateTypeConstraint()) {
3583           SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch);
3584           break;
3585         }
3586         if (!isTypeConstraintAnnotation()) {
3587           Diag(Tok, diag::err_requires_expr_expected_type_constraint);
3588           SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch);
3589           break;
3590         }
3591         CXXScopeSpec SS;
3592         if (Tok.is(tok::annot_cxxscope)) {
3593           Actions.RestoreNestedNameSpecifierAnnotation(Tok.getAnnotationValue(),
3594                                                        Tok.getAnnotationRange(),
3595                                                        SS);
3596           ConsumeAnnotationToken();
3597         }
3598 
3599         Req = Actions.ActOnCompoundRequirement(
3600             Expression.get(), NoexceptLoc, SS, takeTemplateIdAnnotation(Tok),
3601             TemplateParameterDepth);
3602         ConsumeAnnotationToken();
3603         if (Req)
3604           Requirements.push_back(Req);
3605         break;
3606       }
3607       default: {
3608         bool PossibleRequiresExprInSimpleRequirement = false;
3609         if (Tok.is(tok::kw_requires)) {
3610           auto IsNestedRequirement = [&] {
3611             RevertingTentativeParsingAction TPA(*this);
3612             ConsumeToken(); // 'requires'
3613             if (Tok.is(tok::l_brace))
3614               // This is a requires expression
3615               // requires (T t) {
3616               //   requires { t++; };
3617               //   ...      ^
3618               // }
3619               return false;
3620             if (Tok.is(tok::l_paren)) {
3621               // This might be the parameter list of a requires expression
3622               ConsumeParen();
3623               auto Res = TryParseParameterDeclarationClause();
3624               if (Res != TPResult::False) {
3625                 // Skip to the closing parenthesis
3626                 unsigned Depth = 1;
3627                 while (Depth != 0) {
3628                   bool FoundParen = SkipUntil(tok::l_paren, tok::r_paren,
3629                                               SkipUntilFlags::StopBeforeMatch);
3630                   if (!FoundParen)
3631                     break;
3632                   if (Tok.is(tok::l_paren))
3633                     Depth++;
3634                   else if (Tok.is(tok::r_paren))
3635                     Depth--;
3636                   ConsumeAnyToken();
3637                 }
3638                 // requires (T t) {
3639                 //   requires () ?
3640                 //   ...         ^
3641                 //   - OR -
3642                 //   requires (int x) ?
3643                 //   ...              ^
3644                 // }
3645                 if (Tok.is(tok::l_brace))
3646                   // requires (...) {
3647                   //                ^ - a requires expression as a
3648                   //                    simple-requirement.
3649                   return false;
3650               }
3651             }
3652             return true;
3653           };
3654           if (IsNestedRequirement()) {
3655             ConsumeToken();
3656             // Nested requirement
3657             // C++ [expr.prim.req.nested]
3658             //     nested-requirement:
3659             //         'requires' constraint-expression ';'
3660             ExprResult ConstraintExpr =
3661                 Actions.CorrectDelayedTyposInExpr(ParseConstraintExpression());
3662             if (ConstraintExpr.isInvalid() || !ConstraintExpr.isUsable()) {
3663               SkipUntil(tok::semi, tok::r_brace,
3664                         SkipUntilFlags::StopBeforeMatch);
3665               break;
3666             }
3667             if (auto *Req =
3668                     Actions.ActOnNestedRequirement(ConstraintExpr.get()))
3669               Requirements.push_back(Req);
3670             else {
3671               SkipUntil(tok::semi, tok::r_brace,
3672                         SkipUntilFlags::StopBeforeMatch);
3673               break;
3674             }
3675             break;
3676           } else
3677             PossibleRequiresExprInSimpleRequirement = true;
3678         } else if (Tok.is(tok::kw_typename)) {
3679           // This might be 'typename T::value_type;' (a type requirement) or
3680           // 'typename T::value_type{};' (a simple requirement).
3681           TentativeParsingAction TPA(*this);
3682 
3683           // We need to consume the typename to allow 'requires { typename a; }'
3684           SourceLocation TypenameKWLoc = ConsumeToken();
3685           if (TryAnnotateOptionalCXXScopeToken()) {
3686             TPA.Commit();
3687             SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch);
3688             break;
3689           }
3690           CXXScopeSpec SS;
3691           if (Tok.is(tok::annot_cxxscope)) {
3692             Actions.RestoreNestedNameSpecifierAnnotation(
3693                 Tok.getAnnotationValue(), Tok.getAnnotationRange(), SS);
3694             ConsumeAnnotationToken();
3695           }
3696 
3697           if (Tok.isOneOf(tok::identifier, tok::annot_template_id) &&
3698               !NextToken().isOneOf(tok::l_brace, tok::l_paren)) {
3699             TPA.Commit();
3700             SourceLocation NameLoc = Tok.getLocation();
3701             IdentifierInfo *II = nullptr;
3702             TemplateIdAnnotation *TemplateId = nullptr;
3703             if (Tok.is(tok::identifier)) {
3704               II = Tok.getIdentifierInfo();
3705               ConsumeToken();
3706             } else {
3707               TemplateId = takeTemplateIdAnnotation(Tok);
3708               ConsumeAnnotationToken();
3709               if (TemplateId->isInvalid())
3710                 break;
3711             }
3712 
3713             if (auto *Req = Actions.ActOnTypeRequirement(TypenameKWLoc, SS,
3714                                                          NameLoc, II,
3715                                                          TemplateId)) {
3716               Requirements.push_back(Req);
3717             }
3718             break;
3719           }
3720           TPA.Revert();
3721         }
3722         // Simple requirement
3723         // C++ [expr.prim.req.simple]
3724         //     simple-requirement:
3725         //         expression ';'
3726         SourceLocation StartLoc = Tok.getLocation();
3727         ExprResult Expression =
3728             Actions.CorrectDelayedTyposInExpr(ParseExpression());
3729         if (!Expression.isUsable()) {
3730           SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch);
3731           break;
3732         }
3733         if (!Expression.isInvalid() && PossibleRequiresExprInSimpleRequirement)
3734           Diag(StartLoc, diag::err_requires_expr_in_simple_requirement)
3735               << FixItHint::CreateInsertion(StartLoc, "requires");
3736         if (auto *Req = Actions.ActOnSimpleRequirement(Expression.get()))
3737           Requirements.push_back(Req);
3738         else {
3739           SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch);
3740           break;
3741         }
3742         // User may have tried to put some compound requirement stuff here
3743         if (Tok.is(tok::kw_noexcept)) {
3744           Diag(Tok, diag::err_requires_expr_simple_requirement_noexcept)
3745               << FixItHint::CreateInsertion(StartLoc, "{")
3746               << FixItHint::CreateInsertion(Tok.getLocation(), "}");
3747           SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch);
3748           break;
3749         }
3750         break;
3751       }
3752       }
3753       if (ExpectAndConsumeSemi(diag::err_expected_semi_requirement)) {
3754         SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch);
3755         TryConsumeToken(tok::semi);
3756         break;
3757       }
3758     }
3759     if (Requirements.empty()) {
3760       // Don't emit an empty requires expr here to avoid confusing the user with
3761       // other diagnostics quoting an empty requires expression they never
3762       // wrote.
3763       Braces.consumeClose();
3764       Actions.ActOnFinishRequiresExpr();
3765       return ExprError();
3766     }
3767   }
3768   Braces.consumeClose();
3769   Actions.ActOnFinishRequiresExpr();
3770   ParsingBodyDecl.complete(Body);
3771   return Actions.ActOnRequiresExpr(
3772       RequiresKWLoc, Body, Parens.getOpenLocation(), LocalParameterDecls,
3773       Parens.getCloseLocation(), Requirements, Braces.getCloseLocation());
3774 }
3775 
3776 static TypeTrait TypeTraitFromTokKind(tok::TokenKind kind) {
3777   switch (kind) {
3778   default: llvm_unreachable("Not a known type trait");
3779 #define TYPE_TRAIT_1(Spelling, Name, Key) \
3780 case tok::kw_ ## Spelling: return UTT_ ## Name;
3781 #define TYPE_TRAIT_2(Spelling, Name, Key) \
3782 case tok::kw_ ## Spelling: return BTT_ ## Name;
3783 #include "clang/Basic/TokenKinds.def"
3784 #define TYPE_TRAIT_N(Spelling, Name, Key) \
3785   case tok::kw_ ## Spelling: return TT_ ## Name;
3786 #include "clang/Basic/TokenKinds.def"
3787   }
3788 }
3789 
3790 static ArrayTypeTrait ArrayTypeTraitFromTokKind(tok::TokenKind kind) {
3791   switch (kind) {
3792   default:
3793     llvm_unreachable("Not a known array type trait");
3794 #define ARRAY_TYPE_TRAIT(Spelling, Name, Key)                                  \
3795   case tok::kw_##Spelling:                                                     \
3796     return ATT_##Name;
3797 #include "clang/Basic/TokenKinds.def"
3798   }
3799 }
3800 
3801 static ExpressionTrait ExpressionTraitFromTokKind(tok::TokenKind kind) {
3802   switch (kind) {
3803   default:
3804     llvm_unreachable("Not a known unary expression trait.");
3805 #define EXPRESSION_TRAIT(Spelling, Name, Key)                                  \
3806   case tok::kw_##Spelling:                                                     \
3807     return ET_##Name;
3808 #include "clang/Basic/TokenKinds.def"
3809   }
3810 }
3811 
3812 /// Parse the built-in type-trait pseudo-functions that allow
3813 /// implementation of the TR1/C++11 type traits templates.
3814 ///
3815 ///       primary-expression:
3816 ///          unary-type-trait '(' type-id ')'
3817 ///          binary-type-trait '(' type-id ',' type-id ')'
3818 ///          type-trait '(' type-id-seq ')'
3819 ///
3820 ///       type-id-seq:
3821 ///          type-id ...[opt] type-id-seq[opt]
3822 ///
3823 ExprResult Parser::ParseTypeTrait() {
3824   tok::TokenKind Kind = Tok.getKind();
3825 
3826   SourceLocation Loc = ConsumeToken();
3827 
3828   BalancedDelimiterTracker Parens(*this, tok::l_paren);
3829   if (Parens.expectAndConsume())
3830     return ExprError();
3831 
3832   SmallVector<ParsedType, 2> Args;
3833   do {
3834     // Parse the next type.
3835     TypeResult Ty = ParseTypeName();
3836     if (Ty.isInvalid()) {
3837       Parens.skipToEnd();
3838       return ExprError();
3839     }
3840 
3841     // Parse the ellipsis, if present.
3842     if (Tok.is(tok::ellipsis)) {
3843       Ty = Actions.ActOnPackExpansion(Ty.get(), ConsumeToken());
3844       if (Ty.isInvalid()) {
3845         Parens.skipToEnd();
3846         return ExprError();
3847       }
3848     }
3849 
3850     // Add this type to the list of arguments.
3851     Args.push_back(Ty.get());
3852   } while (TryConsumeToken(tok::comma));
3853 
3854   if (Parens.consumeClose())
3855     return ExprError();
3856 
3857   SourceLocation EndLoc = Parens.getCloseLocation();
3858 
3859   return Actions.ActOnTypeTrait(TypeTraitFromTokKind(Kind), Loc, Args, EndLoc);
3860 }
3861 
3862 /// ParseArrayTypeTrait - Parse the built-in array type-trait
3863 /// pseudo-functions.
3864 ///
3865 ///       primary-expression:
3866 /// [Embarcadero]     '__array_rank' '(' type-id ')'
3867 /// [Embarcadero]     '__array_extent' '(' type-id ',' expression ')'
3868 ///
3869 ExprResult Parser::ParseArrayTypeTrait() {
3870   ArrayTypeTrait ATT = ArrayTypeTraitFromTokKind(Tok.getKind());
3871   SourceLocation Loc = ConsumeToken();
3872 
3873   BalancedDelimiterTracker T(*this, tok::l_paren);
3874   if (T.expectAndConsume())
3875     return ExprError();
3876 
3877   TypeResult Ty = ParseTypeName();
3878   if (Ty.isInvalid()) {
3879     SkipUntil(tok::comma, StopAtSemi);
3880     SkipUntil(tok::r_paren, StopAtSemi);
3881     return ExprError();
3882   }
3883 
3884   switch (ATT) {
3885   case ATT_ArrayRank: {
3886     T.consumeClose();
3887     return Actions.ActOnArrayTypeTrait(ATT, Loc, Ty.get(), nullptr,
3888                                        T.getCloseLocation());
3889   }
3890   case ATT_ArrayExtent: {
3891     if (ExpectAndConsume(tok::comma)) {
3892       SkipUntil(tok::r_paren, StopAtSemi);
3893       return ExprError();
3894     }
3895 
3896     ExprResult DimExpr = ParseExpression();
3897     T.consumeClose();
3898 
3899     return Actions.ActOnArrayTypeTrait(ATT, Loc, Ty.get(), DimExpr.get(),
3900                                        T.getCloseLocation());
3901   }
3902   }
3903   llvm_unreachable("Invalid ArrayTypeTrait!");
3904 }
3905 
3906 /// ParseExpressionTrait - Parse built-in expression-trait
3907 /// pseudo-functions like __is_lvalue_expr( xxx ).
3908 ///
3909 ///       primary-expression:
3910 /// [Embarcadero]     expression-trait '(' expression ')'
3911 ///
3912 ExprResult Parser::ParseExpressionTrait() {
3913   ExpressionTrait ET = ExpressionTraitFromTokKind(Tok.getKind());
3914   SourceLocation Loc = ConsumeToken();
3915 
3916   BalancedDelimiterTracker T(*this, tok::l_paren);
3917   if (T.expectAndConsume())
3918     return ExprError();
3919 
3920   ExprResult Expr = ParseExpression();
3921 
3922   T.consumeClose();
3923 
3924   return Actions.ActOnExpressionTrait(ET, Loc, Expr.get(),
3925                                       T.getCloseLocation());
3926 }
3927 
3928 
3929 /// ParseCXXAmbiguousParenExpression - We have parsed the left paren of a
3930 /// parenthesized ambiguous type-id. This uses tentative parsing to disambiguate
3931 /// based on the context past the parens.
3932 ExprResult
3933 Parser::ParseCXXAmbiguousParenExpression(ParenParseOption &ExprType,
3934                                          ParsedType &CastTy,
3935                                          BalancedDelimiterTracker &Tracker,
3936                                          ColonProtectionRAIIObject &ColonProt) {
3937   assert(getLangOpts().CPlusPlus && "Should only be called for C++!");
3938   assert(ExprType == CastExpr && "Compound literals are not ambiguous!");
3939   assert(isTypeIdInParens() && "Not a type-id!");
3940 
3941   ExprResult Result(true);
3942   CastTy = nullptr;
3943 
3944   // We need to disambiguate a very ugly part of the C++ syntax:
3945   //
3946   // (T())x;  - type-id
3947   // (T())*x; - type-id
3948   // (T())/x; - expression
3949   // (T());   - expression
3950   //
3951   // The bad news is that we cannot use the specialized tentative parser, since
3952   // it can only verify that the thing inside the parens can be parsed as
3953   // type-id, it is not useful for determining the context past the parens.
3954   //
3955   // The good news is that the parser can disambiguate this part without
3956   // making any unnecessary Action calls.
3957   //
3958   // It uses a scheme similar to parsing inline methods. The parenthesized
3959   // tokens are cached, the context that follows is determined (possibly by
3960   // parsing a cast-expression), and then we re-introduce the cached tokens
3961   // into the token stream and parse them appropriately.
3962 
3963   ParenParseOption ParseAs;
3964   CachedTokens Toks;
3965 
3966   // Store the tokens of the parentheses. We will parse them after we determine
3967   // the context that follows them.
3968   if (!ConsumeAndStoreUntil(tok::r_paren, Toks)) {
3969     // We didn't find the ')' we expected.
3970     Tracker.consumeClose();
3971     return ExprError();
3972   }
3973 
3974   if (Tok.is(tok::l_brace)) {
3975     ParseAs = CompoundLiteral;
3976   } else {
3977     bool NotCastExpr;
3978     if (Tok.is(tok::l_paren) && NextToken().is(tok::r_paren)) {
3979       NotCastExpr = true;
3980     } else {
3981       // Try parsing the cast-expression that may follow.
3982       // If it is not a cast-expression, NotCastExpr will be true and no token
3983       // will be consumed.
3984       ColonProt.restore();
3985       Result = ParseCastExpression(AnyCastExpr,
3986                                    false/*isAddressofOperand*/,
3987                                    NotCastExpr,
3988                                    // type-id has priority.
3989                                    IsTypeCast);
3990     }
3991 
3992     // If we parsed a cast-expression, it's really a type-id, otherwise it's
3993     // an expression.
3994     ParseAs = NotCastExpr ? SimpleExpr : CastExpr;
3995   }
3996 
3997   // Create a fake EOF to mark end of Toks buffer.
3998   Token AttrEnd;
3999   AttrEnd.startToken();
4000   AttrEnd.setKind(tok::eof);
4001   AttrEnd.setLocation(Tok.getLocation());
4002   AttrEnd.setEofData(Toks.data());
4003   Toks.push_back(AttrEnd);
4004 
4005   // The current token should go after the cached tokens.
4006   Toks.push_back(Tok);
4007   // Re-enter the stored parenthesized tokens into the token stream, so we may
4008   // parse them now.
4009   PP.EnterTokenStream(Toks, /*DisableMacroExpansion*/ true,
4010                       /*IsReinject*/ true);
4011   // Drop the current token and bring the first cached one. It's the same token
4012   // as when we entered this function.
4013   ConsumeAnyToken();
4014 
4015   if (ParseAs >= CompoundLiteral) {
4016     // Parse the type declarator.
4017     DeclSpec DS(AttrFactory);
4018     Declarator DeclaratorInfo(DS, ParsedAttributesView::none(),
4019                               DeclaratorContext::TypeName);
4020     {
4021       ColonProtectionRAIIObject InnerColonProtection(*this);
4022       ParseSpecifierQualifierList(DS);
4023       ParseDeclarator(DeclaratorInfo);
4024     }
4025 
4026     // Match the ')'.
4027     Tracker.consumeClose();
4028     ColonProt.restore();
4029 
4030     // Consume EOF marker for Toks buffer.
4031     assert(Tok.is(tok::eof) && Tok.getEofData() == AttrEnd.getEofData());
4032     ConsumeAnyToken();
4033 
4034     if (ParseAs == CompoundLiteral) {
4035       ExprType = CompoundLiteral;
4036       if (DeclaratorInfo.isInvalidType())
4037         return ExprError();
4038 
4039       TypeResult Ty = Actions.ActOnTypeName(DeclaratorInfo);
4040       return ParseCompoundLiteralExpression(Ty.get(),
4041                                             Tracker.getOpenLocation(),
4042                                             Tracker.getCloseLocation());
4043     }
4044 
4045     // We parsed '(' type-id ')' and the thing after it wasn't a '{'.
4046     assert(ParseAs == CastExpr);
4047 
4048     if (DeclaratorInfo.isInvalidType())
4049       return ExprError();
4050 
4051     // Result is what ParseCastExpression returned earlier.
4052     if (!Result.isInvalid())
4053       Result = Actions.ActOnCastExpr(getCurScope(), Tracker.getOpenLocation(),
4054                                     DeclaratorInfo, CastTy,
4055                                     Tracker.getCloseLocation(), Result.get());
4056     return Result;
4057   }
4058 
4059   // Not a compound literal, and not followed by a cast-expression.
4060   assert(ParseAs == SimpleExpr);
4061 
4062   ExprType = SimpleExpr;
4063   Result = ParseExpression();
4064   if (!Result.isInvalid() && Tok.is(tok::r_paren))
4065     Result = Actions.ActOnParenExpr(Tracker.getOpenLocation(),
4066                                     Tok.getLocation(), Result.get());
4067 
4068   // Match the ')'.
4069   if (Result.isInvalid()) {
4070     while (Tok.isNot(tok::eof))
4071       ConsumeAnyToken();
4072     assert(Tok.getEofData() == AttrEnd.getEofData());
4073     ConsumeAnyToken();
4074     return ExprError();
4075   }
4076 
4077   Tracker.consumeClose();
4078   // Consume EOF marker for Toks buffer.
4079   assert(Tok.is(tok::eof) && Tok.getEofData() == AttrEnd.getEofData());
4080   ConsumeAnyToken();
4081   return Result;
4082 }
4083 
4084 /// Parse a __builtin_bit_cast(T, E).
4085 ExprResult Parser::ParseBuiltinBitCast() {
4086   SourceLocation KWLoc = ConsumeToken();
4087 
4088   BalancedDelimiterTracker T(*this, tok::l_paren);
4089   if (T.expectAndConsume(diag::err_expected_lparen_after, "__builtin_bit_cast"))
4090     return ExprError();
4091 
4092   // Parse the common declaration-specifiers piece.
4093   DeclSpec DS(AttrFactory);
4094   ParseSpecifierQualifierList(DS);
4095 
4096   // Parse the abstract-declarator, if present.
4097   Declarator DeclaratorInfo(DS, ParsedAttributesView::none(),
4098                             DeclaratorContext::TypeName);
4099   ParseDeclarator(DeclaratorInfo);
4100 
4101   if (ExpectAndConsume(tok::comma)) {
4102     Diag(Tok.getLocation(), diag::err_expected) << tok::comma;
4103     SkipUntil(tok::r_paren, StopAtSemi);
4104     return ExprError();
4105   }
4106 
4107   ExprResult Operand = ParseExpression();
4108 
4109   if (T.consumeClose())
4110     return ExprError();
4111 
4112   if (Operand.isInvalid() || DeclaratorInfo.isInvalidType())
4113     return ExprError();
4114 
4115   return Actions.ActOnBuiltinBitCastExpr(KWLoc, DeclaratorInfo, Operand,
4116                                          T.getCloseLocation());
4117 }
4118