llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-clang @llvm/pr-subscribers-clang-analysis Author: None (martinboehme) <details> <summary>Changes</summary> See also discussion in #<!-- -->88726. --- Full diff: https://github.com/llvm/llvm-project/pull/88865.diff 1 Files Affected: - (modified) clang/lib/Analysis/FlowSensitive/DataflowEnvironment.cpp (+41-27) ``````````diff diff --git a/clang/lib/Analysis/FlowSensitive/DataflowEnvironment.cpp b/clang/lib/Analysis/FlowSensitive/DataflowEnvironment.cpp index ee2581143e1141..7ef6b9d1df5182 100644 --- a/clang/lib/Analysis/FlowSensitive/DataflowEnvironment.cpp +++ b/clang/lib/Analysis/FlowSensitive/DataflowEnvironment.cpp @@ -500,21 +500,43 @@ class ResultObjectVisitor : public RecursiveASTVisitor<ResultObjectVisitor> { ResultObjectMap[E] = Loc; + switch (E->getStmtClass()) { // The following AST node kinds are "original initializers": They are the // lowest-level AST node that initializes a given object, and nothing // below them can initialize the same object (or part of it). - if (isa<CXXConstructExpr>(E) || isa<CallExpr>(E) || isa<LambdaExpr>(E) || - isa<CXXDefaultArgExpr>(E) || isa<CXXDefaultInitExpr>(E) || - isa<CXXStdInitializerListExpr>(E)) { + case Stmt::CXXConstructExprClass: + case Stmt::CallExprClass: + case Stmt::LambdaExprClass: + case Stmt::CXXDefaultArgExprClass: + case Stmt::CXXDefaultInitExprClass: + case Stmt::CXXStdInitializerListExprClass: + return; + case Stmt::BinaryOperatorClass: { + auto *Op = cast<BinaryOperator>(E); + if (Op->getOpcode() == BO_Cmp) { + // Builtin `<=>` returns a `std::strong_ordering` object. We + // consider this to be an "original" initializer too (see above). + return; + } + if (Op->isCommaOp()) { + PropagateResultObject(Op->getRHS(), Loc); + return; + } + // We don't expect any other binary operators to produce a record + // prvalue, so if we get here, we've hit some case we don't know + // about. + assert(false); return; } - if (auto *Op = dyn_cast<BinaryOperator>(E); - Op && Op->getOpcode() == BO_Cmp) { - // Builtin `<=>` returns a `std::strong_ordering` object. + case Stmt::BinaryConditionalOperatorClass: + case Stmt::ConditionalOperatorClass: { + auto *Cond = cast<AbstractConditionalOperator>(E); + PropagateResultObject(Cond->getTrueExpr(), Loc); + PropagateResultObject(Cond->getFalseExpr(), Loc); return; } - - if (auto *InitList = dyn_cast<InitListExpr>(E)) { + case Stmt::InitListExprClass: { + auto *InitList = cast<InitListExpr>(E); if (!InitList->isSemanticForm()) return; if (InitList->isTransparent()) { @@ -544,28 +566,20 @@ class ResultObjectVisitor : public RecursiveASTVisitor<ResultObjectVisitor> { } return; } - - if (auto *Op = dyn_cast<BinaryOperator>(E); Op && Op->isCommaOp()) { - PropagateResultObject(Op->getRHS(), Loc); + default: { + // All other expression nodes that propagate a record prvalue should + // have exactly one child. + SmallVector<Stmt *, 1> Children(E->child_begin(), E->child_end()); + LLVM_DEBUG({ + if (Children.size() != 1) + E->dump(); + }); + assert(Children.size() == 1); + for (Stmt *S : Children) + PropagateResultObject(cast<Expr>(S), Loc); return; } - - if (auto *Cond = dyn_cast<AbstractConditionalOperator>(E)) { - PropagateResultObject(Cond->getTrueExpr(), Loc); - PropagateResultObject(Cond->getFalseExpr(), Loc); - return; } - - // All other expression nodes that propagate a record prvalue should have - // exactly one child. - SmallVector<Stmt *, 1> Children(E->child_begin(), E->child_end()); - LLVM_DEBUG({ - if (Children.size() != 1) - E->dump(); - }); - assert(Children.size() == 1); - for (Stmt *S : Children) - PropagateResultObject(cast<Expr>(S), Loc); } private: `````````` </details> https://github.com/llvm/llvm-project/pull/88865 _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
