emit an error when a match arm has a guard

Author: folkertdev

compiler/rustc_mir_build/messages.ftl

@@ -217,11 +217,14 @@ mir_build_literal_in_range_out_of_bounds =
     literal out of range for `{$ty}`
     .label = this value does not fit into the type `{$ty}` whose range is `{$min}..={$max}`
 
+mir_build_loop_match_arm_with_guard =
+    match arms that are part of a `#[loop_match]` cannot have guards
+
 mir_build_loop_match_bad_rhs =
     this expression must be a single `match` wrapped in a labeled block
 
 mir_build_loop_match_bad_statements =
-    statements are not allowed in this position within a `loop_match`
+    statements are not allowed in this position within a `#[loop_match]`
 
 mir_build_loop_match_invalid_match =
     invalid match on `loop_match` state

compiler/rustc_mir_build/src/builder/expr/into.rs

@@ -17,6 +17,7 @@ use tracing::{debug, instrument};
 use crate::builder::expr::category::{Category, RvalueFunc};
 use crate::builder::matches::{DeclareLetBindings, HasMatchGuard};
 use crate::builder::{BlockAnd, BlockAndExtension, BlockFrame, Builder, NeedsTemporary};
+use crate::errors::LoopMatchArmWithGuard;
 
 impl<'a, 'tcx> Builder<'a, 'tcx> {
     /// Compile `expr`, storing the result into `destination`, which
@@ -268,15 +269,18 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         unpack!(body_block = this.as_place_builder(body_block, state));
                     let scrutinee_span = this.thir.exprs[state].span;
                     let match_start_span = scrutinee_span; // span.shrink_to_lo().to(scrutinee_span); FIXME
-                    let patterns = arms
-                        .iter()
-                        .map(|&arm_id| {
-                            // FIXME nice error for guards (which are not allowed)
-                            let arm = &this.thir[arm_id];
-                            assert!(arm.guard.is_none());
-                            (&*arm.pattern, HasMatchGuard::No)
-                        })
-                        .collect();
+
+                    let mut patterns = Vec::with_capacity(arms.len());
+                    for &arm_id in arms.iter() {
+                        let arm = &this.thir[arm_id];
+
+                        if let Some(guard) = arm.guard {
+                            let span = this.thir.exprs[guard].span;
+                            this.tcx.dcx().emit_fatal(LoopMatchArmWithGuard { span })
+                        }
+
+                        patterns.push((&*arm.pattern, HasMatchGuard::No));
+                    }
 
                     let built_tree = this.lower_match_tree(
                         body_block,

compiler/rustc_mir_build/src/errors.rs

@@ -1200,6 +1200,13 @@ pub(crate) struct LoopMatchMissingAssignment {
     pub span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(mir_build_loop_match_arm_with_guard)]
+pub(crate) struct LoopMatchArmWithGuard {
+    #[primary_span]
+    pub span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(mir_build_const_continue_missing_value)]
 pub(crate) struct ConstContinueMissingValue {

tests/ui/loop-match/invalid.rs

@@ -41,7 +41,7 @@ fn bad_statements_1() {
     #[loop_match]
     loop {
         1;
-        //~^ ERROR statements are not allowed in this position within a `loop_match`
+        //~^ ERROR statements are not allowed in this position within a `#[loop_match]`
         state = 'blk: {
             match State::A {
                 _ => State::B,
@@ -56,7 +56,7 @@ fn bad_statements_2() {
     loop {
         state = 'blk: {
             1;
-            //~^ ERROR statements are not allowed in this position within a `loop_match`
+            //~^ ERROR statements are not allowed in this position within a `#[loop_match]`
             match State::A {
                 _ => State::B,
             }
@@ -142,3 +142,21 @@ fn break_without_value_unit() {
         }
     }
 }
+
+fn arm_has_guard(cond: bool) {
+    let state = State::A;
+    #[loop_match]
+    'a: loop {
+        state = 'blk: {
+            match state {
+                State::A => {
+                    #[const_continue]
+                    break 'blk State::B;
+                }
+                State::B if cond => break 'a,
+                //~^ ERROR match arms that are part of a `#[loop_match]` cannot have guards
+                _ => break 'a,
+            }
+        }
+    }
+}

tests/ui/loop-match/invalid.stderr

@@ -26,13 +26,13 @@ LL |             match State::A {
    |
    = note: only matches on local variables are valid
 
-error: statements are not allowed in this position within a `loop_match`
+error: statements are not allowed in this position within a `#[loop_match]`
   --> $DIR/invalid.rs:43:9
    |
 LL |         1;
    |         ^^
 
-error: statements are not allowed in this position within a `loop_match`
+error: statements are not allowed in this position within a `#[loop_match]`
   --> $DIR/invalid.rs:58:13
    |
 LL |             1;
@@ -80,6 +80,12 @@ error: a `#[const_continue]` must break to a label with a value
 LL |                     break 'blk;
    |                     ^^^^^^^^^^
 
-error: aborting due to 11 previous errors
+error: match arms that are part of a `#[loop_match]` cannot have guards
+  --> $DIR/invalid.rs:156:29
+   |
+LL |                 State::B if cond => break 'a,
+   |                             ^^^^
+
+error: aborting due to 12 previous errors
 
 For more information about this error, try `rustc --explain E0308`.