diff --git a/.github/workflows/format.yml b/.github/workflows/format.yml
index 1b7412f4..4e7ae3ff 100644
--- a/.github/workflows/format.yml
+++ b/.github/workflows/format.yml
@@ -41,6 +41,7 @@ jobs:
           cargo fmt --manifest-path rules/Cargo.toml -- --check
           cargo fmt --manifest-path rule-preprocessor/Cargo.toml -- --check
           cargo fmt --manifest-path libcc2rs/Cargo.toml -- --check
+          cargo fmt --manifest-path libcc2rs-macros/Cargo.toml -- --check
           find tests -name '*.rs' -print0 | xargs -0 rustfmt --check
 
       - name: Check Rust lints
@@ -48,3 +49,4 @@ jobs:
           cargo clippy --manifest-path rules/Cargo.toml --all-targets --all-features -- -Dwarnings
           cargo +nightly clippy --manifest-path rule-preprocessor/Cargo.toml --all-targets --all-features -- -Dwarnings
           cargo clippy --manifest-path libcc2rs/Cargo.toml --all-targets --all-features -- -Dwarnings
+          cargo clippy --manifest-path libcc2rs-macros/Cargo.toml --all-targets --all-features -- -Dwarnings
diff --git a/CMakeLists.txt b/CMakeLists.txt
index c53fd6b9..003bc860 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -100,6 +100,7 @@ add_custom_target("format"
                   COMMAND rustup run ${RUST_STABLE_VERSION} cargo fmt --manifest-path ${PROJECT_SOURCE_DIR}/rules/Cargo.toml
                   COMMAND rustup run ${RUST_STABLE_VERSION} cargo fmt --manifest-path ${PROJECT_SOURCE_DIR}/rule-preprocessor/Cargo.toml
                   COMMAND rustup run ${RUST_STABLE_VERSION} cargo fmt --manifest-path ${PROJECT_SOURCE_DIR}/libcc2rs/Cargo.toml
+                  COMMAND rustup run ${RUST_STABLE_VERSION} cargo fmt --manifest-path ${PROJECT_SOURCE_DIR}/libcc2rs-macros/Cargo.toml
                   DEPENDS "install-rust-toolchain"
                   COMMENT "Running clang-format and cargo fmt on all source files"
                   VERBATIM
diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp
index 5cad686c..12077b91 100644
--- a/cpp2rust/converter/converter.cpp
+++ b/cpp2rust/converter/converter.cpp
@@ -2704,14 +2704,31 @@ void Converter::EmitSwitchArm(clang::CompoundStmt *body, clang::SwitchCase *sc,
 }
 
 bool Converter::VisitSwitchStmt(clang::SwitchStmt *stmt) {
-  PushBreakTarget push(break_target_, BreakTarget::Switch);
+  bool has_fallthrough = SwitchHasFallthrough(stmt);
+  PushBreakTarget push(break_target_, has_fallthrough
+                                          ? BreakTarget::FallthroughSwitch
+                                          : 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("{");
+  if (has_fallthrough) {
+    // Use the switch-with-fallthrough macro
+    StrCat("switch!");
+  } else {
+    StrCat("'switch:");
+  }
+
+  PushParen switch_macro_paren(*this, has_fallthrough);
+  PushBrace switch_label_brace(*this, !has_fallthrough);
+
+  if (has_fallthrough) {
+    StrCat("match", ToString(stmt->getCond()));
+  } else {
+    StrCat(std::format("let __match_cond = {};", ToString(stmt->getCond())));
+    StrCat("match __match_cond");
+  }
+
+  PushBrace match_brace(*this);
 
   clang::SwitchCase *default_case = nullptr;
   for (auto *sc : GetTopLevelSwitchCases(stmt)) {
@@ -2728,8 +2745,6 @@ bool Converter::VisitSwitchStmt(clang::SwitchStmt *stmt) {
     StrCat(R"( _ => {})");
   }
 
-  StrCat("}");
-  StrCat("}");
   return false;
 }
 
diff --git a/cpp2rust/converter/converter.h b/cpp2rust/converter/converter.h
index a948d1a9..1678a643 100644
--- a/cpp2rust/converter/converter.h
+++ b/cpp2rust/converter/converter.h
@@ -497,7 +497,7 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
   std::stack<clang::Expr *> curr_for_inc_;
   std::stack<clang::QualType> curr_init_type_;
 
-  enum class BreakTarget { Loop, Switch };
+  enum class BreakTarget { Loop, FallthroughSwitch, Switch };
   std::stack<BreakTarget> break_target_;
 
   bool isSwitchBreak() const {
diff --git a/cpp2rust/converter/converter_lib.cpp b/cpp2rust/converter/converter_lib.cpp
index 88a4c9b1..689d583d 100644
--- a/cpp2rust/converter/converter_lib.cpp
+++ b/cpp2rust/converter/converter_lib.cpp
@@ -744,6 +744,36 @@ std::vector<clang::Stmt *> GetSwitchCaseBody(clang::CompoundStmt *body,
   return out;
 }
 
+static bool SwitchCaseHasFallthrough(clang::Stmt *stmt) {
+  if (!stmt) {
+    return false;
+  }
+  if (auto *compound = clang::dyn_cast<clang::CompoundStmt>(stmt)) {
+    if (compound->body_empty()) {
+      return true;
+    }
+    return SwitchCaseHasFallthrough(compound->body_back());
+  }
+  if (clang::isa<clang::BreakStmt>(stmt) ||
+      clang::isa<clang::ContinueStmt>(stmt) ||
+      clang::isa<clang::ReturnStmt>(stmt)) {
+    return false;
+  }
+  return true;
+}
+
+bool SwitchHasFallthrough(clang::SwitchStmt *stmt) {
+  if (auto *body = clang::dyn_cast<clang::CompoundStmt>(stmt->getBody())) {
+    for (auto top_level_case : GetTopLevelSwitchCases(stmt)) {
+      auto arm = GetSwitchCaseBody(body, top_level_case);
+      if (arm.empty() || SwitchCaseHasFallthrough(arm.back())) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
 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);
diff --git a/cpp2rust/converter/converter_lib.h b/cpp2rust/converter/converter_lib.h
index c82dbb3c..0ba12b74 100644
--- a/cpp2rust/converter/converter_lib.h
+++ b/cpp2rust/converter/converter_lib.h
@@ -165,6 +165,8 @@ bool SwitchCaseContainsDefault(clang::SwitchCase *c);
 std::vector<clang::Stmt *> GetSwitchCaseBody(clang::CompoundStmt *body,
                                              clang::SwitchCase *head);
 
+bool SwitchHasFallthrough(clang::SwitchStmt *stmt);
+
 void Unwrap(std::string &s, std::string_view prefix, std::string_view suffix);
 
 } // namespace cpp2rust
diff --git a/libcc2rs-macros/Cargo.toml b/libcc2rs-macros/Cargo.toml
new file mode 100644
index 00000000..5a895659
--- /dev/null
+++ b/libcc2rs-macros/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "libcc2rs-macros"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+proc-macro2 = "1"
+quote = "1"
+syn = { version = "2", features = ["full", "visit-mut", "extra-traits"] }
+
+[dev-dependencies]
+trybuild = "1"
diff --git a/libcc2rs-macros/src/goto.rs b/libcc2rs-macros/src/goto.rs
new file mode 100644
index 00000000..916fd211
--- /dev/null
+++ b/libcc2rs-macros/src/goto.rs
@@ -0,0 +1,48 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+use proc_macro::TokenStream;
+use syn::parse::{Parse, ParseStream};
+use syn::{parse_macro_input, Expr, Lifetime, Token};
+
+use crate::state_machine::{Arm, GotoStateMachine, StateMachine};
+
+pub fn expand(input: TokenStream) -> TokenStream {
+    let GotoBlockInput { arms } = parse_macro_input!(input as GotoBlockInput);
+    GotoStateMachine {
+        arms: arms
+            .into_iter()
+            .map(|a| Arm {
+                label: a.label.ident.to_string(),
+                body: a.body,
+            })
+            .collect(),
+    }
+    .emit()
+    .into()
+}
+
+struct GotoBlockInput {
+    arms: Vec<GotoArm>,
+}
+
+struct GotoArm {
+    label: Lifetime,
+    body: Expr,
+}
+
+impl Parse for GotoBlockInput {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        let mut arms = Vec::new();
+        while !input.is_empty() {
+            let label: Lifetime = input.parse()?;
+            input.parse::<Token![=>]>()?;
+            let body: Expr = input.parse()?;
+            arms.push(GotoArm { label, body });
+            if input.peek(Token![,]) {
+                input.parse::<Token![,]>()?;
+            }
+        }
+        Ok(Self { arms })
+    }
+}
diff --git a/libcc2rs-macros/src/lib.rs b/libcc2rs-macros/src/lib.rs
new file mode 100644
index 00000000..10317cf4
--- /dev/null
+++ b/libcc2rs-macros/src/lib.rs
@@ -0,0 +1,81 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+use proc_macro::TokenStream;
+
+mod goto;
+mod state_machine;
+mod switch;
+
+//     switch!(match <condition> {
+//         <pat> [if <guard>] => { /* body; may contain break or continue */ },
+//         ...
+//         _ => <body>,
+//     });
+//
+// Desugars to a goto_block! with a synthetic dispatch arm prepended.
+//
+//     goto_block! {
+//         '__dispatch => {
+//             match <condition> {
+//                 <pat_1> => { __s = 1; continue '__sm; }
+//                 ...
+//                 _       => break '__sm,
+//             }
+//         },
+//         '__c1 => { /* body_1 with `break` rewritten to `break '__sm` */ },
+//         ...
+//         '__cN => { /* body_N with same rewrite */ },
+//     };
+//
+// __sm is the inner label used to describe the state machine insinde goto_block. See goto_block!
+// for more info.
+
+#[proc_macro]
+pub fn switch(input: TokenStream) -> TokenStream {
+    switch::expand(input)
+}
+
+//     goto_block! {
+//         '<label> => { /* body; may contain `break` or `continue` */ },
+//         ...
+//     };
+//
+// Expands to
+//
+//     {
+//         let mut __user_break:    bool = false; // only if any arm has `break`
+//         let mut __user_continue: bool = false; // only if any arm has `continue`
+//         let mut __s: u32 = 0;
+//         '__sm: loop {
+//             match __s {
+//                 0u32 => {
+//                     /* body_0 with these rewrites (outside nested user loops): */
+//                     /*   break;    ->  { __user_break    = true; break '__sm; } */
+//                     /*   continue; ->  { __user_continue = true; break '__sm; } */
+//                     __s = 1; continue '__sm;
+//                 }
+//                 ...
+//                 (N-1)u32 => { /* body_N-1 with same rewrites */ break '__sm; }
+//                 _        => break '__sm, // written only for match exhaustiveness
+//             }
+//         }
+//         if __user_break    { break; }    // only if any arm has `break;`
+//         if __user_continue { continue; } // only if any arm has `continue;`
+//     }
+//
+//  __user_break and __user_continue propagate the `break`s and `continue`s outside the goto state
+//  machine loop.
+
+#[proc_macro]
+pub fn goto_block(input: TokenStream) -> TokenStream {
+    goto::expand(input)
+}
+
+#[proc_macro]
+pub fn goto(_input: TokenStream) -> TokenStream {
+    quote::quote! {
+        compile_error!("goto!() can only be used inside goto_block!")
+    }
+    .into()
+}
diff --git a/libcc2rs-macros/src/state_machine.rs b/libcc2rs-macros/src/state_machine.rs
new file mode 100644
index 00000000..f313a7a5
--- /dev/null
+++ b/libcc2rs-macros/src/state_machine.rs
@@ -0,0 +1,275 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+use proc_macro2::{Ident, Span, TokenStream as TokenStream2};
+use quote::{format_ident, quote};
+use syn::visit_mut::{self, VisitMut};
+use syn::{Expr, ExprBreak, ExprContinue, Lifetime, Pat};
+
+pub struct Arm {
+    pub label: String,
+    pub body: Expr,
+}
+
+pub struct DispatchCase {
+    pub pat: Pat,
+    pub guard: Option<Expr>,
+    pub target: String,
+}
+
+pub trait StateMachine {
+    fn emit(self) -> TokenStream2;
+}
+
+fn sm_label() -> Lifetime {
+    Lifetime::new("'__sm", Span::call_site())
+}
+
+// Collection of labeled arms that fall-through by default
+pub struct GotoStateMachine {
+    pub arms: Vec<Arm>,
+}
+
+impl GotoStateMachine {
+    // Rewrites unlabeled break / continue to { flag = true; break '__sm; }
+    fn propagate_rewrite(
+        body: &mut Expr,
+        label: &Lifetime,
+        break_flag: &Ident,
+        cont_flag: &Ident,
+    ) -> (bool, bool) {
+        let mut br = PropagateRewriter::for_break(label.clone(), break_flag.clone());
+        br.visit_expr_mut(body);
+        let mut cr = PropagateRewriter::for_continue(label.clone(), cont_flag.clone());
+        cr.visit_expr_mut(body);
+        (br.found, cr.found)
+    }
+
+    // idx => { body; tail }
+    fn emit_body_arm(
+        idx: u32,
+        body: &Expr,
+        is_last: bool,
+        label: &Lifetime,
+        state: &Ident,
+    ) -> TokenStream2 {
+        let tail = if is_last {
+            quote! { break #label; }
+        } else {
+            let next = idx + 1;
+            quote! { #state = #next; continue #label; }
+        };
+        quote! {
+            #idx => {
+                #[allow(unreachable_code)]
+                { #body; #tail }
+            }
+        }
+    }
+
+    fn bailout(
+        should_emit: bool,
+        flag: &Ident,
+        stmt: TokenStream2,
+    ) -> (TokenStream2, TokenStream2) {
+        if !should_emit {
+            return (TokenStream2::new(), TokenStream2::new());
+        }
+        (
+            quote! { let mut #flag: bool = false; },
+            quote! {
+                #[allow(unreachable_code)]
+                if #flag { #stmt }
+            },
+        )
+    }
+}
+
+impl StateMachine for GotoStateMachine {
+    fn emit(self) -> TokenStream2 {
+        let lbl = sm_label();
+        let s = format_ident!("__s");
+        let break_flag = format_ident!("__user_break");
+        let cont_flag = format_ident!("__user_continue");
+
+        let n = self.arms.len();
+        let mut arms_have_break = false;
+        let mut arms_have_continue = false;
+        let body_arms: Vec<_> = self
+            .arms
+            .iter()
+            .enumerate()
+            .map(|(i, arm)| {
+                let mut body = arm.body.clone();
+                let (had_br, had_cn) =
+                    Self::propagate_rewrite(&mut body, &lbl, &break_flag, &cont_flag);
+                arms_have_break |= had_br;
+                arms_have_continue |= had_cn;
+                Self::emit_body_arm(i as u32, &body, i + 1 == n, &lbl, &s)
+            })
+            .collect();
+
+        let (brk_decl, brk_bailout) =
+            Self::bailout(arms_have_break, &break_flag, quote! { break; });
+        let (cnt_decl, cnt_bailout) =
+            Self::bailout(arms_have_continue, &cont_flag, quote! { continue; });
+
+        quote! {{
+            #brk_decl
+            #cnt_decl
+            let mut #s: u32 = 0;
+            #[allow(unreachable_code, unused_labels)]
+            #lbl: loop {
+                match #s {
+                    #(#body_arms)*
+                    _ => break #lbl,
+                }
+            }
+            #brk_bailout
+            #cnt_bailout
+        }}
+    }
+}
+
+// GotoStateMachine(dispatch arm + cases)
+pub struct SwitchStateMachine {
+    pub goto: GotoStateMachine,
+    pub condition: Expr,
+    pub cases: Vec<DispatchCase>,
+}
+
+impl SwitchStateMachine {
+    // Rewrite break into break '__sm
+    fn convert_break_to_switch_exit(arms: &[Arm], label: &Lifetime) -> Vec<Arm> {
+        arms.iter()
+            .map(|a| {
+                let mut body = a.body.clone();
+                ExitSwitchRewriter {
+                    label: label.clone(),
+                }
+                .visit_expr_mut(&mut body);
+                Arm {
+                    label: a.label.clone(),
+                    body,
+                }
+            })
+            .collect()
+    }
+
+    fn build_dispatch_arm(&self, user_arms: &[Arm], label: &Lifetime, state: &Ident) -> Arm {
+        let cond = &self.condition;
+        let case_arms = self.cases.iter().map(|c| {
+            let target_pos = user_arms
+                .iter()
+                .position(|a| a.label == c.target)
+                .expect("dispatch target must reference an arm label");
+            let idx = (target_pos as u32) + 1;
+            let pat = &c.pat;
+            let guard = c.guard.as_ref().map(|g| quote! { if #g });
+            quote! { #pat #guard => { #state = #idx; continue #label; } }
+        });
+        let body: Expr = syn::parse_quote! {
+            {
+                #[allow(unreachable_patterns)]
+                match #cond {
+                    #(#case_arms,)*
+                    _ => break #label,
+                }
+            }
+        };
+        Arm {
+            label: "__dispatch".into(),
+            body,
+        }
+    }
+}
+
+impl StateMachine for SwitchStateMachine {
+    fn emit(self) -> TokenStream2 {
+        let lbl = sm_label();
+        let s = format_ident!("__s");
+
+        let user_arms = Self::convert_break_to_switch_exit(&self.goto.arms, &lbl);
+        let dispatch = self.build_dispatch_arm(&user_arms, &lbl, &s);
+
+        let mut arms = Vec::new();
+        arms.push(dispatch);
+        arms.extend(user_arms);
+
+        GotoStateMachine { arms }.emit()
+    }
+}
+
+// Rewrite break into break '__sm
+struct ExitSwitchRewriter {
+    label: Lifetime,
+}
+
+impl VisitMut for ExitSwitchRewriter {
+    fn visit_expr_break_mut(&mut self, node: &mut ExprBreak) {
+        if node.label.is_none() {
+            node.label = Some(self.label.clone());
+        }
+    }
+    fn visit_expr_loop_mut(&mut self, _: &mut syn::ExprLoop) {}
+    fn visit_expr_while_mut(&mut self, _: &mut syn::ExprWhile) {}
+    fn visit_expr_for_loop_mut(&mut self, _: &mut syn::ExprForLoop) {}
+}
+
+enum ControlKind {
+    Break,
+    Continue,
+}
+
+// Rewrites unlabeled break / continue to { flag = true; break '__sm; }
+struct PropagateRewriter {
+    label: Lifetime,
+    flag: Ident,
+    kind: ControlKind,
+    found: bool,
+}
+
+impl PropagateRewriter {
+    fn for_break(label: Lifetime, flag: Ident) -> Self {
+        Self {
+            label,
+            flag,
+            kind: ControlKind::Break,
+            found: false,
+        }
+    }
+    fn for_continue(label: Lifetime, flag: Ident) -> Self {
+        Self {
+            label,
+            flag,
+            kind: ControlKind::Continue,
+            found: false,
+        }
+    }
+}
+
+impl VisitMut for PropagateRewriter {
+    fn visit_expr_mut(&mut self, expr: &mut Expr) {
+        let hit = match self.kind {
+            ControlKind::Break => {
+                matches!(expr, Expr::Break(ExprBreak { label: None, .. }))
+            }
+            ControlKind::Continue => {
+                matches!(expr, Expr::Continue(ExprContinue { label: None, .. }))
+            }
+        };
+        if hit {
+            self.found = true;
+            let flag = &self.flag;
+            let lbl = &self.label;
+            *expr = syn::parse_quote! {
+                { #flag = true; break #lbl; }
+            };
+            return;
+        }
+        visit_mut::visit_expr_mut(self, expr);
+    }
+    fn visit_expr_loop_mut(&mut self, _: &mut syn::ExprLoop) {}
+    fn visit_expr_while_mut(&mut self, _: &mut syn::ExprWhile) {}
+    fn visit_expr_for_loop_mut(&mut self, _: &mut syn::ExprForLoop) {}
+}
diff --git a/libcc2rs-macros/src/switch.rs b/libcc2rs-macros/src/switch.rs
new file mode 100644
index 00000000..dfb45002
--- /dev/null
+++ b/libcc2rs-macros/src/switch.rs
@@ -0,0 +1,62 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+use proc_macro::TokenStream;
+use syn::parse::{Parse, ParseStream};
+use syn::{parse_macro_input, Expr, Pat};
+
+use crate::state_machine::{Arm, DispatchCase, GotoStateMachine, StateMachine, SwitchStateMachine};
+
+pub fn expand(input: TokenStream) -> TokenStream {
+    let SwitchInput { condition, arms } = parse_macro_input!(input as SwitchInput);
+    let mut cases = Vec::with_capacity(arms.len());
+    let mut cfg_arms = Vec::with_capacity(arms.len());
+    for (i, a) in arms.into_iter().enumerate() {
+        let label = format!("__c{}", i);
+        cases.push(DispatchCase {
+            pat: a.pat,
+            guard: a.guard,
+            target: label.clone(),
+        });
+        cfg_arms.push(Arm {
+            label,
+            body: a.body,
+        });
+    }
+    SwitchStateMachine {
+        goto: GotoStateMachine { arms: cfg_arms },
+        condition,
+        cases,
+    }
+    .emit()
+    .into()
+}
+
+struct SwitchInput {
+    condition: Expr,
+    arms: Vec<SwitchArm>,
+}
+
+struct SwitchArm {
+    pat: Pat,
+    guard: Option<Expr>,
+    body: Expr,
+}
+
+impl Parse for SwitchInput {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        let m: syn::ExprMatch = input.parse()?;
+        Ok(Self {
+            condition: *m.expr,
+            arms: m
+                .arms
+                .into_iter()
+                .map(|a| SwitchArm {
+                    pat: a.pat,
+                    guard: a.guard.map(|(_if, e)| *e),
+                    body: *a.body,
+                })
+                .collect(),
+        })
+    }
+}
diff --git a/libcc2rs-macros/tests/compile_fail.rs b/libcc2rs-macros/tests/compile_fail.rs
new file mode 100644
index 00000000..03eeb131
--- /dev/null
+++ b/libcc2rs-macros/tests/compile_fail.rs
@@ -0,0 +1,8 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+#[test]
+fn compile_fail() {
+    let t = trybuild::TestCases::new();
+    t.compile_fail("tests/ui/*.rs");
+}
diff --git a/libcc2rs-macros/tests/control_flow.rs b/libcc2rs-macros/tests/control_flow.rs
new file mode 100644
index 00000000..4549c260
--- /dev/null
+++ b/libcc2rs-macros/tests/control_flow.rs
@@ -0,0 +1,309 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+use libcc2rs_macros::{goto_block, switch};
+
+#[test]
+fn switch_dispatch_each_case() {
+    for (input, expected) in [(0, "zero"), (1, "one"), (2, "two"), (9, "default")] {
+        let mut out = "";
+        switch!(match input {
+            0 => {
+                out = "zero";
+                break;
+            }
+            1 => {
+                out = "one";
+                break;
+            }
+            2 => {
+                out = "two";
+                break;
+            }
+            _ => {
+                out = "default";
+                break;
+            }
+        });
+        assert_eq!(out, expected, "input = {}", input);
+    }
+}
+
+#[test]
+fn switch_fallthrough() {
+    let mut v = 0;
+    switch!(match 0 {
+        0 => {
+            v += 1;
+        } // fall-through
+        1 => {
+            v += 10;
+            break;
+        }
+        _ => {
+            v = -1;
+            break;
+        }
+    });
+    assert_eq!(v, 11);
+}
+
+#[test]
+fn switch_fallthrough_chain() {
+    let mut v = 0;
+    switch!(match 0 {
+        0 => {
+            v += 1;
+        }
+        1 => {
+            v += 10;
+        }
+        2 => {
+            v += 100;
+            break;
+        }
+        _ => {
+            v = -1;
+            break;
+        }
+    });
+    assert_eq!(v, 111);
+}
+
+#[test]
+fn switch_break_exits() {
+    let mut v = 0;
+    switch!(match 1 {
+        0 => {
+            v = 999;
+            break;
+        }
+        1 => {
+            v = 1;
+            break;
+        }
+        _ => {
+            v = 2;
+            break;
+        }
+    });
+    assert_eq!(v, 1);
+}
+
+#[test]
+fn switch_default_case() {
+    let mut v = 0;
+    switch!(match 42 {
+        0 => {
+            v = 1;
+            break;
+        }
+        _ => {
+            v = 2;
+            break;
+        }
+    });
+    assert_eq!(v, 2);
+}
+
+#[test]
+fn switch_or_pattern() {
+    for x in [1, 2, 5] {
+        let mut v = "other";
+        switch!(match x {
+            1..=3 => {
+                v = "low";
+                break;
+            }
+            _ => {
+                v = "other";
+                break;
+            }
+        });
+        let expected = if x <= 3 { "low" } else { "other" };
+        assert_eq!(v, expected);
+    }
+}
+
+#[test]
+fn switch_guard_stacked_cases() {
+    for (x, expected) in [(1, 100), (2, 100), (3, 100), (4, 200), (5, 200), (9, 300)] {
+        let mut r = 0;
+        switch!(match x {
+            v if v == 1 || v == 2 || v == 3 => {
+                r = 100;
+                break;
+            }
+            v if v == 4 || v == 5 => {
+                r = 200;
+                break;
+            }
+            _ => {
+                r = 300;
+                break;
+            }
+        });
+        assert_eq!(r, expected, "x = {}", x);
+    }
+}
+
+#[test]
+fn switch_guard_fallthrough() {
+    let mut v = 0;
+    switch!(match 1 {
+        w if w == 0 || w == 1 => {
+            v += 1;
+        }
+        w if w == 2 => {
+            v += 10;
+            break;
+        }
+        _ => {
+            v = -1;
+            break;
+        }
+    });
+    assert_eq!(v, 11);
+}
+
+#[test]
+fn switch_guard_no_match_hits_default() {
+    let mut r = 0;
+    switch!(match 42 {
+        v if v == 1 => {
+            r = 1;
+            break;
+        }
+        v if v == 2 || v == 3 => {
+            r = 2;
+            break;
+        }
+        _ => {
+            r = 99;
+            break;
+        }
+    });
+    assert_eq!(r, 99);
+}
+
+#[test]
+fn switch_range_pattern() {
+    let mut v = 0;
+    switch!(match 50i32 {
+        0..=9 => {
+            v = 1;
+            break;
+        }
+        10..=99 => {
+            v = 2;
+            break;
+        }
+        _ => {
+            v = 3;
+            break;
+        }
+    });
+    assert_eq!(v, 2);
+}
+
+#[test]
+fn switch_nested_loop_break_targets_inner() {
+    let mut sum = 0;
+    switch!(match 0 {
+        0 => {
+            for i in 0..10 {
+                if i == 3 {
+                    break; // targets the for loop (LoopControlForbidden skips descent)
+                }
+                sum += i;
+            }
+            sum += 100;
+            break;
+        }
+        _ => {
+            break;
+        }
+    });
+    assert_eq!(sum, 103);
+}
+
+#[test]
+fn switch_return_from_case() {
+    #[allow(unreachable_code)]
+    fn classify(x: i32) -> &'static str {
+        switch!(match x {
+            0 => {
+                return "zero";
+            }
+            1 => {
+                return "one";
+            }
+            _ => {
+                return "other";
+            }
+        });
+        "unreachable"
+    }
+    assert_eq!(classify(0), "zero");
+    assert_eq!(classify(1), "one");
+    assert_eq!(classify(5), "other");
+}
+
+#[test]
+fn switch_in_loop() {
+    let mut count = 0;
+    for x in 0..5 {
+        switch!(match x {
+            0 | 2 | 4 => {
+                count += 1;
+                break;
+            }
+            _ => {
+                break;
+            }
+        });
+    }
+    assert_eq!(count, 3);
+}
+
+#[test]
+fn goto_block_linear_fallthrough() {
+    let mut v = 0;
+    goto_block! {
+        'a => { v += 1; },
+        'b => { v += 10; },
+        'c => { v += 100; },
+    };
+    assert_eq!(v, 111);
+}
+
+#[test]
+fn goto_block_return_from_arm() {
+    #[allow(unreachable_code)]
+    fn run(start: u32) -> &'static str {
+        goto_block! {
+            'a => { if start == 0 { return "a"; } },
+            'b => { if start == 1 { return "b"; } },
+            'c => { return "c"; },
+        };
+        "fallthrough"
+    }
+    assert_eq!(run(0), "a");
+    assert_eq!(run(1), "b");
+    assert_eq!(run(2), "c");
+}
+
+#[test]
+fn goto_block_nested_loop_break_targets_inner() {
+    let mut sum = 0;
+    goto_block! {
+        'entry => {
+            for i in 0..10 {
+                if i == 3 { break; } // targets the for loop
+                sum += i;
+            }
+            sum += 100;
+        },
+    };
+    assert_eq!(sum, 103);
+}
diff --git a/libcc2rs-macros/tests/ui/forbidden.rs b/libcc2rs-macros/tests/ui/forbidden.rs
new file mode 100644
index 00000000..c483c0d6
--- /dev/null
+++ b/libcc2rs-macros/tests/ui/forbidden.rs
@@ -0,0 +1,21 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+use libcc2rs_macros::{goto, switch};
+
+fn continue_with_no_outer_loop() {
+    let mut v = 0;
+    // No outer loop to continue
+    switch!(match 0 {
+        0 => { v = 1; continue; }
+        _ => { v = 2; }
+    });
+    let _ = v;
+}
+
+fn goto_outside_goto_block() {
+    // goto!() used outside goto_block!
+    goto!('nowhere);
+}
+
+fn main() {}
diff --git a/libcc2rs-macros/tests/ui/forbidden.stderr b/libcc2rs-macros/tests/ui/forbidden.stderr
new file mode 100644
index 00000000..e7e084a8
--- /dev/null
+++ b/libcc2rs-macros/tests/ui/forbidden.stderr
@@ -0,0 +1,18 @@
+error: goto!() can only be used inside goto_block!
+  --> tests/ui/forbidden.rs:22:5
+   |
+22 |     goto!('nowhere);
+   |     ^^^^^^^^^^^^^^^
+   |
+   = note: this error originates in the macro `goto` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0268]: `continue` outside of a loop
+  --> tests/ui/forbidden.rs:13:5
+   |
+13 | /     switch!(match 0 {
+14 | |         0 => { v = 1; continue; }
+15 | |         _ => { v = 2; }
+16 | |     });
+   | |______^ cannot `continue` outside of a loop
+   |
+   = note: this error originates in the macro `switch` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/libcc2rs/CMakeLists.txt b/libcc2rs/CMakeLists.txt
index 563fb652..ddaae3d0 100644
--- a/libcc2rs/CMakeLists.txt
+++ b/libcc2rs/CMakeLists.txt
@@ -1,12 +1,18 @@
 set(RUST_LIB_DIR ${CMAKE_SOURCE_DIR}/libcc2rs)
+set(RUST_MACROS_DIR ${CMAKE_SOURCE_DIR}/libcc2rs-macros)
 set(RUST_BUILD_DIR ${CMAKE_BINARY_DIR}/rust)
 file(GLOB_RECURSE LIBCC2RS_SOURCE "${RUST_LIB_DIR}/*.rs")
+file(GLOB_RECURSE LIBCC2RS_MACROS_SOURCE "${RUST_MACROS_DIR}/*.rs")
 
 add_custom_command(
     OUTPUT ${RUST_BUILD_DIR}/release/liblibcc2rs.rlib
     COMMAND ${CMAKE_COMMAND} -E env CARGO_TARGET_DIR=${RUST_BUILD_DIR} cargo build --release
     WORKING_DIRECTORY ${RUST_LIB_DIR}
-    DEPENDS ${LIBCC2RS_SOURCE} ${RUST_LIB_DIR}/Cargo.toml
+    DEPENDS
+        ${LIBCC2RS_SOURCE}
+        ${LIBCC2RS_MACROS_SOURCE}
+        ${RUST_LIB_DIR}/Cargo.toml
+        ${RUST_MACROS_DIR}/Cargo.toml
     COMMENT "Building libcc2rs"
 )
 
diff --git a/libcc2rs/Cargo.toml b/libcc2rs/Cargo.toml
index cdc1405a..0ce61d9d 100644
--- a/libcc2rs/Cargo.toml
+++ b/libcc2rs/Cargo.toml
@@ -4,3 +4,6 @@ version = "0.1.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+libcc2rs-macros = { path = "../libcc2rs-macros", version = "0.1.0" }
diff --git a/libcc2rs/src/lib.rs b/libcc2rs/src/lib.rs
index 1271b941..859ba5cc 100644
--- a/libcc2rs/src/lib.rs
+++ b/libcc2rs/src/lib.rs
@@ -30,3 +30,5 @@ pub use compat::*;
 
 mod va_args;
 pub use va_args::*;
+
+pub use libcc2rs_macros::{goto, goto_block, switch};
diff --git a/tests/unit/out/refcount/switch_borrow_in_condition_and_in_body.rs b/tests/unit/out/refcount/switch_borrow_in_condition_and_in_body.rs
index af2d3986..a7272ca8 100644
--- a/tests/unit/out/refcount/switch_borrow_in_condition_and_in_body.rs
+++ b/tests/unit/out/refcount/switch_borrow_in_condition_and_in_body.rs
@@ -8,15 +8,12 @@ use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn borrow_in_condition_and_in_body_0(x: i32) -> i32 {
     let x: Value<i32> = Rc::new(RefCell::new(x));
-    'switch: {
-        let __match_cond = (*x.borrow());
-        match __match_cond {
-            v if v == 0 => {}
-            _ => {
-                return ((*x.borrow()) + 1);
-            }
+    switch!(match (*x.borrow()) {
+        v if v == 0 => {}
+        _ => {
+            return ((*x.borrow()) + 1);
         }
-    };
+    });
     panic!("ub: non-void function does not return a value")
 }
 pub fn main() {
diff --git a/tests/unit/out/refcount/switch_fallthrough_chain.rs b/tests/unit/out/refcount/switch_fallthrough_chain.rs
index 355e916d..f389991b 100644
--- a/tests/unit/out/refcount/switch_fallthrough_chain.rs
+++ b/tests/unit/out/refcount/switch_fallthrough_chain.rs
@@ -9,28 +9,25 @@ use std::rc::{Rc, Weak};
 pub fn fallthrough_chain_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 == 1 => {
-                (*r.borrow_mut()) += 1;
-            }
-            v if v == 2 => {
-                (*r.borrow_mut()) += 2;
-            }
-            v if v == 3 => {
-                (*r.borrow_mut()) += 4;
-            }
-            v if v == 4 => {
-                (*r.borrow_mut()) += 8;
-                break 'switch;
-            }
-            _ => {
-                (*r.borrow_mut()) = -1_i32;
-                break 'switch;
-            }
+    switch!(match (*x.borrow()) {
+        v if v == 1 => {
+            (*r.borrow_mut()) += 1;
         }
-    };
+        v if v == 2 => {
+            (*r.borrow_mut()) += 2;
+        }
+        v if v == 3 => {
+            (*r.borrow_mut()) += 4;
+        }
+        v if v == 4 => {
+            (*r.borrow_mut()) += 8;
+            break;
+        }
+        _ => {
+            (*r.borrow_mut()) = -1_i32;
+            break;
+        }
+    });
     return (*r.borrow());
 }
 pub fn main() {
diff --git a/tests/unit/out/refcount/switch_fallthrough_default.rs b/tests/unit/out/refcount/switch_fallthrough_default.rs
index 5a6da239..3a42ef09 100644
--- a/tests/unit/out/refcount/switch_fallthrough_default.rs
+++ b/tests/unit/out/refcount/switch_fallthrough_default.rs
@@ -10,21 +10,18 @@ pub fn fallthrough_default_0(x: i32, flag: i32) -> i32 {
     let x: Value<i32> = Rc::new(RefCell::new(x));
     let flag: Value<i32> = Rc::new(RefCell::new(flag));
     let r: Value<i32> = Rc::new(RefCell::new(0));
-    'switch: {
-        let __match_cond = (*x.borrow());
-        match __match_cond {
-            v if v == 7 => {
-                if ((*flag.borrow()) != 0) {
-                    (*r.borrow_mut()) = 100;
-                    break 'switch;
-                };
-            }
-            _ => {
-                (*r.borrow_mut()) = 42;
-                break 'switch;
-            }
+    switch!(match (*x.borrow()) {
+        v if v == 7 => {
+            if ((*flag.borrow()) != 0) {
+                (*r.borrow_mut()) = 100;
+                break;
+            };
         }
-    };
+        _ => {
+            (*r.borrow_mut()) = 42;
+            break;
+        }
+    });
     return (*r.borrow());
 }
 pub fn main() {
diff --git a/tests/unit/out/refcount/switch_fallthrough_into_block.rs b/tests/unit/out/refcount/switch_fallthrough_into_block.rs
index ffdc09d3..5fca913a 100644
--- a/tests/unit/out/refcount/switch_fallthrough_into_block.rs
+++ b/tests/unit/out/refcount/switch_fallthrough_into_block.rs
@@ -9,23 +9,20 @@ use std::rc::{Rc, Weak};
 pub fn fallthrough_into_block_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 == 1 => {
-                (*r.borrow_mut()) += 1;
-            }
-            v if v == 2 => {
-                let tmp: Value<i32> = Rc::new(RefCell::new(((*r.borrow()) * 10)));
-                (*r.borrow_mut()) = ((*tmp.borrow()) + 5);
-                break 'switch;
-            }
-            _ => {
-                (*r.borrow_mut()) = -1_i32;
-                break 'switch;
-            }
+    switch!(match (*x.borrow()) {
+        v if v == 1 => {
+            (*r.borrow_mut()) += 1;
         }
-    };
+        v if v == 2 => {
+            let tmp: Value<i32> = Rc::new(RefCell::new(((*r.borrow()) * 10)));
+            (*r.borrow_mut()) = ((*tmp.borrow()) + 5);
+            break;
+        }
+        _ => {
+            (*r.borrow_mut()) = -1_i32;
+            break;
+        }
+    });
     return (*r.borrow());
 }
 pub fn main() {
diff --git a/tests/unit/out/refcount/switch_fallthrough_one.rs b/tests/unit/out/refcount/switch_fallthrough_one.rs
index 490e6b8d..47f997ff 100644
--- a/tests/unit/out/refcount/switch_fallthrough_one.rs
+++ b/tests/unit/out/refcount/switch_fallthrough_one.rs
@@ -9,22 +9,19 @@ use std::rc::{Rc, Weak};
 pub fn fallthrough_one_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 == 1 => {
-                (*r.borrow_mut()) += 10;
-            }
-            v if v == 2 => {
-                (*r.borrow_mut()) += 20;
-                break 'switch;
-            }
-            _ => {
-                (*r.borrow_mut()) = -1_i32;
-                break 'switch;
-            }
+    switch!(match (*x.borrow()) {
+        v if v == 1 => {
+            (*r.borrow_mut()) += 10;
         }
-    };
+        v if v == 2 => {
+            (*r.borrow_mut()) += 20;
+            break;
+        }
+        _ => {
+            (*r.borrow_mut()) = -1_i32;
+            break;
+        }
+    });
     return (*r.borrow());
 }
 pub fn main() {
diff --git a/tests/unit/out/refcount/switch_stacked_with_inner_fallthrough.rs b/tests/unit/out/refcount/switch_stacked_with_inner_fallthrough.rs
index a317f423..8241abc5 100644
--- a/tests/unit/out/refcount/switch_stacked_with_inner_fallthrough.rs
+++ b/tests/unit/out/refcount/switch_stacked_with_inner_fallthrough.rs
@@ -10,21 +10,18 @@ pub fn stacked_with_inner_fallthrough_0(x: i32, flag: i32) -> i32 {
     let x: Value<i32> = Rc::new(RefCell::new(x));
     let flag: Value<i32> = Rc::new(RefCell::new(flag));
     let r: Value<i32> = Rc::new(RefCell::new(0));
-    'switch: {
-        let __match_cond = (*x.borrow());
-        match __match_cond {
-            v if v == 1 || v == 2 || v == 3 => {
-                if !((*flag.borrow()) != 0) {
-                    (*r.borrow_mut()) = 50;
-                    break 'switch;
-                };
-            }
-            _ => {
-                (*r.borrow_mut()) = 999;
-                break 'switch;
-            }
+    switch!(match (*x.borrow()) {
+        v if v == 1 || v == 2 || v == 3 => {
+            if !((*flag.borrow()) != 0) {
+                (*r.borrow_mut()) = 50;
+                break;
+            };
         }
-    };
+        _ => {
+            (*r.borrow_mut()) = 999;
+            break;
+        }
+    });
     return (*r.borrow());
 }
 pub fn main() {
diff --git a/tests/unit/out/unsafe/switch_borrow_in_condition_and_in_body.rs b/tests/unit/out/unsafe/switch_borrow_in_condition_and_in_body.rs
index 0c00b7ef..e139a2bd 100644
--- a/tests/unit/out/unsafe/switch_borrow_in_condition_and_in_body.rs
+++ b/tests/unit/out/unsafe/switch_borrow_in_condition_and_in_body.rs
@@ -7,15 +7,12 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub unsafe fn borrow_in_condition_and_in_body_0(mut x: i32) -> i32 {
-    'switch: {
-        let __match_cond = x;
-        match __match_cond {
-            v if v == 0 => {}
-            _ => {
-                return ((x) + (1));
-            }
+    switch!(match x {
+        v if v == 0 => {}
+        _ => {
+            return ((x) + (1));
         }
-    };
+    });
     panic!("ub: non-void function does not return a value")
 }
 pub fn main() {
diff --git a/tests/unit/out/unsafe/switch_fallthrough_chain.rs b/tests/unit/out/unsafe/switch_fallthrough_chain.rs
index 9c0b51bd..1c787562 100644
--- a/tests/unit/out/unsafe/switch_fallthrough_chain.rs
+++ b/tests/unit/out/unsafe/switch_fallthrough_chain.rs
@@ -8,28 +8,25 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub unsafe fn fallthrough_chain_0(mut x: i32) -> i32 {
     let mut r: i32 = 0;
-    'switch: {
-        let __match_cond = x;
-        match __match_cond {
-            v if v == 1 => {
-                r += 1;
-            }
-            v if v == 2 => {
-                r += 2;
-            }
-            v if v == 3 => {
-                r += 4;
-            }
-            v if v == 4 => {
-                r += 8;
-                break 'switch;
-            }
-            _ => {
-                r = -1_i32;
-                break 'switch;
-            }
+    switch!(match x {
+        v if v == 1 => {
+            r += 1;
         }
-    };
+        v if v == 2 => {
+            r += 2;
+        }
+        v if v == 3 => {
+            r += 4;
+        }
+        v if v == 4 => {
+            r += 8;
+            break;
+        }
+        _ => {
+            r = -1_i32;
+            break;
+        }
+    });
     return r;
 }
 pub fn main() {
diff --git a/tests/unit/out/unsafe/switch_fallthrough_default.rs b/tests/unit/out/unsafe/switch_fallthrough_default.rs
index 23ee0d70..d9d5dfd3 100644
--- a/tests/unit/out/unsafe/switch_fallthrough_default.rs
+++ b/tests/unit/out/unsafe/switch_fallthrough_default.rs
@@ -8,21 +8,18 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub unsafe fn fallthrough_default_0(mut x: i32, mut flag: i32) -> i32 {
     let mut r: i32 = 0;
-    'switch: {
-        let __match_cond = x;
-        match __match_cond {
-            v if v == 7 => {
-                if (flag != 0) {
-                    r = 100;
-                    break 'switch;
-                };
-            }
-            _ => {
-                r = 42;
-                break 'switch;
-            }
+    switch!(match x {
+        v if v == 7 => {
+            if (flag != 0) {
+                r = 100;
+                break;
+            };
         }
-    };
+        _ => {
+            r = 42;
+            break;
+        }
+    });
     return r;
 }
 pub fn main() {
diff --git a/tests/unit/out/unsafe/switch_fallthrough_into_block.rs b/tests/unit/out/unsafe/switch_fallthrough_into_block.rs
index 151af852..ba0dc430 100644
--- a/tests/unit/out/unsafe/switch_fallthrough_into_block.rs
+++ b/tests/unit/out/unsafe/switch_fallthrough_into_block.rs
@@ -8,23 +8,20 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub unsafe fn fallthrough_into_block_0(mut x: i32) -> i32 {
     let mut r: i32 = 0;
-    'switch: {
-        let __match_cond = x;
-        match __match_cond {
-            v if v == 1 => {
-                r += 1;
-            }
-            v if v == 2 => {
-                let mut tmp: i32 = ((r) * (10));
-                r = ((tmp) + (5));
-                break 'switch;
-            }
-            _ => {
-                r = -1_i32;
-                break 'switch;
-            }
+    switch!(match x {
+        v if v == 1 => {
+            r += 1;
         }
-    };
+        v if v == 2 => {
+            let mut tmp: i32 = ((r) * (10));
+            r = ((tmp) + (5));
+            break;
+        }
+        _ => {
+            r = -1_i32;
+            break;
+        }
+    });
     return r;
 }
 pub fn main() {
diff --git a/tests/unit/out/unsafe/switch_fallthrough_one.rs b/tests/unit/out/unsafe/switch_fallthrough_one.rs
index 4df2875a..f894740b 100644
--- a/tests/unit/out/unsafe/switch_fallthrough_one.rs
+++ b/tests/unit/out/unsafe/switch_fallthrough_one.rs
@@ -8,22 +8,19 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub unsafe fn fallthrough_one_0(mut x: i32) -> i32 {
     let mut r: i32 = 0;
-    'switch: {
-        let __match_cond = x;
-        match __match_cond {
-            v if v == 1 => {
-                r += 10;
-            }
-            v if v == 2 => {
-                r += 20;
-                break 'switch;
-            }
-            _ => {
-                r = -1_i32;
-                break 'switch;
-            }
+    switch!(match x {
+        v if v == 1 => {
+            r += 10;
         }
-    };
+        v if v == 2 => {
+            r += 20;
+            break;
+        }
+        _ => {
+            r = -1_i32;
+            break;
+        }
+    });
     return r;
 }
 pub fn main() {
diff --git a/tests/unit/out/unsafe/switch_stacked_with_inner_fallthrough.rs b/tests/unit/out/unsafe/switch_stacked_with_inner_fallthrough.rs
index e5eae4d3..515da37b 100644
--- a/tests/unit/out/unsafe/switch_stacked_with_inner_fallthrough.rs
+++ b/tests/unit/out/unsafe/switch_stacked_with_inner_fallthrough.rs
@@ -8,21 +8,18 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub unsafe fn stacked_with_inner_fallthrough_0(mut x: i32, mut flag: i32) -> i32 {
     let mut r: i32 = 0;
-    'switch: {
-        let __match_cond = x;
-        match __match_cond {
-            v if v == 1 || v == 2 || v == 3 => {
-                if !(flag != 0) {
-                    r = 50;
-                    break 'switch;
-                };
-            }
-            _ => {
-                r = 999;
-                break 'switch;
-            }
+    switch!(match x {
+        v if v == 1 || v == 2 || v == 3 => {
+            if !(flag != 0) {
+                r = 50;
+                break;
+            };
         }
-    };
+        _ => {
+            r = 999;
+            break;
+        }
+    });
     return r;
 }
 pub fn main() {
diff --git a/tests/unit/switch_borrow_in_condition_and_in_body.cpp b/tests/unit/switch_borrow_in_condition_and_in_body.cpp
index 5783dfa6..0c31421c 100644
--- a/tests/unit/switch_borrow_in_condition_and_in_body.cpp
+++ b/tests/unit/switch_borrow_in_condition_and_in_body.cpp
@@ -1,4 +1,3 @@
-// panic
 #include <cassert>
 
 int borrow_in_condition_and_in_body(int x) {
diff --git a/tests/unit/switch_fallthrough_chain.cpp b/tests/unit/switch_fallthrough_chain.cpp
index 271d4936..54f36df8 100644
--- a/tests/unit/switch_fallthrough_chain.cpp
+++ b/tests/unit/switch_fallthrough_chain.cpp
@@ -1,4 +1,3 @@
-// panic
 #include <cassert>
 
 int fallthrough_chain(int x) {
diff --git a/tests/unit/switch_fallthrough_default.cpp b/tests/unit/switch_fallthrough_default.cpp
index e7b3eff4..b016e749 100644
--- a/tests/unit/switch_fallthrough_default.cpp
+++ b/tests/unit/switch_fallthrough_default.cpp
@@ -1,4 +1,3 @@
-// panic
 #include <cassert>
 
 int fallthrough_default(int x, int flag) {
diff --git a/tests/unit/switch_fallthrough_into_block.cpp b/tests/unit/switch_fallthrough_into_block.cpp
index 206f3ee8..fe028648 100644
--- a/tests/unit/switch_fallthrough_into_block.cpp
+++ b/tests/unit/switch_fallthrough_into_block.cpp
@@ -1,4 +1,3 @@
-// panic
 #include <cassert>
 
 int fallthrough_into_block(int x) {
diff --git a/tests/unit/switch_fallthrough_one.cpp b/tests/unit/switch_fallthrough_one.cpp
index 58afd769..fc39bcd1 100644
--- a/tests/unit/switch_fallthrough_one.cpp
+++ b/tests/unit/switch_fallthrough_one.cpp
@@ -1,4 +1,3 @@
-// panic
 #include <cassert>
 
 int fallthrough_one(int x) {
diff --git a/tests/unit/switch_stacked_with_inner_fallthrough.cpp b/tests/unit/switch_stacked_with_inner_fallthrough.cpp
index d96c86d1..76f08f62 100644
--- a/tests/unit/switch_stacked_with_inner_fallthrough.cpp
+++ b/tests/unit/switch_stacked_with_inner_fallthrough.cpp
@@ -1,4 +1,3 @@
-// panic
 #include <cassert>
 
 int stacked_with_inner_fallthrough(int x, int flag) {