[clang-tools-extra] 1a7a2cd - [Ignore Expressions][NFC] Refactor to better use `IgnoreExpr.h` and nits
Eduardo Caldas via cfe-commits
cfe-commits at lists.llvm.org
Mon Sep 7 02:32:52 PDT 2020
Author: Eduardo Caldas
Date: 2020-09-07T09:32:30Z
New Revision: 1a7a2cd7474e6d321120ffe7ca9c52163eb228f0
URL: https://github.com/llvm/llvm-project/commit/1a7a2cd7474e6d321120ffe7ca9c52163eb228f0
DIFF: https://github.com/llvm/llvm-project/commit/1a7a2cd7474e6d321120ffe7ca9c52163eb228f0.diff
LOG: [Ignore Expressions][NFC] Refactor to better use `IgnoreExpr.h` and nits
This change groups
* Rename: `ignoreParenBaseCasts` -> `IgnoreParenBaseCasts` for uniformity
* Rename: `IgnoreConversionOperator` -> `IgnoreConversionOperatorSingleStep` for uniformity
* Inline `IgnoreNoopCastsSingleStep` into a lambda inside `IgnoreNoopCasts`
* Refactor `IgnoreUnlessSpelledInSource` to make adequate use of `IgnoreExprNodes`
Differential Revision: https://reviews.llvm.org/D86880
Added:
Modified:
clang-tools-extra/clang-tidy/modernize/UseAutoCheck.cpp
clang-tools-extra/clang-tidy/readability/SimplifyBooleanExprCheck.cpp
clang/include/clang/AST/Expr.h
clang/lib/AST/Expr.cpp
clang/lib/CodeGen/CGExprCXX.cpp
clang/lib/Sema/SemaExpr.cpp
clang/lib/StaticAnalyzer/Core/CallEvent.cpp
Removed:
################################################################################
diff --git a/clang-tools-extra/clang-tidy/modernize/UseAutoCheck.cpp b/clang-tools-extra/clang-tidy/modernize/UseAutoCheck.cpp
index 04dc61f02df1..44ae380b63b2 100644
--- a/clang-tools-extra/clang-tidy/modernize/UseAutoCheck.cpp
+++ b/clang-tools-extra/clang-tidy/modernize/UseAutoCheck.cpp
@@ -338,7 +338,7 @@ void UseAutoCheck::replaceIterators(const DeclStmt *D, ASTContext *Context) {
// Drill down to the as-written initializer.
const Expr *E = (*Construct->arg_begin())->IgnoreParenImpCasts();
- if (E != E->IgnoreConversionOperator()) {
+ if (E != E->IgnoreConversionOperatorSingleStep()) {
// We hit a conversion operator. Early-out now as they imply an implicit
// conversion from a
diff erent type. Could also mean an explicit
// conversion from the same type but that's pretty rare.
diff --git a/clang-tools-extra/clang-tidy/readability/SimplifyBooleanExprCheck.cpp b/clang-tools-extra/clang-tidy/readability/SimplifyBooleanExprCheck.cpp
index 9dcb10b9d20c..7e8ba4eb90c6 100644
--- a/clang-tools-extra/clang-tidy/readability/SimplifyBooleanExprCheck.cpp
+++ b/clang-tools-extra/clang-tidy/readability/SimplifyBooleanExprCheck.cpp
@@ -205,7 +205,7 @@ std::string compareExpressionToZero(const MatchFinder::MatchResult &Result,
std::string replacementExpression(const MatchFinder::MatchResult &Result,
bool Negated, const Expr *E) {
- E = E->ignoreParenBaseCasts();
+ E = E->IgnoreParenBaseCasts();
if (const auto *EC = dyn_cast<ExprWithCleanups>(E))
E = EC->getSubExpr();
diff --git a/clang/include/clang/AST/Expr.h b/clang/include/clang/AST/Expr.h
index 5edca2593789..26e52ad367f8 100644
--- a/clang/include/clang/AST/Expr.h
+++ b/clang/include/clang/AST/Expr.h
@@ -867,9 +867,9 @@ class Expr : public ValueStmt {
/// Skip conversion operators. If this Expr is a call to a conversion
/// operator, return the argument.
- Expr *IgnoreConversionOperator() LLVM_READONLY;
- const Expr *IgnoreConversionOperator() const {
- return const_cast<Expr *>(this)->IgnoreConversionOperator();
+ Expr *IgnoreConversionOperatorSingleStep() LLVM_READONLY;
+ const Expr *IgnoreConversionOperatorSingleStep() const {
+ return const_cast<Expr *>(this)->IgnoreConversionOperatorSingleStep();
}
/// Skip past any parentheses and lvalue casts which might surround this
@@ -901,9 +901,9 @@ class Expr : public ValueStmt {
/// * What IgnoreParens() skips
/// * CastExpr which represent a derived-to-base cast (CK_DerivedToBase,
/// CK_UncheckedDerivedToBase and CK_NoOp)
- Expr *ignoreParenBaseCasts() LLVM_READONLY;
- const Expr *ignoreParenBaseCasts() const {
- return const_cast<Expr *>(this)->ignoreParenBaseCasts();
+ Expr *IgnoreParenBaseCasts() LLVM_READONLY;
+ const Expr *IgnoreParenBaseCasts() const {
+ return const_cast<Expr *>(this)->IgnoreParenBaseCasts();
}
/// Determine whether this expression is a default function argument.
diff --git a/clang/lib/AST/Expr.cpp b/clang/lib/AST/Expr.cpp
index 1029acbf68cd..15f3df0fd216 100644
--- a/clang/lib/AST/Expr.cpp
+++ b/clang/lib/AST/Expr.cpp
@@ -40,7 +40,7 @@ using namespace clang;
const Expr *Expr::getBestDynamicClassTypeExpr() const {
const Expr *E = this;
while (true) {
- E = E->ignoreParenBaseCasts();
+ E = E->IgnoreParenBaseCasts();
// Follow the RHS of a comma operator.
if (auto *BO = dyn_cast<BinaryOperator>(E)) {
@@ -2780,29 +2780,6 @@ QualType Expr::findBoundMemberType(const Expr *expr) {
return QualType();
}
-static Expr *IgnoreNoopCastsSingleStep(const ASTContext &Ctx, Expr *E) {
- if (auto *CE = dyn_cast<CastExpr>(E)) {
- // We ignore integer <-> casts that are of the same width, ptr<->ptr and
- // ptr<->int casts of the same width. We also ignore all identity casts.
- Expr *SubExpr = CE->getSubExpr();
- bool IsIdentityCast =
- Ctx.hasSameUnqualifiedType(E->getType(), SubExpr->getType());
- bool IsSameWidthCast =
- (E->getType()->isPointerType() || E->getType()->isIntegralType(Ctx)) &&
- (SubExpr->getType()->isPointerType() ||
- SubExpr->getType()->isIntegralType(Ctx)) &&
- (Ctx.getTypeSize(E->getType()) == Ctx.getTypeSize(SubExpr->getType()));
-
- if (IsIdentityCast || IsSameWidthCast)
- return SubExpr;
- }
-
- else if (auto *NTTP = dyn_cast<SubstNonTypeTemplateParmExpr>(E))
- return NTTP->getReplacement();
-
- return E;
-}
-
Expr *Expr::IgnoreImpCasts() {
return IgnoreExprNodes(this, IgnoreImplicitCastsSingleStep);
}
@@ -2832,7 +2809,7 @@ Expr *Expr::IgnoreParenCasts() {
return IgnoreExprNodes(this, IgnoreParensSingleStep, IgnoreCastsSingleStep);
}
-Expr *Expr::IgnoreConversionOperator() {
+Expr *Expr::IgnoreConversionOperatorSingleStep() {
if (auto *MCE = dyn_cast<CXXMemberCallExpr>(this)) {
if (MCE->getMethodDecl() && isa<CXXConversionDecl>(MCE->getMethodDecl()))
return MCE->getImplicitObjectArgument();
@@ -2845,58 +2822,72 @@ Expr *Expr::IgnoreParenLValueCasts() {
IgnoreLValueCastsSingleStep);
}
-Expr *Expr::ignoreParenBaseCasts() {
+Expr *Expr::IgnoreParenBaseCasts() {
return IgnoreExprNodes(this, IgnoreParensSingleStep,
IgnoreBaseCastsSingleStep);
}
Expr *Expr::IgnoreParenNoopCasts(const ASTContext &Ctx) {
- return IgnoreExprNodes(this, IgnoreParensSingleStep, [&Ctx](Expr *E) {
- return IgnoreNoopCastsSingleStep(Ctx, E);
- });
+ auto IgnoreNoopCastsSingleStep = [&Ctx](Expr *E) {
+ if (auto *CE = dyn_cast<CastExpr>(E)) {
+ // We ignore integer <-> casts that are of the same width, ptr<->ptr and
+ // ptr<->int casts of the same width. We also ignore all identity casts.
+ Expr *SubExpr = CE->getSubExpr();
+ bool IsIdentityCast =
+ Ctx.hasSameUnqualifiedType(E->getType(), SubExpr->getType());
+ bool IsSameWidthCast = (E->getType()->isPointerType() ||
+ E->getType()->isIntegralType(Ctx)) &&
+ (SubExpr->getType()->isPointerType() ||
+ SubExpr->getType()->isIntegralType(Ctx)) &&
+ (Ctx.getTypeSize(E->getType()) ==
+ Ctx.getTypeSize(SubExpr->getType()));
+
+ if (IsIdentityCast || IsSameWidthCast)
+ return SubExpr;
+ } else if (auto *NTTP = dyn_cast<SubstNonTypeTemplateParmExpr>(E))
+ return NTTP->getReplacement();
+
+ return E;
+ };
+ return IgnoreExprNodes(this, IgnoreParensSingleStep,
+ IgnoreNoopCastsSingleStep);
}
Expr *Expr::IgnoreUnlessSpelledInSource() {
- Expr *E = this;
-
- Expr *LastE = nullptr;
- while (E != LastE) {
- LastE = E;
- E = IgnoreExprNodes(E, IgnoreImplicitSingleStep,
- IgnoreImplicitCastsExtraSingleStep,
- IgnoreParensOnlySingleStep);
-
- auto SR = E->getSourceRange();
-
+ auto IgnoreImplicitConstructorSingleStep = [](Expr *E) {
if (auto *C = dyn_cast<CXXConstructExpr>(E)) {
auto NumArgs = C->getNumArgs();
if (NumArgs == 1 ||
(NumArgs > 1 && isa<CXXDefaultArgExpr>(C->getArg(1)))) {
Expr *A = C->getArg(0);
- if (A->getSourceRange() == SR || !isa<CXXTemporaryObjectExpr>(C))
- E = A;
+ if (A->getSourceRange() == E->getSourceRange() ||
+ !isa<CXXTemporaryObjectExpr>(C))
+ return A;
}
}
-
+ return E;
+ };
+ auto IgnoreImplicitMemberCallSingleStep = [](Expr *E) {
if (auto *C = dyn_cast<CXXMemberCallExpr>(E)) {
Expr *ExprNode = C->getImplicitObjectArgument();
- if (ExprNode->getSourceRange() == SR) {
- E = ExprNode;
- continue;
+ if (ExprNode->getSourceRange() == E->getSourceRange()) {
+ return ExprNode;
}
if (auto *PE = dyn_cast<ParenExpr>(ExprNode)) {
if (PE->getSourceRange() == C->getSourceRange()) {
- E = PE;
- continue;
+ return cast<Expr>(PE);
}
}
ExprNode = ExprNode->IgnoreParenImpCasts();
- if (ExprNode->getSourceRange() == SR)
- E = ExprNode;
+ if (ExprNode->getSourceRange() == E->getSourceRange())
+ return ExprNode;
}
- }
-
- return E;
+ return E;
+ };
+ return IgnoreExprNodes(
+ this, IgnoreImplicitSingleStep, IgnoreImplicitCastsExtraSingleStep,
+ IgnoreParensOnlySingleStep, IgnoreImplicitConstructorSingleStep,
+ IgnoreImplicitMemberCallSingleStep);
}
bool Expr::isDefaultArgument() const {
diff --git a/clang/lib/CodeGen/CGExprCXX.cpp b/clang/lib/CodeGen/CGExprCXX.cpp
index d0e0c7d6c060..50b6079bd80b 100644
--- a/clang/lib/CodeGen/CGExprCXX.cpp
+++ b/clang/lib/CodeGen/CGExprCXX.cpp
@@ -220,7 +220,7 @@ RValue CodeGenFunction::EmitCXXMemberOrOperatorMemberCallExpr(
DevirtualizedMethod = MD->getCorrespondingMethodInClass(BestDynamicDecl);
assert(DevirtualizedMethod);
const CXXRecordDecl *DevirtualizedClass = DevirtualizedMethod->getParent();
- const Expr *Inner = Base->ignoreParenBaseCasts();
+ const Expr *Inner = Base->IgnoreParenBaseCasts();
if (DevirtualizedMethod->getReturnType().getCanonicalType() !=
MD->getReturnType().getCanonicalType())
// If the return types are not the same, this might be a case where more
diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp
index cd71ce70c70e..d6f0a12106fe 100644
--- a/clang/lib/Sema/SemaExpr.cpp
+++ b/clang/lib/Sema/SemaExpr.cpp
@@ -8372,7 +8372,7 @@ static bool IsArithmeticBinaryExpr(Expr *E, BinaryOperatorKind *Opcode,
Expr **RHSExprs) {
// Don't strip parenthesis: we should not warn if E is in parenthesis.
E = E->IgnoreImpCasts();
- E = E->IgnoreConversionOperator();
+ E = E->IgnoreConversionOperatorSingleStep();
E = E->IgnoreImpCasts();
if (auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E)) {
E = MTE->getSubExpr();
diff --git a/clang/lib/StaticAnalyzer/Core/CallEvent.cpp b/clang/lib/StaticAnalyzer/Core/CallEvent.cpp
index 78d13ddfb773..a55d9302ca58 100644
--- a/clang/lib/StaticAnalyzer/Core/CallEvent.cpp
+++ b/clang/lib/StaticAnalyzer/Core/CallEvent.cpp
@@ -687,7 +687,7 @@ void CXXInstanceCall::getExtraInvalidatedValues(
// base class decl, rather than the class of the instance which needs to be
// checked for mutable fields.
// TODO: We might as well look at the dynamic type of the object.
- const Expr *Ex = getCXXThisExpr()->ignoreParenBaseCasts();
+ const Expr *Ex = getCXXThisExpr()->IgnoreParenBaseCasts();
QualType T = Ex->getType();
if (T->isPointerType()) // Arrow or implicit-this syntax?
T = T->getPointeeType();
More information about the cfe-commits
mailing list