From: Faisal Vali Date: Sat, 21 Nov 2020 15:49:52 +0000 (-0600) Subject: [NFC, Refactor] Modernize enum FunctionDefinitionKind (DeclSpech.h) into a scoped... X-Git-Tag: llvmorg-13-init~5450 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=9930d4dff31a130890f21a64f43d530a83ae3d0a;p=platform%2Fupstream%2Fllvm.git [NFC, Refactor] Modernize enum FunctionDefinitionKind (DeclSpech.h) into a scoped enum Reviewed by aaron.ballman, rsmith, wchilders Highlights of review: - avoid specifying an underlying type (unless such an enum is stored (or part of an abi?)) - avoid using enums as bit-fields, preferring unsigned bit-fields that we static_cast enumerators to. (MS's abi laysout enum bit-fields differently). - clang-format, clang-format, clang-format. https://reviews.llvm.org/D91035 Thank you! --- diff --git a/clang/include/clang/Sema/DeclSpec.h b/clang/include/clang/Sema/DeclSpec.h index d2acafc..afcbbaa 100644 --- a/clang/include/clang/Sema/DeclSpec.h +++ b/clang/include/clang/Sema/DeclSpec.h @@ -1748,11 +1748,11 @@ public: /// Described the kind of function definition (if any) provided for /// a function. -enum FunctionDefinitionKind { - FDK_Declaration, - FDK_Definition, - FDK_Defaulted, - FDK_Deleted +enum class FunctionDefinitionKind { + Declaration, + Definition, + Defaulted, + Deleted }; enum class DeclaratorContext { @@ -1888,7 +1888,8 @@ public: Declarator(const DeclSpec &ds, DeclaratorContext C) : DS(ds), Range(ds.getSourceRange()), Context(C), InvalidType(DS.getTypeSpecType() == DeclSpec::TST_error), - GroupingParens(false), FunctionDefinition(FDK_Declaration), + GroupingParens(false), FunctionDefinition(static_cast( + FunctionDefinitionKind::Declaration)), Redeclaration(false), Extension(false), ObjCIvar(false), ObjCWeakProperty(false), InlineStorageUsed(false), Attrs(ds.getAttributePool().getFactory()), AsmLabel(nullptr), @@ -2562,11 +2563,11 @@ public: void setEllipsisLoc(SourceLocation EL) { EllipsisLoc = EL; } void setFunctionDefinitionKind(FunctionDefinitionKind Val) { - FunctionDefinition = Val; + FunctionDefinition = static_cast(Val); } bool isFunctionDefinition() const { - return getFunctionDefinitionKind() != FDK_Declaration; + return getFunctionDefinitionKind() != FunctionDefinitionKind::Declaration; } FunctionDefinitionKind getFunctionDefinitionKind() const { diff --git a/clang/lib/Parse/ParseCXXInlineMethods.cpp b/clang/lib/Parse/ParseCXXInlineMethods.cpp index 12941f2..b033590 100644 --- a/clang/lib/Parse/ParseCXXInlineMethods.cpp +++ b/clang/lib/Parse/ParseCXXInlineMethods.cpp @@ -108,7 +108,7 @@ NamedDecl *Parser::ParseCXXInlineMethodDef( // 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()) && diff --git a/clang/lib/Parse/ParseDeclCXX.cpp b/clang/lib/Parse/ParseDeclCXX.cpp index 0a810fc..9525c02 100644 --- a/clang/lib/Parse/ParseDeclCXX.cpp +++ b/clang/lib/Parse/ParseDeclCXX.cpp @@ -1045,8 +1045,16 @@ void Parser::AnnotateExistingDecltypeSpecifier(const DeclSpec& DS, SourceLocation StartLoc, SourceLocation EndLoc) { // make sure we have a token we can turn into an annotation token - if (PP.isBacktrackEnabled()) + if (PP.isBacktrackEnabled()) { PP.RevertCachedTokens(1); + if (DS.getTypeSpecType() == TST_error) { + // We encountered an error in parsing 'decltype(...)' so lets annotate all + // the tokens in the backtracking cache - that we likely had to skip over + // to get to a token that allows us to resume parsing, such as a + // semi-colon. + EndLoc = PP.getLastCachedTokenLocation(); + } + } else PP.EnterToken(Tok, /*IsReinject*/true); @@ -2707,23 +2715,23 @@ Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS, if (getLangOpts().MicrosoftExt && DeclaratorInfo.isDeclarationOfFunction()) TryConsumePureSpecifier(/*AllowDefinition*/ true); - FunctionDefinitionKind DefinitionKind = FDK_Declaration; + FunctionDefinitionKind DefinitionKind = FunctionDefinitionKind::Declaration; // function-definition: // // In C++11, a non-function declarator followed by an open brace is a // braced-init-list for an in-class member initialization, not an // erroneous function definition. if (Tok.is(tok::l_brace) && !getLangOpts().CPlusPlus11) { - DefinitionKind = FDK_Definition; + DefinitionKind = FunctionDefinitionKind::Definition; } else if (DeclaratorInfo.isFunctionDeclarator()) { if (Tok.isOneOf(tok::l_brace, tok::colon, tok::kw_try)) { - DefinitionKind = FDK_Definition; + DefinitionKind = FunctionDefinitionKind::Definition; } else if (Tok.is(tok::equal)) { const Token &KW = NextToken(); if (KW.is(tok::kw_default)) - DefinitionKind = FDK_Defaulted; + DefinitionKind = FunctionDefinitionKind::Defaulted; else if (KW.is(tok::kw_delete)) - DefinitionKind = FDK_Deleted; + DefinitionKind = FunctionDefinitionKind::Deleted; else if (KW.is(tok::code_completion)) { Actions.CodeCompleteAfterFunctionEquals(DeclaratorInfo); cutOffParsing(); @@ -2736,13 +2744,14 @@ Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS, // C++11 [dcl.attr.grammar] p4: If an attribute-specifier-seq appertains // to a friend declaration, that declaration shall be a definition. if (DeclaratorInfo.isFunctionDeclarator() && - DefinitionKind == FDK_Declaration && DS.isFriendSpecified()) { + DefinitionKind == FunctionDefinitionKind::Declaration && + DS.isFriendSpecified()) { // Diagnose attributes that appear before decl specifier: // [[]] friend int foo(); ProhibitAttributes(FnAttrs); } - if (DefinitionKind != FDK_Declaration) { + if (DefinitionKind != FunctionDefinitionKind::Declaration) { if (!DeclaratorInfo.isFunctionDeclarator()) { Diag(DeclaratorInfo.getIdentifierLoc(), diag::err_func_def_no_params); ConsumeBrace(); diff --git a/clang/lib/Parse/ParseExpr.cpp b/clang/lib/Parse/ParseExpr.cpp index 1475cc7..b3dae626 100644 --- a/clang/lib/Parse/ParseExpr.cpp +++ b/clang/lib/Parse/ParseExpr.cpp @@ -3414,7 +3414,7 @@ void Parser::ParseBlockId(SourceLocation CaretLoc) { // Parse the block-declarator. Declarator DeclaratorInfo(DS, DeclaratorContext::BlockLiteral); - DeclaratorInfo.setFunctionDefinitionKind(FDK_Definition); + DeclaratorInfo.setFunctionDefinitionKind(FunctionDefinitionKind::Definition); ParseDeclarator(DeclaratorInfo); MaybeParseGNUAttributes(DeclaratorInfo); @@ -3453,7 +3453,7 @@ ExprResult Parser::ParseBlockLiteralExpression() { // Parse the return type if present. DeclSpec DS(AttrFactory); Declarator ParamInfo(DS, DeclaratorContext::BlockLiteral); - ParamInfo.setFunctionDefinitionKind(FDK_Definition); + ParamInfo.setFunctionDefinitionKind(FunctionDefinitionKind::Definition); // FIXME: Since the return type isn't actually parsed, it can't be used to // fill ParamInfo with an initial valid range, so do it manually. ParamInfo.SetSourceRange(SourceRange(Tok.getLocation(), Tok.getLocation())); diff --git a/clang/lib/Parse/Parser.cpp b/clang/lib/Parse/Parser.cpp index 825e004..9b0f921 100644 --- a/clang/lib/Parse/Parser.cpp +++ b/clang/lib/Parse/Parser.cpp @@ -1228,7 +1228,7 @@ Decl *Parser::ParseFunctionDefinition(ParsingDeclarator &D, Scope::CompoundStmtScope); Scope *ParentScope = getCurScope()->getParent(); - D.setFunctionDefinitionKind(FDK_Definition); + D.setFunctionDefinitionKind(FunctionDefinitionKind::Definition); Decl *DP = Actions.HandleDeclarator(ParentScope, D, TemplateParameterLists); D.complete(DP); @@ -1259,7 +1259,7 @@ Decl *Parser::ParseFunctionDefinition(ParsingDeclarator &D, Scope::CompoundStmtScope); Scope *ParentScope = getCurScope()->getParent(); - D.setFunctionDefinitionKind(FDK_Definition); + D.setFunctionDefinitionKind(FunctionDefinitionKind::Definition); Decl *FuncDecl = Actions.HandleDeclarator(ParentScope, D, MultiTemplateParamsArg()); D.complete(FuncDecl); diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp index c78d37f..ce7475b 100644 --- a/clang/lib/Sema/SemaDecl.cpp +++ b/clang/lib/Sema/SemaDecl.cpp @@ -5543,7 +5543,7 @@ static bool RebuildDeclaratorInCurrentInstantiation(Sema &S, Declarator &D, } Decl *Sema::ActOnDeclarator(Scope *S, Declarator &D) { - D.setFunctionDefinitionKind(FDK_Declaration); + D.setFunctionDefinitionKind(FunctionDefinitionKind::Declaration); Decl *Dcl = HandleDeclarator(S, D, MultiTemplateParamsArg()); if (OriginalLexicalContext && OriginalLexicalContext->isObjCContainer() && @@ -9163,17 +9163,17 @@ Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC, // If a function is defined as defaulted or deleted, mark it as such now. // We'll do the relevant checks on defaulted / deleted functions later. switch (D.getFunctionDefinitionKind()) { - case FDK_Declaration: - case FDK_Definition: - break; + case FunctionDefinitionKind::Declaration: + case FunctionDefinitionKind::Definition: + break; - case FDK_Defaulted: - NewFD->setDefaulted(); - break; + case FunctionDefinitionKind::Defaulted: + NewFD->setDefaulted(); + break; - case FDK_Deleted: - NewFD->setDeletedAsWritten(); - break; + case FunctionDefinitionKind::Deleted: + NewFD->setDeletedAsWritten(); + break; } if (isa(NewFD) && DC == CurContext && @@ -9874,17 +9874,17 @@ Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC, // because Sema::ActOnStartOfFunctionDef has not been called yet. if (const auto *NBA = NewFD->getAttr()) switch (D.getFunctionDefinitionKind()) { - case FDK_Defaulted: - case FDK_Deleted: + case FunctionDefinitionKind::Defaulted: + case FunctionDefinitionKind::Deleted: Diag(NBA->getLocation(), diag::err_attribute_no_builtin_on_defaulted_deleted_function) << NBA->getSpelling(); break; - case FDK_Declaration: + case FunctionDefinitionKind::Declaration: Diag(NBA->getLocation(), diag::err_attribute_no_builtin_on_non_definition) << NBA->getSpelling(); break; - case FDK_Definition: + case FunctionDefinitionKind::Definition: break; } @@ -13789,7 +13789,7 @@ Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Declarator &D, ActOnStartOfFunctionDefinitionInOpenMPDeclareVariantScope( ParentScope, D, TemplateParameterLists, Bases); - D.setFunctionDefinitionKind(FDK_Definition); + D.setFunctionDefinitionKind(FunctionDefinitionKind::Definition); Decl *DP = HandleDeclarator(ParentScope, D, TemplateParameterLists); Decl *Dcl = ActOnStartOfFunctionDef(FnBodyScope, DP, SkipBody); diff --git a/clang/lib/Sema/SemaOpenMP.cpp b/clang/lib/Sema/SemaOpenMP.cpp index b882ecc..63ea297 100644 --- a/clang/lib/Sema/SemaOpenMP.cpp +++ b/clang/lib/Sema/SemaOpenMP.cpp @@ -5942,7 +5942,7 @@ void Sema::ActOnStartOfFunctionDefinitionInOpenMPDeclareVariantScope( llvm::omp::TraitProperty::implementation_extension_disable_implicit_base); // If no base was found we create a declaration that we use as base. if (Bases.empty() && UseImplicitBase) { - D.setFunctionDefinitionKind(FDK_Declaration); + D.setFunctionDefinitionKind(FunctionDefinitionKind::Declaration); Decl *BaseD = HandleDeclarator(S, D, TemplateParamLists); BaseD->setImplicit(true); if (auto *BaseTemplD = dyn_cast(BaseD)) diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp index 3fb2e65..a8ba064 100644 --- a/clang/lib/Sema/SemaType.cpp +++ b/clang/lib/Sema/SemaType.cpp @@ -3593,10 +3593,9 @@ static void warnAboutAmbiguousFunction(Sema &S, Declarator &D, // Only warn if this declarator is declaring a function at block scope, and // doesn't have a storage class (such as 'extern') specified. if (!D.isFunctionDeclarator() || - D.getFunctionDefinitionKind() != FDK_Declaration || + D.getFunctionDefinitionKind() != FunctionDefinitionKind::Declaration || !S.CurContext->isFunctionOrMethod() || - D.getDeclSpec().getStorageClassSpec() - != DeclSpec::SCS_unspecified) + D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_unspecified) return; // Inside a condition, a direct initializer is not permitted. We allow one to @@ -5050,7 +5049,8 @@ static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state, !(S.getLangOpts().CPlusPlus && (T->isDependentType() || T->isRecordType()))) { if (T->isVoidType() && !S.getLangOpts().CPlusPlus && - D.getFunctionDefinitionKind() == FDK_Definition) { + D.getFunctionDefinitionKind() == + FunctionDefinitionKind::Definition) { // [6.9.1/3] qualified void return is invalid on a C // function definition. Apparently ok on declarations and // in C++ though (!) @@ -5421,7 +5421,8 @@ static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state, // The empty list in a function declarator that is not part of a definition // of that function specifies that no information about the number or types // of the parameters is supplied. - if (!LangOpts.CPlusPlus && D.getFunctionDefinitionKind() == FDK_Declaration) { + if (!LangOpts.CPlusPlus && + D.getFunctionDefinitionKind() == FunctionDefinitionKind::Declaration) { bool IsBlock = false; for (const DeclaratorChunk &DeclType : D.type_objects()) { switch (DeclType.Kind) {