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 { _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits