clang 20.0.0git
ParseCXXInlineMethods.cpp
Go to the documentation of this file.
1//===--- ParseCXXInlineMethods.cpp - C++ class inline methods 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 parsing for C++ class inline methods.
10//
11//===----------------------------------------------------------------------===//
12
15#include "clang/Parse/Parser.h"
17#include "clang/Sema/DeclSpec.h"
19#include "clang/Sema/Scope.h"
20
21using namespace clang;
22
23/// Parse the optional ("message") part of a deleted-function-body.
24StringLiteral *Parser::ParseCXXDeletedFunctionMessage() {
25 if (!Tok.is(tok::l_paren))
26 return nullptr;
27 StringLiteral *Message = nullptr;
28 BalancedDelimiterTracker BT{*this, tok::l_paren};
29 BT.consumeOpen();
30
31 if (isTokenStringLiteral()) {
33 if (Res.isUsable()) {
34 Message = Res.getAs<StringLiteral>();
35 Diag(Message->getBeginLoc(), getLangOpts().CPlusPlus26
36 ? diag::warn_cxx23_delete_with_message
37 : diag::ext_delete_with_message)
38 << Message->getSourceRange();
39 }
40 } else {
41 Diag(Tok.getLocation(), diag::err_expected_string_literal)
42 << /*Source='in'*/ 0 << "'delete'";
43 SkipUntil(tok::r_paren, StopAtSemi | StopBeforeMatch);
44 }
45
46 BT.consumeClose();
47 return Message;
48}
49
50/// If we've encountered '= delete' in a context where it is ill-formed, such
51/// as in the declaration of a non-function, also skip the ("message") part if
52/// it is present to avoid issuing further diagnostics.
53void Parser::SkipDeletedFunctionBody() {
54 if (!Tok.is(tok::l_paren))
55 return;
56
57 BalancedDelimiterTracker BT{*this, tok::l_paren};
58 BT.consumeOpen();
59
60 // Just skip to the end of the current declaration.
61 SkipUntil(tok::r_paren, tok::comma, StopAtSemi | StopBeforeMatch);
62 if (Tok.is(tok::r_paren))
63 BT.consumeClose();
64}
65
66/// ParseCXXInlineMethodDef - We parsed and verified that the specified
67/// Declarator is a well formed C++ inline method definition. Now lex its body
68/// and store its tokens for parsing after the C++ class is complete.
69NamedDecl *Parser::ParseCXXInlineMethodDef(
70 AccessSpecifier AS, const ParsedAttributesView &AccessAttrs,
71 ParsingDeclarator &D, const ParsedTemplateInfo &TemplateInfo,
72 const VirtSpecifiers &VS, SourceLocation PureSpecLoc) {
73 assert(D.isFunctionDeclarator() && "This isn't a function declarator!");
74 assert(Tok.isOneOf(tok::l_brace, tok::colon, tok::kw_try, tok::equal) &&
75 "Current token not a '{', ':', '=', or 'try'!");
76
77 MultiTemplateParamsArg TemplateParams(
78 TemplateInfo.TemplateParams ? TemplateInfo.TemplateParams->data()
79 : nullptr,
80 TemplateInfo.TemplateParams ? TemplateInfo.TemplateParams->size() : 0);
81
82 NamedDecl *FnD;
83 if (D.getDeclSpec().isFriendSpecified())
84 FnD = Actions.ActOnFriendFunctionDecl(getCurScope(), D,
85 TemplateParams);
86 else {
87 FnD = Actions.ActOnCXXMemberDeclarator(getCurScope(), AS, D,
88 TemplateParams, nullptr,
89 VS, ICIS_NoInit);
90 if (FnD) {
91 Actions.ProcessDeclAttributeList(getCurScope(), FnD, AccessAttrs);
92 if (PureSpecLoc.isValid())
93 Actions.ActOnPureSpecifier(FnD, PureSpecLoc);
94 }
95 }
96
97 if (FnD)
98 HandleMemberFunctionDeclDelays(D, FnD);
99
100 D.complete(FnD);
101
102 if (TryConsumeToken(tok::equal)) {
103 if (!FnD) {
104 SkipUntil(tok::semi);
105 return nullptr;
106 }
107
108 bool Delete = false;
109 SourceLocation KWLoc;
110 SourceLocation KWEndLoc = Tok.getEndLoc().getLocWithOffset(-1);
111 if (TryConsumeToken(tok::kw_delete, KWLoc)) {
113 ? diag::warn_cxx98_compat_defaulted_deleted_function
114 : diag::ext_defaulted_deleted_function)
115 << 1 /* deleted */;
116 StringLiteral *Message = ParseCXXDeletedFunctionMessage();
117 Actions.SetDeclDeleted(FnD, KWLoc, Message);
118 Delete = true;
119 if (auto *DeclAsFunction = dyn_cast<FunctionDecl>(FnD)) {
120 DeclAsFunction->setRangeEnd(KWEndLoc);
121 }
122 } else if (TryConsumeToken(tok::kw_default, KWLoc)) {
124 ? diag::warn_cxx98_compat_defaulted_deleted_function
125 : diag::ext_defaulted_deleted_function)
126 << 0 /* defaulted */;
127 Actions.SetDeclDefaulted(FnD, KWLoc);
128 if (auto *DeclAsFunction = dyn_cast<FunctionDecl>(FnD)) {
129 DeclAsFunction->setRangeEnd(KWEndLoc);
130 }
131 } else {
132 llvm_unreachable("function definition after = not 'delete' or 'default'");
133 }
134
135 if (Tok.is(tok::comma)) {
136 Diag(KWLoc, diag::err_default_delete_in_multiple_declaration)
137 << Delete;
138 SkipUntil(tok::semi);
139 } else if (ExpectAndConsume(tok::semi, diag::err_expected_after,
140 Delete ? "delete" : "default")) {
141 SkipUntil(tok::semi);
142 }
143
144 return FnD;
145 }
146
147 if (SkipFunctionBodies && (!FnD || Actions.canSkipFunctionBody(FnD)) &&
148 trySkippingFunctionBody()) {
149 Actions.ActOnSkippedFunctionBody(FnD);
150 return FnD;
151 }
152
153 // In delayed template parsing mode, if we are within a class template
154 // or if we are about to parse function member template then consume
155 // the tokens and store them for parsing at the end of the translation unit.
156 if (getLangOpts().DelayedTemplateParsing &&
157 D.getFunctionDefinitionKind() == FunctionDefinitionKind::Definition &&
158 !D.getDeclSpec().hasConstexprSpecifier() &&
159 !(FnD && FnD->getAsFunction() &&
161 ((Actions.CurContext->isDependentContext() ||
162 (TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate &&
163 TemplateInfo.Kind != ParsedTemplateInfo::ExplicitSpecialization)) &&
165
166 CachedTokens Toks;
167 LexTemplateFunctionForLateParsing(Toks);
168
169 if (FnD) {
170 FunctionDecl *FD = FnD->getAsFunction();
172 Actions.MarkAsLateParsedTemplate(FD, FnD, Toks);
173 }
174
175 return FnD;
176 }
177
178 // Consume the tokens and store them for later parsing.
179
180 LexedMethod* LM = new LexedMethod(this, FnD);
181 getCurrentClass().LateParsedDeclarations.push_back(LM);
182 CachedTokens &Toks = LM->Toks;
183
185 // Consume everything up to (and including) the left brace of the
186 // function body.
187 if (ConsumeAndStoreFunctionPrologue(Toks)) {
188 // We didn't find the left-brace we expected after the
189 // constructor initializer.
190
191 // If we're code-completing and the completion point was in the broken
192 // initializer, we want to parse it even though that will fail.
193 if (PP.isCodeCompletionEnabled() &&
194 llvm::any_of(Toks, [](const Token &Tok) {
195 return Tok.is(tok::code_completion);
196 })) {
197 // If we gave up at the completion point, the initializer list was
198 // likely truncated, so don't eat more tokens. We'll hit some extra
199 // errors, but they should be ignored in code completion.
200 return FnD;
201 }
202
203 // We already printed an error, and it's likely impossible to recover,
204 // so don't try to parse this method later.
205 // Skip over the rest of the decl and back to somewhere that looks
206 // reasonable.
208 delete getCurrentClass().LateParsedDeclarations.back();
209 getCurrentClass().LateParsedDeclarations.pop_back();
210 return FnD;
211 } else {
212 // Consume everything up to (and including) the matching right brace.
213 ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/false);
214 }
215
216 // If we're in a function-try-block, we need to store all the catch blocks.
217 if (kind == tok::kw_try) {
218 while (Tok.is(tok::kw_catch)) {
219 ConsumeAndStoreUntil(tok::l_brace, Toks, /*StopAtSemi=*/false);
220 ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/false);
221 }
222 }
223
224 if (FnD) {
225 FunctionDecl *FD = FnD->getAsFunction();
226 // Track that this function will eventually have a body; Sema needs
227 // to know this.
229 FD->setWillHaveBody(true);
230 } else {
231 // If semantic analysis could not build a function declaration,
232 // just throw away the late-parsed declaration.
233 delete getCurrentClass().LateParsedDeclarations.back();
234 getCurrentClass().LateParsedDeclarations.pop_back();
235 }
236
237 return FnD;
238}
239
240/// ParseCXXNonStaticMemberInitializer - We parsed and verified that the
241/// specified Declarator is a well formed C++ non-static data member
242/// declaration. Now lex its initializer and store its tokens for parsing
243/// after the class is complete.
244void Parser::ParseCXXNonStaticMemberInitializer(Decl *VarD) {
245 assert(Tok.isOneOf(tok::l_brace, tok::equal) &&
246 "Current token not a '{' or '='!");
247
248 LateParsedMemberInitializer *MI =
249 new LateParsedMemberInitializer(this, VarD);
250 getCurrentClass().LateParsedDeclarations.push_back(MI);
251 CachedTokens &Toks = MI->Toks;
252
254 if (kind == tok::equal) {
255 Toks.push_back(Tok);
256 ConsumeToken();
257 }
258
259 if (kind == tok::l_brace) {
260 // Begin by storing the '{' token.
261 Toks.push_back(Tok);
262 ConsumeBrace();
263
264 // Consume everything up to (and including) the matching right brace.
265 ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/true);
266 } else {
267 // Consume everything up to (but excluding) the comma or semicolon.
268 ConsumeAndStoreInitializer(Toks, CIK_DefaultInitializer);
269 }
270
271 // Store an artificial EOF token to ensure that we don't run off the end of
272 // the initializer when we come to parse it.
273 Token Eof;
274 Eof.startToken();
275 Eof.setKind(tok::eof);
276 Eof.setLocation(Tok.getLocation());
277 Eof.setEofData(VarD);
278 Toks.push_back(Eof);
279}
280
281Parser::LateParsedDeclaration::~LateParsedDeclaration() {}
282void Parser::LateParsedDeclaration::ParseLexedMethodDeclarations() {}
283void Parser::LateParsedDeclaration::ParseLexedMemberInitializers() {}
284void Parser::LateParsedDeclaration::ParseLexedMethodDefs() {}
285void Parser::LateParsedDeclaration::ParseLexedAttributes() {}
286void Parser::LateParsedDeclaration::ParseLexedPragmas() {}
287
288Parser::LateParsedClass::LateParsedClass(Parser *P, ParsingClass *C)
289 : Self(P), Class(C) {}
290
291Parser::LateParsedClass::~LateParsedClass() {
292 Self->DeallocateParsedClasses(Class);
293}
294
295void Parser::LateParsedClass::ParseLexedMethodDeclarations() {
296 Self->ParseLexedMethodDeclarations(*Class);
297}
298
299void Parser::LateParsedClass::ParseLexedMemberInitializers() {
300 Self->ParseLexedMemberInitializers(*Class);
301}
302
303void Parser::LateParsedClass::ParseLexedMethodDefs() {
304 Self->ParseLexedMethodDefs(*Class);
305}
306
307void Parser::LateParsedClass::ParseLexedAttributes() {
308 Self->ParseLexedAttributes(*Class);
309}
310
311void Parser::LateParsedClass::ParseLexedPragmas() {
312 Self->ParseLexedPragmas(*Class);
313}
314
315void Parser::LateParsedMethodDeclaration::ParseLexedMethodDeclarations() {
316 Self->ParseLexedMethodDeclaration(*this);
317}
318
319void Parser::LexedMethod::ParseLexedMethodDefs() {
320 Self->ParseLexedMethodDef(*this);
321}
322
323void Parser::LateParsedMemberInitializer::ParseLexedMemberInitializers() {
324 Self->ParseLexedMemberInitializer(*this);
325}
326
327void Parser::LateParsedAttribute::ParseLexedAttributes() {
328 Self->ParseLexedAttribute(*this, true, false);
329}
330
331void Parser::LateParsedPragma::ParseLexedPragmas() {
332 Self->ParseLexedPragma(*this);
333}
334
335/// Utility to re-enter a possibly-templated scope while parsing its
336/// late-parsed components.
340 TemplateParameterDepthRAII CurTemplateDepthTracker;
341
342 ReenterTemplateScopeRAII(Parser &P, Decl *MaybeTemplated, bool Enter = true)
343 : P(P), Scopes(P), CurTemplateDepthTracker(P.TemplateParameterDepth) {
344 if (Enter) {
346 P.ReenterTemplateScopes(Scopes, MaybeTemplated));
347 }
348 }
349};
350
351/// Utility to re-enter a class scope while parsing its late-parsed components.
353 ParsingClass &Class;
354
356 : ReenterTemplateScopeRAII(P, Class.TagOrTemplate,
357 /*Enter=*/!Class.TopLevelClass),
358 Class(Class) {
359 // If this is the top-level class, we're still within its scope.
360 if (Class.TopLevelClass)
361 return;
362
363 // Re-enter the class scope itself.
366 Class.TagOrTemplate);
367 }
369 if (Class.TopLevelClass)
370 return;
371
373 Class.TagOrTemplate);
374 }
375};
376
377/// ParseLexedMethodDeclarations - We finished parsing the member
378/// specification of a top (non-nested) C++ class. Now go over the
379/// stack of method declarations with some parts for which parsing was
380/// delayed (such as default arguments) and parse them.
381void Parser::ParseLexedMethodDeclarations(ParsingClass &Class) {
382 ReenterClassScopeRAII InClassScope(*this, Class);
383
384 for (LateParsedDeclaration *LateD : Class.LateParsedDeclarations)
385 LateD->ParseLexedMethodDeclarations();
386}
387
388void Parser::ParseLexedMethodDeclaration(LateParsedMethodDeclaration &LM) {
389 // If this is a member template, introduce the template parameter scope.
390 ReenterTemplateScopeRAII InFunctionTemplateScope(*this, LM.Method);
391
392 // Start the delayed C++ method declaration
394
395 // Introduce the parameters into scope and parse their default
396 // arguments.
397 InFunctionTemplateScope.Scopes.Enter(Scope::FunctionPrototypeScope |
400 for (unsigned I = 0, N = LM.DefaultArgs.size(); I != N; ++I) {
401 auto Param = cast<ParmVarDecl>(LM.DefaultArgs[I].Param);
402 // Introduce the parameter into scope.
403 bool HasUnparsed = Param->hasUnparsedDefaultArg();
405 std::unique_ptr<CachedTokens> Toks = std::move(LM.DefaultArgs[I].Toks);
406 if (Toks) {
407 ParenBraceBracketBalancer BalancerRAIIObj(*this);
408
409 // Mark the end of the default argument so that we know when to stop when
410 // we parse it later on.
411 Token LastDefaultArgToken = Toks->back();
412 Token DefArgEnd;
413 DefArgEnd.startToken();
414 DefArgEnd.setKind(tok::eof);
415 DefArgEnd.setLocation(LastDefaultArgToken.getEndLoc());
416 DefArgEnd.setEofData(Param);
417 Toks->push_back(DefArgEnd);
418
419 // Parse the default argument from its saved token stream.
420 Toks->push_back(Tok); // So that the current token doesn't get lost
421 PP.EnterTokenStream(*Toks, true, /*IsReinject*/ true);
422
423 // Consume the previously-pushed token.
425
426 // Consume the '='.
427 assert(Tok.is(tok::equal) && "Default argument not starting with '='");
428 SourceLocation EqualLoc = ConsumeToken();
429
430 // The argument isn't actually potentially evaluated unless it is
431 // used.
433 Actions,
435
436 ExprResult DefArgResult;
437 if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
438 Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);
439 DefArgResult = ParseBraceInitializer();
440 } else
441 DefArgResult = ParseAssignmentExpression();
442 DefArgResult = Actions.CorrectDelayedTyposInExpr(DefArgResult, Param);
443 if (DefArgResult.isInvalid()) {
444 Actions.ActOnParamDefaultArgumentError(Param, EqualLoc,
445 /*DefaultArg=*/nullptr);
446 } else {
447 if (Tok.isNot(tok::eof) || Tok.getEofData() != Param) {
448 // The last two tokens are the terminator and the saved value of
449 // Tok; the last token in the default argument is the one before
450 // those.
451 assert(Toks->size() >= 3 && "expected a token in default arg");
452 Diag(Tok.getLocation(), diag::err_default_arg_unparsed)
453 << SourceRange(Tok.getLocation(),
454 (*Toks)[Toks->size() - 3].getLocation());
455 }
456 Actions.ActOnParamDefaultArgument(Param, EqualLoc,
457 DefArgResult.get());
458 }
459
460 // There could be leftover tokens (e.g. because of an error).
461 // Skip through until we reach the 'end of default argument' token.
462 while (Tok.isNot(tok::eof))
464
465 if (Tok.is(tok::eof) && Tok.getEofData() == Param)
467 } else if (HasUnparsed) {
468 assert(Param->hasInheritedDefaultArg());
469 FunctionDecl *Old;
470 if (const auto *FunTmpl = dyn_cast<FunctionTemplateDecl>(LM.Method))
471 Old =
472 cast<FunctionDecl>(FunTmpl->getTemplatedDecl())->getPreviousDecl();
473 else
474 Old = cast<FunctionDecl>(LM.Method)->getPreviousDecl();
475 if (Old) {
476 ParmVarDecl *OldParam = Old->getParamDecl(I);
477 assert(!OldParam->hasUnparsedDefaultArg());
478 if (OldParam->hasUninstantiatedDefaultArg())
479 Param->setUninstantiatedDefaultArg(
480 OldParam->getUninstantiatedDefaultArg());
481 else
482 Param->setDefaultArg(OldParam->getInit());
483 }
484 }
485 }
486
487 // Parse a delayed exception-specification, if there is one.
488 if (CachedTokens *Toks = LM.ExceptionSpecTokens) {
489 ParenBraceBracketBalancer BalancerRAIIObj(*this);
490
491 // Add the 'stop' token.
492 Token LastExceptionSpecToken = Toks->back();
493 Token ExceptionSpecEnd;
494 ExceptionSpecEnd.startToken();
495 ExceptionSpecEnd.setKind(tok::eof);
496 ExceptionSpecEnd.setLocation(LastExceptionSpecToken.getEndLoc());
497 ExceptionSpecEnd.setEofData(LM.Method);
498 Toks->push_back(ExceptionSpecEnd);
499
500 // Parse the default argument from its saved token stream.
501 Toks->push_back(Tok); // So that the current token doesn't get lost
502 PP.EnterTokenStream(*Toks, true, /*IsReinject*/true);
503
504 // Consume the previously-pushed token.
506
507 // C++11 [expr.prim.general]p3:
508 // If a declaration declares a member function or member function
509 // template of a class X, the expression this is a prvalue of type
510 // "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq
511 // and the end of the function-definition, member-declarator, or
512 // declarator.
513 CXXMethodDecl *Method;
514 FunctionDecl *FunctionToPush;
515 if (FunctionTemplateDecl *FunTmpl
516 = dyn_cast<FunctionTemplateDecl>(LM.Method))
517 FunctionToPush = FunTmpl->getTemplatedDecl();
518 else
519 FunctionToPush = cast<FunctionDecl>(LM.Method);
520 Method = dyn_cast<CXXMethodDecl>(FunctionToPush);
521
522 // Push a function scope so that tryCaptureVariable() can properly visit
523 // function scopes involving function parameters that are referenced inside
524 // the noexcept specifier e.g. through a lambda expression.
525 // Example:
526 // struct X {
527 // void ICE(int val) noexcept(noexcept([val]{}));
528 // };
529 // Setup the CurScope to match the function DeclContext - we have such
530 // assumption in IsInFnTryBlockHandler().
531 ParseScope FnScope(this, Scope::FnScope);
532 Sema::ContextRAII FnContext(Actions, FunctionToPush,
533 /*NewThisContext=*/false);
534 Sema::FunctionScopeRAII PopFnContext(Actions);
535 Actions.PushFunctionScope();
536
537 Sema::CXXThisScopeRAII ThisScope(
538 Actions, Method ? Method->getParent() : nullptr,
539 Method ? Method->getMethodQualifiers() : Qualifiers{},
540 Method && getLangOpts().CPlusPlus11);
541
542 // Parse the exception-specification.
543 SourceRange SpecificationRange;
544 SmallVector<ParsedType, 4> DynamicExceptions;
545 SmallVector<SourceRange, 4> DynamicExceptionRanges;
546 ExprResult NoexceptExpr;
547 CachedTokens *ExceptionSpecTokens;
548
550 = tryParseExceptionSpecification(/*Delayed=*/false, SpecificationRange,
551 DynamicExceptions,
552 DynamicExceptionRanges, NoexceptExpr,
553 ExceptionSpecTokens);
554
555 if (Tok.isNot(tok::eof) || Tok.getEofData() != LM.Method)
556 Diag(Tok.getLocation(), diag::err_except_spec_unparsed);
557
558 // Attach the exception-specification to the method.
559 Actions.actOnDelayedExceptionSpecification(LM.Method, EST,
560 SpecificationRange,
561 DynamicExceptions,
562 DynamicExceptionRanges,
563 NoexceptExpr.isUsable()?
564 NoexceptExpr.get() : nullptr);
565
566 // There could be leftover tokens (e.g. because of an error).
567 // Skip through until we reach the original token position.
568 while (Tok.isNot(tok::eof))
570
571 // Clean up the remaining EOF token.
572 if (Tok.is(tok::eof) && Tok.getEofData() == LM.Method)
574
575 delete Toks;
576 LM.ExceptionSpecTokens = nullptr;
577 }
578
579 InFunctionTemplateScope.Scopes.Exit();
580
581 // Finish the delayed C++ method declaration.
583}
584
585/// ParseLexedMethodDefs - We finished parsing the member specification of a top
586/// (non-nested) C++ class. Now go over the stack of lexed methods that were
587/// collected during its parsing and parse them all.
588void Parser::ParseLexedMethodDefs(ParsingClass &Class) {
589 ReenterClassScopeRAII InClassScope(*this, Class);
590
591 for (LateParsedDeclaration *D : Class.LateParsedDeclarations)
592 D->ParseLexedMethodDefs();
593}
594
595void Parser::ParseLexedMethodDef(LexedMethod &LM) {
596 // If this is a member template, introduce the template parameter scope.
597 ReenterTemplateScopeRAII InFunctionTemplateScope(*this, LM.D);
598
599 ParenBraceBracketBalancer BalancerRAIIObj(*this);
600
601 assert(!LM.Toks.empty() && "Empty body!");
602 Token LastBodyToken = LM.Toks.back();
603 Token BodyEnd;
604 BodyEnd.startToken();
605 BodyEnd.setKind(tok::eof);
606 BodyEnd.setLocation(LastBodyToken.getEndLoc());
607 BodyEnd.setEofData(LM.D);
608 LM.Toks.push_back(BodyEnd);
609 // Append the current token at the end of the new token stream so that it
610 // doesn't get lost.
611 LM.Toks.push_back(Tok);
612 PP.EnterTokenStream(LM.Toks, true, /*IsReinject*/true);
613
614 // Consume the previously pushed token.
615 ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true);
616 assert(Tok.isOneOf(tok::l_brace, tok::colon, tok::kw_try)
617 && "Inline method not starting with '{', ':' or 'try'");
618
619 // Parse the method body. Function body parsing code is similar enough
620 // to be re-used for method bodies as well.
621 ParseScope FnScope(this, Scope::FnScope | Scope::DeclScope |
623 Sema::FPFeaturesStateRAII SaveFPFeatures(Actions);
624
625 Actions.ActOnStartOfFunctionDef(getCurScope(), LM.D);
626
627 if (Tok.is(tok::kw_try)) {
628 ParseFunctionTryBlock(LM.D, FnScope);
629
630 while (Tok.isNot(tok::eof))
632
633 if (Tok.is(tok::eof) && Tok.getEofData() == LM.D)
635 return;
636 }
637 if (Tok.is(tok::colon)) {
638 ParseConstructorInitializer(LM.D);
639
640 // Error recovery.
641 if (!Tok.is(tok::l_brace)) {
642 FnScope.Exit();
643 Actions.ActOnFinishFunctionBody(LM.D, nullptr);
644
645 while (Tok.isNot(tok::eof))
647
648 if (Tok.is(tok::eof) && Tok.getEofData() == LM.D)
650 return;
651 }
652 } else
653 Actions.ActOnDefaultCtorInitializers(LM.D);
654
655 assert((Actions.getDiagnostics().hasErrorOccurred() ||
656 !isa<FunctionTemplateDecl>(LM.D) ||
657 cast<FunctionTemplateDecl>(LM.D)->getTemplateParameters()->getDepth()
658 < TemplateParameterDepth) &&
659 "TemplateParameterDepth should be greater than the depth of "
660 "current template being instantiated!");
661
662 ParseFunctionStatementBody(LM.D, FnScope);
663
664 while (Tok.isNot(tok::eof))
666
667 if (Tok.is(tok::eof) && Tok.getEofData() == LM.D)
669
670 if (auto *FD = dyn_cast_or_null<FunctionDecl>(LM.D))
671 if (isa<CXXMethodDecl>(FD) ||
674}
675
676/// ParseLexedMemberInitializers - We finished parsing the member specification
677/// of a top (non-nested) C++ class. Now go over the stack of lexed data member
678/// initializers that were collected during its parsing and parse them all.
679void Parser::ParseLexedMemberInitializers(ParsingClass &Class) {
680 ReenterClassScopeRAII InClassScope(*this, Class);
681
682 if (!Class.LateParsedDeclarations.empty()) {
683 // C++11 [expr.prim.general]p4:
684 // Otherwise, if a member-declarator declares a non-static data member
685 // (9.2) of a class X, the expression this is a prvalue of type "pointer
686 // to X" within the optional brace-or-equal-initializer. It shall not
687 // appear elsewhere in the member-declarator.
688 // FIXME: This should be done in ParseLexedMemberInitializer, not here.
689 Sema::CXXThisScopeRAII ThisScope(Actions, Class.TagOrTemplate,
690 Qualifiers());
691
692 for (LateParsedDeclaration *D : Class.LateParsedDeclarations)
693 D->ParseLexedMemberInitializers();
694 }
695
696 Actions.ActOnFinishDelayedMemberInitializers(Class.TagOrTemplate);
697}
698
699void Parser::ParseLexedMemberInitializer(LateParsedMemberInitializer &MI) {
700 if (!MI.Field || MI.Field->isInvalidDecl())
701 return;
702
703 ParenBraceBracketBalancer BalancerRAIIObj(*this);
704
705 // Append the current token at the end of the new token stream so that it
706 // doesn't get lost.
707 MI.Toks.push_back(Tok);
708 PP.EnterTokenStream(MI.Toks, true, /*IsReinject*/true);
709
710 // Consume the previously pushed token.
711 ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true);
712
713 SourceLocation EqualLoc;
714
716
717 // The initializer isn't actually potentially evaluated unless it is
718 // used.
721
722 ExprResult Init = ParseCXXMemberInitializer(MI.Field, /*IsFunction=*/false,
723 EqualLoc);
724
725 Actions.ActOnFinishCXXInClassMemberInitializer(MI.Field, EqualLoc,
726 Init.get());
727
728 // The next token should be our artificial terminating EOF token.
729 if (Tok.isNot(tok::eof)) {
730 if (!Init.isInvalid()) {
731 SourceLocation EndLoc = PP.getLocForEndOfToken(PrevTokLocation);
732 if (!EndLoc.isValid())
733 EndLoc = Tok.getLocation();
734 // No fixit; we can't recover as if there were a semicolon here.
735 Diag(EndLoc, diag::err_expected_semi_decl_list);
736 }
737
738 // Consume tokens until we hit the artificial EOF.
739 while (Tok.isNot(tok::eof))
741 }
742 // Make sure this is *our* artificial EOF token.
743 if (Tok.getEofData() == MI.Field)
745}
746
747/// Wrapper class which calls ParseLexedAttribute, after setting up the
748/// scope appropriately.
749void Parser::ParseLexedAttributes(ParsingClass &Class) {
750 ReenterClassScopeRAII InClassScope(*this, Class);
751
752 for (LateParsedDeclaration *LateD : Class.LateParsedDeclarations)
753 LateD->ParseLexedAttributes();
754}
755
756/// Parse all attributes in LAs, and attach them to Decl D.
757void Parser::ParseLexedAttributeList(LateParsedAttrList &LAs, Decl *D,
758 bool EnterScope, bool OnDefinition) {
759 assert(LAs.parseSoon() &&
760 "Attribute list should be marked for immediate parsing.");
761 for (unsigned i = 0, ni = LAs.size(); i < ni; ++i) {
762 if (D)
763 LAs[i]->addDecl(D);
764 ParseLexedAttribute(*LAs[i], EnterScope, OnDefinition);
765 delete LAs[i];
766 }
767 LAs.clear();
768}
769
770/// Finish parsing an attribute for which parsing was delayed.
771/// This will be called at the end of parsing a class declaration
772/// for each LateParsedAttribute. We consume the saved tokens and
773/// create an attribute with the arguments filled in. We add this
774/// to the Attribute list for the decl.
775void Parser::ParseLexedAttribute(LateParsedAttribute &LA,
776 bool EnterScope, bool OnDefinition) {
777 // Create a fake EOF so that attribute parsing won't go off the end of the
778 // attribute.
779 Token AttrEnd;
780 AttrEnd.startToken();
781 AttrEnd.setKind(tok::eof);
782 AttrEnd.setLocation(Tok.getLocation());
783 AttrEnd.setEofData(LA.Toks.data());
784 LA.Toks.push_back(AttrEnd);
785
786 // Append the current token at the end of the new token stream so that it
787 // doesn't get lost.
788 LA.Toks.push_back(Tok);
789 PP.EnterTokenStream(LA.Toks, true, /*IsReinject=*/true);
790 // Consume the previously pushed token.
791 ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true);
792
793 ParsedAttributes Attrs(AttrFactory);
794
795 if (LA.Decls.size() > 0) {
796 Decl *D = LA.Decls[0];
797 NamedDecl *ND = dyn_cast<NamedDecl>(D);
798 RecordDecl *RD = dyn_cast_or_null<RecordDecl>(D->getDeclContext());
799
800 // Allow 'this' within late-parsed attributes.
801 Sema::CXXThisScopeRAII ThisScope(Actions, RD, Qualifiers(),
802 ND && ND->isCXXInstanceMember());
803
804 if (LA.Decls.size() == 1) {
805 // If the Decl is templatized, add template parameters to scope.
806 ReenterTemplateScopeRAII InDeclScope(*this, D, EnterScope);
807
808 // If the Decl is on a function, add function parameters to the scope.
809 bool HasFunScope = EnterScope && D->isFunctionOrFunctionTemplate();
810 if (HasFunScope) {
811 InDeclScope.Scopes.Enter(Scope::FnScope | Scope::DeclScope |
813 Actions.ActOnReenterFunctionContext(Actions.CurScope, D);
814 }
815
816 ParseGNUAttributeArgs(&LA.AttrName, LA.AttrNameLoc, Attrs, nullptr,
817 nullptr, SourceLocation(), ParsedAttr::Form::GNU(),
818 nullptr);
819
820 if (HasFunScope)
821 Actions.ActOnExitFunctionContext();
822 } else {
823 // If there are multiple decls, then the decl cannot be within the
824 // function scope.
825 ParseGNUAttributeArgs(&LA.AttrName, LA.AttrNameLoc, Attrs, nullptr,
826 nullptr, SourceLocation(), ParsedAttr::Form::GNU(),
827 nullptr);
828 }
829 } else {
830 Diag(Tok, diag::warn_attribute_no_decl) << LA.AttrName.getName();
831 }
832
833 if (OnDefinition && !Attrs.empty() && !Attrs.begin()->isCXX11Attribute() &&
834 Attrs.begin()->isKnownToGCC())
835 Diag(Tok, diag::warn_attribute_on_function_definition)
836 << &LA.AttrName;
837
838 for (unsigned i = 0, ni = LA.Decls.size(); i < ni; ++i)
839 Actions.ActOnFinishDelayedAttribute(getCurScope(), LA.Decls[i], Attrs);
840
841 // Due to a parsing error, we either went over the cached tokens or
842 // there are still cached tokens left, so we skip the leftover tokens.
843 while (Tok.isNot(tok::eof))
845
846 if (Tok.is(tok::eof) && Tok.getEofData() == AttrEnd.getEofData())
848}
849
850void Parser::ParseLexedPragmas(ParsingClass &Class) {
851 ReenterClassScopeRAII InClassScope(*this, Class);
852
853 for (LateParsedDeclaration *D : Class.LateParsedDeclarations)
854 D->ParseLexedPragmas();
855}
856
857void Parser::ParseLexedPragma(LateParsedPragma &LP) {
858 PP.EnterToken(Tok, /*IsReinject=*/true);
859 PP.EnterTokenStream(LP.toks(), /*DisableMacroExpansion=*/true,
860 /*IsReinject=*/true);
861
862 // Consume the previously pushed token.
863 ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true);
864 assert(Tok.isAnnotation() && "Expected annotation token.");
865 switch (Tok.getKind()) {
866 case tok::annot_attr_openmp:
867 case tok::annot_pragma_openmp: {
868 AccessSpecifier AS = LP.getAccessSpecifier();
869 ParsedAttributes Attrs(AttrFactory);
870 (void)ParseOpenMPDeclarativeDirectiveWithExtDecl(AS, Attrs);
871 break;
872 }
873 default:
874 llvm_unreachable("Unexpected token.");
875 }
876}
877
878/// ConsumeAndStoreUntil - Consume and store the token at the passed token
879/// container until the token 'T' is reached (which gets
880/// consumed/stored too, if ConsumeFinalToken).
881/// If StopAtSemi is true, then we will stop early at a ';' character.
882/// Returns true if token 'T1' or 'T2' was found.
883/// NOTE: This is a specialized version of Parser::SkipUntil.
884bool Parser::ConsumeAndStoreUntil(tok::TokenKind T1, tok::TokenKind T2,
885 CachedTokens &Toks,
886 bool StopAtSemi, bool ConsumeFinalToken) {
887 // We always want this function to consume at least one token if the first
888 // token isn't T and if not at EOF.
889 bool isFirstTokenConsumed = true;
890 while (true) {
891 // If we found one of the tokens, stop and return true.
892 if (Tok.is(T1) || Tok.is(T2)) {
893 if (ConsumeFinalToken) {
894 Toks.push_back(Tok);
896 }
897 return true;
898 }
899
900 switch (Tok.getKind()) {
901 case tok::eof:
902 case tok::annot_module_begin:
903 case tok::annot_module_end:
904 case tok::annot_module_include:
905 case tok::annot_repl_input_end:
906 // Ran out of tokens.
907 return false;
908
909 case tok::l_paren:
910 // Recursively consume properly-nested parens.
911 Toks.push_back(Tok);
912 ConsumeParen();
913 ConsumeAndStoreUntil(tok::r_paren, Toks, /*StopAtSemi=*/false);
914 break;
915 case tok::l_square:
916 // Recursively consume properly-nested square brackets.
917 Toks.push_back(Tok);
918 ConsumeBracket();
919 ConsumeAndStoreUntil(tok::r_square, Toks, /*StopAtSemi=*/false);
920 break;
921 case tok::l_brace:
922 // Recursively consume properly-nested braces.
923 Toks.push_back(Tok);
924 ConsumeBrace();
925 ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/false);
926 break;
927
928 // Okay, we found a ']' or '}' or ')', which we think should be balanced.
929 // Since the user wasn't looking for this token (if they were, it would
930 // already be handled), this isn't balanced. If there is a LHS token at a
931 // higher level, we will assume that this matches the unbalanced token
932 // and return it. Otherwise, this is a spurious RHS token, which we skip.
933 case tok::r_paren:
934 if (ParenCount && !isFirstTokenConsumed)
935 return false; // Matches something.
936 Toks.push_back(Tok);
937 ConsumeParen();
938 break;
939 case tok::r_square:
940 if (BracketCount && !isFirstTokenConsumed)
941 return false; // Matches something.
942 Toks.push_back(Tok);
943 ConsumeBracket();
944 break;
945 case tok::r_brace:
946 if (BraceCount && !isFirstTokenConsumed)
947 return false; // Matches something.
948 Toks.push_back(Tok);
949 ConsumeBrace();
950 break;
951
952 case tok::semi:
953 if (StopAtSemi)
954 return false;
955 [[fallthrough]];
956 default:
957 // consume this token.
958 Toks.push_back(Tok);
959 ConsumeAnyToken(/*ConsumeCodeCompletionTok*/true);
960 break;
961 }
962 isFirstTokenConsumed = false;
963 }
964}
965
966/// Consume tokens and store them in the passed token container until
967/// we've passed the try keyword and constructor initializers and have consumed
968/// the opening brace of the function body. The opening brace will be consumed
969/// if and only if there was no error.
970///
971/// \return True on error.
972bool Parser::ConsumeAndStoreFunctionPrologue(CachedTokens &Toks) {
973 if (Tok.is(tok::kw_try)) {
974 Toks.push_back(Tok);
975 ConsumeToken();
976 }
977
978 if (Tok.isNot(tok::colon)) {
979 // Easy case, just a function body.
980
981 // Grab any remaining garbage to be diagnosed later. We stop when we reach a
982 // brace: an opening one is the function body, while a closing one probably
983 // means we've reached the end of the class.
984 ConsumeAndStoreUntil(tok::l_brace, tok::r_brace, Toks,
985 /*StopAtSemi=*/true,
986 /*ConsumeFinalToken=*/false);
987 if (Tok.isNot(tok::l_brace))
988 return Diag(Tok.getLocation(), diag::err_expected) << tok::l_brace;
989
990 Toks.push_back(Tok);
991 ConsumeBrace();
992 return false;
993 }
994
995 Toks.push_back(Tok);
996 ConsumeToken();
997
998 // We can't reliably skip over a mem-initializer-id, because it could be
999 // a template-id involving not-yet-declared names. Given:
1000 //
1001 // S ( ) : a < b < c > ( e )
1002 //
1003 // 'e' might be an initializer or part of a template argument, depending
1004 // on whether 'b' is a template.
1005
1006 // Track whether we might be inside a template argument. We can give
1007 // significantly better diagnostics if we know that we're not.
1008 bool MightBeTemplateArgument = false;
1009
1010 while (true) {
1011 // Skip over the mem-initializer-id, if possible.
1012 if (Tok.is(tok::kw_decltype)) {
1013 Toks.push_back(Tok);
1014 SourceLocation OpenLoc = ConsumeToken();
1015 if (Tok.isNot(tok::l_paren))
1016 return Diag(Tok.getLocation(), diag::err_expected_lparen_after)
1017 << "decltype";
1018 Toks.push_back(Tok);
1019 ConsumeParen();
1020 if (!ConsumeAndStoreUntil(tok::r_paren, Toks, /*StopAtSemi=*/true)) {
1021 Diag(Tok.getLocation(), diag::err_expected) << tok::r_paren;
1022 Diag(OpenLoc, diag::note_matching) << tok::l_paren;
1023 return true;
1024 }
1025 }
1026 do {
1027 // Walk over a component of a nested-name-specifier.
1028 if (Tok.is(tok::coloncolon)) {
1029 Toks.push_back(Tok);
1030 ConsumeToken();
1031
1032 if (Tok.is(tok::kw_template)) {
1033 Toks.push_back(Tok);
1034 ConsumeToken();
1035 }
1036 }
1037
1038 if (Tok.is(tok::identifier)) {
1039 Toks.push_back(Tok);
1040 ConsumeToken();
1041 } else {
1042 break;
1043 }
1044 // Pack indexing
1045 if (Tok.is(tok::ellipsis) && NextToken().is(tok::l_square)) {
1046 Toks.push_back(Tok);
1047 SourceLocation OpenLoc = ConsumeToken();
1048 Toks.push_back(Tok);
1049 ConsumeBracket();
1050 if (!ConsumeAndStoreUntil(tok::r_square, Toks, /*StopAtSemi=*/true)) {
1051 Diag(Tok.getLocation(), diag::err_expected) << tok::r_square;
1052 Diag(OpenLoc, diag::note_matching) << tok::l_square;
1053 return true;
1054 }
1055 }
1056
1057 } while (Tok.is(tok::coloncolon));
1058
1059 if (Tok.is(tok::code_completion)) {
1060 Toks.push_back(Tok);
1061 ConsumeCodeCompletionToken();
1062 if (Tok.isOneOf(tok::identifier, tok::coloncolon, tok::kw_decltype)) {
1063 // Could be the start of another member initializer (the ',' has not
1064 // been written yet)
1065 continue;
1066 }
1067 }
1068
1069 if (Tok.is(tok::comma)) {
1070 // The initialization is missing, we'll diagnose it later.
1071 Toks.push_back(Tok);
1072 ConsumeToken();
1073 continue;
1074 }
1075 if (Tok.is(tok::less))
1076 MightBeTemplateArgument = true;
1077
1078 if (MightBeTemplateArgument) {
1079 // We may be inside a template argument list. Grab up to the start of the
1080 // next parenthesized initializer or braced-init-list. This *might* be the
1081 // initializer, or it might be a subexpression in the template argument
1082 // list.
1083 // FIXME: Count angle brackets, and clear MightBeTemplateArgument
1084 // if all angles are closed.
1085 if (!ConsumeAndStoreUntil(tok::l_paren, tok::l_brace, Toks,
1086 /*StopAtSemi=*/true,
1087 /*ConsumeFinalToken=*/false)) {
1088 // We're not just missing the initializer, we're also missing the
1089 // function body!
1090 return Diag(Tok.getLocation(), diag::err_expected) << tok::l_brace;
1091 }
1092 } else if (Tok.isNot(tok::l_paren) && Tok.isNot(tok::l_brace)) {
1093 // We found something weird in a mem-initializer-id.
1095 return Diag(Tok.getLocation(), diag::err_expected_either)
1096 << tok::l_paren << tok::l_brace;
1097 else
1098 return Diag(Tok.getLocation(), diag::err_expected) << tok::l_paren;
1099 }
1100
1101 tok::TokenKind kind = Tok.getKind();
1102 Toks.push_back(Tok);
1103 bool IsLParen = (kind == tok::l_paren);
1104 SourceLocation OpenLoc = Tok.getLocation();
1105
1106 if (IsLParen) {
1107 ConsumeParen();
1108 } else {
1109 assert(kind == tok::l_brace && "Must be left paren or brace here.");
1110 ConsumeBrace();
1111 // In C++03, this has to be the start of the function body, which
1112 // means the initializer is malformed; we'll diagnose it later.
1113 if (!getLangOpts().CPlusPlus11)
1114 return false;
1115
1116 const Token &PreviousToken = Toks[Toks.size() - 2];
1117 if (!MightBeTemplateArgument &&
1118 !PreviousToken.isOneOf(tok::identifier, tok::greater,
1119 tok::greatergreater)) {
1120 // If the opening brace is not preceded by one of these tokens, we are
1121 // missing the mem-initializer-id. In order to recover better, we need
1122 // to use heuristics to determine if this '{' is most likely the
1123 // beginning of a brace-init-list or the function body.
1124 // Check the token after the corresponding '}'.
1125 TentativeParsingAction PA(*this);
1126 if (SkipUntil(tok::r_brace) &&
1127 !Tok.isOneOf(tok::comma, tok::ellipsis, tok::l_brace)) {
1128 // Consider there was a malformed initializer and this is the start
1129 // of the function body. We'll diagnose it later.
1130 PA.Revert();
1131 return false;
1132 }
1133 PA.Revert();
1134 }
1135 }
1136
1137 // Grab the initializer (or the subexpression of the template argument).
1138 // FIXME: If we support lambdas here, we'll need to set StopAtSemi to false
1139 // if we might be inside the braces of a lambda-expression.
1140 tok::TokenKind CloseKind = IsLParen ? tok::r_paren : tok::r_brace;
1141 if (!ConsumeAndStoreUntil(CloseKind, Toks, /*StopAtSemi=*/true)) {
1142 Diag(Tok, diag::err_expected) << CloseKind;
1143 Diag(OpenLoc, diag::note_matching) << kind;
1144 return true;
1145 }
1146
1147 // Grab pack ellipsis, if present.
1148 if (Tok.is(tok::ellipsis)) {
1149 Toks.push_back(Tok);
1150 ConsumeToken();
1151 }
1152
1153 // If we know we just consumed a mem-initializer, we must have ',' or '{'
1154 // next.
1155 if (Tok.is(tok::comma)) {
1156 Toks.push_back(Tok);
1157 ConsumeToken();
1158 } else if (Tok.is(tok::l_brace)) {
1159 // This is the function body if the ')' or '}' is immediately followed by
1160 // a '{'. That cannot happen within a template argument, apart from the
1161 // case where a template argument contains a compound literal:
1162 //
1163 // S ( ) : a < b < c > ( d ) { }
1164 // // End of declaration, or still inside the template argument?
1165 //
1166 // ... and the case where the template argument contains a lambda:
1167 //
1168 // S ( ) : a < 0 && b < c > ( d ) + [ ] ( ) { return 0; }
1169 // ( ) > ( ) { }
1170 //
1171 // FIXME: Disambiguate these cases. Note that the latter case is probably
1172 // going to be made ill-formed by core issue 1607.
1173 Toks.push_back(Tok);
1174 ConsumeBrace();
1175 return false;
1176 } else if (!MightBeTemplateArgument) {
1177 return Diag(Tok.getLocation(), diag::err_expected_either) << tok::l_brace
1178 << tok::comma;
1179 }
1180 }
1181}
1182
1183/// Consume and store tokens from the '?' to the ':' in a conditional
1184/// expression.
1185bool Parser::ConsumeAndStoreConditional(CachedTokens &Toks) {
1186 // Consume '?'.
1187 assert(Tok.is(tok::question));
1188 Toks.push_back(Tok);
1189 ConsumeToken();
1190
1191 while (Tok.isNot(tok::colon)) {
1192 if (!ConsumeAndStoreUntil(tok::question, tok::colon, Toks,
1193 /*StopAtSemi=*/true,
1194 /*ConsumeFinalToken=*/false))
1195 return false;
1196
1197 // If we found a nested conditional, consume it.
1198 if (Tok.is(tok::question) && !ConsumeAndStoreConditional(Toks))
1199 return false;
1200 }
1201
1202 // Consume ':'.
1203 Toks.push_back(Tok);
1204 ConsumeToken();
1205 return true;
1206}
1207
1208/// ConsumeAndStoreInitializer - Consume and store the token at the passed token
1209/// container until the end of the current initializer expression (either a
1210/// default argument or an in-class initializer for a non-static data member).
1211///
1212/// Returns \c true if we reached the end of something initializer-shaped,
1213/// \c false if we bailed out.
1214bool Parser::ConsumeAndStoreInitializer(CachedTokens &Toks,
1215 CachedInitKind CIK) {
1216 // We always want this function to consume at least one token if not at EOF.
1217 bool IsFirstToken = true;
1218
1219 // Number of possible unclosed <s we've seen so far. These might be templates,
1220 // and might not, but if there were none of them (or we know for sure that
1221 // we're within a template), we can avoid a tentative parse.
1222 unsigned AngleCount = 0;
1223 unsigned KnownTemplateCount = 0;
1224
1225 while (true) {
1226 switch (Tok.getKind()) {
1227 case tok::comma:
1228 // If we might be in a template, perform a tentative parse to check.
1229 if (!AngleCount)
1230 // Not a template argument: this is the end of the initializer.
1231 return true;
1232 if (KnownTemplateCount)
1233 goto consume_token;
1234
1235 // We hit a comma inside angle brackets. This is the hard case. The
1236 // rule we follow is:
1237 // * For a default argument, if the tokens after the comma form a
1238 // syntactically-valid parameter-declaration-clause, in which each
1239 // parameter has an initializer, then this comma ends the default
1240 // argument.
1241 // * For a default initializer, if the tokens after the comma form a
1242 // syntactically-valid init-declarator-list, then this comma ends
1243 // the default initializer.
1244 {
1245 TentativeParsingAction TPA(*this, /*Unannotated=*/true);
1247
1248 TPResult Result = TPResult::Error;
1249 ConsumeToken();
1250 switch (CIK) {
1251 case CIK_DefaultInitializer:
1252 Result = TryParseInitDeclaratorList();
1253 // If we parsed a complete, ambiguous init-declarator-list, this
1254 // is only syntactically-valid if it's followed by a semicolon.
1255 if (Result == TPResult::Ambiguous && Tok.isNot(tok::semi))
1256 Result = TPResult::False;
1257 break;
1258
1259 case CIK_DefaultArgument:
1260 bool InvalidAsDeclaration = false;
1261 Result = TryParseParameterDeclarationClause(
1262 &InvalidAsDeclaration, /*VersusTemplateArg=*/true);
1263 // If this is an expression or a declaration with a missing
1264 // 'typename', assume it's not a declaration.
1265 if (Result == TPResult::Ambiguous && InvalidAsDeclaration)
1266 Result = TPResult::False;
1267 break;
1268 }
1269
1270 // Put the token stream back and undo any annotations we performed
1271 // after the comma. They may reflect a different parse than the one
1272 // we will actually perform at the end of the class.
1273 TPA.Revert();
1274
1275 // If what follows could be a declaration, it is a declaration.
1276 if (Result != TPResult::False && Result != TPResult::Error)
1277 return true;
1278 }
1279
1280 // Keep going. We know we're inside a template argument list now.
1281 ++KnownTemplateCount;
1282 goto consume_token;
1283
1284 case tok::eof:
1285 case tok::annot_module_begin:
1286 case tok::annot_module_end:
1287 case tok::annot_module_include:
1288 case tok::annot_repl_input_end:
1289 // Ran out of tokens.
1290 return false;
1291
1292 case tok::less:
1293 // FIXME: A '<' can only start a template-id if it's preceded by an
1294 // identifier, an operator-function-id, or a literal-operator-id.
1295 ++AngleCount;
1296 goto consume_token;
1297
1298 case tok::question:
1299 // In 'a ? b : c', 'b' can contain an unparenthesized comma. If it does,
1300 // that is *never* the end of the initializer. Skip to the ':'.
1301 if (!ConsumeAndStoreConditional(Toks))
1302 return false;
1303 break;
1304
1305 case tok::greatergreatergreater:
1306 if (!getLangOpts().CPlusPlus11)
1307 goto consume_token;
1308 if (AngleCount) --AngleCount;
1309 if (KnownTemplateCount) --KnownTemplateCount;
1310 [[fallthrough]];
1311 case tok::greatergreater:
1312 if (!getLangOpts().CPlusPlus11)
1313 goto consume_token;
1314 if (AngleCount) --AngleCount;
1315 if (KnownTemplateCount) --KnownTemplateCount;
1316 [[fallthrough]];
1317 case tok::greater:
1318 if (AngleCount) --AngleCount;
1319 if (KnownTemplateCount) --KnownTemplateCount;
1320 goto consume_token;
1321
1322 case tok::kw_template:
1323 // 'template' identifier '<' is known to start a template argument list,
1324 // and can be used to disambiguate the parse.
1325 // FIXME: Support all forms of 'template' unqualified-id '<'.
1326 Toks.push_back(Tok);
1327 ConsumeToken();
1328 if (Tok.is(tok::identifier)) {
1329 Toks.push_back(Tok);
1330 ConsumeToken();
1331 if (Tok.is(tok::less)) {
1332 ++AngleCount;
1333 ++KnownTemplateCount;
1334 Toks.push_back(Tok);
1335 ConsumeToken();
1336 }
1337 }
1338 break;
1339
1340 case tok::kw_operator:
1341 // If 'operator' precedes other punctuation, that punctuation loses
1342 // its special behavior.
1343 Toks.push_back(Tok);
1344 ConsumeToken();
1345 switch (Tok.getKind()) {
1346 case tok::comma:
1347 case tok::greatergreatergreater:
1348 case tok::greatergreater:
1349 case tok::greater:
1350 case tok::less:
1351 Toks.push_back(Tok);
1352 ConsumeToken();
1353 break;
1354 default:
1355 break;
1356 }
1357 break;
1358
1359 case tok::l_paren:
1360 // Recursively consume properly-nested parens.
1361 Toks.push_back(Tok);
1362 ConsumeParen();
1363 ConsumeAndStoreUntil(tok::r_paren, Toks, /*StopAtSemi=*/false);
1364 break;
1365 case tok::l_square:
1366 // Recursively consume properly-nested square brackets.
1367 Toks.push_back(Tok);
1368 ConsumeBracket();
1369 ConsumeAndStoreUntil(tok::r_square, Toks, /*StopAtSemi=*/false);
1370 break;
1371 case tok::l_brace:
1372 // Recursively consume properly-nested braces.
1373 Toks.push_back(Tok);
1374 ConsumeBrace();
1375 ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/false);
1376 break;
1377
1378 // Okay, we found a ']' or '}' or ')', which we think should be balanced.
1379 // Since the user wasn't looking for this token (if they were, it would
1380 // already be handled), this isn't balanced. If there is a LHS token at a
1381 // higher level, we will assume that this matches the unbalanced token
1382 // and return it. Otherwise, this is a spurious RHS token, which we
1383 // consume and pass on to downstream code to diagnose.
1384 case tok::r_paren:
1385 if (CIK == CIK_DefaultArgument)
1386 return true; // End of the default argument.
1387 if (ParenCount && !IsFirstToken)
1388 return false;
1389 Toks.push_back(Tok);
1390 ConsumeParen();
1391 continue;
1392 case tok::r_square:
1393 if (BracketCount && !IsFirstToken)
1394 return false;
1395 Toks.push_back(Tok);
1396 ConsumeBracket();
1397 continue;
1398 case tok::r_brace:
1399 if (BraceCount && !IsFirstToken)
1400 return false;
1401 Toks.push_back(Tok);
1402 ConsumeBrace();
1403 continue;
1404
1405 case tok::code_completion:
1406 Toks.push_back(Tok);
1407 ConsumeCodeCompletionToken();
1408 break;
1409
1410 case tok::string_literal:
1411 case tok::wide_string_literal:
1412 case tok::utf8_string_literal:
1413 case tok::utf16_string_literal:
1414 case tok::utf32_string_literal:
1415 Toks.push_back(Tok);
1416 ConsumeStringToken();
1417 break;
1418 case tok::semi:
1419 if (CIK == CIK_DefaultInitializer)
1420 return true; // End of the default initializer.
1421 [[fallthrough]];
1422 default:
1423 consume_token:
1424 Toks.push_back(Tok);
1425 ConsumeToken();
1426 break;
1427 }
1428 IsFirstToken = false;
1429 }
1430}
StringRef P
const Decl * D
Defines the C++ template declaration subclasses.
PtrTy get() const
Definition: Ownership.h:170
bool isInvalid() const
Definition: Ownership.h:166
bool isUsable() const
Definition: Ownership.h:168
RAII class that helps handle the parsing of an open/close delimiter pair, such as braces { ....
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:2064
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
Definition: DeclCXX.h:2190
Qualifiers getMethodQualifiers() const
Definition: DeclCXX.h:2225
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
Definition: DeclBase.cpp:1333
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
bool isFunctionOrFunctionTemplate() const
Whether this declaration is a function or function template.
Definition: DeclBase.h:1109
bool isInIdentifierNamespace(unsigned NS) const
Definition: DeclBase.h:883
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
Definition: DeclBase.cpp:249
@ IDNS_OrdinaryFriend
This declaration is a friend function.
Definition: DeclBase.h:152
DeclContext * getDeclContext()
Definition: DeclBase.h:455
bool hasErrorOccurred() const
Definition: Diagnostic.h:843
RAII object that enters a new expression evaluation context.
Represents a function declaration or definition.
Definition: Decl.h:1932
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:2669
QualType getReturnType() const
Definition: Decl.h:2717
void setWillHaveBody(bool V=true)
Definition: Decl.h:2559
Declaration of a template function.
Definition: DeclTemplate.h:957
This represents a decl that may have a name.
Definition: Decl.h:249
bool isCXXInstanceMember() const
Determine whether the given declaration is an instance member of a C++ class.
Definition: Decl.cpp:1944
RAII object that makes sure paren/bracket/brace count is correct after declaration/statement parsing,...
Represents a parameter to a function.
Definition: Decl.h:1722
bool hasUnparsedDefaultArg() const
Determines whether this parameter has a default argument that has not yet been parsed.
Definition: Decl.h:1851
bool hasUninstantiatedDefaultArg() const
Definition: Decl.h:1855
Expr * getUninstantiatedDefaultArg()
Definition: Decl.cpp:2998
ParsedAttributes - A collection of parsed attributes.
Definition: ParsedAttr.h:958
Introduces zero or more scopes for parsing.
Definition: Parser.h:1209
void Enter(unsigned ScopeFlags)
Definition: Parser.h:1217
Parser - This implements a parser for the C family of languages.
Definition: Parser.h:58
DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Definition: Parser.cpp:81
SourceLocation ConsumeToken()
ConsumeToken - Consume the current 'peek token' and lex the next one.
Definition: Parser.h:548
void EnterScope(unsigned ScopeFlags)
EnterScope - Start a new scope.
Definition: Parser.cpp:420
SourceLocation ConsumeAnyToken(bool ConsumeCodeCompletionTok=false)
ConsumeAnyToken - Dispatch to the right Consume* method based on the current token type.
Definition: Parser.h:576
bool TryConsumeToken(tok::TokenKind Expected)
Definition: Parser.h:556
Scope * getCurScope() const
Definition: Parser.h:502
bool SkipUntil(tok::TokenKind T, SkipUntilFlags Flags=static_cast< SkipUntilFlags >(0))
SkipUntil - Read tokens until we get to the specified token, then consume it (unless StopBeforeMatch ...
Definition: Parser.h:1294
void SkipMalformedDecl()
SkipMalformedDecl - Read tokens until we get to some likely good stopping point for skipping past a s...
Definition: ParseDecl.cpp:2214
ExprResult ParseAssignmentExpression(TypeCastState isTypeCast=NotTypeCast)
Parse an expr that doesn't include (top-level) commas.
Definition: ParseExpr.cpp:171
const LangOptions & getLangOpts() const
Definition: Parser.h:495
@ StopBeforeMatch
Stop skipping at specified token, but don't skip the token itself.
Definition: Parser.h:1275
@ StopAtSemi
Stop skipping at semicolon.
Definition: Parser.h:1273
ExprResult ParseUnevaluatedStringLiteralExpression()
const Token & NextToken()
NextToken - This peeks ahead one token and returns it without consuming it.
Definition: Parser.h:872
unsigned ReenterTemplateScopes(MultiParseScope &S, Decl *D)
Re-enter the template scopes for a declaration that might be a template.
A class for parsing a declarator.
void EnterToken(const Token &Tok, bool IsReinject)
Enters a token in the token stream to be lexed next.
bool isCodeCompletionEnabled() const
Determine if we are performing code completion.
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Computes the source location just past the end of the token at this source location.
The collection of all-type qualifiers we support.
Definition: Type.h:319
Represents a struct/union/class.
Definition: Decl.h:4145
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
Definition: Redeclarable.h:205
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:41
@ FunctionPrototypeScope
This is a scope that corresponds to the parameters within a function prototype.
Definition: Scope.h:85
@ CompoundStmtScope
This is a compound statement scope.
Definition: Scope.h:134
@ ClassScope
The scope of a struct/union/class definition.
Definition: Scope.h:69
@ FunctionDeclarationScope
This is a scope that corresponds to the parameters within a function prototype for a function declara...
Definition: Scope.h:91
@ FnScope
This indicates that the scope corresponds to a function, which means that labels are set here.
Definition: Scope.h:51
@ DeclScope
This is a scope that can contain a declaration.
Definition: Scope.h:63
RAII object used to temporarily allow the C++ 'this' expression to be used, with the given qualifiers...
Definition: Sema.h:8073
A RAII object to temporarily push a declaration context.
Definition: Sema.h:3023
Records and restores the CurFPFeatures state on entry/exit of compound statements.
Definition: Sema.h:13569
RAII class used to indicate that we are performing provisional semantic analysis to determine the val...
Definition: Sema.h:12138
Decl * ActOnSkippedFunctionBody(Decl *Decl)
Definition: SemaDecl.cpp:15735
void ActOnParamDefaultArgumentError(Decl *param, SourceLocation EqualLoc, Expr *DefaultArg)
ActOnParamDefaultArgumentError - Parsing or semantic analysis of the default argument for the paramet...
void ActOnFinishDelayedMemberInitializers(Decl *Record)
void ActOnExitFunctionContext()
Definition: SemaDecl.cpp:1454
NamedDecl * ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS, Declarator &D, MultiTemplateParamsArg TemplateParameterLists, Expr *BitfieldWidth, const VirtSpecifiers &VS, InClassInitStyle InitStyle)
ActOnCXXMemberDeclarator - This is invoked when a C++ class member declarator is parsed.
bool IsInsideALocalClassWithinATemplateFunction()
void ActOnReenterFunctionContext(Scope *S, Decl *D)
Push the parameters of D, which must be a function, into scope.
Definition: SemaDecl.cpp:1430
void ActOnParamDefaultArgument(Decl *param, SourceLocation EqualLoc, Expr *defarg)
ActOnParamDefaultArgument - Check whether the default argument provided for a function parameter is w...
void ActOnFinishDelayedCXXMethodDeclaration(Scope *S, Decl *Method)
ActOnFinishDelayedCXXMethodDeclaration - We have finished processing the delayed method declaration f...
DiagnosticsEngine & getDiagnostics() const
Definition: Sema.h:557
NamedDecl * ActOnFriendFunctionDecl(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParams)
void MarkAsLateParsedTemplate(FunctionDecl *FD, Decl *FnD, CachedTokens &Toks)
void ActOnStartCXXInClassMemberInitializer()
Enter a new C++ default initializer scope.
void ActOnFinishDelayedMemberDeclarations(Scope *S, Decl *Record)
void PushFunctionScope()
Enter a new function scope.
Definition: Sema.cpp:2184
void SetDeclDefaulted(Decl *dcl, SourceLocation DefaultLoc)
Decl * ActOnStartOfFunctionDef(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParamLists, SkipBodyInfo *SkipBody=nullptr, FnBodyKind BodyKind=FnBodyKind::Other)
Definition: SemaDecl.cpp:15229
void ProcessDeclAttributeList(Scope *S, Decl *D, const ParsedAttributesView &AttrList, const ProcessDeclAttributeOptions &Options=ProcessDeclAttributeOptions())
ProcessDeclAttributeList - Apply all the decl attributes in the specified attribute list to the speci...
void CheckForFunctionRedefinition(FunctionDecl *FD, const FunctionDecl *EffectiveDefinition=nullptr, SkipBodyInfo *SkipBody=nullptr)
Definition: SemaDecl.cpp:15335
void ActOnFinishInlineFunctionDef(FunctionDecl *D)
Definition: SemaDecl.cpp:15259
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:1097
bool canSkipFunctionBody(Decl *D)
Determine whether we can skip parsing the body of a function definition, assuming we don't care about...
Definition: SemaDecl.cpp:15717
void ActOnFinishCXXInClassMemberInitializer(Decl *VarDecl, SourceLocation EqualLoc, Expr *Init)
This is invoked after parsing an in-class initializer for a non-static C++ class member,...
Decl * ActOnFinishFunctionBody(Decl *Decl, Stmt *Body)
Definition: SemaDecl.cpp:15745
void ActOnDefaultCtorInitializers(Decl *CDtorDecl)
@ PotentiallyEvaluatedIfUsed
The current expression is potentially evaluated, but any declarations referenced inside that expressi...
void actOnDelayedExceptionSpecification(Decl *D, ExceptionSpecificationType EST, SourceRange SpecificationRange, ArrayRef< ParsedType > DynamicExceptions, ArrayRef< SourceRange > DynamicExceptionRanges, Expr *NoexceptExpr)
Add an exception-specification to the given member or friend function (or function template).
void SetDeclDeleted(Decl *dcl, SourceLocation DelLoc, StringLiteral *Message=nullptr)
void ActOnStartDelayedCXXMethodDeclaration(Scope *S, Decl *Method)
ActOnStartDelayedCXXMethodDeclaration - We have completed parsing a top-level (non-nested) C++ class,...
void ActOnFinishDelayedAttribute(Scope *S, Decl *D, ParsedAttributes &Attrs)
ActOnFinishDelayedAttribute - Invoked when we have finished parsing an attribute for which parsing is...
Definition: SemaDecl.cpp:16261
void ActOnPureSpecifier(Decl *D, SourceLocation PureSpecLoc)
void ActOnStartDelayedMemberDeclarations(Scope *S, Decl *Record)
void ActOnDelayedCXXMethodParameter(Scope *S, Decl *Param)
ActOnDelayedCXXMethodParameter - We've already started a delayed C++ method declaration.
ExprResult CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl=nullptr, bool RecoverUncorrectedTypos=false, llvm::function_ref< ExprResult(Expr *)> Filter=[](Expr *E) -> ExprResult { return E;})
Process any TypoExprs in the given Expr and its children, generating diagnostics as appropriate and r...
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
SourceLocation getLocWithOffset(IntTy Offset) const
Return a source location with the specified offset from this SourceLocation.
A trivial tuple used to represent a source range.
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1778
Token - This structure provides full information about a lexed token.
Definition: Token.h:36
SourceLocation getEndLoc() const
Definition: Token.h:159
SourceLocation getLocation() const
Return a source location identifier for the specified offset in the current file.
Definition: Token.h:132
void setKind(tok::TokenKind K)
Definition: Token.h:95
bool is(tok::TokenKind K) const
is/isNot - Predicates to check if this token is a specific kind, as in "if (Tok.is(tok::l_brace)) {....
Definition: Token.h:99
tok::TokenKind getKind() const
Definition: Token.h:94
void setEofData(const void *D)
Definition: Token.h:204
void setLocation(SourceLocation L)
Definition: Token.h:140
bool isOneOf(tok::TokenKind K1, tok::TokenKind K2) const
Definition: Token.h:101
bool isNot(tok::TokenKind K) const
Definition: Token.h:100
bool isAnnotation() const
Return true if this is any of tok::annot_* kind tokens.
Definition: Token.h:121
const void * getEofData() const
Definition: Token.h:200
void startToken()
Reset all flags to cleared.
Definition: Token.h:177
AutoType * getContainedAutoType() const
Get the AutoType whose type will be deduced for a variable with an initializer of this type.
Definition: Type.h:2800
const Expr * getInit() const
Definition: Decl.h:1316
Represents a C++11 virt-specifier-seq.
Definition: DeclSpec.h:2783
unsigned kind
All of the diagnostics that can be emitted by the frontend.
Definition: DiagnosticIDs.h:68
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Definition: TokenKinds.h:25
The JSON file list parser is used to communicate input to InstallAPI.
@ Self
'self' clause, allowed on Compute and Combined Constructs, plus 'update'.
@ Delete
'delete' clause, allowed on the 'exit data' construct.
@ CPlusPlus11
Definition: LangStandard.h:57
@ CPlusPlus26
Definition: LangStandard.h:62
@ ICIS_NoInit
No in-class initializer.
Definition: Specifiers.h:272
@ Result
The result type of a method or function.
@ Class
The "class" keyword introduces the elaborated-type-specifier.
ExceptionSpecificationType
The various types of exception specifications that exist in C++11.
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition: Specifiers.h:123
Utility to re-enter a class scope while parsing its late-parsed components.
ReenterClassScopeRAII(Parser &P, ParsingClass &Class)
Utility to re-enter a possibly-templated scope while parsing its late-parsed components.
ReenterTemplateScopeRAII(Parser &P, Decl *MaybeTemplated, bool Enter=true)
TemplateParameterDepthRAII CurTemplateDepthTracker
An RAII helper that pops function a function scope on exit.
Definition: Sema.h:982