clang  3.9.0svn
ParseCXXInlineMethods.cpp
Go to the documentation of this file.
1 //===--- ParseCXXInlineMethods.cpp - C++ class inline methods parsing------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements parsing for C++ class inline methods.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "clang/Parse/Parser.h"
15 #include "RAIIObjectsForParser.h"
16 #include "clang/AST/DeclTemplate.h"
18 #include "clang/Sema/DeclSpec.h"
19 #include "clang/Sema/Scope.h"
20 using namespace clang;
21 
22 /// ParseCXXInlineMethodDef - We parsed and verified that the specified
23 /// Declarator is a well formed C++ inline method definition. Now lex its body
24 /// and store its tokens for parsing after the C++ class is complete.
25 NamedDecl *Parser::ParseCXXInlineMethodDef(AccessSpecifier AS,
26  AttributeList *AccessAttrs,
28  const ParsedTemplateInfo &TemplateInfo,
29  const VirtSpecifiers& VS,
30  SourceLocation PureSpecLoc) {
31  assert(D.isFunctionDeclarator() && "This isn't a function declarator!");
32  assert(Tok.isOneOf(tok::l_brace, tok::colon, tok::kw_try, tok::equal) &&
33  "Current token not a '{', ':', '=', or 'try'!");
34 
35  MultiTemplateParamsArg TemplateParams(
36  TemplateInfo.TemplateParams ? TemplateInfo.TemplateParams->data()
37  : nullptr,
38  TemplateInfo.TemplateParams ? TemplateInfo.TemplateParams->size() : 0);
39 
40  NamedDecl *FnD;
42  FnD = Actions.ActOnFriendFunctionDecl(getCurScope(), D,
43  TemplateParams);
44  else {
45  FnD = Actions.ActOnCXXMemberDeclarator(getCurScope(), AS, D,
46  TemplateParams, nullptr,
47  VS, ICIS_NoInit);
48  if (FnD) {
49  Actions.ProcessDeclAttributeList(getCurScope(), FnD, AccessAttrs);
50  if (PureSpecLoc.isValid())
51  Actions.ActOnPureSpecifier(FnD, PureSpecLoc);
52  }
53  }
54 
55  if (FnD)
56  HandleMemberFunctionDeclDelays(D, FnD);
57 
58  D.complete(FnD);
59 
60  if (TryConsumeToken(tok::equal)) {
61  if (!FnD) {
62  SkipUntil(tok::semi);
63  return nullptr;
64  }
65 
66  bool Delete = false;
67  SourceLocation KWLoc;
68  SourceLocation KWEndLoc = Tok.getEndLoc().getLocWithOffset(-1);
69  if (TryConsumeToken(tok::kw_delete, KWLoc)) {
71  ? diag::warn_cxx98_compat_defaulted_deleted_function
72  : diag::ext_defaulted_deleted_function)
73  << 1 /* deleted */;
74  Actions.SetDeclDeleted(FnD, KWLoc);
75  Delete = true;
76  if (auto *DeclAsFunction = dyn_cast<FunctionDecl>(FnD)) {
77  DeclAsFunction->setRangeEnd(KWEndLoc);
78  }
79  } else if (TryConsumeToken(tok::kw_default, KWLoc)) {
81  ? diag::warn_cxx98_compat_defaulted_deleted_function
82  : diag::ext_defaulted_deleted_function)
83  << 0 /* defaulted */;
84  Actions.SetDeclDefaulted(FnD, KWLoc);
85  if (auto *DeclAsFunction = dyn_cast<FunctionDecl>(FnD)) {
86  DeclAsFunction->setRangeEnd(KWEndLoc);
87  }
88  } else {
89  llvm_unreachable("function definition after = not 'delete' or 'default'");
90  }
91 
92  if (Tok.is(tok::comma)) {
93  Diag(KWLoc, diag::err_default_delete_in_multiple_declaration)
94  << Delete;
95  SkipUntil(tok::semi);
96  } else if (ExpectAndConsume(tok::semi, diag::err_expected_after,
97  Delete ? "delete" : "default")) {
98  SkipUntil(tok::semi);
99  }
100 
101  return FnD;
102  }
103 
104  // In delayed template parsing mode, if we are within a class template
105  // or if we are about to parse function member template then consume
106  // the tokens and store them for parsing at the end of the translation unit.
107  if (getLangOpts().DelayedTemplateParsing &&
110  !(FnD && FnD->getAsFunction() &&
111  FnD->getAsFunction()->getReturnType()->getContainedAutoType()) &&
112  ((Actions.CurContext->isDependentContext() ||
113  (TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate &&
114  TemplateInfo.Kind != ParsedTemplateInfo::ExplicitSpecialization)) &&
116 
117  CachedTokens Toks;
118  LexTemplateFunctionForLateParsing(Toks);
119 
120  if (FnD) {
121  FunctionDecl *FD = FnD->getAsFunction();
122  Actions.CheckForFunctionRedefinition(FD);
123  Actions.MarkAsLateParsedTemplate(FD, FnD, Toks);
124  }
125 
126  return FnD;
127  }
128 
129  // Consume the tokens and store them for later parsing.
130 
131  LexedMethod* LM = new LexedMethod(this, FnD);
132  getCurrentClass().LateParsedDeclarations.push_back(LM);
133  LM->TemplateScope = getCurScope()->isTemplateParamScope();
134  CachedTokens &Toks = LM->Toks;
135 
136  tok::TokenKind kind = Tok.getKind();
137  // Consume everything up to (and including) the left brace of the
138  // function body.
139  if (ConsumeAndStoreFunctionPrologue(Toks)) {
140  // We didn't find the left-brace we expected after the
141  // constructor initializer; we already printed an error, and it's likely
142  // impossible to recover, so don't try to parse this method later.
143  // Skip over the rest of the decl and back to somewhere that looks
144  // reasonable.
146  delete getCurrentClass().LateParsedDeclarations.back();
147  getCurrentClass().LateParsedDeclarations.pop_back();
148  return FnD;
149  } else {
150  // Consume everything up to (and including) the matching right brace.
151  ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/false);
152  }
153 
154  // If we're in a function-try-block, we need to store all the catch blocks.
155  if (kind == tok::kw_try) {
156  while (Tok.is(tok::kw_catch)) {
157  ConsumeAndStoreUntil(tok::l_brace, Toks, /*StopAtSemi=*/false);
158  ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/false);
159  }
160  }
161 
162  if (FnD) {
163  // If this is a friend function, mark that it's late-parsed so that
164  // it's still known to be a definition even before we attach the
165  // parsed body. Sema needs to treat friend function definitions
166  // differently during template instantiation, and it's possible for
167  // the containing class to be instantiated before all its member
168  // function definitions are parsed.
169  //
170  // If you remove this, you can remove the code that clears the flag
171  // after parsing the member.
172  if (D.getDeclSpec().isFriendSpecified()) {
173  FunctionDecl *FD = FnD->getAsFunction();
174  Actions.CheckForFunctionRedefinition(FD);
175  FD->setLateTemplateParsed(true);
176  }
177  } else {
178  // If semantic analysis could not build a function declaration,
179  // just throw away the late-parsed declaration.
180  delete getCurrentClass().LateParsedDeclarations.back();
181  getCurrentClass().LateParsedDeclarations.pop_back();
182  }
183 
184  return FnD;
185 }
186 
187 /// ParseCXXNonStaticMemberInitializer - We parsed and verified that the
188 /// specified Declarator is a well formed C++ non-static data member
189 /// declaration. Now lex its initializer and store its tokens for parsing
190 /// after the class is complete.
191 void Parser::ParseCXXNonStaticMemberInitializer(Decl *VarD) {
192  assert(Tok.isOneOf(tok::l_brace, tok::equal) &&
193  "Current token not a '{' or '='!");
194 
195  LateParsedMemberInitializer *MI =
196  new LateParsedMemberInitializer(this, VarD);
197  getCurrentClass().LateParsedDeclarations.push_back(MI);
198  CachedTokens &Toks = MI->Toks;
199 
200  tok::TokenKind kind = Tok.getKind();
201  if (kind == tok::equal) {
202  Toks.push_back(Tok);
203  ConsumeToken();
204  }
205 
206  if (kind == tok::l_brace) {
207  // Begin by storing the '{' token.
208  Toks.push_back(Tok);
209  ConsumeBrace();
210 
211  // Consume everything up to (and including) the matching right brace.
212  ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/true);
213  } else {
214  // Consume everything up to (but excluding) the comma or semicolon.
215  ConsumeAndStoreInitializer(Toks, CIK_DefaultInitializer);
216  }
217 
218  // Store an artificial EOF token to ensure that we don't run off the end of
219  // the initializer when we come to parse it.
220  Token Eof;
221  Eof.startToken();
222  Eof.setKind(tok::eof);
223  Eof.setLocation(Tok.getLocation());
224  Eof.setEofData(VarD);
225  Toks.push_back(Eof);
226 }
227 
228 Parser::LateParsedDeclaration::~LateParsedDeclaration() {}
229 void Parser::LateParsedDeclaration::ParseLexedMethodDeclarations() {}
230 void Parser::LateParsedDeclaration::ParseLexedMemberInitializers() {}
231 void Parser::LateParsedDeclaration::ParseLexedMethodDefs() {}
232 
233 Parser::LateParsedClass::LateParsedClass(Parser *P, ParsingClass *C)
234  : Self(P), Class(C) {}
235 
236 Parser::LateParsedClass::~LateParsedClass() {
237  Self->DeallocateParsedClasses(Class);
238 }
239 
240 void Parser::LateParsedClass::ParseLexedMethodDeclarations() {
241  Self->ParseLexedMethodDeclarations(*Class);
242 }
243 
244 void Parser::LateParsedClass::ParseLexedMemberInitializers() {
245  Self->ParseLexedMemberInitializers(*Class);
246 }
247 
248 void Parser::LateParsedClass::ParseLexedMethodDefs() {
249  Self->ParseLexedMethodDefs(*Class);
250 }
251 
252 void Parser::LateParsedMethodDeclaration::ParseLexedMethodDeclarations() {
253  Self->ParseLexedMethodDeclaration(*this);
254 }
255 
256 void Parser::LexedMethod::ParseLexedMethodDefs() {
257  Self->ParseLexedMethodDef(*this);
258 }
259 
260 void Parser::LateParsedMemberInitializer::ParseLexedMemberInitializers() {
261  Self->ParseLexedMemberInitializer(*this);
262 }
263 
264 /// ParseLexedMethodDeclarations - We finished parsing the member
265 /// specification of a top (non-nested) C++ class. Now go over the
266 /// stack of method declarations with some parts for which parsing was
267 /// delayed (such as default arguments) and parse them.
268 void Parser::ParseLexedMethodDeclarations(ParsingClass &Class) {
269  bool HasTemplateScope = !Class.TopLevelClass && Class.TemplateScope;
270  ParseScope ClassTemplateScope(this, Scope::TemplateParamScope,
271  HasTemplateScope);
272  TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth);
273  if (HasTemplateScope) {
274  Actions.ActOnReenterTemplateScope(getCurScope(), Class.TagOrTemplate);
275  ++CurTemplateDepthTracker;
276  }
277 
278  // The current scope is still active if we're the top-level class.
279  // Otherwise we'll need to push and enter a new scope.
280  bool HasClassScope = !Class.TopLevelClass;
281  ParseScope ClassScope(this, Scope::ClassScope|Scope::DeclScope,
282  HasClassScope);
283  if (HasClassScope)
285  Class.TagOrTemplate);
286 
287  for (size_t i = 0; i < Class.LateParsedDeclarations.size(); ++i) {
288  Class.LateParsedDeclarations[i]->ParseLexedMethodDeclarations();
289  }
290 
291  if (HasClassScope)
293  Class.TagOrTemplate);
294 }
295 
296 void Parser::ParseLexedMethodDeclaration(LateParsedMethodDeclaration &LM) {
297  // If this is a member template, introduce the template parameter scope.
298  ParseScope TemplateScope(this, Scope::TemplateParamScope, LM.TemplateScope);
299  TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth);
300  if (LM.TemplateScope) {
301  Actions.ActOnReenterTemplateScope(getCurScope(), LM.Method);
302  ++CurTemplateDepthTracker;
303  }
304  // Start the delayed C++ method declaration
306 
307  // Introduce the parameters into scope and parse their default
308  // arguments.
309  ParseScope PrototypeScope(this, Scope::FunctionPrototypeScope |
311  for (unsigned I = 0, N = LM.DefaultArgs.size(); I != N; ++I) {
312  auto Param = cast<ParmVarDecl>(LM.DefaultArgs[I].Param);
313  // Introduce the parameter into scope.
314  bool HasUnparsed = Param->hasUnparsedDefaultArg();
316  if (CachedTokens *Toks = LM.DefaultArgs[I].Toks) {
317  // Mark the end of the default argument so that we know when to stop when
318  // we parse it later on.
319  Token LastDefaultArgToken = Toks->back();
320  Token DefArgEnd;
321  DefArgEnd.startToken();
322  DefArgEnd.setKind(tok::eof);
323  DefArgEnd.setLocation(LastDefaultArgToken.getEndLoc());
324  DefArgEnd.setEofData(Param);
325  Toks->push_back(DefArgEnd);
326 
327  // Parse the default argument from its saved token stream.
328  Toks->push_back(Tok); // So that the current token doesn't get lost
329  PP.EnterTokenStream(*Toks, true);
330 
331  // Consume the previously-pushed token.
332  ConsumeAnyToken();
333 
334  // Consume the '='.
335  assert(Tok.is(tok::equal) && "Default argument not starting with '='");
336  SourceLocation EqualLoc = ConsumeToken();
337 
338  // The argument isn't actually potentially evaluated unless it is
339  // used.
342  Param);
343 
344  ExprResult DefArgResult;
345  if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
346  Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);
347  DefArgResult = ParseBraceInitializer();
348  } else
349  DefArgResult = ParseAssignmentExpression();
350  DefArgResult = Actions.CorrectDelayedTyposInExpr(DefArgResult);
351  if (DefArgResult.isInvalid()) {
352  Actions.ActOnParamDefaultArgumentError(Param, EqualLoc);
353  } else {
354  if (Tok.isNot(tok::eof) || Tok.getEofData() != Param) {
355  // The last two tokens are the terminator and the saved value of
356  // Tok; the last token in the default argument is the one before
357  // those.
358  assert(Toks->size() >= 3 && "expected a token in default arg");
359  Diag(Tok.getLocation(), diag::err_default_arg_unparsed)
360  << SourceRange(Tok.getLocation(),
361  (*Toks)[Toks->size() - 3].getLocation());
362  }
363  Actions.ActOnParamDefaultArgument(Param, EqualLoc,
364  DefArgResult.get());
365  }
366 
367  // There could be leftover tokens (e.g. because of an error).
368  // Skip through until we reach the 'end of default argument' token.
369  while (Tok.isNot(tok::eof))
370  ConsumeAnyToken();
371 
372  if (Tok.is(tok::eof) && Tok.getEofData() == Param)
373  ConsumeAnyToken();
374 
375  delete Toks;
376  LM.DefaultArgs[I].Toks = nullptr;
377  } else if (HasUnparsed) {
378  assert(Param->hasInheritedDefaultArg());
379  FunctionDecl *Old = cast<FunctionDecl>(LM.Method)->getPreviousDecl();
380  ParmVarDecl *OldParam = Old->getParamDecl(I);
381  assert (!OldParam->hasUnparsedDefaultArg());
382  if (OldParam->hasUninstantiatedDefaultArg())
384  Param->getUninstantiatedDefaultArg());
385  else
386  Param->setDefaultArg(OldParam->getInit());
387  }
388  }
389 
390  // Parse a delayed exception-specification, if there is one.
391  if (CachedTokens *Toks = LM.ExceptionSpecTokens) {
392  // Add the 'stop' token.
393  Token LastExceptionSpecToken = Toks->back();
394  Token ExceptionSpecEnd;
395  ExceptionSpecEnd.startToken();
396  ExceptionSpecEnd.setKind(tok::eof);
397  ExceptionSpecEnd.setLocation(LastExceptionSpecToken.getEndLoc());
398  ExceptionSpecEnd.setEofData(LM.Method);
399  Toks->push_back(ExceptionSpecEnd);
400 
401  // Parse the default argument from its saved token stream.
402  Toks->push_back(Tok); // So that the current token doesn't get lost
403  PP.EnterTokenStream(*Toks, true);
404 
405  // Consume the previously-pushed token.
406  ConsumeAnyToken();
407 
408  // C++11 [expr.prim.general]p3:
409  // If a declaration declares a member function or member function
410  // template of a class X, the expression this is a prvalue of type
411  // "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq
412  // and the end of the function-definition, member-declarator, or
413  // declarator.
414  CXXMethodDecl *Method;
415  if (FunctionTemplateDecl *FunTmpl
416  = dyn_cast<FunctionTemplateDecl>(LM.Method))
417  Method = cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl());
418  else
419  Method = cast<CXXMethodDecl>(LM.Method);
420 
421  Sema::CXXThisScopeRAII ThisScope(Actions, Method->getParent(),
422  Method->getTypeQualifiers(),
423  getLangOpts().CPlusPlus11);
424 
425  // Parse the exception-specification.
426  SourceRange SpecificationRange;
427  SmallVector<ParsedType, 4> DynamicExceptions;
428  SmallVector<SourceRange, 4> DynamicExceptionRanges;
429  ExprResult NoexceptExpr;
430  CachedTokens *ExceptionSpecTokens;
431 
433  = tryParseExceptionSpecification(/*Delayed=*/false, SpecificationRange,
434  DynamicExceptions,
435  DynamicExceptionRanges, NoexceptExpr,
436  ExceptionSpecTokens);
437 
438  if (Tok.isNot(tok::eof) || Tok.getEofData() != LM.Method)
439  Diag(Tok.getLocation(), diag::err_except_spec_unparsed);
440 
441  // Attach the exception-specification to the method.
442  Actions.actOnDelayedExceptionSpecification(LM.Method, EST,
443  SpecificationRange,
444  DynamicExceptions,
445  DynamicExceptionRanges,
446  NoexceptExpr.isUsable()?
447  NoexceptExpr.get() : nullptr);
448 
449  // There could be leftover tokens (e.g. because of an error).
450  // Skip through until we reach the original token position.
451  while (Tok.isNot(tok::eof))
452  ConsumeAnyToken();
453 
454  // Clean up the remaining EOF token.
455  if (Tok.is(tok::eof) && Tok.getEofData() == LM.Method)
456  ConsumeAnyToken();
457 
458  delete Toks;
459  LM.ExceptionSpecTokens = nullptr;
460  }
461 
462  PrototypeScope.Exit();
463 
464  // Finish the delayed C++ method declaration.
466 }
467 
468 /// ParseLexedMethodDefs - We finished parsing the member specification of a top
469 /// (non-nested) C++ class. Now go over the stack of lexed methods that were
470 /// collected during its parsing and parse them all.
471 void Parser::ParseLexedMethodDefs(ParsingClass &Class) {
472  bool HasTemplateScope = !Class.TopLevelClass && Class.TemplateScope;
473  ParseScope ClassTemplateScope(this, Scope::TemplateParamScope, HasTemplateScope);
474  TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth);
475  if (HasTemplateScope) {
476  Actions.ActOnReenterTemplateScope(getCurScope(), Class.TagOrTemplate);
477  ++CurTemplateDepthTracker;
478  }
479  bool HasClassScope = !Class.TopLevelClass;
480  ParseScope ClassScope(this, Scope::ClassScope|Scope::DeclScope,
481  HasClassScope);
482 
483  for (size_t i = 0; i < Class.LateParsedDeclarations.size(); ++i) {
484  Class.LateParsedDeclarations[i]->ParseLexedMethodDefs();
485  }
486 }
487 
488 void Parser::ParseLexedMethodDef(LexedMethod &LM) {
489  // If this is a member template, introduce the template parameter scope.
490  ParseScope TemplateScope(this, Scope::TemplateParamScope, LM.TemplateScope);
491  TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth);
492  if (LM.TemplateScope) {
493  Actions.ActOnReenterTemplateScope(getCurScope(), LM.D);
494  ++CurTemplateDepthTracker;
495  }
496 
497  assert(!LM.Toks.empty() && "Empty body!");
498  Token LastBodyToken = LM.Toks.back();
499  Token BodyEnd;
500  BodyEnd.startToken();
501  BodyEnd.setKind(tok::eof);
502  BodyEnd.setLocation(LastBodyToken.getEndLoc());
503  BodyEnd.setEofData(LM.D);
504  LM.Toks.push_back(BodyEnd);
505  // Append the current token at the end of the new token stream so that it
506  // doesn't get lost.
507  LM.Toks.push_back(Tok);
508  PP.EnterTokenStream(LM.Toks, true);
509 
510  // Consume the previously pushed token.
511  ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true);
512  assert(Tok.isOneOf(tok::l_brace, tok::colon, tok::kw_try)
513  && "Inline method not starting with '{', ':' or 'try'");
514 
515  // Parse the method body. Function body parsing code is similar enough
516  // to be re-used for method bodies as well.
517  ParseScope FnScope(this, Scope::FnScope|Scope::DeclScope);
518  Actions.ActOnStartOfFunctionDef(getCurScope(), LM.D);
519 
520  if (Tok.is(tok::kw_try)) {
521  ParseFunctionTryBlock(LM.D, FnScope);
522 
523  while (Tok.isNot(tok::eof))
524  ConsumeAnyToken();
525 
526  if (Tok.is(tok::eof) && Tok.getEofData() == LM.D)
527  ConsumeAnyToken();
528  return;
529  }
530  if (Tok.is(tok::colon)) {
531  ParseConstructorInitializer(LM.D);
532 
533  // Error recovery.
534  if (!Tok.is(tok::l_brace)) {
535  FnScope.Exit();
536  Actions.ActOnFinishFunctionBody(LM.D, nullptr);
537 
538  while (Tok.isNot(tok::eof))
539  ConsumeAnyToken();
540 
541  if (Tok.is(tok::eof) && Tok.getEofData() == LM.D)
542  ConsumeAnyToken();
543  return;
544  }
545  } else
546  Actions.ActOnDefaultCtorInitializers(LM.D);
547 
548  assert((Actions.getDiagnostics().hasErrorOccurred() ||
549  !isa<FunctionTemplateDecl>(LM.D) ||
550  cast<FunctionTemplateDecl>(LM.D)->getTemplateParameters()->getDepth()
551  < TemplateParameterDepth) &&
552  "TemplateParameterDepth should be greater than the depth of "
553  "current template being instantiated!");
554 
555  ParseFunctionStatementBody(LM.D, FnScope);
556 
557  // Clear the late-template-parsed bit if we set it before.
558  if (LM.D)
559  LM.D->getAsFunction()->setLateTemplateParsed(false);
560 
561  while (Tok.isNot(tok::eof))
562  ConsumeAnyToken();
563 
564  if (Tok.is(tok::eof) && Tok.getEofData() == LM.D)
565  ConsumeAnyToken();
566 
567  if (auto *FD = dyn_cast_or_null<FunctionDecl>(LM.D))
568  if (isa<CXXMethodDecl>(FD) ||
570  Actions.ActOnFinishInlineFunctionDef(FD);
571 }
572 
573 /// ParseLexedMemberInitializers - We finished parsing the member specification
574 /// of a top (non-nested) C++ class. Now go over the stack of lexed data member
575 /// initializers that were collected during its parsing and parse them all.
576 void Parser::ParseLexedMemberInitializers(ParsingClass &Class) {
577  bool HasTemplateScope = !Class.TopLevelClass && Class.TemplateScope;
578  ParseScope ClassTemplateScope(this, Scope::TemplateParamScope,
579  HasTemplateScope);
580  TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth);
581  if (HasTemplateScope) {
582  Actions.ActOnReenterTemplateScope(getCurScope(), Class.TagOrTemplate);
583  ++CurTemplateDepthTracker;
584  }
585  // Set or update the scope flags.
586  bool AlreadyHasClassScope = Class.TopLevelClass;
587  unsigned ScopeFlags = Scope::ClassScope|Scope::DeclScope;
588  ParseScope ClassScope(this, ScopeFlags, !AlreadyHasClassScope);
589  ParseScopeFlags ClassScopeFlags(this, ScopeFlags, AlreadyHasClassScope);
590 
591  if (!AlreadyHasClassScope)
593  Class.TagOrTemplate);
594 
595  if (!Class.LateParsedDeclarations.empty()) {
596  // C++11 [expr.prim.general]p4:
597  // Otherwise, if a member-declarator declares a non-static data member
598  // (9.2) of a class X, the expression this is a prvalue of type "pointer
599  // to X" within the optional brace-or-equal-initializer. It shall not
600  // appear elsewhere in the member-declarator.
601  Sema::CXXThisScopeRAII ThisScope(Actions, Class.TagOrTemplate,
602  /*TypeQuals=*/(unsigned)0);
603 
604  for (size_t i = 0; i < Class.LateParsedDeclarations.size(); ++i) {
605  Class.LateParsedDeclarations[i]->ParseLexedMemberInitializers();
606  }
607  }
608 
609  if (!AlreadyHasClassScope)
611  Class.TagOrTemplate);
612 
613  Actions.ActOnFinishDelayedMemberInitializers(Class.TagOrTemplate);
614 }
615 
616 void Parser::ParseLexedMemberInitializer(LateParsedMemberInitializer &MI) {
617  if (!MI.Field || MI.Field->isInvalidDecl())
618  return;
619 
620  // Append the current token at the end of the new token stream so that it
621  // doesn't get lost.
622  MI.Toks.push_back(Tok);
623  PP.EnterTokenStream(MI.Toks, true);
624 
625  // Consume the previously pushed token.
626  ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true);
627 
628  SourceLocation EqualLoc;
629 
631 
632  ExprResult Init = ParseCXXMemberInitializer(MI.Field, /*IsFunction=*/false,
633  EqualLoc);
634 
635  Actions.ActOnFinishCXXInClassMemberInitializer(MI.Field, EqualLoc,
636  Init.get());
637 
638  // The next token should be our artificial terminating EOF token.
639  if (Tok.isNot(tok::eof)) {
640  if (!Init.isInvalid()) {
641  SourceLocation EndLoc = PP.getLocForEndOfToken(PrevTokLocation);
642  if (!EndLoc.isValid())
643  EndLoc = Tok.getLocation();
644  // No fixit; we can't recover as if there were a semicolon here.
645  Diag(EndLoc, diag::err_expected_semi_decl_list);
646  }
647 
648  // Consume tokens until we hit the artificial EOF.
649  while (Tok.isNot(tok::eof))
650  ConsumeAnyToken();
651  }
652  // Make sure this is *our* artificial EOF token.
653  if (Tok.getEofData() == MI.Field)
654  ConsumeAnyToken();
655 }
656 
657 /// ConsumeAndStoreUntil - Consume and store the token at the passed token
658 /// container until the token 'T' is reached (which gets
659 /// consumed/stored too, if ConsumeFinalToken).
660 /// If StopAtSemi is true, then we will stop early at a ';' character.
661 /// Returns true if token 'T1' or 'T2' was found.
662 /// NOTE: This is a specialized version of Parser::SkipUntil.
663 bool Parser::ConsumeAndStoreUntil(tok::TokenKind T1, tok::TokenKind T2,
664  CachedTokens &Toks,
665  bool StopAtSemi, bool ConsumeFinalToken) {
666  // We always want this function to consume at least one token if the first
667  // token isn't T and if not at EOF.
668  bool isFirstTokenConsumed = true;
669  while (1) {
670  // If we found one of the tokens, stop and return true.
671  if (Tok.is(T1) || Tok.is(T2)) {
672  if (ConsumeFinalToken) {
673  Toks.push_back(Tok);
674  ConsumeAnyToken();
675  }
676  return true;
677  }
678 
679  switch (Tok.getKind()) {
680  case tok::eof:
681  case tok::annot_module_begin:
682  case tok::annot_module_end:
683  case tok::annot_module_include:
684  // Ran out of tokens.
685  return false;
686 
687  case tok::l_paren:
688  // Recursively consume properly-nested parens.
689  Toks.push_back(Tok);
690  ConsumeParen();
691  ConsumeAndStoreUntil(tok::r_paren, Toks, /*StopAtSemi=*/false);
692  break;
693  case tok::l_square:
694  // Recursively consume properly-nested square brackets.
695  Toks.push_back(Tok);
696  ConsumeBracket();
697  ConsumeAndStoreUntil(tok::r_square, Toks, /*StopAtSemi=*/false);
698  break;
699  case tok::l_brace:
700  // Recursively consume properly-nested braces.
701  Toks.push_back(Tok);
702  ConsumeBrace();
703  ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/false);
704  break;
705 
706  // Okay, we found a ']' or '}' or ')', which we think should be balanced.
707  // Since the user wasn't looking for this token (if they were, it would
708  // already be handled), this isn't balanced. If there is a LHS token at a
709  // higher level, we will assume that this matches the unbalanced token
710  // and return it. Otherwise, this is a spurious RHS token, which we skip.
711  case tok::r_paren:
712  if (ParenCount && !isFirstTokenConsumed)
713  return false; // Matches something.
714  Toks.push_back(Tok);
715  ConsumeParen();
716  break;
717  case tok::r_square:
718  if (BracketCount && !isFirstTokenConsumed)
719  return false; // Matches something.
720  Toks.push_back(Tok);
721  ConsumeBracket();
722  break;
723  case tok::r_brace:
724  if (BraceCount && !isFirstTokenConsumed)
725  return false; // Matches something.
726  Toks.push_back(Tok);
727  ConsumeBrace();
728  break;
729 
730  case tok::code_completion:
731  Toks.push_back(Tok);
732  ConsumeCodeCompletionToken();
733  break;
734 
735  case tok::string_literal:
736  case tok::wide_string_literal:
737  case tok::utf8_string_literal:
738  case tok::utf16_string_literal:
739  case tok::utf32_string_literal:
740  Toks.push_back(Tok);
741  ConsumeStringToken();
742  break;
743  case tok::semi:
744  if (StopAtSemi)
745  return false;
746  // FALL THROUGH.
747  default:
748  // consume this token.
749  Toks.push_back(Tok);
750  ConsumeToken();
751  break;
752  }
753  isFirstTokenConsumed = false;
754  }
755 }
756 
757 /// \brief Consume tokens and store them in the passed token container until
758 /// we've passed the try keyword and constructor initializers and have consumed
759 /// the opening brace of the function body. The opening brace will be consumed
760 /// if and only if there was no error.
761 ///
762 /// \return True on error.
763 bool Parser::ConsumeAndStoreFunctionPrologue(CachedTokens &Toks) {
764  if (Tok.is(tok::kw_try)) {
765  Toks.push_back(Tok);
766  ConsumeToken();
767  }
768 
769  if (Tok.isNot(tok::colon)) {
770  // Easy case, just a function body.
771 
772  // Grab any remaining garbage to be diagnosed later. We stop when we reach a
773  // brace: an opening one is the function body, while a closing one probably
774  // means we've reached the end of the class.
775  ConsumeAndStoreUntil(tok::l_brace, tok::r_brace, Toks,
776  /*StopAtSemi=*/true,
777  /*ConsumeFinalToken=*/false);
778  if (Tok.isNot(tok::l_brace))
779  return Diag(Tok.getLocation(), diag::err_expected) << tok::l_brace;
780 
781  Toks.push_back(Tok);
782  ConsumeBrace();
783  return false;
784  }
785 
786  Toks.push_back(Tok);
787  ConsumeToken();
788 
789  // We can't reliably skip over a mem-initializer-id, because it could be
790  // a template-id involving not-yet-declared names. Given:
791  //
792  // S ( ) : a < b < c > ( e )
793  //
794  // 'e' might be an initializer or part of a template argument, depending
795  // on whether 'b' is a template.
796 
797  // Track whether we might be inside a template argument. We can give
798  // significantly better diagnostics if we know that we're not.
799  bool MightBeTemplateArgument = false;
800 
801  while (true) {
802  // Skip over the mem-initializer-id, if possible.
803  if (Tok.is(tok::kw_decltype)) {
804  Toks.push_back(Tok);
805  SourceLocation OpenLoc = ConsumeToken();
806  if (Tok.isNot(tok::l_paren))
807  return Diag(Tok.getLocation(), diag::err_expected_lparen_after)
808  << "decltype";
809  Toks.push_back(Tok);
810  ConsumeParen();
811  if (!ConsumeAndStoreUntil(tok::r_paren, Toks, /*StopAtSemi=*/true)) {
812  Diag(Tok.getLocation(), diag::err_expected) << tok::r_paren;
813  Diag(OpenLoc, diag::note_matching) << tok::l_paren;
814  return true;
815  }
816  }
817  do {
818  // Walk over a component of a nested-name-specifier.
819  if (Tok.is(tok::coloncolon)) {
820  Toks.push_back(Tok);
821  ConsumeToken();
822 
823  if (Tok.is(tok::kw_template)) {
824  Toks.push_back(Tok);
825  ConsumeToken();
826  }
827  }
828 
829  if (Tok.isOneOf(tok::identifier, tok::kw_template)) {
830  Toks.push_back(Tok);
831  ConsumeToken();
832  } else if (Tok.is(tok::code_completion)) {
833  Toks.push_back(Tok);
834  ConsumeCodeCompletionToken();
835  // Consume the rest of the initializers permissively.
836  // FIXME: We should be able to perform code-completion here even if
837  // there isn't a subsequent '{' token.
838  MightBeTemplateArgument = true;
839  break;
840  } else {
841  break;
842  }
843  } while (Tok.is(tok::coloncolon));
844 
845  if (Tok.is(tok::less))
846  MightBeTemplateArgument = true;
847 
848  if (MightBeTemplateArgument) {
849  // We may be inside a template argument list. Grab up to the start of the
850  // next parenthesized initializer or braced-init-list. This *might* be the
851  // initializer, or it might be a subexpression in the template argument
852  // list.
853  // FIXME: Count angle brackets, and clear MightBeTemplateArgument
854  // if all angles are closed.
855  if (!ConsumeAndStoreUntil(tok::l_paren, tok::l_brace, Toks,
856  /*StopAtSemi=*/true,
857  /*ConsumeFinalToken=*/false)) {
858  // We're not just missing the initializer, we're also missing the
859  // function body!
860  return Diag(Tok.getLocation(), diag::err_expected) << tok::l_brace;
861  }
862  } else if (Tok.isNot(tok::l_paren) && Tok.isNot(tok::l_brace)) {
863  // We found something weird in a mem-initializer-id.
864  if (getLangOpts().CPlusPlus11)
865  return Diag(Tok.getLocation(), diag::err_expected_either)
866  << tok::l_paren << tok::l_brace;
867  else
868  return Diag(Tok.getLocation(), diag::err_expected) << tok::l_paren;
869  }
870 
871  tok::TokenKind kind = Tok.getKind();
872  Toks.push_back(Tok);
873  bool IsLParen = (kind == tok::l_paren);
874  SourceLocation OpenLoc = Tok.getLocation();
875 
876  if (IsLParen) {
877  ConsumeParen();
878  } else {
879  assert(kind == tok::l_brace && "Must be left paren or brace here.");
880  ConsumeBrace();
881  // In C++03, this has to be the start of the function body, which
882  // means the initializer is malformed; we'll diagnose it later.
883  if (!getLangOpts().CPlusPlus11)
884  return false;
885  }
886 
887  // Grab the initializer (or the subexpression of the template argument).
888  // FIXME: If we support lambdas here, we'll need to set StopAtSemi to false
889  // if we might be inside the braces of a lambda-expression.
890  tok::TokenKind CloseKind = IsLParen ? tok::r_paren : tok::r_brace;
891  if (!ConsumeAndStoreUntil(CloseKind, Toks, /*StopAtSemi=*/true)) {
892  Diag(Tok, diag::err_expected) << CloseKind;
893  Diag(OpenLoc, diag::note_matching) << kind;
894  return true;
895  }
896 
897  // Grab pack ellipsis, if present.
898  if (Tok.is(tok::ellipsis)) {
899  Toks.push_back(Tok);
900  ConsumeToken();
901  }
902 
903  // If we know we just consumed a mem-initializer, we must have ',' or '{'
904  // next.
905  if (Tok.is(tok::comma)) {
906  Toks.push_back(Tok);
907  ConsumeToken();
908  } else if (Tok.is(tok::l_brace)) {
909  // This is the function body if the ')' or '}' is immediately followed by
910  // a '{'. That cannot happen within a template argument, apart from the
911  // case where a template argument contains a compound literal:
912  //
913  // S ( ) : a < b < c > ( d ) { }
914  // // End of declaration, or still inside the template argument?
915  //
916  // ... and the case where the template argument contains a lambda:
917  //
918  // S ( ) : a < 0 && b < c > ( d ) + [ ] ( ) { return 0; }
919  // ( ) > ( ) { }
920  //
921  // FIXME: Disambiguate these cases. Note that the latter case is probably
922  // going to be made ill-formed by core issue 1607.
923  Toks.push_back(Tok);
924  ConsumeBrace();
925  return false;
926  } else if (!MightBeTemplateArgument) {
927  return Diag(Tok.getLocation(), diag::err_expected_either) << tok::l_brace
928  << tok::comma;
929  }
930  }
931 }
932 
933 /// \brief Consume and store tokens from the '?' to the ':' in a conditional
934 /// expression.
935 bool Parser::ConsumeAndStoreConditional(CachedTokens &Toks) {
936  // Consume '?'.
937  assert(Tok.is(tok::question));
938  Toks.push_back(Tok);
939  ConsumeToken();
940 
941  while (Tok.isNot(tok::colon)) {
942  if (!ConsumeAndStoreUntil(tok::question, tok::colon, Toks,
943  /*StopAtSemi=*/true,
944  /*ConsumeFinalToken=*/false))
945  return false;
946 
947  // If we found a nested conditional, consume it.
948  if (Tok.is(tok::question) && !ConsumeAndStoreConditional(Toks))
949  return false;
950  }
951 
952  // Consume ':'.
953  Toks.push_back(Tok);
954  ConsumeToken();
955  return true;
956 }
957 
958 /// \brief A tentative parsing action that can also revert token annotations.
959 class Parser::UnannotatedTentativeParsingAction : public TentativeParsingAction {
960 public:
962  tok::TokenKind EndKind)
963  : TentativeParsingAction(Self), Self(Self), EndKind(EndKind) {
964  // Stash away the old token stream, so we can restore it once the
965  // tentative parse is complete.
966  TentativeParsingAction Inner(Self);
967  Self.ConsumeAndStoreUntil(EndKind, Toks, true, /*ConsumeFinalToken*/false);
968  Inner.Revert();
969  }
970 
972  Revert();
973 
974  // Put back the original tokens.
975  Self.SkipUntil(EndKind, StopAtSemi | StopBeforeMatch);
976  if (Toks.size()) {
977  auto Buffer = llvm::make_unique<Token[]>(Toks.size());
978  std::copy(Toks.begin() + 1, Toks.end(), Buffer.get());
979  Buffer[Toks.size() - 1] = Self.Tok;
980  Self.PP.EnterTokenStream(std::move(Buffer), Toks.size(), true);
981 
982  Self.Tok = Toks.front();
983  }
984  }
985 
986 private:
987  Parser &Self;
988  CachedTokens Toks;
989  tok::TokenKind EndKind;
990 };
991 
992 /// ConsumeAndStoreInitializer - Consume and store the token at the passed token
993 /// container until the end of the current initializer expression (either a
994 /// default argument or an in-class initializer for a non-static data member).
995 ///
996 /// Returns \c true if we reached the end of something initializer-shaped,
997 /// \c false if we bailed out.
998 bool Parser::ConsumeAndStoreInitializer(CachedTokens &Toks,
999  CachedInitKind CIK) {
1000  // We always want this function to consume at least one token if not at EOF.
1001  bool IsFirstToken = true;
1002 
1003  // Number of possible unclosed <s we've seen so far. These might be templates,
1004  // and might not, but if there were none of them (or we know for sure that
1005  // we're within a template), we can avoid a tentative parse.
1006  unsigned AngleCount = 0;
1007  unsigned KnownTemplateCount = 0;
1008 
1009  while (1) {
1010  switch (Tok.getKind()) {
1011  case tok::comma:
1012  // If we might be in a template, perform a tentative parse to check.
1013  if (!AngleCount)
1014  // Not a template argument: this is the end of the initializer.
1015  return true;
1016  if (KnownTemplateCount)
1017  goto consume_token;
1018 
1019  // We hit a comma inside angle brackets. This is the hard case. The
1020  // rule we follow is:
1021  // * For a default argument, if the tokens after the comma form a
1022  // syntactically-valid parameter-declaration-clause, in which each
1023  // parameter has an initializer, then this comma ends the default
1024  // argument.
1025  // * For a default initializer, if the tokens after the comma form a
1026  // syntactically-valid init-declarator-list, then this comma ends
1027  // the default initializer.
1028  {
1030  CIK == CIK_DefaultInitializer
1031  ? tok::semi : tok::r_paren);
1033 
1034  TPResult Result = TPResult::Error;
1035  ConsumeToken();
1036  switch (CIK) {
1037  case CIK_DefaultInitializer:
1038  Result = TryParseInitDeclaratorList();
1039  // If we parsed a complete, ambiguous init-declarator-list, this
1040  // is only syntactically-valid if it's followed by a semicolon.
1041  if (Result == TPResult::Ambiguous && Tok.isNot(tok::semi))
1042  Result = TPResult::False;
1043  break;
1044 
1045  case CIK_DefaultArgument:
1046  bool InvalidAsDeclaration = false;
1047  Result = TryParseParameterDeclarationClause(
1048  &InvalidAsDeclaration, /*VersusTemplateArgument=*/true);
1049  // If this is an expression or a declaration with a missing
1050  // 'typename', assume it's not a declaration.
1051  if (Result == TPResult::Ambiguous && InvalidAsDeclaration)
1052  Result = TPResult::False;
1053  break;
1054  }
1055 
1056  // If what follows could be a declaration, it is a declaration.
1057  if (Result != TPResult::False && Result != TPResult::Error) {
1058  PA.Revert();
1059  return true;
1060  }
1061 
1062  // In the uncommon case that we decide the following tokens are part
1063  // of a template argument, revert any annotations we've performed in
1064  // those tokens. We're not going to look them up until we've parsed
1065  // the rest of the class, and that might add more declarations.
1066  PA.RevertAnnotations();
1067  }
1068 
1069  // Keep going. We know we're inside a template argument list now.
1070  ++KnownTemplateCount;
1071  goto consume_token;
1072 
1073  case tok::eof:
1074  case tok::annot_module_begin:
1075  case tok::annot_module_end:
1076  case tok::annot_module_include:
1077  // Ran out of tokens.
1078  return false;
1079 
1080  case tok::less:
1081  // FIXME: A '<' can only start a template-id if it's preceded by an
1082  // identifier, an operator-function-id, or a literal-operator-id.
1083  ++AngleCount;
1084  goto consume_token;
1085 
1086  case tok::question:
1087  // In 'a ? b : c', 'b' can contain an unparenthesized comma. If it does,
1088  // that is *never* the end of the initializer. Skip to the ':'.
1089  if (!ConsumeAndStoreConditional(Toks))
1090  return false;
1091  break;
1092 
1093  case tok::greatergreatergreater:
1094  if (!getLangOpts().CPlusPlus11)
1095  goto consume_token;
1096  if (AngleCount) --AngleCount;
1097  if (KnownTemplateCount) --KnownTemplateCount;
1098  // Fall through.
1099  case tok::greatergreater:
1100  if (!getLangOpts().CPlusPlus11)
1101  goto consume_token;
1102  if (AngleCount) --AngleCount;
1103  if (KnownTemplateCount) --KnownTemplateCount;
1104  // Fall through.
1105  case tok::greater:
1106  if (AngleCount) --AngleCount;
1107  if (KnownTemplateCount) --KnownTemplateCount;
1108  goto consume_token;
1109 
1110  case tok::kw_template:
1111  // 'template' identifier '<' is known to start a template argument list,
1112  // and can be used to disambiguate the parse.
1113  // FIXME: Support all forms of 'template' unqualified-id '<'.
1114  Toks.push_back(Tok);
1115  ConsumeToken();
1116  if (Tok.is(tok::identifier)) {
1117  Toks.push_back(Tok);
1118  ConsumeToken();
1119  if (Tok.is(tok::less)) {
1120  ++AngleCount;
1121  ++KnownTemplateCount;
1122  Toks.push_back(Tok);
1123  ConsumeToken();
1124  }
1125  }
1126  break;
1127 
1128  case tok::kw_operator:
1129  // If 'operator' precedes other punctuation, that punctuation loses
1130  // its special behavior.
1131  Toks.push_back(Tok);
1132  ConsumeToken();
1133  switch (Tok.getKind()) {
1134  case tok::comma:
1135  case tok::greatergreatergreater:
1136  case tok::greatergreater:
1137  case tok::greater:
1138  case tok::less:
1139  Toks.push_back(Tok);
1140  ConsumeToken();
1141  break;
1142  default:
1143  break;
1144  }
1145  break;
1146 
1147  case tok::l_paren:
1148  // Recursively consume properly-nested parens.
1149  Toks.push_back(Tok);
1150  ConsumeParen();
1151  ConsumeAndStoreUntil(tok::r_paren, Toks, /*StopAtSemi=*/false);
1152  break;
1153  case tok::l_square:
1154  // Recursively consume properly-nested square brackets.
1155  Toks.push_back(Tok);
1156  ConsumeBracket();
1157  ConsumeAndStoreUntil(tok::r_square, Toks, /*StopAtSemi=*/false);
1158  break;
1159  case tok::l_brace:
1160  // Recursively consume properly-nested braces.
1161  Toks.push_back(Tok);
1162  ConsumeBrace();
1163  ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/false);
1164  break;
1165 
1166  // Okay, we found a ']' or '}' or ')', which we think should be balanced.
1167  // Since the user wasn't looking for this token (if they were, it would
1168  // already be handled), this isn't balanced. If there is a LHS token at a
1169  // higher level, we will assume that this matches the unbalanced token
1170  // and return it. Otherwise, this is a spurious RHS token, which we
1171  // consume and pass on to downstream code to diagnose.
1172  case tok::r_paren:
1173  if (CIK == CIK_DefaultArgument)
1174  return true; // End of the default argument.
1175  if (ParenCount && !IsFirstToken)
1176  return false;
1177  Toks.push_back(Tok);
1178  ConsumeParen();
1179  continue;
1180  case tok::r_square:
1181  if (BracketCount && !IsFirstToken)
1182  return false;
1183  Toks.push_back(Tok);
1184  ConsumeBracket();
1185  continue;
1186  case tok::r_brace:
1187  if (BraceCount && !IsFirstToken)
1188  return false;
1189  Toks.push_back(Tok);
1190  ConsumeBrace();
1191  continue;
1192 
1193  case tok::code_completion:
1194  Toks.push_back(Tok);
1195  ConsumeCodeCompletionToken();
1196  break;
1197 
1198  case tok::string_literal:
1199  case tok::wide_string_literal:
1200  case tok::utf8_string_literal:
1201  case tok::utf16_string_literal:
1202  case tok::utf32_string_literal:
1203  Toks.push_back(Tok);
1204  ConsumeStringToken();
1205  break;
1206  case tok::semi:
1207  if (CIK == CIK_DefaultInitializer)
1208  return true; // End of the default initializer.
1209  // FALL THROUGH.
1210  default:
1211  consume_token:
1212  Toks.push_back(Tok);
1213  ConsumeToken();
1214  break;
1215  }
1216  IsFirstToken = false;
1217  }
1218 }
void ActOnFinishDelayedMemberInitializers(Decl *Record)
FunctionDecl - An instance of this class is created to represent a function declaration or definition...
Definition: Decl.h:1539
This is a scope that corresponds to the parameters within a function prototype.
Definition: Scope.h:80
bool isInvalid() const
Definition: Ownership.h:160
const LangOptions & getLangOpts() const
Definition: Parse/Parser.h:250
void ActOnStartDelayedCXXMethodDeclaration(Scope *S, Decl *Method)
ActOnStartDelayedCXXMethodDeclaration - We have completed parsing a top-level (non-nested) C++ class...
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:78
Defines the C++ template declaration subclasses.
StringRef P
bool hasErrorOccurred() const
Definition: Diagnostic.h:580
FunctionDefinitionKind getFunctionDefinitionKind() const
Definition: DeclSpec.h:2227
PtrTy get() const
Definition: Ownership.h:164
This indicates that the scope corresponds to a function, which means that labels are set here...
Definition: Scope.h:46
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
Definition: DeclBase.cpp:920
void ActOnFinishDelayedCXXMethodDeclaration(Scope *S, Decl *Method)
ActOnFinishDelayedCXXMethodDeclaration - We have finished processing the delayed method declaration f...
const Expr * getInit() const
Definition: Decl.h:1135
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition: Specifiers.h:92
Parser - This implements a parser for the C family of languages.
Definition: Parse/Parser.h:56
void ActOnDefaultCtorInitializers(Decl *CDtorDecl)
RAII object that enters a new expression evaluation context.
Definition: Sema.h:9430
void ActOnStartDelayedMemberDeclarations(Scope *S, Decl *Record)
RAII object used to temporarily allow the C++ &#39;this&#39; expression to be used, with the given qualifiers...
Definition: Sema.h:4632
const ParsingDeclSpec & getDeclSpec() const
ParmVarDecl - Represents a parameter to a function.
Definition: Decl.h:1355
void MarkAsLateParsedTemplate(FunctionDecl *FD, Decl *FnD, CachedTokens &Toks)
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: Parse/Parser.h:872
Decl * ActOnStartOfFunctionDef(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParamLists, SkipBodyInfo *SkipBody=nullptr)
Definition: SemaDecl.cpp:10943
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Computes the source location just past the end of the token at this source location.
bool TryConsumeToken(tok::TokenKind Expected)
Definition: Parse/Parser.h:299
bool hasUninstantiatedDefaultArg() const
Definition: Decl.h:1470
void setUninstantiatedDefaultArg(Expr *arg)
Definition: Decl.cpp:2410
bool isInIdentifierNamespace(unsigned NS) const
Definition: DeclBase.h:697
This declaration is a friend function.
Definition: DeclBase.h:147
Token - This structure provides full information about a lexed token.
Definition: Token.h:37
void setKind(tok::TokenKind K)
Definition: Token.h:92
The current expression is potentially evaluated, but any declarations referenced inside that expressi...
Definition: Sema.h:824
SourceLocation getLocWithOffset(int Offset) const
Return a source location with the specified offset from this SourceLocation.
RAII class used to indicate that we are performing provisional semantic analysis to determine the val...
Definition: Sema.h:6921
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:39
tok::TokenKind getKind() const
Definition: Token.h:91
Decl * ActOnFinishFunctionBody(Decl *Decl, Stmt *Body)
Definition: SemaDecl.cpp:11305
void ProcessDeclAttributeList(Scope *S, Decl *D, const AttributeList *AL, bool IncludeCXX11Attributes=true)
ProcessDeclAttributeList - Apply all the decl attributes in the specified attribute list to the speci...
bool isFunctionDeclarator(unsigned &idx) const
isFunctionDeclarator - This method returns true if the declarator is a function declarator (looking t...
Definition: DeclSpec.h:2049
const void * getEofData() const
Definition: Token.h:191
A class for parsing a declarator.
UnannotatedTentativeParsingAction(Parser &Self, tok::TokenKind EndKind)
This file defines the classes used to store parsed information about declaration-specifiers and decla...
void SkipMalformedDecl()
SkipMalformedDecl - Read tokens until we get to some likely good stopping point for skipping past a s...
Definition: ParseDecl.cpp:1641
void setEofData(const void *D)
Definition: Token.h:195
void ActOnFinishCXXInClassMemberInitializer(Decl *VarDecl, SourceLocation EqualLoc, Expr *Init)
This is invoked after parsing an in-class initializer for a non-static C++ class member, and after instantiating an in-class initializer in a class template.
void ActOnDelayedCXXMethodParameter(Scope *S, Decl *Param)
ActOnDelayedCXXMethodParameter - We&#39;ve already started a delayed C++ method declaration.
void setLateTemplateParsed(bool ILT=true)
Definition: Decl.h:1809
SourceLocation getLocation() const
Return a source location identifier for the specified offset in the current file. ...
Definition: Token.h:125
bool isConstexprSpecified() const
Definition: DeclSpec.h:701
bool isNot(tok::TokenKind K) const
Definition: Token.h:97
void SetDeclDeleted(Decl *dcl, SourceLocation DelLoc)
DiagnosticsEngine & getDiagnostics() const
Definition: Sema.h:1061
The result type of a method or function.
This is a scope that corresponds to the parameters within a function prototype for a function declara...
Definition: Scope.h:86
void CheckForFunctionRedefinition(FunctionDecl *FD, const FunctionDecl *EffectiveDefinition=nullptr, SkipBodyInfo *SkipBody=nullptr)
Definition: SemaDecl.cpp:11015
void ActOnStartCXXInClassMemberInitializer()
Enter a new C++ default initializer scope.
Stop skipping at semicolon.
Definition: Parse/Parser.h:852
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
Definition: DeclBase.cpp:187
Encodes a location in the source.
void ActOnFinishDelayedMemberDeclarations(Scope *S, Decl *Record)
SourceLocation getEndLoc() const
Definition: Token.h:152
bool isValid() const
Return true if this is a valid SourceLocation object.
Scope * getCurScope() const
Definition: Parse/Parser.h:257
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1733
void SetDeclDefaulted(Decl *dcl, SourceLocation DefaultLoc)
A tentative parsing action that can also revert token annotations.
bool isTemplateParamScope() const
isTemplateParamScope - Return true if this scope is a C++ template parameter scope.
Definition: Scope.h:365
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).
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Definition: TokenKinds.h:25
Represents a C++11 virt-specifier-seq.
Definition: DeclSpec.h:2258
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:96
void ActOnFinishInlineFunctionDef(FunctionDecl *D)
Definition: SemaDecl.cpp:10955
The scope of a struct/union/class definition.
Definition: Scope.h:64
Dataflow Directional Tag Classes.
bool hasUnparsedDefaultArg() const
hasUnparsedDefaultArg - Determines whether this parameter has a default argument that has not yet bee...
Definition: Decl.h:1466
bool isFriendSpecified() const
Definition: DeclSpec.h:695
void ActOnParamDefaultArgument(Decl *param, SourceLocation EqualLoc, Expr *defarg)
ActOnParamDefaultArgument - Check whether the default argument provided for a function parameter is w...
This is a scope that corresponds to the template parameters of a C++ template.
Definition: Scope.h:76
bool isOneOf(tok::TokenKind K1, tok::TokenKind K2) const
Definition: Token.h:98
DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
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.
ExprResult ParseAssignmentExpression(TypeCastState isTypeCast=NotTypeCast)
Parse an expr that doesn&#39;t include (top-level) commas.
Definition: ParseExpr.cpp:157
ExceptionSpecificationType
The various types of exception specifications that exist in C++11.
bool isUsable() const
Definition: Ownership.h:161
This is a scope that can contain a declaration.
Definition: Scope.h:58
void ActOnParamDefaultArgumentError(Decl *param, SourceLocation EqualLoc)
ActOnParamDefaultArgumentError - Parsing or semantic analysis of the default argument for the paramet...
SourceLocation ConsumeToken()
ConsumeToken - Consume the current &#39;peek token&#39; and lex the next one.
Definition: Parse/Parser.h:291
void ActOnPureSpecifier(Decl *D, SourceLocation PureSpecLoc)
ExprResult CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl=nullptr, 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...
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:310
unsigned kind
All of the diagnostics that can be emitted by the frontend.
Definition: DiagnosticIDs.h:43
void setLocation(SourceLocation L)
Definition: Token.h:133
A trivial tuple used to represent a source range.
NamedDecl - This represents a decl with a name.
Definition: Decl.h:213
No in-class initializer.
Definition: Specifiers.h:224
Declaration of a template function.
Definition: DeclTemplate.h:839
bool IsInsideALocalClassWithinATemplateFunction()
void startToken()
Reset all flags to cleared.
Definition: Token.h:170
AttributeList - Represents a syntactic attribute.
Definition: AttributeList.h:94
Stop skipping at specified token, but don&#39;t skip the token itself.
Definition: Parse/Parser.h:854
NamedDecl * ActOnFriendFunctionDecl(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParams)
unsigned ActOnReenterTemplateScope(Scope *S, Decl *Template)