accept macros inside the labeled block before the match

Author: folkertdev

compiler/rustc_mir_build/src/thir/cx/expr.rs

@@ -895,9 +895,12 @@ impl<'tcx> ThirBuildCx<'tcx> {
                         dcx.emit_fatal(LoopMatchBadRhs { span: rhs_expr.span })
                     };
 
-                    if let Some(first) = block_body.stmts.first() {
-                        let span = first.span.to(block_body.stmts.last().unwrap().span);
-                        dcx.emit_fatal(LoopMatchBadStatements { span })
+                    // The labeled block should contain one match expression, but defining items is
+                    // allowed.
+                    for stmt in block_body.stmts {
+                        if !matches!(stmt.kind, rustc_hir::StmtKind::Item(_)) {
+                            dcx.emit_fatal(LoopMatchBadStatements { span: stmt.span })
+                        }
                     }
 
                     let Some(block_body_expr) = block_body.expr else {

compiler/rustc_passes/src/loops.rs

@@ -233,7 +233,9 @@ impl<'hir> Visitor<'hir> for CheckLoopVisitor<'hir> {
                 if attrs.iter().any(|attr| attr.has_name(sym::const_continue)) {
                     if let Some(break_label) = break_label.label {
                         let is_target_label = |cx: &Context| match cx {
-                            Context::LoopMatch { labeled_block } => break_label == *labeled_block,
+                            Context::LoopMatch { labeled_block } => {
+                                break_label.ident.name == labeled_block.ident.name
+                            }
                             _ => false,
                         };
 

tests/ui/loop-match/macro.rs

@@ -0,0 +1,48 @@
+// Test that macros can be defined in the labeled block. This should not trigger an error about
+// statements not being allowed in that position, and should of course work as expected.
+
+//@ run-pass
+
+#![allow(incomplete_features)]
+#![feature(loop_match)]
+
+enum State {
+    A,
+    B,
+    C,
+}
+
+fn main() {
+    let mut state = State::A;
+    #[loop_match]
+    'a: loop {
+        state = 'blk: {
+            macro_rules! const_continue {
+                ($e:expr) => {
+                    #[const_continue]
+                    break 'blk $e;
+                };
+            }
+            match state {
+                State::A => {
+                    const_continue!(State::B);
+                }
+                State::B => {
+                    // Without special logic, the compiler believes this is a
+                    // reassignment to an immutable variable because of the
+                    // `loop`. So this tests that local variables work.
+                    let _a = 0;
+
+                    if true {
+                        const_continue!(State::C);
+                    } else {
+                        const_continue!(State::A);
+                    }
+                }
+                State::C => break 'a,
+            }
+        };
+    }
+
+    assert!(matches!(state, State::C))
+}