Handle default case in the middle of the switch statement

cpp2rust/converter/converter.cpp

@@ -990,6 +990,7 @@ bool Converter::VisitIfStmt(clang::IfStmt *stmt) {
 }
 
 bool Converter::VisitWhileStmt(clang::WhileStmt *stmt) {
+  PushBreakTarget push(break_target_, BreakTarget::Loop);
   StrCat("'loop_:");
   StrCat(keyword::kWhile);
   ConvertCondition(stmt->getCond());
@@ -1002,6 +1003,7 @@ bool Converter::VisitWhileStmt(clang::WhileStmt *stmt) {
 }
 
 bool Converter::VisitDoStmt(clang::DoStmt *stmt) {
+  PushBreakTarget push(break_target_, BreakTarget::Loop);
   StrCat("'loop_:");
   StrCat(keyword::kLoop, token::kOpenCurlyBracket);
   curr_for_inc_.emplace(nullptr);
@@ -1016,6 +1018,7 @@ bool Converter::VisitDoStmt(clang::DoStmt *stmt) {
 }
 
 bool Converter::VisitForStmt(clang::ForStmt *stmt) {
+  PushBreakTarget push(break_target_, BreakTarget::Loop);
   Convert(stmt->getInit());
   StrCat("'loop_:");
   StrCat(keyword::kWhile);
@@ -1055,6 +1058,7 @@ void Converter::ConvertLoopVariable(clang::VarDecl *decl,
 
 void Converter::ConvertForRangeBody(clang::CXXForRangeStmt *stmt,
                                     const clang::VarDecl *map_iter_decl) {
+  PushBreakTarget push(break_target_, BreakTarget::Loop);
   std::optional<ScopedMapIterDecl> skip;
   if (map_iter_decl)
     skip.emplace(*this, map_iter_decl);
@@ -1137,7 +1141,7 @@ bool Converter::VisitCXXForRangeStmtIndexBased(clang::CXXForRangeStmt *stmt,
 
 bool Converter::VisitBreakStmt([[maybe_unused]] clang::BreakStmt *stmt) {
   StrCat(keyword::kBreak);
-  if (break_with_explicit_label_) {
+  if (isSwitchBreak()) {
     StrCat("'switch");
   }
   return false;
@@ -2617,66 +2621,69 @@ bool Converter::VisitImplicitValueInitExpr(clang::ImplicitValueInitExpr *expr) {
   return false;
 }
 
-static std::unordered_set<clang::SwitchCase *> visited_cases;
+bool Converter::ConvertSwitchCaseCondition(clang::SwitchCase *stmt) {
+  clang::Stmt *cur = stmt;
+  clang::SwitchCase *last = nullptr;
+  bool first = true;
 
-bool Converter::VisitSwitchCase(clang::SwitchCase *stmt) {
-  if (visited_cases.contains(stmt)) {
-    return false;
+  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);
-
-  break_with_explicit_label_ = true;
-  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"( _ => {})");
   }
-  break_with_explicit_label_ = false;
 
   StrCat("}");
   StrCat("}");

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);
 
@@ -463,10 +466,30 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
   clang::ASTContext &ctx_;
   clang::FunctionDecl *curr_function_ = nullptr;
   bool in_function_formals_ = false;
-  bool break_with_explicit_label_ = false;
   std::stack<clang::Expr *> curr_for_inc_;
   std::stack<clang::QualType> curr_init_type_;
 
+  enum class BreakTarget { Loop, Switch };
+  std::stack<BreakTarget> break_target_;
+
+  bool isSwitchBreak() const {
+    return !break_target_.empty() && break_target_.top() == BreakTarget::Switch;
+  }
+
+  class PushBreakTarget {
+  public:
+    PushBreakTarget(std::stack<BreakTarget> &stack, BreakTarget target)
+        : stack_(stack) {
+      stack_.push(target);
+    }
+    ~PushBreakTarget() { stack_.pop(); }
+    PushBreakTarget(const PushBreakTarget &) = delete;
+    PushBreakTarget &operator=(const PushBreakTarget &) = delete;
+
+  private:
+    std::stack<BreakTarget> &stack_;
+  };
+
   std::unordered_set<const clang::VarDecl *> map_iter_decls_;
 
   struct ScopedMapIterDecl {

cpp2rust/converter/converter_lib.cpp

@@ -660,4 +660,56 @@ 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;
+}
+
 } // namespace cpp2rust

cpp2rust/converter/converter_lib.h

@@ -154,4 +154,12 @@ 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);
+
 } // namespace cpp2rust

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());

tests/unit/out/refcount/switch_for_in_switch_break.rs

@@ -16,7 +16,7 @@ pub fn for_in_switch_break_0(n: i32) -> i32 {
                 let i: Value<i32> = Rc::new(RefCell::new(0));
                 'loop_: while ((*i.borrow()) < 10) {
                     if ((*i.borrow()) == 3) {
-                        break 'switch;
+                        break;
                     }
                     (*r.borrow_mut()) += (*i.borrow());
                     (*i.borrow_mut()).prefix_inc();

tests/unit/out/refcount/switch_for_switch_for_break.rs

@@ -18,7 +18,7 @@ pub fn for_switch_for_break_0(n: i32) -> i32 {
                     let j: Value<i32> = Rc::new(RefCell::new(0));
                     'loop_: while ((*j.borrow()) < 10) {
                         if ((*j.borrow()) == 2) {
-                            break 'switch;
+                            break;
                         }
                         (*r.borrow_mut()) += 1;
                         (*j.borrow_mut()).prefix_inc();

tests/unit/out/refcount/switch_nested.rs

@@ -32,15 +32,15 @@ pub fn nested_0(a: i32, b: i32) -> i32 {
                     }
                 };
                 (*r.borrow_mut()) += 1;
-                break;
+                break 'switch;
             }
             v if v == 2 => {
                 (*r.borrow_mut()) = 2;
-                break;
+                break 'switch;
             }
             _ => {
                 (*r.borrow_mut()) = -1_i32;
-                break;
+                break 'switch;
             }
         }
     };

tests/unit/out/refcount/switch_while_in_switch_break.rs

@@ -16,7 +16,7 @@ pub fn while_in_switch_break_0(n: i32) -> i32 {
                 let i: Value<i32> = Rc::new(RefCell::new(0));
                 'loop_: while ((*i.borrow()) < 10) {
                     if ((*i.borrow()) == 4) {
-                        break 'switch;
+                        break;
                     }
                     (*r.borrow_mut()) += (*i.borrow());
                     (*i.borrow_mut()).prefix_inc();

tests/unit/out/unsafe/switch_default_first.rs

@@ -11,10 +11,6 @@ pub unsafe fn default_first_0(mut x: i32) -> i32 {
     'switch: {
         let __match_cond = x;
         match __match_cond {
-            _ => {
-                r = 7;
-                break 'switch;
-            }
             v if v == 1 => {
                 r = 1;
                 break 'switch;
@@ -23,6 +19,10 @@ pub unsafe fn default_first_0(mut x: i32) -> i32 {
                 r = 2;
                 break 'switch;
             }
+            _ => {
+                r = 7;
+                break 'switch;
+            }
         }
     };
     return r;

tests/unit/out/unsafe/switch_default_middle.rs

@@ -15,14 +15,14 @@ pub unsafe fn default_middle_0(mut x: i32) -> i32 {
                 r = 1;
                 break 'switch;
             }
-            _ => {
-                r = 99;
-                break 'switch;
-            }
             v if v == 2 => {
                 r = 2;
                 break 'switch;
             }
+            _ => {
+                r = 99;
+                break 'switch;
+            }
         }
     };
     return r;