[clang] d8ca85a - [clang][ExprConst] Remove Loc param (#151461)
via cfe-commits
cfe-commits at lists.llvm.org
Fri Aug 1 05:09:10 PDT 2025
Author: Timm Baeder
Date: 2025-08-01T14:09:06+02:00
New Revision: d8ca85a184c0fb511fe6483c4c24e48b5b1eb07a
URL: https://github.com/llvm/llvm-project/commit/d8ca85a184c0fb511fe6483c4c24e48b5b1eb07a
DIFF: https://github.com/llvm/llvm-project/commit/d8ca85a184c0fb511fe6483c4c24e48b5b1eb07a.diff
LOG: [clang][ExprConst] Remove Loc param (#151461)
The Loc param to these functions was weird and not always set in error
cases. It wasn't reliable to use.
This was almost entirely unused inside of clang and the one call site
that used the returned source location doesn't make a difference in
practice.
Added:
Modified:
clang/include/clang/AST/Expr.h
clang/lib/AST/ExprConstant.cpp
clang/lib/Sema/SemaDecl.cpp
Removed:
################################################################################
diff --git a/clang/include/clang/AST/Expr.h b/clang/include/clang/AST/Expr.h
index 6c124aa96cdb4..237b3b2cf7444 100644
--- a/clang/include/clang/AST/Expr.h
+++ b/clang/include/clang/AST/Expr.h
@@ -553,17 +553,13 @@ class Expr : public ValueStmt {
bool IgnoreTemplateOrMacroSubstitution = false) const;
/// isIntegerConstantExpr - Return the value if this expression is a valid
- /// integer constant expression. If not a valid i-c-e, return std::nullopt
- /// and fill in Loc (if specified) with the location of the invalid
- /// expression.
+ /// integer constant expression. If not a valid i-c-e, return std::nullopt.
///
/// Note: This does not perform the implicit conversions required by C++11
/// [expr.const]p5.
std::optional<llvm::APSInt>
- getIntegerConstantExpr(const ASTContext &Ctx,
- SourceLocation *Loc = nullptr) const;
- bool isIntegerConstantExpr(const ASTContext &Ctx,
- SourceLocation *Loc = nullptr) const;
+ getIntegerConstantExpr(const ASTContext &Ctx) const;
+ bool isIntegerConstantExpr(const ASTContext &Ctx) const;
/// isCXX98IntegralConstantExpr - Return true if this expression is an
/// integral constant expression in C++98. Can only be used in C++.
@@ -574,8 +570,8 @@ class Expr : public ValueStmt {
///
/// Note: This does not perform the implicit conversions required by C++11
/// [expr.const]p5.
- bool isCXX11ConstantExpr(const ASTContext &Ctx, APValue *Result = nullptr,
- SourceLocation *Loc = nullptr) const;
+ bool isCXX11ConstantExpr(const ASTContext &Ctx,
+ APValue *Result = nullptr) const;
/// isPotentialConstantExpr - Return true if this function's definition
/// might be usable in a constant expression in C++11, if it were marked
diff --git a/clang/lib/AST/ExprConstant.cpp b/clang/lib/AST/ExprConstant.cpp
index 993b64b2752e9..244fd92a1ac17 100644
--- a/clang/lib/AST/ExprConstant.cpp
+++ b/clang/lib/AST/ExprConstant.cpp
@@ -17312,8 +17312,7 @@ bool Expr::EvalResult::isGlobalLValue() const {
/// comma, etc
// CheckICE - This function does the fundamental ICE checking: the returned
-// ICEDiag contains an ICEKind indicating whether the expression is an ICE,
-// and a (possibly null) SourceLocation indicating the location of the problem.
+// ICEDiag contains an ICEKind indicating whether the expression is an ICE.
//
// Note that to reduce code duplication, this helper does no evaluation
// itself; the caller checks whether the expression is evaluatable, and
@@ -17777,46 +17776,38 @@ static ICEDiag CheckICE(const Expr* E, const ASTContext &Ctx) {
/// Evaluate an expression as a C++11 integral constant expression.
static bool EvaluateCPlusPlus11IntegralConstantExpr(const ASTContext &Ctx,
const Expr *E,
- llvm::APSInt *Value,
- SourceLocation *Loc) {
- if (!E->getType()->isIntegralOrUnscopedEnumerationType()) {
- if (Loc) *Loc = E->getExprLoc();
+ llvm::APSInt *Value) {
+ if (!E->getType()->isIntegralOrUnscopedEnumerationType())
return false;
- }
APValue Result;
- if (!E->isCXX11ConstantExpr(Ctx, &Result, Loc))
+ if (!E->isCXX11ConstantExpr(Ctx, &Result))
return false;
- if (!Result.isInt()) {
- if (Loc) *Loc = E->getExprLoc();
+ if (!Result.isInt())
return false;
- }
if (Value) *Value = Result.getInt();
return true;
}
-bool Expr::isIntegerConstantExpr(const ASTContext &Ctx,
- SourceLocation *Loc) const {
+bool Expr::isIntegerConstantExpr(const ASTContext &Ctx) const {
assert(!isValueDependent() &&
"Expression evaluator can't be called on a dependent expression.");
ExprTimeTraceScope TimeScope(this, Ctx, "isIntegerConstantExpr");
if (Ctx.getLangOpts().CPlusPlus11)
- return EvaluateCPlusPlus11IntegralConstantExpr(Ctx, this, nullptr, Loc);
+ return EvaluateCPlusPlus11IntegralConstantExpr(Ctx, this, nullptr);
ICEDiag D = CheckICE(this, Ctx);
- if (D.Kind != IK_ICE) {
- if (Loc) *Loc = D.Loc;
+ if (D.Kind != IK_ICE)
return false;
- }
return true;
}
std::optional<llvm::APSInt>
-Expr::getIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc) const {
+Expr::getIntegerConstantExpr(const ASTContext &Ctx) const {
if (isValueDependent()) {
// Expression evaluator can't succeed on a dependent expression.
return std::nullopt;
@@ -17825,12 +17816,12 @@ Expr::getIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc) const {
APSInt Value;
if (Ctx.getLangOpts().CPlusPlus11) {
- if (EvaluateCPlusPlus11IntegralConstantExpr(Ctx, this, &Value, Loc))
+ if (EvaluateCPlusPlus11IntegralConstantExpr(Ctx, this, &Value))
return Value;
return std::nullopt;
}
- if (!isIntegerConstantExpr(Ctx, Loc))
+ if (!isIntegerConstantExpr(Ctx))
return std::nullopt;
// The only possible side-effects here are due to UB discovered in the
@@ -17855,8 +17846,7 @@ bool Expr::isCXX98IntegralConstantExpr(const ASTContext &Ctx) const {
return CheckICE(this, Ctx).Kind == IK_ICE;
}
-bool Expr::isCXX11ConstantExpr(const ASTContext &Ctx, APValue *Result,
- SourceLocation *Loc) const {
+bool Expr::isCXX11ConstantExpr(const ASTContext &Ctx, APValue *Result) const {
assert(!isValueDependent() &&
"Expression evaluator can't be called on a dependent expression.");
@@ -17877,15 +17867,7 @@ bool Expr::isCXX11ConstantExpr(const ASTContext &Ctx, APValue *Result,
// call us on arbitrary full-expressions should generally not care.
Info.discardCleanups() && !Status.HasSideEffects;
- if (!Diags.empty()) {
- IsConstExpr = false;
- if (Loc) *Loc = Diags[0].first;
- } else if (!IsConstExpr) {
- // FIXME: This shouldn't happen.
- if (Loc) *Loc = getExprLoc();
- }
-
- return IsConstExpr;
+ return IsConstExpr && Diags.empty();
}
bool Expr::EvaluateWithSubstitution(APValue &Value, ASTContext &Ctx,
diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp
index d255c117129d9..20fdf2de59cb1 100644
--- a/clang/lib/Sema/SemaDecl.cpp
+++ b/clang/lib/Sema/SemaDecl.cpp
@@ -14724,9 +14724,10 @@ void Sema::CheckCompleteVariableDeclaration(VarDecl *var) {
type->isIntegralOrEnumerationType()) {
// In C++98, in-class initialization for a static data member must
// be an integer constant expression.
- SourceLocation Loc;
- if (!Init->isIntegerConstantExpr(Context, &Loc)) {
- Diag(Loc, diag::ext_in_class_initializer_non_constant)
+ // SourceLocation Loc;
+ if (!Init->isIntegerConstantExpr(Context)) {
+ Diag(Init->getExprLoc(),
+ diag::ext_in_class_initializer_non_constant)
<< Init->getSourceRange();
}
}
More information about the cfe-commits
mailing list