CbC/CbC_llvm: clang/lib/Parse/ParseCXXInlineMethods.cpp comparison

comparison clang/lib/Parse/ParseCXXInlineMethods.cpp @ 207:2e18cbf3894f

LLVM12

author	Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date	Tue, 08 Jun 2021 06:07:14 +0900
parents	0572611fdcc8
children	5f17cb93ff66

comparison

equal deleted inserted replaced

-:0572611fdcc8
+:2e18cbf3894f
 // In delayed template parsing mode, if we are within a class template
 // or if we are about to parse function member template then consume
 // the tokens and store them for parsing at the end of the translation unit.
 if (getLangOpts().DelayedTemplateParsing &&
-D.getFunctionDefinitionKind() == FDK_Definition &&
+D.getFunctionDefinitionKind() == FunctionDefinitionKind::Definition &&
 !D.getDeclSpec().hasConstexprSpecifier() &&
 !(FnD && FnD->getAsFunction() &&
 FnD->getAsFunction()->getReturnType()->getContainedAutoType()) &&
 ((Actions.CurContext->isDependentContext() ||
 (TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate &&
 // Consume the tokens and store them for later parsing.
 LexedMethod* LM = new LexedMethod(this, FnD);
 getCurrentClass().LateParsedDeclarations.push_back(LM);
-LM->TemplateScope = getCurScope()->isTemplateParamScope() ||
-(FnD && isa<FunctionTemplateDecl>(FnD) &&
-cast<FunctionTemplateDecl>(FnD)->isAbbreviated());
 CachedTokens &Toks = LM->Toks;
 tok::TokenKind kind = Tok.getKind();
 // Consume everything up to (and including) the left brace of the
 // function body.
 Parser::LateParsedDeclaration::~LateParsedDeclaration() {}
 void Parser::LateParsedDeclaration::ParseLexedMethodDeclarations() {}
 void Parser::LateParsedDeclaration::ParseLexedMemberInitializers() {}
 void Parser::LateParsedDeclaration::ParseLexedMethodDefs() {}
+void Parser::LateParsedDeclaration::ParseLexedAttributes() {}
 void Parser::LateParsedDeclaration::ParseLexedPragmas() {}
 Parser::LateParsedClass::LateParsedClass(Parser *P, ParsingClass *C)
 : Self(P), Class(C) {}
 void Parser::LateParsedClass::ParseLexedMethodDefs() {
 Self->ParseLexedMethodDefs(*Class);
 }
+void Parser::LateParsedClass::ParseLexedAttributes() {
+Self->ParseLexedAttributes(*Class);
+}
 void Parser::LateParsedClass::ParseLexedPragmas() {
 Self->ParseLexedPragmas(*Class);
 }
 void Parser::LateParsedMethodDeclaration::ParseLexedMethodDeclarations() {
 void Parser::LateParsedMemberInitializer::ParseLexedMemberInitializers() {
 Self->ParseLexedMemberInitializer(*this);
 }
+void Parser::LateParsedAttribute::ParseLexedAttributes() {
+Self->ParseLexedAttribute(*this, true, false);
+}
 void Parser::LateParsedPragma::ParseLexedPragmas() {
 Self->ParseLexedPragma(*this);
 }
+/// Utility to re-enter a possibly-templated scope while parsing its
+/// late-parsed components.
+struct Parser::ReenterTemplateScopeRAII {
+Parser &P;
+MultiParseScope Scopes;
+TemplateParameterDepthRAII CurTemplateDepthTracker;
+ReenterTemplateScopeRAII(Parser &P, Decl *MaybeTemplated, bool Enter = true)
+: P(P), Scopes(P), CurTemplateDepthTracker(P.TemplateParameterDepth) {
+if (Enter) {
+CurTemplateDepthTracker.addDepth(
+P.ReenterTemplateScopes(Scopes, MaybeTemplated));
+}
+}
+};
+/// Utility to re-enter a class scope while parsing its late-parsed components.
+struct Parser::ReenterClassScopeRAII : ReenterTemplateScopeRAII {
+ParsingClass &Class;
+ReenterClassScopeRAII(Parser &P, ParsingClass &Class)
+: ReenterTemplateScopeRAII(P, Class.TagOrTemplate,
+/*Enter=*/!Class.TopLevelClass),
+Class(Class) {
+// If this is the top-level class, we're still within its scope.
+if (Class.TopLevelClass)
+return;
+// Re-enter the class scope itself.
+Scopes.Enter(Scope::ClassScope|Scope::DeclScope);
+P.Actions.ActOnStartDelayedMemberDeclarations(P.getCurScope(),
+Class.TagOrTemplate);
+}
+~ReenterClassScopeRAII() {
+if (Class.TopLevelClass)
+return;
+P.Actions.ActOnFinishDelayedMemberDeclarations(P.getCurScope(),
+Class.TagOrTemplate);
+}
+};
 /// ParseLexedMethodDeclarations - We finished parsing the member
 /// specification of a top (non-nested) C++ class. Now go over the
 /// stack of method declarations with some parts for which parsing was
 /// delayed (such as default arguments) and parse them.
 void Parser::ParseLexedMethodDeclarations(ParsingClass &Class) {
-bool HasTemplateScope = !Class.TopLevelClass && Class.TemplateScope;
+ReenterClassScopeRAII InClassScope(*this, Class);
-ParseScope ClassTemplateScope(this, Scope::TemplateParamScope,
-HasTemplateScope);
+for (LateParsedDeclaration *LateD : Class.LateParsedDeclarations)
-TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth);
+LateD->ParseLexedMethodDeclarations();
-if (HasTemplateScope) {
-Actions.ActOnReenterTemplateScope(getCurScope(), Class.TagOrTemplate);
-++CurTemplateDepthTracker;
-}
-// The current scope is still active if we're the top-level class.
-// Otherwise we'll need to push and enter a new scope.
-bool HasClassScope = !Class.TopLevelClass;
-ParseScope ClassScope(this, Scope::ClassScope|Scope::DeclScope,
-HasClassScope);
-if (HasClassScope)
-Actions.ActOnStartDelayedMemberDeclarations(getCurScope(),
-Class.TagOrTemplate);
-for (size_t i = 0; i < Class.LateParsedDeclarations.size(); ++i) {
-Class.LateParsedDeclarations[i]->ParseLexedMethodDeclarations();
-}
-if (HasClassScope)
-Actions.ActOnFinishDelayedMemberDeclarations(getCurScope(),
-Class.TagOrTemplate);
 }
 void Parser::ParseLexedMethodDeclaration(LateParsedMethodDeclaration &LM) {
 // If this is a member template, introduce the template parameter scope.
-ParseScope TemplateScope(this, Scope::TemplateParamScope, LM.TemplateScope);
+ReenterTemplateScopeRAII InFunctionTemplateScope(*this, LM.Method);
-TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth);
-if (LM.TemplateScope) {
-Actions.ActOnReenterTemplateScope(getCurScope(), LM.Method);
-++CurTemplateDepthTracker;
-}
 // Start the delayed C++ method declaration
 Actions.ActOnStartDelayedCXXMethodDeclaration(getCurScope(), LM.Method);
 // Introduce the parameters into scope and parse their default
 // arguments.
-ParseScope PrototypeScope(this, Scope::FunctionPrototypeScope |
+InFunctionTemplateScope.Scopes.Enter(Scope::FunctionPrototypeScope |
-Scope::FunctionDeclarationScope | Scope::DeclScope);
+Scope::FunctionDeclarationScope |
+Scope::DeclScope);
 for (unsigned I = 0, N = LM.DefaultArgs.size(); I != N; ++I) {
 auto Param = cast<ParmVarDecl>(LM.DefaultArgs[I].Param);
 // Introduce the parameter into scope.
 bool HasUnparsed = Param->hasUnparsedDefaultArg();
 Actions.ActOnDelayedCXXMethodParameter(getCurScope(), Param);
 if (Tok.is(tok::eof) && Tok.getEofData() == Param)
 ConsumeAnyToken();
 } else if (HasUnparsed) {
 assert(Param->hasInheritedDefaultArg());
-FunctionDecl *Old = cast<FunctionDecl>(LM.Method)->getPreviousDecl();
+const FunctionDecl *Old;
-ParmVarDecl *OldParam = Old->getParamDecl(I);
+if (const auto *FunTmpl = dyn_cast<FunctionTemplateDecl>(LM.Method))
-assert (!OldParam->hasUnparsedDefaultArg());
+Old =
-if (OldParam->hasUninstantiatedDefaultArg())
+cast<FunctionDecl>(FunTmpl->getTemplatedDecl())->getPreviousDecl();
-Param->setUninstantiatedDefaultArg(
-OldParam->getUninstantiatedDefaultArg());
 else
-Param->setDefaultArg(OldParam->getInit());
+Old = cast<FunctionDecl>(LM.Method)->getPreviousDecl();
+if (Old) {
+ParmVarDecl *OldParam = const_cast<ParmVarDecl*>(Old->getParamDecl(I));
+assert(!OldParam->hasUnparsedDefaultArg());
+if (OldParam->hasUninstantiatedDefaultArg())
+Param->setUninstantiatedDefaultArg(
+OldParam->getUninstantiatedDefaultArg());
+else
+Param->setDefaultArg(OldParam->getInit());
+}
 }
 }
 // Parse a delayed exception-specification, if there is one.
 if (CachedTokens *Toks = LM.ExceptionSpecTokens) {
 delete Toks;
 LM.ExceptionSpecTokens = nullptr;
 }
-PrototypeScope.Exit();
+InFunctionTemplateScope.Scopes.Exit();
 // Finish the delayed C++ method declaration.
 Actions.ActOnFinishDelayedCXXMethodDeclaration(getCurScope(), LM.Method);
 }
 /// ParseLexedMethodDefs - We finished parsing the member specification of a top
 /// (non-nested) C++ class. Now go over the stack of lexed methods that were
 /// collected during its parsing and parse them all.
 void Parser::ParseLexedMethodDefs(ParsingClass &Class) {
-bool HasTemplateScope = !Class.TopLevelClass && Class.TemplateScope;
+ReenterClassScopeRAII InClassScope(*this, Class);
-ParseScope ClassTemplateScope(this, Scope::TemplateParamScope, HasTemplateScope);
-TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth);
+for (LateParsedDeclaration *D : Class.LateParsedDeclarations)
-if (HasTemplateScope) {
+D->ParseLexedMethodDefs();
-Actions.ActOnReenterTemplateScope(getCurScope(), Class.TagOrTemplate);
-++CurTemplateDepthTracker;
-}
-bool HasClassScope = !Class.TopLevelClass;
-ParseScope ClassScope(this, Scope::ClassScope|Scope::DeclScope,
-HasClassScope);
-for (size_t i = 0; i < Class.LateParsedDeclarations.size(); ++i) {
-Class.LateParsedDeclarations[i]->ParseLexedMethodDefs();
-}
 }
 void Parser::ParseLexedMethodDef(LexedMethod &LM) {
 // If this is a member template, introduce the template parameter scope.
-ParseScope TemplateScope(this, Scope::TemplateParamScope, LM.TemplateScope);
+ReenterTemplateScopeRAII InFunctionTemplateScope(*this, LM.D);
-TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth);
-if (LM.TemplateScope) {
-Actions.ActOnReenterTemplateScope(getCurScope(), LM.D);
-++CurTemplateDepthTracker;
-}
 ParenBraceBracketBalancer BalancerRAIIObj(*this);
 assert(!LM.Toks.empty() && "Empty body!");
 Token LastBodyToken = LM.Toks.back();
 /// ParseLexedMemberInitializers - We finished parsing the member specification
 /// of a top (non-nested) C++ class. Now go over the stack of lexed data member
 /// initializers that were collected during its parsing and parse them all.
 void Parser::ParseLexedMemberInitializers(ParsingClass &Class) {
-bool HasTemplateScope = !Class.TopLevelClass && Class.TemplateScope;
+ReenterClassScopeRAII InClassScope(*this, Class);
-ParseScope ClassTemplateScope(this, Scope::TemplateParamScope,
-HasTemplateScope);
-TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth);
-if (HasTemplateScope) {
-Actions.ActOnReenterTemplateScope(getCurScope(), Class.TagOrTemplate);
-++CurTemplateDepthTracker;
-}
-// Set or update the scope flags.
-bool AlreadyHasClassScope = Class.TopLevelClass;
-unsigned ScopeFlags = Scope::ClassScope|Scope::DeclScope;
-ParseScope ClassScope(this, ScopeFlags, !AlreadyHasClassScope);
-ParseScopeFlags ClassScopeFlags(this, ScopeFlags, AlreadyHasClassScope);
-if (!AlreadyHasClassScope)
-Actions.ActOnStartDelayedMemberDeclarations(getCurScope(),
-Class.TagOrTemplate);
 if (!Class.LateParsedDeclarations.empty()) {
 // C++11 [expr.prim.general]p4:
 //   Otherwise, if a member-declarator declares a non-static data member
 //  (9.2) of a class X, the expression this is a prvalue of type "pointer
 //  to X" within the optional brace-or-equal-initializer. It shall not
 //  appear elsewhere in the member-declarator.
+// FIXME: This should be done in ParseLexedMemberInitializer, not here.
 Sema::CXXThisScopeRAII ThisScope(Actions, Class.TagOrTemplate,
 Qualifiers());
-for (size_t i = 0; i < Class.LateParsedDeclarations.size(); ++i) {
+for (LateParsedDeclaration *D : Class.LateParsedDeclarations)
-Class.LateParsedDeclarations[i]->ParseLexedMemberInitializers();
+D->ParseLexedMemberInitializers();
 }
-}
-if (!AlreadyHasClassScope)
-Actions.ActOnFinishDelayedMemberDeclarations(getCurScope(),
-Class.TagOrTemplate);
 Actions.ActOnFinishDelayedMemberInitializers(Class.TagOrTemplate);
 }
 void Parser::ParseLexedMemberInitializer(LateParsedMemberInitializer &MI) {
 // Make sure this is *our* artificial EOF token.
 if (Tok.getEofData() == MI.Field)
 ConsumeAnyToken();
 }
+/// Wrapper class which calls ParseLexedAttribute, after setting up the
+/// scope appropriately.
+void Parser::ParseLexedAttributes(ParsingClass &Class) {
+ReenterClassScopeRAII InClassScope(*this, Class);
+for (LateParsedDeclaration *LateD : Class.LateParsedDeclarations)
+LateD->ParseLexedAttributes();
+}
+/// Parse all attributes in LAs, and attach them to Decl D.
+void Parser::ParseLexedAttributeList(LateParsedAttrList &LAs, Decl *D,
+bool EnterScope, bool OnDefinition) {
+assert(LAs.parseSoon() &&
+"Attribute list should be marked for immediate parsing.");
+for (unsigned i = 0, ni = LAs.size(); i < ni; ++i) {
+if (D)
+LAs[i]->addDecl(D);
+ParseLexedAttribute(*LAs[i], EnterScope, OnDefinition);
+delete LAs[i];
+}
+LAs.clear();
+}
+/// Finish parsing an attribute for which parsing was delayed.
+/// This will be called at the end of parsing a class declaration
+/// for each LateParsedAttribute. We consume the saved tokens and
+/// create an attribute with the arguments filled in. We add this
+/// to the Attribute list for the decl.
+void Parser::ParseLexedAttribute(LateParsedAttribute &LA,
+bool EnterScope, bool OnDefinition) {
+// Create a fake EOF so that attribute parsing won't go off the end of the
+// attribute.
+Token AttrEnd;
+AttrEnd.startToken();
+AttrEnd.setKind(tok::eof);
+AttrEnd.setLocation(Tok.getLocation());
+AttrEnd.setEofData(LA.Toks.data());
+LA.Toks.push_back(AttrEnd);
+// Append the current token at the end of the new token stream so that it
+// doesn't get lost.
+LA.Toks.push_back(Tok);
+PP.EnterTokenStream(LA.Toks, true, /*IsReinject=*/true);
+// Consume the previously pushed token.
+ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true);
+ParsedAttributes Attrs(AttrFactory);
+SourceLocation endLoc;
+if (LA.Decls.size() > 0) {
+Decl *D = LA.Decls[0];
+NamedDecl *ND  = dyn_cast<NamedDecl>(D);
+RecordDecl *RD = dyn_cast_or_null<RecordDecl>(D->getDeclContext());
+// Allow 'this' within late-parsed attributes.
+Sema::CXXThisScopeRAII ThisScope(Actions, RD, Qualifiers(),
+ND && ND->isCXXInstanceMember());
+if (LA.Decls.size() == 1) {
+// If the Decl is templatized, add template parameters to scope.
+ReenterTemplateScopeRAII InDeclScope(*this, D, EnterScope);
+// If the Decl is on a function, add function parameters to the scope.
+bool HasFunScope = EnterScope && D->isFunctionOrFunctionTemplate();
+if (HasFunScope) {
+InDeclScope.Scopes.Enter(Scope::FnScope | Scope::DeclScope |
+Scope::CompoundStmtScope);
+Actions.ActOnReenterFunctionContext(Actions.CurScope, D);
+}
+ParseGNUAttributeArgs(&LA.AttrName, LA.AttrNameLoc, Attrs, &endLoc,
+nullptr, SourceLocation(), ParsedAttr::AS_GNU,
+nullptr);
+if (HasFunScope)
+Actions.ActOnExitFunctionContext();
+} else {
+// If there are multiple decls, then the decl cannot be within the
+// function scope.
+ParseGNUAttributeArgs(&LA.AttrName, LA.AttrNameLoc, Attrs, &endLoc,
+nullptr, SourceLocation(), ParsedAttr::AS_GNU,
+nullptr);
+}
+} else {
+Diag(Tok, diag::warn_attribute_no_decl) << LA.AttrName.getName();
+}
+if (OnDefinition && !Attrs.empty() && !Attrs.begin()->isCXX11Attribute() &&
+Attrs.begin()->isKnownToGCC())
+Diag(Tok, diag::warn_attribute_on_function_definition)
+<< &LA.AttrName;
+for (unsigned i = 0, ni = LA.Decls.size(); i < ni; ++i)
+Actions.ActOnFinishDelayedAttribute(getCurScope(), LA.Decls[i], Attrs);
+// Due to a parsing error, we either went over the cached tokens or
+// there are still cached tokens left, so we skip the leftover tokens.
+while (Tok.isNot(tok::eof))
+ConsumeAnyToken();
+if (Tok.is(tok::eof) && Tok.getEofData() == AttrEnd.getEofData())
+ConsumeAnyToken();
+}
 void Parser::ParseLexedPragmas(ParsingClass &Class) {
-bool HasTemplateScope = !Class.TopLevelClass && Class.TemplateScope;
+ReenterClassScopeRAII InClassScope(*this, Class);
-ParseScope ClassTemplateScope(this, Scope::TemplateParamScope,
-HasTemplateScope);
+for (LateParsedDeclaration *D : Class.LateParsedDeclarations)
-TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth);
+D->ParseLexedPragmas();
-if (HasTemplateScope) {
-Actions.ActOnReenterTemplateScope(getCurScope(), Class.TagOrTemplate);
-++CurTemplateDepthTracker;
-}
-bool HasClassScope = !Class.TopLevelClass;
-ParseScope ClassScope(this, Scope::ClassScope | Scope::DeclScope,
-HasClassScope);
-for (LateParsedDeclaration *LPD : Class.LateParsedDeclarations)
-LPD->ParseLexedPragmas();
 }
 void Parser::ParseLexedPragma(LateParsedPragma &LP) {
 PP.EnterToken(Tok, /*IsReinject=*/true);
 PP.EnterTokenStream(LP.toks(), /*DisableMacroExpansion=*/true,

Mercurial > hg > CbC > CbC_llvm

comparison clang/lib/Parse/ParseCXXInlineMethods.cpp @ 207:2e18cbf3894f