r354216 - Revert "[AST] Factor out the logic of the various Expr::Ignore*"
Bruno Ricci via cfe-commits
cfe-commits at lists.llvm.org
Sun Feb 17 05:47:29 PST 2019
Author: brunoricci
Date: Sun Feb 17 05:47:29 2019
New Revision: 354216
URL: http://llvm.org/viewvc/llvm-project?rev=354216&view=rev
Log:
Revert "[AST] Factor out the logic of the various Expr::Ignore*"
This breaks some clang-tidy checks. For some reason they were
not included in check-clang ?
Modified:
cfe/trunk/include/clang/AST/Expr.h
cfe/trunk/lib/AST/Expr.cpp
Modified: cfe/trunk/include/clang/AST/Expr.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/AST/Expr.h?rev=354216&r1=354215&r2=354216&view=diff
==============================================================================
--- cfe/trunk/include/clang/AST/Expr.h (original)
+++ cfe/trunk/include/clang/AST/Expr.h Sun Feb 17 05:47:29 2019
@@ -794,7 +794,7 @@ public:
/// IgnoreParens() + IgnoreImpCasts() until reaching a fixed point. However
/// this is currently not the case. Instead IgnoreParenImpCasts() skips:
/// * What IgnoreParens() skips
- /// * What IgnoreImpCasts() skips
+ /// * ImplicitCastExpr
/// * MaterializeTemporaryExpr
/// * SubstNonTypeTemplateParmExpr
Expr *IgnoreParenImpCasts() LLVM_READONLY;
Modified: cfe/trunk/lib/AST/Expr.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/AST/Expr.cpp?rev=354216&r1=354215&r2=354216&view=diff
==============================================================================
--- cfe/trunk/lib/AST/Expr.cpp (original)
+++ cfe/trunk/lib/AST/Expr.cpp Sun Feb 17 05:47:29 2019
@@ -2556,173 +2556,185 @@ QualType Expr::findBoundMemberType(const
return QualType();
}
-static Expr *IgnoreImpCastsSingleStep(Expr *E) {
- if (auto *ICE = dyn_cast<ImplicitCastExpr>(E))
- return ICE->getSubExpr();
-
- if (auto *FE = dyn_cast<FullExpr>(E))
- return FE->getSubExpr();
-
- return E;
-}
-
-static Expr *IgnoreImpCastsExtraSingleStep(Expr *E) {
- // FIXME: Skip MaterializeTemporaryExpr and SubstNonTypeTemplateParmExpr in
- // addition to what IgnoreImpCasts() skips to account for the current
- // behaviour of IgnoreParenImpCasts().
- Expr *SubE = IgnoreImpCastsSingleStep(E);
- if (SubE != E)
- return SubE;
-
- if (auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E))
- return MTE->GetTemporaryExpr();
-
- if (auto *NTTP = dyn_cast<SubstNonTypeTemplateParmExpr>(E))
- return NTTP->getReplacement();
-
- return E;
-}
-
-static Expr *IgnoreCastsSingleStep(Expr *E) {
- if (auto *CE = dyn_cast<CastExpr>(E))
- return CE->getSubExpr();
-
- if (auto *FE = dyn_cast<FullExpr>(E))
- return FE->getSubExpr();
-
- if (auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E))
- return MTE->GetTemporaryExpr();
-
- if (auto *NTTP = dyn_cast<SubstNonTypeTemplateParmExpr>(E))
- return NTTP->getReplacement();
-
+Expr *Expr::IgnoreImpCasts() {
+ Expr *E = this;
+ while (true) {
+ if (auto *ICE = dyn_cast<ImplicitCastExpr>(E))
+ E = ICE->getSubExpr();
+ else if (auto *FE = dyn_cast<FullExpr>(E))
+ E = FE->getSubExpr();
+ else
+ break;
+ }
return E;
}
-static Expr *IgnoreLValueCastsSingleStep(Expr *E) {
- // Skip what IgnoreCastsSingleStep skips, except that only
- // lvalue-to-rvalue casts are skipped.
- if (auto *CE = dyn_cast<CastExpr>(E))
- if (CE->getCastKind() != CK_LValueToRValue)
- return E;
-
- return IgnoreCastsSingleStep(E);
-}
-
-static Expr *IgnoreBaseCastsSingleStep(Expr *E) {
- if (auto *CE = dyn_cast<CastExpr>(E))
- if (CE->getCastKind() == CK_DerivedToBase ||
- CE->getCastKind() == CK_UncheckedDerivedToBase ||
- CE->getCastKind() == CK_NoOp)
- return CE->getSubExpr();
-
- return E;
-}
+Expr *Expr::IgnoreImplicit() {
+ Expr *E = this;
+ Expr *LastE = nullptr;
+ while (E != LastE) {
+ LastE = E;
-static Expr *IgnoreImplicitSingleStep(Expr *E) {
- Expr *SubE = IgnoreImpCastsSingleStep(E);
- if (SubE != E)
- return SubE;
+ if (auto *ICE = dyn_cast<ImplicitCastExpr>(E))
+ E = ICE->getSubExpr();
- if (auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E))
- return MTE->GetTemporaryExpr();
+ if (auto *FE = dyn_cast<FullExpr>(E))
+ E = FE->getSubExpr();
- if (auto *BTE = dyn_cast<CXXBindTemporaryExpr>(E))
- return BTE->getSubExpr();
+ if (auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E))
+ E = MTE->GetTemporaryExpr();
+ if (auto *BTE = dyn_cast<CXXBindTemporaryExpr>(E))
+ E = BTE->getSubExpr();
+ }
return E;
}
-static Expr *IgnoreParensSingleStep(Expr *E) {
- if (auto *PE = dyn_cast<ParenExpr>(E))
- return PE->getSubExpr();
-
- if (auto *UO = dyn_cast<UnaryOperator>(E)) {
- if (UO->getOpcode() == UO_Extension)
- return UO->getSubExpr();
- }
-
- else if (auto *GSE = dyn_cast<GenericSelectionExpr>(E)) {
- if (!GSE->isResultDependent())
- return GSE->getResultExpr();
- }
-
- else if (auto *CE = dyn_cast<ChooseExpr>(E)) {
- if (!CE->isConditionDependent())
- return CE->getChosenSubExpr();
+Expr *Expr::IgnoreParens() {
+ Expr *E = this;
+ while (true) {
+ if (auto *PE = dyn_cast<ParenExpr>(E)) {
+ E = PE->getSubExpr();
+ continue;
+ }
+ if (auto *UO = dyn_cast<UnaryOperator>(E)) {
+ if (UO->getOpcode() == UO_Extension) {
+ E = UO->getSubExpr();
+ continue;
+ }
+ }
+ if (auto *GSE = dyn_cast<GenericSelectionExpr>(E)) {
+ if (!GSE->isResultDependent()) {
+ E = GSE->getResultExpr();
+ continue;
+ }
+ }
+ if (auto *CE = dyn_cast<ChooseExpr>(E)) {
+ if (!CE->isConditionDependent()) {
+ E = CE->getChosenSubExpr();
+ continue;
+ }
+ }
+ if (auto *CE = dyn_cast<ConstantExpr>(E)) {
+ E = CE->getSubExpr();
+ continue;
+ }
+ return E;
}
-
- else if (auto *CE = dyn_cast<ConstantExpr>(E))
- return CE->getSubExpr();
-
- return E;
}
-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;
+/// IgnoreParenCasts - Ignore parentheses and casts. Strip off any ParenExpr
+/// or CastExprs or ImplicitCastExprs, returning their operand.
+Expr *Expr::IgnoreParenCasts() {
+ Expr *E = this;
+ while (true) {
+ E = E->IgnoreParens();
+ if (auto *CE = dyn_cast<CastExpr>(E)) {
+ E = CE->getSubExpr();
+ continue;
+ }
+ if (auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E)) {
+ E = MTE->GetTemporaryExpr();
+ continue;
+ }
+ if (auto *NTTP = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
+ E = NTTP->getReplacement();
+ continue;
+ }
+ if (auto *FE = dyn_cast<FullExpr>(E)) {
+ E = FE->getSubExpr();
+ continue;
+ }
+ return E;
}
-
- else if (auto *NTTP = dyn_cast<SubstNonTypeTemplateParmExpr>(E))
- return NTTP->getReplacement();
-
- return E;
}
-static Expr *IgnoreExprNodesImpl(Expr *E) { return E; }
-template <typename FnTy, typename... FnTys>
-static Expr *IgnoreExprNodesImpl(Expr *E, FnTy &&Fn, FnTys &&... Fns) {
- return IgnoreExprNodesImpl(Fn(E), std::forward<FnTys>(Fns)...);
+Expr *Expr::IgnoreCasts() {
+ Expr *E = this;
+ while (true) {
+ if (auto *CE = dyn_cast<CastExpr>(E)) {
+ E = CE->getSubExpr();
+ continue;
+ }
+ if (auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E)) {
+ E = MTE->GetTemporaryExpr();
+ continue;
+ }
+ if (auto *NTTP = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
+ E = NTTP->getReplacement();
+ continue;
+ }
+ if (auto *FE = dyn_cast<FullExpr>(E)) {
+ E = FE->getSubExpr();
+ continue;
+ }
+ return E;
+ }
}
-/// Given an expression E and functions Fn_1,...,Fn_n : Expr * -> Expr *,
-/// Recursively apply each of the functions to E until reaching a fixed point.
-/// Note that a null E is valid; in this case nothing is done.
-template <typename... FnTys>
-static Expr *IgnoreExprNodes(Expr *E, FnTys &&... Fns) {
- Expr *LastE = nullptr;
- while (E != LastE) {
- LastE = E;
- E = IgnoreExprNodesImpl(E, std::forward<FnTys>(Fns)...);
+/// IgnoreParenLValueCasts - Ignore parentheses and lvalue-to-rvalue
+/// casts. This is intended purely as a temporary workaround for code
+/// that hasn't yet been rewritten to do the right thing about those
+/// casts, and may disappear along with the last internal use.
+Expr *Expr::IgnoreParenLValueCasts() {
+ Expr *E = this;
+ while (true) {
+ E = E->IgnoreParens();
+ if (auto *CE = dyn_cast<CastExpr>(E)) {
+ if (CE->getCastKind() == CK_LValueToRValue) {
+ E = CE->getSubExpr();
+ continue;
+ }
+ } else if (auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E)) {
+ E = MTE->GetTemporaryExpr();
+ continue;
+ } else if (auto *NTTP = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
+ E = NTTP->getReplacement();
+ continue;
+ } else if (auto *FE = dyn_cast<FullExpr>(E)) {
+ E = FE->getSubExpr();
+ continue;
+ }
+ break;
}
return E;
}
-Expr *Expr::IgnoreImpCasts() {
- return IgnoreExprNodes(this, IgnoreImpCastsSingleStep);
-}
-
-Expr *Expr::IgnoreCasts() {
- return IgnoreExprNodes(this, IgnoreCastsSingleStep);
-}
-
-Expr *Expr::IgnoreImplicit() {
- return IgnoreExprNodes(this, IgnoreImplicitSingleStep);
-}
+Expr *Expr::ignoreParenBaseCasts() {
+ Expr *E = this;
+ while (true) {
+ E = E->IgnoreParens();
+ if (auto *CE = dyn_cast<CastExpr>(E)) {
+ if (CE->getCastKind() == CK_DerivedToBase ||
+ CE->getCastKind() == CK_UncheckedDerivedToBase ||
+ CE->getCastKind() == CK_NoOp) {
+ E = CE->getSubExpr();
+ continue;
+ }
+ }
-Expr *Expr::IgnoreParens() {
- return IgnoreExprNodes(this, IgnoreParensSingleStep);
+ return E;
+ }
}
Expr *Expr::IgnoreParenImpCasts() {
- return IgnoreExprNodes(this, IgnoreParensSingleStep,
- IgnoreImpCastsExtraSingleStep);
-}
-
-Expr *Expr::IgnoreParenCasts() {
- return IgnoreExprNodes(this, IgnoreParensSingleStep, IgnoreCastsSingleStep);
+ Expr *E = this;
+ while (true) {
+ E = E->IgnoreParens();
+ if (auto *ICE = dyn_cast<ImplicitCastExpr>(E)) {
+ E = ICE->getSubExpr();
+ continue;
+ }
+ if (auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E)) {
+ E = MTE->GetTemporaryExpr();
+ continue;
+ }
+ if (auto *NTTP = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
+ E = NTTP->getReplacement();
+ continue;
+ }
+ return E;
+ }
}
Expr *Expr::IgnoreConversionOperator() {
@@ -2733,20 +2745,41 @@ Expr *Expr::IgnoreConversionOperator() {
return this;
}
-Expr *Expr::IgnoreParenLValueCasts() {
- return IgnoreExprNodes(this, IgnoreParensSingleStep,
- IgnoreLValueCastsSingleStep);
-}
-
-Expr *Expr::ignoreParenBaseCasts() {
- return IgnoreExprNodes(this, IgnoreParensSingleStep,
- IgnoreBaseCastsSingleStep);
-}
-
+/// IgnoreParenNoopCasts - Ignore parentheses and casts that do not change the
+/// value (including ptr->int casts of the same size). Strip off any
+/// ParenExpr or CastExprs, returning their operand.
Expr *Expr::IgnoreParenNoopCasts(const ASTContext &Ctx) {
- return IgnoreExprNodes(this, IgnoreParensSingleStep, [&Ctx](Expr *E) {
- return IgnoreNoopCastsSingleStep(Ctx, E);
- });
+ Expr *E = this;
+ while (true) {
+ E = E->IgnoreParens();
+
+ 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 *SE = CE->getSubExpr();
+
+ if (Ctx.hasSameUnqualifiedType(E->getType(), SE->getType())) {
+ E = SE;
+ continue;
+ }
+
+ if ((E->getType()->isPointerType() ||
+ E->getType()->isIntegralType(Ctx)) &&
+ (SE->getType()->isPointerType() ||
+ SE->getType()->isIntegralType(Ctx)) &&
+ Ctx.getTypeSize(E->getType()) == Ctx.getTypeSize(SE->getType())) {
+ E = SE;
+ continue;
+ }
+ }
+
+ if (auto *NTTP = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
+ E = NTTP->getReplacement();
+ continue;
+ }
+
+ return E;
+ }
}
bool Expr::isDefaultArgument() const {
More information about the cfe-commits
mailing list