[clang] d0dcfd4 - [clang][NFC] Convert `Sema::VarArgKind` to scoped enum
Vlad Serebrennikov via cfe-commits
cfe-commits at lists.llvm.org
Fri May 2 01:24:15 PDT 2025
Author: Vlad Serebrennikov
Date: 2025-05-02T11:24:08+03:00
New Revision: d0dcfd4c68171c3b9b863626c08efa7f38cd0c54
URL: https://github.com/llvm/llvm-project/commit/d0dcfd4c68171c3b9b863626c08efa7f38cd0c54
DIFF: https://github.com/llvm/llvm-project/commit/d0dcfd4c68171c3b9b863626c08efa7f38cd0c54.diff
LOG: [clang][NFC] Convert `Sema::VarArgKind` to scoped enum
Added:
Modified:
clang/include/clang/Sema/Sema.h
clang/lib/Sema/SemaChecking.cpp
clang/lib/Sema/SemaExpr.cpp
Removed:
################################################################################
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index b52754bd531f1..e0abc0a3193ac 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -667,6 +667,16 @@ enum class ArithConvKind {
CompAssign,
};
+// Used for determining in which context a type is allowed to be passed to a
+// vararg function.
+enum class VarArgKind {
+ Valid,
+ ValidInCXX11,
+ Undefined,
+ MSVCUndefined,
+ Invalid
+};
+
/// Sema - This implements semantic analysis and AST building for C.
/// \nosubgrouping
class Sema final : public SemaBase {
@@ -7722,16 +7732,6 @@ class Sema final : public SemaBase {
const FunctionProtoType *Proto,
Expr *Fn);
- // Used for determining in which context a type is allowed to be passed to a
- // vararg function.
- enum VarArgKind {
- VAK_Valid,
- VAK_ValidInCXX11,
- VAK_Undefined,
- VAK_MSVCUndefined,
- VAK_Invalid
- };
-
/// Determine the degree of POD-ness for an expression.
/// Incomplete types are considered POD, since this check can be performed
/// when we're in an unevaluated context.
diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp
index 6847e9d3028bc..97f623f61a405 100644
--- a/clang/lib/Sema/SemaChecking.cpp
+++ b/clang/lib/Sema/SemaChecking.cpp
@@ -8306,8 +8306,8 @@ CheckPrintfHandler::checkFormatExpr(const analyze_printf::PrintfSpecifier &FS,
// arguments here.
bool EmitTypeMismatch = false;
switch (S.isValidVarArgType(ExprTy)) {
- case Sema::VAK_Valid:
- case Sema::VAK_ValidInCXX11: {
+ case VarArgKind::Valid:
+ case VarArgKind::ValidInCXX11: {
unsigned Diag;
switch (Match) {
case ArgType::Match:
@@ -8332,8 +8332,8 @@ CheckPrintfHandler::checkFormatExpr(const analyze_printf::PrintfSpecifier &FS,
E->getBeginLoc(), /*IsStringLocation*/ false, CSR);
break;
}
- case Sema::VAK_Undefined:
- case Sema::VAK_MSVCUndefined:
+ case VarArgKind::Undefined:
+ case VarArgKind::MSVCUndefined:
if (CallType == VariadicCallType::DoesNotApply) {
EmitTypeMismatch = true;
} else {
@@ -8347,7 +8347,7 @@ CheckPrintfHandler::checkFormatExpr(const analyze_printf::PrintfSpecifier &FS,
}
break;
- case Sema::VAK_Invalid:
+ case VarArgKind::Invalid:
if (CallType == VariadicCallType::DoesNotApply)
EmitTypeMismatch = true;
else if (ExprTy->isObjCObjectType())
diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp
index 4628fb9fe2225..38b04e7c2802b 100644
--- a/clang/lib/Sema/SemaExpr.cpp
+++ b/clang/lib/Sema/SemaExpr.cpp
@@ -951,7 +951,7 @@ ExprResult Sema::DefaultArgumentPromotion(Expr *E) {
return E;
}
-Sema::VarArgKind Sema::isValidVarArgType(const QualType &Ty) {
+VarArgKind Sema::isValidVarArgType(const QualType &Ty) {
if (Ty->isIncompleteType()) {
// C++11 [expr.call]p7:
// After these conversions, if the argument does not have arithmetic,
@@ -962,23 +962,23 @@ Sema::VarArgKind Sema::isValidVarArgType(const QualType &Ty) {
// decay and function-to-pointer decay, the only such type in C++ is cv
// void. This also handles initializer lists as variadic arguments.
if (Ty->isVoidType())
- return VAK_Invalid;
+ return VarArgKind::Invalid;
if (Ty->isObjCObjectType())
- return VAK_Invalid;
- return VAK_Valid;
+ return VarArgKind::Invalid;
+ return VarArgKind::Valid;
}
if (Ty.isDestructedType() == QualType::DK_nontrivial_c_struct)
- return VAK_Invalid;
+ return VarArgKind::Invalid;
if (Context.getTargetInfo().getTriple().isWasm() &&
Ty.isWebAssemblyReferenceType()) {
- return VAK_Invalid;
+ return VarArgKind::Invalid;
}
if (Ty.isCXX98PODType(Context))
- return VAK_Valid;
+ return VarArgKind::Valid;
// C++11 [expr.call]p7:
// Passing a potentially-evaluated argument of class type (Clause 9)
@@ -990,26 +990,26 @@ Sema::VarArgKind Sema::isValidVarArgType(const QualType &Ty) {
if (!Record->hasNonTrivialCopyConstructor() &&
!Record->hasNonTrivialMoveConstructor() &&
!Record->hasNonTrivialDestructor())
- return VAK_ValidInCXX11;
+ return VarArgKind::ValidInCXX11;
if (getLangOpts().ObjCAutoRefCount && Ty->isObjCLifetimeType())
- return VAK_Valid;
+ return VarArgKind::Valid;
if (Ty->isObjCObjectType())
- return VAK_Invalid;
+ return VarArgKind::Invalid;
if (getLangOpts().HLSL && Ty->getAs<HLSLAttributedResourceType>())
- return VAK_Valid;
+ return VarArgKind::Valid;
if (getLangOpts().MSVCCompat)
- return VAK_MSVCUndefined;
+ return VarArgKind::MSVCUndefined;
if (getLangOpts().HLSL && Ty->getAs<HLSLAttributedResourceType>())
- return VAK_Valid;
+ return VarArgKind::Valid;
// FIXME: In C++11, these cases are conditionally-supported, meaning we're
// permitted to reject them. We should consider doing so.
- return VAK_Undefined;
+ return VarArgKind::Undefined;
}
void Sema::checkVariadicArgument(const Expr *E, VariadicCallType CT) {
@@ -1019,12 +1019,12 @@ void Sema::checkVariadicArgument(const Expr *E, VariadicCallType CT) {
// Complain about passing non-POD types through varargs.
switch (VAK) {
- case VAK_ValidInCXX11:
+ case VarArgKind::ValidInCXX11:
DiagRuntimeBehavior(
E->getBeginLoc(), nullptr,
PDiag(diag::warn_cxx98_compat_pass_non_pod_arg_to_vararg) << Ty << CT);
[[fallthrough]];
- case VAK_Valid:
+ case VarArgKind::Valid:
if (Ty->isRecordType()) {
// This is unlikely to be what the user intended. If the class has a
// 'c_str' member function, the user probably meant to call that.
@@ -1034,14 +1034,14 @@ void Sema::checkVariadicArgument(const Expr *E, VariadicCallType CT) {
}
break;
- case VAK_Undefined:
- case VAK_MSVCUndefined:
+ case VarArgKind::Undefined:
+ case VarArgKind::MSVCUndefined:
DiagRuntimeBehavior(E->getBeginLoc(), nullptr,
PDiag(diag::warn_cannot_pass_non_pod_arg_to_vararg)
<< getLangOpts().CPlusPlus11 << Ty << CT);
break;
- case VAK_Invalid:
+ case VarArgKind::Invalid:
if (Ty.isDestructedType() == QualType::DK_nontrivial_c_struct)
Diag(E->getBeginLoc(),
diag::err_cannot_pass_non_trivial_c_struct_to_vararg)
@@ -1087,7 +1087,7 @@ ExprResult Sema::DefaultVariadicArgumentPromotion(Expr *E, VariadicCallType CT,
// Diagnostics regarding non-POD argument types are
// emitted along with format string checking in Sema::CheckFunctionCall().
- if (isValidVarArgType(E->getType()) == VAK_Undefined) {
+ if (isValidVarArgType(E->getType()) == VarArgKind::Undefined) {
// Turn this into a trap.
CXXScopeSpec SS;
SourceLocation TemplateKWLoc;
More information about the cfe-commits
mailing list