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