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