[clang] 6e63b68 - [clang][NFC] Convert `Sema::OverloadKind` to scoped enum
Vlad Serebrennikov via cfe-commits
cfe-commits at lists.llvm.org
Fri May 2 03:44:38 PDT 2025
Author: Vlad Serebrennikov
Date: 2025-05-02T13:44:32+03:00
New Revision: 6e63b68389983194b5007d8d489e74d1ffcea500
URL: https://github.com/llvm/llvm-project/commit/6e63b68389983194b5007d8d489e74d1ffcea500
DIFF: https://github.com/llvm/llvm-project/commit/6e63b68389983194b5007d8d489e74d1ffcea500.diff
LOG: [clang][NFC] Convert `Sema::OverloadKind` to scoped enum
Added:
Modified:
clang/include/clang/Sema/Sema.h
clang/lib/Sema/SemaDecl.cpp
clang/lib/Sema/SemaDeclCXX.cpp
clang/lib/Sema/SemaOverload.cpp
Removed:
################################################################################
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index 9896caaf41a5f..41582096f7dc1 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -804,6 +804,20 @@ enum class CorrectTypoKind {
ErrorRecovery // CorrectTypo used in normal error recovery.
};
+enum class OverloadKind {
+ /// This is a legitimate overload: the existing declarations are
+ /// functions or function templates with
diff erent signatures.
+ Overload,
+
+ /// This is not an overload because the signature exactly matches
+ /// an existing declaration.
+ Match,
+
+ /// This is not an overload because the lookup results contain a
+ /// non-function.
+ NonFunction
+};
+
/// Sema - This implements semantic analysis and AST building for C.
/// \nosubgrouping
class Sema final : public SemaBase {
@@ -9987,28 +10001,14 @@ class Sema final : public SemaBase {
/// if Sema is already doing so, which would cause infinite recursions.
bool IsBuildingRecoveryCallExpr;
- enum OverloadKind {
- /// This is a legitimate overload: the existing declarations are
- /// functions or function templates with
diff erent signatures.
- Ovl_Overload,
-
- /// This is not an overload because the signature exactly matches
- /// an existing declaration.
- Ovl_Match,
-
- /// This is not an overload because the lookup results contain a
- /// non-function.
- Ovl_NonFunction
- };
-
/// Determine whether the given New declaration is an overload of the
- /// declarations in Old. This routine returns Ovl_Match or Ovl_NonFunction if
- /// New and Old cannot be overloaded, e.g., if New has the same signature as
- /// some function in Old (C++ 1.3.10) or if the Old declarations aren't
- /// functions (or function templates) at all. When it does return Ovl_Match or
- /// Ovl_NonFunction, MatchedDecl will point to the decl that New cannot be
- /// overloaded with. This decl may be a UsingShadowDecl on top of the
- /// underlying declaration.
+ /// declarations in Old. This routine returns OverloadKind::Match or
+ /// OverloadKind::NonFunction if New and Old cannot be overloaded, e.g., if
+ /// New has the same signature as some function in Old (C++ 1.3.10) or if the
+ /// Old declarations aren't functions (or function templates) at all. When it
+ /// does return OverloadKind::Match or OverloadKind::NonFunction, MatchedDecl
+ /// will point to the decl that New cannot be overloaded with. This decl may
+ /// be a UsingShadowDecl on top of the underlying declaration.
///
/// Example: Given the following input:
///
@@ -10021,14 +10021,15 @@ class Sema final : public SemaBase {
///
/// When we process #2, Old contains only the FunctionDecl for #1. By
/// comparing the parameter types, we see that #1 and #2 are overloaded (since
- /// they have
diff erent signatures), so this routine returns Ovl_Overload;
- /// MatchedDecl is unchanged.
+ /// they have
diff erent signatures), so this routine returns
+ /// OverloadKind::Overload; MatchedDecl is unchanged.
///
/// When we process #3, Old is an overload set containing #1 and #2. We
/// compare the signatures of #3 to #1 (they're overloaded, so we do nothing)
/// and then #3 to #2. Since the signatures of #3 and #2 are identical (return
/// types of functions are not part of the signature), IsOverload returns
- /// Ovl_Match and MatchedDecl will be set to point to the FunctionDecl for #2.
+ /// OverloadKind::Match and MatchedDecl will be set to point to the
+ /// FunctionDecl for #2.
///
/// 'NewIsUsingShadowDecl' indicates that 'New' is being introduced into a
/// class by a using declaration. The rules for whether to hide shadow
diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp
index 329013471c934..829207b4cf910 100644
--- a/clang/lib/Sema/SemaDecl.cpp
+++ b/clang/lib/Sema/SemaDecl.cpp
@@ -12032,15 +12032,15 @@ bool Sema::CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD,
MayNeedOverloadableChecks = true;
switch (CheckOverload(S, NewFD, Previous, OldDecl,
/*NewIsUsingDecl*/ false)) {
- case Ovl_Match:
+ case OverloadKind::Match:
Redeclaration = true;
break;
- case Ovl_NonFunction:
+ case OverloadKind::NonFunction:
Redeclaration = true;
break;
- case Ovl_Overload:
+ case OverloadKind::Overload:
Redeclaration = false;
break;
}
diff --git a/clang/lib/Sema/SemaDeclCXX.cpp b/clang/lib/Sema/SemaDeclCXX.cpp
index 55e2129bf46a2..6e6e39acc1cb3 100644
--- a/clang/lib/Sema/SemaDeclCXX.cpp
+++ b/clang/lib/Sema/SemaDeclCXX.cpp
@@ -12797,15 +12797,15 @@ bool Sema::CheckUsingShadowDecl(BaseUsingDecl *BUD, NamedDecl *Orig,
NamedDecl *OldDecl = nullptr;
switch (CheckOverload(nullptr, FD, Previous, OldDecl,
/*IsForUsingDecl*/ true)) {
- case Ovl_Overload:
+ case OverloadKind::Overload:
return false;
- case Ovl_NonFunction:
+ case OverloadKind::NonFunction:
Diag(BUD->getLocation(), diag::err_using_decl_conflict);
break;
// We found a decl with the exact signature.
- case Ovl_Match:
+ case OverloadKind::Match:
// If we're in a record, we want to hide the target, so we
// return true (without a diagnostic) to tell the caller not to
// build a shadow decl.
diff --git a/clang/lib/Sema/SemaOverload.cpp b/clang/lib/Sema/SemaOverload.cpp
index de2382ffdf1e8..ead87ab8236e9 100644
--- a/clang/lib/Sema/SemaOverload.cpp
+++ b/clang/lib/Sema/SemaOverload.cpp
@@ -1200,9 +1200,9 @@ static bool checkArgPlaceholdersForOverload(Sema &S, MultiExprArg Args,
return false;
}
-Sema::OverloadKind
-Sema::CheckOverload(Scope *S, FunctionDecl *New, const LookupResult &Old,
- NamedDecl *&Match, bool NewIsUsingDecl) {
+OverloadKind Sema::CheckOverload(Scope *S, FunctionDecl *New,
+ const LookupResult &Old, NamedDecl *&Match,
+ bool NewIsUsingDecl) {
for (LookupResult::iterator I = Old.begin(), E = Old.end();
I != E; ++I) {
NamedDecl *OldD = *I;
@@ -1244,14 +1244,14 @@ Sema::CheckOverload(Scope *S, FunctionDecl *New, const LookupResult &Old,
continue;
Match = *I;
- return Ovl_Match;
+ return OverloadKind::Match;
}
// Builtins that have custom typechecking or have a reference should
// not be overloadable or redeclarable.
if (!getASTContext().canBuiltinBeRedeclared(OldF)) {
Match = *I;
- return Ovl_NonFunction;
+ return OverloadKind::NonFunction;
}
} else if (isa<UsingDecl>(OldD) || isa<UsingPackDecl>(OldD)) {
// We can overload with these, which can show up when doing
@@ -1268,14 +1268,14 @@ Sema::CheckOverload(Scope *S, FunctionDecl *New, const LookupResult &Old,
// member, the using declaration can only introduce an enumerator.
if (UUD->getQualifier()->isDependent() && !UUD->isCXXClassMember()) {
Match = *I;
- return Ovl_NonFunction;
+ return OverloadKind::NonFunction;
}
} else {
// (C++ 13p1):
// Only function declarations can be overloaded; object and type
// declarations cannot be overloaded.
Match = *I;
- return Ovl_NonFunction;
+ return OverloadKind::NonFunction;
}
}
@@ -1303,14 +1303,14 @@ Sema::CheckOverload(Scope *S, FunctionDecl *New, const LookupResult &Old,
if (CheckFunctionTemplateSpecialization(New, nullptr, TemplateSpecResult,
/*QualifiedFriend*/true)) {
New->setInvalidDecl();
- return Ovl_Overload;
+ return OverloadKind::Overload;
}
Match = TemplateSpecResult.getAsSingle<FunctionDecl>();
- return Ovl_Match;
+ return OverloadKind::Match;
}
- return Ovl_Overload;
+ return OverloadKind::Overload;
}
template <typename AttrT> static bool hasExplicitAttr(const FunctionDecl *D) {
More information about the cfe-commits
mailing list