[clang] [clang][NFC] Clean up SemaChecking.cpp (PR #141041)
Timm Baeder via cfe-commits
cfe-commits at lists.llvm.org
Thu May 22 04:17:16 PDT 2025
https://github.com/tbaederr created https://github.com/llvm/llvm-project/pull/141041
Make pointer parameters const, remove some unused parameters, fix coding style, etc.
>From a79f0474700c1b96b98ef4d05c30816b48742e5e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Timm=20B=C3=A4der?= <tbaeder at redhat.com>
Date: Thu, 22 May 2025 13:15:36 +0200
Subject: [PATCH] [clang][NFC] Clean up SemaChecking.cpp
---
clang/include/clang/Sema/Sema.h | 7 +-
clang/include/clang/Sema/SemaObjC.h | 2 +-
clang/lib/Sema/SemaChecking.cpp | 145 ++++++++++++++--------------
clang/lib/Sema/SemaObjC.cpp | 4 +-
4 files changed, 77 insertions(+), 81 deletions(-)
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index a994b845e11fc..331601e301365 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -2604,8 +2604,8 @@ class Sema final : public SemaBase {
/// Check for comparisons of floating-point values using == and !=. Issue a
/// warning if the comparison is not likely to do what the programmer
/// intended.
- void CheckFloatComparison(SourceLocation Loc, Expr *LHS, Expr *RHS,
- BinaryOperatorKind Opcode);
+ void CheckFloatComparison(SourceLocation Loc, const Expr *LHS,
+ const Expr *RHS, BinaryOperatorKind Opcode);
/// Register a magic integral constant to be used as a type tag.
void RegisterTypeTagForDatatype(const IdentifierInfo *ArgumentKind,
@@ -3013,7 +3013,8 @@ class Sema final : public SemaBase {
// Warn on anti-patterns as the 'size' argument to strncat.
// The correct size argument should look like following:
// strncat(dst, src, sizeof(dst) - strlen(dest) - 1);
- void CheckStrncatArguments(const CallExpr *Call, IdentifierInfo *FnName);
+ void CheckStrncatArguments(const CallExpr *Call,
+ const IdentifierInfo *FnName);
/// Alerts the user that they are attempting to free a non-malloc'd object.
void CheckFreeArguments(const CallExpr *E);
diff --git a/clang/include/clang/Sema/SemaObjC.h b/clang/include/clang/Sema/SemaObjC.h
index 4cda41a82b61f..b629c6d291402 100644
--- a/clang/include/clang/Sema/SemaObjC.h
+++ b/clang/include/clang/Sema/SemaObjC.h
@@ -170,7 +170,7 @@ class SemaObjC : public SemaBase {
bool isSignedCharBool(QualType Ty);
void adornBoolConversionDiagWithTernaryFixit(
- Expr *SourceExpr, const Sema::SemaDiagnosticBuilder &Builder);
+ const Expr *SourceExpr, const Sema::SemaDiagnosticBuilder &Builder);
/// Check an Objective-C dictionary literal being converted to the given
/// target type.
diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp
index a960b9931ddfd..f50c6172bc200 100644
--- a/clang/lib/Sema/SemaChecking.cpp
+++ b/clang/lib/Sema/SemaChecking.cpp
@@ -9358,10 +9358,10 @@ void Sema::CheckMaxUnsignedZero(const CallExpr *Call,
///
/// This is to catch typos like `if (memcmp(&a, &b, sizeof(a) > 0))`.
static bool CheckMemorySizeofForComparison(Sema &S, const Expr *E,
- IdentifierInfo *FnName,
+ const IdentifierInfo *FnName,
SourceLocation FnLoc,
SourceLocation RParenLoc) {
- const BinaryOperator *Size = dyn_cast<BinaryOperator>(E);
+ const auto *Size = dyn_cast<BinaryOperator>(E);
if (!Size)
return false;
@@ -9955,7 +9955,7 @@ static const Expr *getStrlenExprArg(const Expr *E) {
}
void Sema::CheckStrncatArguments(const CallExpr *CE,
- IdentifierInfo *FnName) {
+ const IdentifierInfo *FnName) {
// Don't crash if the user has the wrong number of arguments.
if (CE->getNumArgs() < 3)
return;
@@ -10050,7 +10050,7 @@ void CheckFreeArgumentsAddressof(Sema &S, const std::string &CalleeName,
const UnaryOperator *UnaryExpr) {
if (const auto *Lvalue = dyn_cast<DeclRefExpr>(UnaryExpr->getSubExpr())) {
const Decl *D = Lvalue->getDecl();
- if (auto *DD = dyn_cast<DeclaratorDecl>(D)) {
+ if (const auto *DD = dyn_cast<DeclaratorDecl>(D)) {
if (!DD->getType()->isReferenceType())
return CheckFreeArgumentsOnLvalue(S, CalleeName, UnaryExpr, D);
}
@@ -10190,15 +10190,15 @@ Sema::CheckReturnValExpr(Expr *RetValExp, QualType lhsType,
PPC().CheckPPCMMAType(RetValExp->getType(), ReturnLoc);
}
-void Sema::CheckFloatComparison(SourceLocation Loc, Expr *LHS, Expr *RHS,
- BinaryOperatorKind Opcode) {
+void Sema::CheckFloatComparison(SourceLocation Loc, const Expr *LHS,
+ const Expr *RHS, BinaryOperatorKind Opcode) {
if (!BinaryOperator::isEqualityOp(Opcode))
return;
// Match and capture subexpressions such as "(float) X == 0.1".
- FloatingLiteral *FPLiteral;
- CastExpr *FPCast;
- auto getCastAndLiteral = [&FPLiteral, &FPCast](Expr *L, Expr *R) {
+ const FloatingLiteral *FPLiteral;
+ const CastExpr *FPCast;
+ auto getCastAndLiteral = [&FPLiteral, &FPCast](const Expr *L, const Expr *R) {
FPLiteral = dyn_cast<FloatingLiteral>(L->IgnoreParens());
FPCast = dyn_cast<CastExpr>(R->IgnoreParens());
return FPLiteral && FPCast;
@@ -10225,13 +10225,13 @@ void Sema::CheckFloatComparison(SourceLocation Loc, Expr *LHS, Expr *RHS,
}
// Match a more general floating-point equality comparison (-Wfloat-equal).
- Expr* LeftExprSansParen = LHS->IgnoreParenImpCasts();
- Expr* RightExprSansParen = RHS->IgnoreParenImpCasts();
+ const Expr *LeftExprSansParen = LHS->IgnoreParenImpCasts();
+ const Expr *RightExprSansParen = RHS->IgnoreParenImpCasts();
// Special case: check for x == x (which is OK).
// Do not emit warnings for such cases.
- if (auto *DRL = dyn_cast<DeclRefExpr>(LeftExprSansParen))
- if (auto *DRR = dyn_cast<DeclRefExpr>(RightExprSansParen))
+ if (const auto *DRL = dyn_cast<DeclRefExpr>(LeftExprSansParen))
+ if (const auto *DRR = dyn_cast<DeclRefExpr>(RightExprSansParen))
if (DRL->getDecl() == DRR->getDecl())
return;
@@ -10240,22 +10240,21 @@ void Sema::CheckFloatComparison(SourceLocation Loc, Expr *LHS, Expr *RHS,
// is a heuristic: often comparison against such literals are used to
// detect if a value in a variable has not changed. This clearly can
// lead to false negatives.
- if (FloatingLiteral* FLL = dyn_cast<FloatingLiteral>(LeftExprSansParen)) {
+ if (const auto *FLL = dyn_cast<FloatingLiteral>(LeftExprSansParen)) {
if (FLL->isExact())
return;
- } else
- if (FloatingLiteral* FLR = dyn_cast<FloatingLiteral>(RightExprSansParen))
- if (FLR->isExact())
- return;
+ } else if (const auto *FLR = dyn_cast<FloatingLiteral>(RightExprSansParen))
+ if (FLR->isExact())
+ return;
// Check for comparisons with builtin types.
- if (CallExpr* CL = dyn_cast<CallExpr>(LeftExprSansParen))
- if (CL->getBuiltinCallee())
- return;
+ if (const auto *CL = dyn_cast<CallExpr>(LeftExprSansParen);
+ CL && CL->getBuiltinCallee())
+ return;
- if (CallExpr* CR = dyn_cast<CallExpr>(RightExprSansParen))
- if (CR->getBuiltinCallee())
- return;
+ if (const auto *CR = dyn_cast<CallExpr>(RightExprSansParen);
+ CR && CR->getBuiltinCallee())
+ return;
// Emit the diagnostic.
Diag(Loc, diag::warn_floatingpoint_eq)
@@ -10302,18 +10301,18 @@ struct IntRange {
static IntRange forValueOfCanonicalType(ASTContext &C, const Type *T) {
assert(T->isCanonicalUnqualified());
- if (const VectorType *VT = dyn_cast<VectorType>(T))
+ if (const auto *VT = dyn_cast<VectorType>(T))
T = VT->getElementType().getTypePtr();
- if (const ComplexType *CT = dyn_cast<ComplexType>(T))
+ if (const auto *CT = dyn_cast<ComplexType>(T))
T = CT->getElementType().getTypePtr();
- if (const AtomicType *AT = dyn_cast<AtomicType>(T))
+ if (const auto *AT = dyn_cast<AtomicType>(T))
T = AT->getValueType().getTypePtr();
if (!C.getLangOpts().CPlusPlus) {
// For enum types in C code, use the underlying datatype.
- if (const EnumType *ET = dyn_cast<EnumType>(T))
+ if (const auto *ET = dyn_cast<EnumType>(T))
T = ET->getDecl()->getIntegerType().getDesugaredType(C).getTypePtr();
- } else if (const EnumType *ET = dyn_cast<EnumType>(T)) {
+ } else if (const auto *ET = dyn_cast<EnumType>(T)) {
// For enum types in C++, use the known bit width of the enumerators.
EnumDecl *Enum = ET->getDecl();
// In C++11, enums can have a fixed underlying type. Use this type to
@@ -10432,8 +10431,7 @@ struct IntRange {
} // namespace
-static IntRange GetValueRange(ASTContext &C, llvm::APSInt &value,
- unsigned MaxWidth) {
+static IntRange GetValueRange(llvm::APSInt &value, unsigned MaxWidth) {
if (value.isSigned() && value.isNegative())
return IntRange(value.getSignificantBits(), false);
@@ -10445,23 +10443,22 @@ static IntRange GetValueRange(ASTContext &C, llvm::APSInt &value,
return IntRange(value.getActiveBits(), true);
}
-static IntRange GetValueRange(ASTContext &C, APValue &result, QualType Ty,
- unsigned MaxWidth) {
+static IntRange GetValueRange(APValue &result, QualType Ty, unsigned MaxWidth) {
if (result.isInt())
- return GetValueRange(C, result.getInt(), MaxWidth);
+ return GetValueRange(result.getInt(), MaxWidth);
if (result.isVector()) {
- IntRange R = GetValueRange(C, result.getVectorElt(0), Ty, MaxWidth);
+ IntRange R = GetValueRange(result.getVectorElt(0), Ty, MaxWidth);
for (unsigned i = 1, e = result.getVectorLength(); i != e; ++i) {
- IntRange El = GetValueRange(C, result.getVectorElt(i), Ty, MaxWidth);
+ IntRange El = GetValueRange(result.getVectorElt(i), Ty, MaxWidth);
R = IntRange::join(R, El);
}
return R;
}
if (result.isComplexInt()) {
- IntRange R = GetValueRange(C, result.getComplexIntReal(), MaxWidth);
- IntRange I = GetValueRange(C, result.getComplexIntImag(), MaxWidth);
+ IntRange R = GetValueRange(result.getComplexIntReal(), MaxWidth);
+ IntRange I = GetValueRange(result.getComplexIntImag(), MaxWidth);
return IntRange::join(R, I);
}
@@ -10476,7 +10473,7 @@ static IntRange GetValueRange(ASTContext &C, APValue &result, QualType Ty,
static QualType GetExprType(const Expr *E) {
QualType Ty = E->getType();
- if (const AtomicType *AtomicRHS = Ty->getAs<AtomicType>())
+ if (const auto *AtomicRHS = Ty->getAs<AtomicType>())
Ty = AtomicRHS->getValueType();
return Ty;
}
@@ -10503,7 +10500,7 @@ static std::optional<IntRange> TryGetExprRange(ASTContext &C, const Expr *E,
// Try a full evaluation first.
Expr::EvalResult result;
if (E->EvaluateAsRValue(result, C, InConstantContext))
- return GetValueRange(C, result.Val, GetExprType(E), MaxWidth);
+ return GetValueRange(result.Val, GetExprType(E), MaxWidth);
// I think we only want to look through implicit casts here; if the
// user has an explicit widening cast, we should treat the value as
@@ -10856,10 +10853,9 @@ static bool IsSameFloatAfterCast(const APValue &value,
static void AnalyzeImplicitConversions(Sema &S, Expr *E, SourceLocation CC,
bool IsListInit = false);
-static bool IsEnumConstOrFromMacro(Sema &S, Expr *E) {
+static bool IsEnumConstOrFromMacro(Sema &S, const Expr *E) {
// Suppress cases where we are comparing against an enum constant.
- if (const DeclRefExpr *DR =
- dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts()))
+ if (const auto *DR = dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts()))
if (isa<EnumConstantDecl>(DR->getDecl()))
return true;
@@ -10877,7 +10873,7 @@ static bool IsEnumConstOrFromMacro(Sema &S, Expr *E) {
return false;
}
-static bool isKnownToHaveUnsignedValue(Expr *E) {
+static bool isKnownToHaveUnsignedValue(const Expr *E) {
return E->getType()->isIntegerType() &&
(!E->getType()->isSignedIntegerType() ||
!E->IgnoreParenImpCasts()->getType()->isSignedIntegerType());
@@ -11008,9 +11004,9 @@ struct PromotedRange {
};
}
-static bool HasEnumType(Expr *E) {
+static bool HasEnumType(const Expr *E) {
// Strip off implicit integral promotions.
- while (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
+ while (const auto *ICE = dyn_cast<ImplicitCastExpr>(E)) {
if (ICE->getCastKind() != CK_IntegralCast &&
ICE->getCastKind() != CK_NoOp)
break;
@@ -11128,7 +11124,7 @@ static bool CheckTautologicalComparison(Sema &S, BinaryOperator *E,
// If this is a comparison to an enum constant, include that
// constant in the diagnostic.
const EnumConstantDecl *ED = nullptr;
- if (const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(Constant))
+ if (const auto *DR = dyn_cast<DeclRefExpr>(Constant))
ED = dyn_cast<EnumConstantDecl>(DR->getDecl());
// Should be enough for uint128 (39 decimal digits)
@@ -11503,9 +11499,9 @@ static void AnalyzeAssignment(Sema &S, BinaryOperator *E) {
}
/// Diagnose an implicit cast; purely a helper for CheckImplicitConversion.
-static void DiagnoseImpCast(Sema &S, Expr *E, QualType SourceType, QualType T,
- SourceLocation CContext, unsigned diag,
- bool pruneControlFlow = false) {
+static void DiagnoseImpCast(Sema &S, const Expr *E, QualType SourceType,
+ QualType T, SourceLocation CContext, unsigned diag,
+ bool PruneControlFlow = false) {
// For languages like HLSL and OpenCL, implicit conversion diagnostics listing
// address space annotations isn't really useful. The warnings aren't because
// you're converting a `private int` to `unsigned int`, it is because you're
@@ -11514,7 +11510,7 @@ static void DiagnoseImpCast(Sema &S, Expr *E, QualType SourceType, QualType T,
SourceType = S.getASTContext().removeAddrSpaceQualType(SourceType);
if (T.hasAddressSpace())
T = S.getASTContext().removeAddrSpaceQualType(T);
- if (pruneControlFlow) {
+ if (PruneControlFlow) {
S.DiagRuntimeBehavior(E->getExprLoc(), E,
S.PDiag(diag)
<< SourceType << T << E->getSourceRange()
@@ -11526,26 +11522,25 @@ static void DiagnoseImpCast(Sema &S, Expr *E, QualType SourceType, QualType T,
}
/// Diagnose an implicit cast; purely a helper for CheckImplicitConversion.
-static void DiagnoseImpCast(Sema &S, Expr *E, QualType T,
- SourceLocation CContext,
- unsigned diag, bool pruneControlFlow = false) {
- DiagnoseImpCast(S, E, E->getType(), T, CContext, diag, pruneControlFlow);
+static void DiagnoseImpCast(Sema &S, const Expr *E, QualType T,
+ SourceLocation CContext, unsigned diag,
+ bool PruneControlFlow = false) {
+ DiagnoseImpCast(S, E, E->getType(), T, CContext, diag, PruneControlFlow);
}
/// Diagnose an implicit cast from a floating point value to an integer value.
-static void DiagnoseFloatingImpCast(Sema &S, Expr *E, QualType T,
+static void DiagnoseFloatingImpCast(Sema &S, const Expr *E, QualType T,
SourceLocation CContext) {
- const bool IsBool = T->isSpecificBuiltinType(BuiltinType::Bool);
- const bool PruneWarnings = S.inTemplateInstantiation();
+ bool IsBool = T->isSpecificBuiltinType(BuiltinType::Bool);
+ bool PruneWarnings = S.inTemplateInstantiation();
- Expr *InnerE = E->IgnoreParenImpCasts();
+ const Expr *InnerE = E->IgnoreParenImpCasts();
// We also want to warn on, e.g., "int i = -1.234"
- if (UnaryOperator *UOp = dyn_cast<UnaryOperator>(InnerE))
+ if (const auto *UOp = dyn_cast<UnaryOperator>(InnerE))
if (UOp->getOpcode() == UO_Minus || UOp->getOpcode() == UO_Plus)
InnerE = UOp->getSubExpr()->IgnoreParenImpCasts();
- const bool IsLiteral =
- isa<FloatingLiteral>(E) || isa<FloatingLiteral>(InnerE);
+ bool IsLiteral = isa<FloatingLiteral>(E) || isa<FloatingLiteral>(InnerE);
llvm::APFloat Value(0.0);
bool IsConstant =
@@ -11703,37 +11698,37 @@ static std::string PrettyPrintInRange(const llvm::APSInt &Value,
return toString(ValueInRange, 10);
}
-static bool IsImplicitBoolFloatConversion(Sema &S, Expr *Ex, bool ToBool) {
+static bool IsImplicitBoolFloatConversion(Sema &S, const Expr *Ex,
+ bool ToBool) {
if (!isa<ImplicitCastExpr>(Ex))
return false;
- Expr *InnerE = Ex->IgnoreParenImpCasts();
+ const Expr *InnerE = Ex->IgnoreParenImpCasts();
const Type *Target = S.Context.getCanonicalType(Ex->getType()).getTypePtr();
const Type *Source =
S.Context.getCanonicalType(InnerE->getType()).getTypePtr();
if (Target->isDependentType())
return false;
- const BuiltinType *FloatCandidateBT =
- dyn_cast<BuiltinType>(ToBool ? Source : Target);
+ const auto *FloatCandidateBT =
+ dyn_cast<BuiltinType>(ToBool ? Source : Target);
const Type *BoolCandidateType = ToBool ? Target : Source;
return (BoolCandidateType->isSpecificBuiltinType(BuiltinType::Bool) &&
FloatCandidateBT && (FloatCandidateBT->isFloatingPoint()));
}
-static void CheckImplicitArgumentConversions(Sema &S, CallExpr *TheCall,
+static void CheckImplicitArgumentConversions(Sema &S, const CallExpr *TheCall,
SourceLocation CC) {
- unsigned NumArgs = TheCall->getNumArgs();
- for (unsigned i = 0; i < NumArgs; ++i) {
- Expr *CurrA = TheCall->getArg(i);
+ for (unsigned I = 0, N = TheCall->getNumArgs(); I < N; ++I) {
+ const Expr *CurrA = TheCall->getArg(I);
if (!IsImplicitBoolFloatConversion(S, CurrA, true))
continue;
- bool IsSwapped = ((i > 0) &&
- IsImplicitBoolFloatConversion(S, TheCall->getArg(i - 1), false));
- IsSwapped |= ((i < (NumArgs - 1)) &&
- IsImplicitBoolFloatConversion(S, TheCall->getArg(i + 1), false));
+ bool IsSwapped = ((I > 0) && IsImplicitBoolFloatConversion(
+ S, TheCall->getArg(I - 1), false));
+ IsSwapped |= ((I < (N - 1)) && IsImplicitBoolFloatConversion(
+ S, TheCall->getArg(I + 1), false));
if (IsSwapped) {
// Warn on this floating-point to bool conversion.
DiagnoseImpCast(S, CurrA->IgnoreParenImpCasts(),
@@ -12568,7 +12563,7 @@ static void AnalyzeImplicitConversions(
}
// Check implicit argument conversions for function calls.
- if (CallExpr *Call = dyn_cast<CallExpr>(SourceExpr))
+ if (const auto *Call = dyn_cast<CallExpr>(SourceExpr))
CheckImplicitArgumentConversions(S, Call, CC);
// Go ahead and check any implicit conversions we might have skipped.
diff --git a/clang/lib/Sema/SemaObjC.cpp b/clang/lib/Sema/SemaObjC.cpp
index 184f67ec270a5..56815cd2731a1 100644
--- a/clang/lib/Sema/SemaObjC.cpp
+++ b/clang/lib/Sema/SemaObjC.cpp
@@ -2314,8 +2314,8 @@ bool SemaObjC::isSignedCharBool(QualType Ty) {
}
void SemaObjC::adornBoolConversionDiagWithTernaryFixit(
- Expr *SourceExpr, const Sema::SemaDiagnosticBuilder &Builder) {
- Expr *Ignored = SourceExpr->IgnoreImplicit();
+ const Expr *SourceExpr, const Sema::SemaDiagnosticBuilder &Builder) {
+ const Expr *Ignored = SourceExpr->IgnoreImplicit();
if (const auto *OVE = dyn_cast<OpaqueValueExpr>(Ignored))
Ignored = OVE->getSourceExpr();
bool NeedsParens = isa<AbstractConditionalOperator>(Ignored) ||
More information about the cfe-commits
mailing list