[clang] Revert "[clang][dataflow] Refactor `PropagateResultObject()` with a switch statement." (PR #89176)

[via cfe-commits]

https://github.com/martinboehme created https://github.com/llvm/llvm-project/pull/89176

Reverts llvm/llvm-project#88865

There were failing tests in the CI that I didn't notice. Sorry.

>From bbcfd7fc26799704dd33cb6d34767ac3f1359dbe Mon Sep 17 00:00:00 2001
From: martinboehme <mboehme at google.com>
Date: Thu, 18 Apr 2024 09:22:28 +0200
Subject: [PATCH] =?UTF-8?q?Revert=20"[clang][dataflow]=20Refactor=20`Propa?=
 =?UTF-8?q?gateResultObject()`=20with=20a=20switch=20st=E2=80=A6"?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This reverts commit da579ad807bd55c686e1c1c52e0a4bcc259347b4.
---
 .../FlowSensitive/DataflowEnvironment.cpp     | 86 ++++++++-----------
 1 file changed, 36 insertions(+), 50 deletions(-)

diff --git a/clang/lib/Analysis/FlowSensitive/DataflowEnvironment.cpp b/clang/lib/Analysis/FlowSensitive/DataflowEnvironment.cpp
index e5aaa8fea4803f..3f1600d9ac5d87 100644
--- a/clang/lib/Analysis/FlowSensitive/DataflowEnvironment.cpp
+++ b/clang/lib/Analysis/FlowSensitive/DataflowEnvironment.cpp
@@ -414,52 +414,25 @@ 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).
-    case Stmt::CXXConstructExprClass:
-    case Stmt::CallExprClass:
-    case Stmt::LambdaExprClass:
-    case Stmt::CXXDefaultArgExprClass:
-    case Stmt::CXXDefaultInitExprClass:
-    case Stmt::CXXStdInitializerListExprClass:
-    // We treat `BuiltinBitCastExpr` as an "original initializer" too as it may
-    // not even be casting from a record type -- and even if it is, the two
-    // objects are in general of unrelated type.
-    case Stmt::BuiltinBitCastExprClass:
-      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);
+    if (isa<CXXConstructExpr>(E) || isa<CallExpr>(E) || isa<LambdaExpr>(E) ||
+        isa<CXXDefaultArgExpr>(E) || isa<CXXDefaultInitExpr>(E) ||
+        isa<CXXStdInitializerListExpr>(E) ||
+        // We treat `BuiltinBitCastExpr` as an "original initializer" too as
+        // it may not even be casting from a record type -- and even if it is,
+        // the two objects are in general of unrelated type.
+        isa<BuiltinBitCastExpr>(E)) {
       return;
     }
-    case Stmt::BinaryConditionalOperatorClass:
-    case Stmt::ConditionalOperatorClass: {
-      auto *Cond = cast<AbstractConditionalOperator>(E);
-      PropagateResultObject(Cond->getTrueExpr(), Loc);
-      PropagateResultObject(Cond->getFalseExpr(), Loc);
-      return;
-    }
-    case Stmt::StmtExprClass: {
-      auto *SE = cast<StmtExpr>(E);
-      PropagateResultObject(cast<Expr>(SE->getSubStmt()->body_back()), Loc);
+    if (auto *Op = dyn_cast<BinaryOperator>(E);
+        Op && Op->getOpcode() == BO_Cmp) {
+      // Builtin `<=>` returns a `std::strong_ordering` object.
       return;
     }
-    case Stmt::InitListExprClass: {
-      auto *InitList = cast<InitListExpr>(E);
+
+    if (auto *InitList = dyn_cast<InitListExpr>(E)) {
       if (!InitList->isSemanticForm())
         return;
       if (InitList->isTransparent()) {
@@ -489,20 +462,33 @@ class ResultObjectVisitor : public RecursiveASTVisitor<ResultObjectVisitor> {
       }
       return;
     }
-    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);
+
+    if (auto *Op = dyn_cast<BinaryOperator>(E); Op && Op->isCommaOp()) {
+      PropagateResultObject(Op->getRHS(), Loc);
       return;
     }
+
+    if (auto *Cond = dyn_cast<AbstractConditionalOperator>(E)) {
+      PropagateResultObject(Cond->getTrueExpr(), Loc);
+      PropagateResultObject(Cond->getFalseExpr(), Loc);
+      return;
     }
+
+    if (auto *SE = dyn_cast<StmtExpr>(E)) {
+      PropagateResultObject(cast<Expr>(SE->getSubStmt()->body_back()), 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: