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
SelectDigraphErrorMessage(tok::TokenKind Kind)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?
areTokensAdjacent(const Token & First,const Token & Second)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.
FixDigraph(Parser & P,Preprocessor & PP,Token & DigraphToken,Token & ColonToken,tok::TokenKind Kind,bool AtDigraph)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.
CheckForTemplateAndDigraph(Token & Next,ParsedType ObjectType,bool EnteringContext,IdentifierInfo & II,CXXScopeSpec & SS)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
ParseOptionalCXXScopeSpecifier(CXXScopeSpec & SS,ParsedType ObjectType,bool ObjectHadErrors,bool EnteringContext,bool * MayBePseudoDestructor,bool IsTypename,IdentifierInfo ** LastII,bool OnlyNamespace,bool InUsingDeclaration)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
tryParseCXXIdExpression(CXXScopeSpec & SS,bool isAddressOfOperand,Token & Replacement)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 ///
ParseCXXIdExpression(bool isAddressOfOperand)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 ///
ParseLambdaExpression()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().
TryParseLambdaExpression()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.
ParseLambdaIntroducer(LambdaIntroducer & Intro,LambdaIntroducerTentativeParse * Tentative)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
tryConsumeLambdaSpecifierToken(Parser & P,SourceLocation & MutableLoc,SourceLocation & StaticLoc,SourceLocation & ConstexprLoc,SourceLocation & ConstevalLoc,SourceLocation & DeclEndLoc)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
addStaticToLambdaDeclSpecifier(Parser & P,SourceLocation StaticLoc,DeclSpec & DS)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
addConstexprToLambdaDeclSpecifier(Parser & P,SourceLocation ConstexprLoc,DeclSpec & DS)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
addConstevalToLambdaDeclSpecifier(Parser & P,SourceLocation ConstevalLoc,DeclSpec & DS)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
DiagnoseStaticSpecifierRestrictions(Parser & P,SourceLocation StaticLoc,SourceLocation MutableLoc,const LambdaIntroducer & Intro)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.
ParseLambdaExpressionAfterIntroducer(LambdaIntroducer & Intro)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 ')'
ParseCXXCasts()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 ///
ParseCXXTypeid()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 ///
ParseCXXUuidof()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
ParseCXXPseudoDestructor(Expr * Base,SourceLocation OpLoc,tok::TokenKind OpKind,CXXScopeSpec & SS,ParsedType ObjectType)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'
ParseCXXBoolLiteral()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]
ParseThrowExpression()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]
ParseCoyieldExpression()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.
ParseCXXThis()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
ParseCXXTypeConstructExpression(const DeclSpec & DS)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
ParseAliasDeclarationInInitStatement(DeclaratorContext Context,ParsedAttributes & Attrs)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
ParseCXXCondition(StmtResult * InitStmt,SourceLocation Loc,Sema::ConditionKind CK,bool MissingOK,ForRangeInfo * FRI,bool EnterForConditionScope)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 ///
ParseCXXSimpleTypeSpecifier(DeclSpec & DS)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 ///
ParseCXXTypeSpecifierSeq(DeclSpec & DS,DeclaratorContext Context)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.
ParseUnqualifiedIdTemplateId(CXXScopeSpec & SS,ParsedType ObjectType,bool ObjectHadErrors,SourceLocation TemplateKWLoc,IdentifierInfo * Name,SourceLocation NameLoc,bool EnteringContext,UnqualifiedId & Id,bool AssumeTemplateId)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.
ParseUnqualifiedIdOperator(CXXScopeSpec & SS,bool EnteringContext,ParsedType ObjectType,UnqualifiedId & Result)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.
ParseUnqualifiedId(CXXScopeSpec & SS,ParsedType ObjectType,bool ObjectHadErrors,bool EnteringContext,bool AllowDestructorName,bool AllowConstructorName,bool AllowDeductionGuide,SourceLocation * TemplateKWLoc,UnqualifiedId & Result)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
ParseCXXNewExpression(bool UseGlobal,SourceLocation Start)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 ///
ParseDirectNewDeclarator(Declarator & D)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 ///
ParseExpressionListOrTypeId(SmallVectorImpl<Expr * > & PlacementArgs,Declarator & D)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
ParseCXXDeleteExpression(bool UseGlobal,SourceLocation Start)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
ParseRequiresExpression()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
TypeTraitFromTokKind(tok::TokenKind kind)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
ArrayTypeTraitFromTokKind(tok::TokenKind kind)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
ExpressionTraitFromTokKind(tok::TokenKind kind)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 ///
ParseTypeTrait()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 ///
ParseArrayTypeTrait()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 ///
ParseExpressionTrait()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
ParseCXXAmbiguousParenExpression(ParenParseOption & ExprType,ParsedType & CastTy,BalancedDelimiterTracker & Tracker,ColonProtectionRAIIObject & ColonProt)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).
ParseBuiltinBitCast()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