Translate switch with default case in the middle

cpp2rust/converter/converter.cpp

@@ -2621,63 +2621,67 @@ bool Converter::VisitImplicitValueInitExpr(clang::ImplicitValueInitExpr *expr) {
   return false;
 }
 
-static std::unordered_set<clang::SwitchCase *> visited_cases;
-
-bool Converter::VisitSwitchCase(clang::SwitchCase *stmt) {
-  if (visited_cases.contains(stmt)) {
-    return false;
+bool Converter::ConvertSwitchCaseCondition(clang::SwitchCase *stmt) {
+  clang::Stmt *cur = stmt;
+  clang::SwitchCase *last = nullptr;
+  bool first = true;
+
+  while (auto *sc = clang::dyn_cast<clang::SwitchCase>(cur)) {
+    if (auto *case_stmt = clang::dyn_cast<clang::CaseStmt>(sc)) {
+      if (!first) {
+        StrCat("|| v == ");
+      }
+      Convert(case_stmt->getLHS());
+    }
+    last = sc;
+    first = false;
+    cur = sc->getSubStmt();
   }
-  visited_cases.insert(stmt);
 
-  if (auto case_stmt = clang::dyn_cast<clang::CaseStmt>(stmt)) {
-    Convert(case_stmt->getLHS());
+  if (clang::isa<clang::CaseStmt>(last)) {
+    StrCat(" => {");
+  } else /* DefaultStmt */ {
+    StrCat("_ => {");
   }
+  return false;
+}
 
-  if (clang::isa<clang::CaseStmt>(stmt->getSubStmt())) {
-    StrCat("|| v == ");
+void Converter::EmitSwitchArm(clang::CompoundStmt *body, clang::SwitchCase *sc,
+                              bool is_default) {
+  if (is_default) {
+    StrCat("_ => {");
   } else {
-    if (clang::isa<clang::CaseStmt>(stmt)) {
-      StrCat(" => {");
-    } else {
-      StrCat("_ => {");
-    }
+    StrCat("v if v == ");
+    ConvertSwitchCaseCondition(sc);
   }
-
-  Convert(stmt->getSubStmt());
-  return false;
+  for (auto *t : GetSwitchCaseBody(body, sc)) {
+    Convert(t);
+  }
+  StrCat("},");
 }
 
 bool Converter::VisitSwitchStmt(clang::SwitchStmt *stmt) {
   PushBreakTarget push(break_target_, BreakTarget::Switch);
+  auto *body = clang::dyn_cast<clang::CompoundStmt>(stmt->getBody());
+  assert(body);
+
   StrCat("'switch: {");
   StrCat(std::format("let __match_cond = {};", ToString(stmt->getCond())));
   StrCat("match __match_cond");
   StrCat("{");
 
-  bool has_default_case = false;
-  auto body = llvm::cast<clang::CompoundStmt>(stmt->getBody());
-  assert(body);
-
-  for (auto it = body->body_begin(), end = body->body_end(); it != end;) {
-    if (auto switch_case = clang::dyn_cast<clang::SwitchCase>(*it)) {
-      if (clang::isa<clang::CaseStmt>(switch_case)) {
-        StrCat("v if v == ");
-      } else {
-        has_default_case = true;
-      }
-      VisitSwitchCase(switch_case);
-      ++it;
-    }
-
-    while (it != end && !clang::isa<clang::SwitchCase>(*it)) {
-      Convert(*it);
-      ++it;
+  clang::SwitchCase *default_case = nullptr;
+  for (auto *sc : GetTopLevelSwitchCases(stmt)) {
+    if (SwitchCaseContainsDefault(sc)) {
+      default_case = sc;
+      continue;
     }
-
-    StrCat("},");
+    EmitSwitchArm(body, sc, /*is_default=*/false);
   }
 
-  if (!has_default_case) {
+  if (default_case) {
+    EmitSwitchArm(body, default_case, /*is_default=*/true);
+  } else {
     StrCat(R"( _ => {})");
   }
 

cpp2rust/converter/converter.h

@@ -290,7 +290,10 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual bool VisitSwitchStmt(clang::SwitchStmt *stmt);
 
-  virtual bool VisitSwitchCase(clang::SwitchCase *stmt);
+  void EmitSwitchArm(clang::CompoundStmt *body, clang::SwitchCase *sc,
+                     bool is_default);
+
+  bool ConvertSwitchCaseCondition(clang::SwitchCase *stmt);
 
   virtual bool VisitVAArgExpr(clang::VAArgExpr *expr);
 

cpp2rust/converter/converter_lib.cpp

@@ -662,6 +662,58 @@ clang::Expr *CreateConversionToBool(clang::Expr *expr, clang::ASTContext &ctx) {
       /*BasePath=*/nullptr, clang::VK_PRValue, clang::FPOptionsOverride());
 }
 
+std::vector<clang::SwitchCase *>
+GetTopLevelSwitchCases(clang::SwitchStmt *stmt) {
+  std::vector<clang::SwitchCase *> cases;
+  if (auto *body = llvm::dyn_cast<clang::CompoundStmt>(stmt->getBody())) {
+    for (auto *s : body->body()) {
+      if (auto *sc = clang::dyn_cast<clang::SwitchCase>(s)) {
+        cases.push_back(sc);
+      }
+    }
+  }
+  return cases;
+}
+
+bool SwitchCaseContainsDefault(clang::SwitchCase *c) {
+  for (clang::Stmt *cur = c;;) {
+    if (clang::isa<clang::DefaultStmt>(cur)) {
+      return true;
+    }
+    auto *sc = clang::dyn_cast<clang::SwitchCase>(cur);
+    if (!sc) {
+      return false;
+    }
+    cur = sc->getSubStmt();
+  }
+  return false;
+}
+
+static clang::Stmt *GetLastStmtOfSwitchCase(clang::SwitchCase *c) {
+  clang::Stmt *cur = c->getSubStmt();
+  while (auto *sc = clang::dyn_cast<clang::SwitchCase>(cur)) {
+    cur = sc->getSubStmt();
+  }
+  return cur;
+}
+
+std::vector<clang::Stmt *> GetSwitchCaseBody(clang::CompoundStmt *body,
+                                             clang::SwitchCase *head) {
+  std::vector<clang::Stmt *> out;
+  out.push_back(GetLastStmtOfSwitchCase(head));
+  auto it = body->body_begin(), end = body->body_end();
+  while (it != end && *it != head) {
+    ++it;
+  }
+  assert(it != end);
+  ++it;
+  while (it != end && !clang::isa<clang::SwitchCase>(*it)) {
+    out.push_back(*it);
+    ++it;
+  }
+  return out;
+}
+
 static std::string_view Trim(std::string_view s) {
   auto is_space = [](unsigned char c) { return std::isspace(c); };
   auto b = std::find_if_not(s.begin(), s.end(), is_space);

cpp2rust/converter/converter_lib.h

@@ -155,6 +155,14 @@ bool ContainsVAArgExpr(const clang::Stmt *stmt);
 
 clang::Expr *CreateConversionToBool(clang::Expr *expr, clang::ASTContext &ctx);
 
+std::vector<clang::SwitchCase *>
+GetTopLevelSwitchCases(clang::SwitchStmt *stmt);
+
+bool SwitchCaseContainsDefault(clang::SwitchCase *c);
+
+std::vector<clang::Stmt *> GetSwitchCaseBody(clang::CompoundStmt *body,
+                                             clang::SwitchCase *head);
+
 void Unwrap(std::string &s, std::string_view prefix, std::string_view suffix);
 
 } // namespace cpp2rust

tests/unit/out/refcount/switch_case_then_default.rs

@@ -0,0 +1,50 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+pub fn case_then_default_0(x: i32) -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(x));
+    let r: Value<i32> = Rc::new(RefCell::new(0));
+    'switch: {
+        let __match_cond = (*x.borrow());
+        match __match_cond {
+            v if v == 2 => {
+                (*r.borrow_mut()) = 20;
+                break 'switch;
+            }
+            _ => {
+                (*r.borrow_mut()) = 10;
+                break 'switch;
+            }
+        }
+    };
+    return (*r.borrow());
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    assert!(
+        (({
+            let _x: i32 = 1;
+            case_then_default_0(_x)
+        }) == 10)
+    );
+    assert!(
+        (({
+            let _x: i32 = 2;
+            case_then_default_0(_x)
+        }) == 20)
+    );
+    assert!(
+        (({
+            let _x: i32 = 99;
+            case_then_default_0(_x)
+        }) == 10)
+    );
+    return 0;
+}

tests/unit/out/refcount/switch_cases_and_default_stacked.rs

@@ -0,0 +1,56 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+pub fn cases_and_default_stacked_0(x: i32) -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(x));
+    let r: Value<i32> = Rc::new(RefCell::new(0));
+    'switch: {
+        let __match_cond = (*x.borrow());
+        match __match_cond {
+            v if v == 3 => {
+                (*r.borrow_mut()) = 3;
+                break 'switch;
+            }
+            _ => {
+                (*r.borrow_mut()) = 42;
+                break 'switch;
+            }
+        }
+    };
+    return (*r.borrow());
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    assert!(
+        (({
+            let _x: i32 = 1;
+            cases_and_default_stacked_0(_x)
+        }) == 42)
+    );
+    assert!(
+        (({
+            let _x: i32 = 2;
+            cases_and_default_stacked_0(_x)
+        }) == 42)
+    );
+    assert!(
+        (({
+            let _x: i32 = 3;
+            cases_and_default_stacked_0(_x)
+        }) == 3)
+    );
+    assert!(
+        (({
+            let _x: i32 = 99;
+            cases_and_default_stacked_0(_x)
+        }) == 42)
+    );
+    return 0;
+}

tests/unit/out/refcount/switch_default_first.rs

@@ -12,10 +12,6 @@ pub fn default_first_0(x: i32) -> i32 {
     'switch: {
         let __match_cond = (*x.borrow());
         match __match_cond {
-            _ => {
-                (*r.borrow_mut()) = 7;
-                break 'switch;
-            }
             v if v == 1 => {
                 (*r.borrow_mut()) = 1;
                 break 'switch;
@@ -24,6 +20,10 @@ pub fn default_first_0(x: i32) -> i32 {
                 (*r.borrow_mut()) = 2;
                 break 'switch;
             }
+            _ => {
+                (*r.borrow_mut()) = 7;
+                break 'switch;
+            }
         }
     };
     return (*r.borrow());

tests/unit/out/refcount/switch_default_middle.rs

@@ -16,14 +16,14 @@ pub fn default_middle_0(x: i32) -> i32 {
                 (*r.borrow_mut()) = 1;
                 break 'switch;
             }
-            _ => {
-                (*r.borrow_mut()) = 99;
-                break 'switch;
-            }
             v if v == 2 => {
                 (*r.borrow_mut()) = 2;
                 break 'switch;
             }
+            _ => {
+                (*r.borrow_mut()) = 99;
+                break 'switch;
+            }
         }
     };
     return (*r.borrow());