loop match: error on #[const_continue] outside #[loop_match]

Author: folkertdev

compiler/rustc_mir_build/messages.ftl

@@ -88,8 +88,12 @@ mir_build_const_continue_bad_const = could not determine the target branch for t
     .label = this value is too generic
     .note = the value must be a literal or a monomorphic const
 
+mir_build_const_continue_invalid_jump = a `#[const_continue]` must break to a labeled block that participates in a `#[loop_match]`
+
 mir_build_const_continue_missing_value = a `#[const_continue]` must break to a label with a value
 
+mir_build_const_continue_not_in_loop_match = a `#[const_continue]` can only occur in a `#[loop_match]` loop
+
 mir_build_const_continue_unknown_jump_target = the target of this `#[const_continue]` is not statically known
     .label = this value must be a literal or a monomorphic const
 

compiler/rustc_mir_build/src/builder/scope.rs

@@ -100,7 +100,10 @@ use tracing::{debug, instrument};
 
 use super::matches::BuiltMatchTree;
 use crate::builder::{BlockAnd, BlockAndExtension, BlockFrame, Builder, CFG};
-use crate::errors::{ConstContinueBadConst, ConstContinueUnknownJumpTarget};
+use crate::errors::{
+    ConstContinueBadConst, ConstContinueInvalidJump, ConstContinueNotInLoopMatch,
+    ConstContinueUnknownJumpTarget,
+};
 
 #[derive(Debug)]
 pub(crate) struct Scopes<'tcx> {
@@ -862,6 +865,20 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
     ) -> BlockAnd<()> {
         let span = source_info.span;
 
+        let opt_break_index = self
+            .scopes
+            .const_continuable_scopes
+            .iter()
+            .rposition(|const_continuable_scope| const_continuable_scope.region_scope == scope);
+
+        let Some(break_index) = opt_break_index else {
+            if self.scopes.const_continuable_scopes.is_empty() {
+                self.tcx.dcx().emit_fatal(ConstContinueNotInLoopMatch { span })
+            } else {
+                self.tcx.dcx().emit_fatal(ConstContinueInvalidJump { span })
+            }
+        };
+
         // A break can only break out of a scope, so the value should be a scope.
         let rustc_middle::thir::ExprKind::Scope { value, .. } = self.thir[value].kind else {
             span_bug!(span, "break value must be a scope")
@@ -890,13 +907,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             _ => self.as_constant(&self.thir[value]),
         };
 
-        let break_index = self
-            .scopes
-            .const_continuable_scopes
-            .iter()
-            .rposition(|const_continuable_scope| const_continuable_scope.region_scope == scope)
-            .unwrap_or_else(|| span_bug!(span, "no enclosing const-continuable scope found"));
-
         let scope = &self.scopes.const_continuable_scopes[break_index];
 
         let state_decl = &self.local_decls[scope.state_place.as_local().unwrap()];

compiler/rustc_mir_build/src/errors.rs

@@ -1221,6 +1221,20 @@ pub(crate) struct ConstContinueBadConst {
     pub span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(mir_build_const_continue_invalid_jump)]
+pub(crate) struct ConstContinueInvalidJump {
+    #[primary_span]
+    pub span: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag(mir_build_const_continue_not_in_loop_match)]
+pub(crate) struct ConstContinueNotInLoopMatch {
+    #[primary_span]
+    pub span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(mir_build_const_continue_missing_value)]
 pub(crate) struct ConstContinueMissingValue {

tests/ui/loop-match/const-continue-outside-loop-match.rs

@@ -0,0 +1,62 @@
+// Test that the correct error is emitted when `#[const_continue]` occurs outside of
+// a loop match. See also https://github.com/rust-lang/rust/issues/143165.
+#![allow(incomplete_features)]
+#![feature(loop_match)]
+#![crate_type = "lib"]
+
+fn main1() {
+    let mut state;
+    loop {
+        state = 'state: {
+            #[const_continue]
+            break break;
+            //~^ ERROR a `#[const_continue]` can only occur in a `#[loop_match]` loop
+            //~| ERROR unlabeled `break` inside of a labeled block
+            //~| ERROR unlabeled `break` inside of a labeled block
+        }
+    }
+}
+
+enum State2 {
+    X,
+    Z,
+}
+
+fn main2() {
+    let mut state1;
+    let mut state2;
+    let mut first;
+    'a: loop {
+        state1 = 'blk1: {
+            match state1 {
+                State1A => {
+                    #[loop_match]
+                    loop {
+                        state2 = 'blk2: {
+                            match state2 {
+                                State2X => {
+                                    break 'blk2 {
+                                        //~^ WARN this labeled break expression is easy to confuse with an unlabeled break
+                                        if first {
+                                            'blk2: {
+                                                //~^ WARN label name `'blk2` shadows a label name that is already in scope
+                                                match state2 {
+                                                    State2X => {
+                                                        #[const_continue]
+                                                        break 'blk2 State2::Z;
+                                                        //~^ ERROR a `#[const_continue]` must break to a labeled block that participates in a `#[loop_match]`
+                                                    }
+                                                }
+                                            };
+                                        }
+                                        break 'blk2 State2::X;
+                                    };
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

tests/ui/loop-match/const-continue-outside-loop-match.stderr

@@ -0,0 +1,58 @@
+warning: label name `'blk2` shadows a label name that is already in scope
+  --> $DIR/const-continue-outside-loop-match.rs:41:45
+   |
+LL |                         state2 = 'blk2: {
+   |                                  ----- first declared here
+...
+LL |                                             'blk2: {
+   |                                             ^^^^^ label `'blk2` already in scope
+
+warning: this labeled break expression is easy to confuse with an unlabeled break with a labeled value expression
+  --> $DIR/const-continue-outside-loop-match.rs:38:37
+   |
+LL | / ...                   break 'blk2 {
+LL | | ...
+LL | | ...                       if first {
+LL | | ...                           'blk2: {
+...  |
+LL | | ...                       break 'blk2 State2::X;
+LL | | ...                   };
+   | |_______________________^
+   |
+   = note: `#[warn(break_with_label_and_loop)]` on by default
+help: wrap this expression in parentheses
+   |
+LL ~                                     break 'blk2 ({
+LL |
+...
+LL |                                         break 'blk2 State2::X;
+LL ~                                     });
+   |
+
+error[E0695]: unlabeled `break` inside of a labeled block
+  --> $DIR/const-continue-outside-loop-match.rs:12:19
+   |
+LL |             break break;
+   |                   ^^^^^ `break` statements that would diverge to or through a labeled block need to bear a label
+
+error[E0695]: unlabeled `break` inside of a labeled block
+  --> $DIR/const-continue-outside-loop-match.rs:12:13
+   |
+LL |             break break;
+   |             ^^^^^^^^^^^ `break` statements that would diverge to or through a labeled block need to bear a label
+
+error: a `#[const_continue]` can only occur in a `#[loop_match]` loop
+  --> $DIR/const-continue-outside-loop-match.rs:12:13
+   |
+LL |             break break;
+   |             ^^^^^^^^^^^
+
+error: a `#[const_continue]` must break to a labeled block that participates in a `#[loop_match]`
+  --> $DIR/const-continue-outside-loop-match.rs:46:57
+   |
+LL | ...                   break 'blk2 State2::Z;
+   |                       ^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 4 previous errors; 2 warnings emitted
+
+For more information about this error, try `rustc --explain E0695`.

tests/ui/loop-match/invalid.rs

@@ -142,6 +142,23 @@ fn break_without_value_unit() {
     }
 }
 
+fn break_without_label() {
+    let mut state = State::A;
+    #[loop_match]
+    'a: loop {
+        state = 'blk: {
+            match state {
+                _ => {
+                    #[const_continue]
+                    break State::A;
+                    //~^ ERROR unlabeled `break` inside of a labeled block
+                    //~| ERROR mismatched types
+                }
+            }
+        }
+    }
+}
+
 fn arm_has_guard(cond: bool) {
     let mut state = State::A;
     #[loop_match]

tests/ui/loop-match/invalid.stderr

@@ -9,6 +9,18 @@ help: give the `break` a value of the expected type
 LL |                     break 'blk /* value */;
    |                                +++++++++++
 
+error[E0695]: unlabeled `break` inside of a labeled block
+  --> $DIR/invalid.rs:153:21
+   |
+LL |                     break State::A;
+   |                     ^^^^^^^^^^^^^^ `break` statements that would diverge to or through a labeled block need to bear a label
+
+error[E0308]: mismatched types
+  --> $DIR/invalid.rs:153:27
+   |
+LL |                     break State::A;
+   |                           ^^^^^^^^ expected `()`, found `State`
+
 error: invalid update of the `#[loop_match]` state
   --> $DIR/invalid.rs:18:9
    |
@@ -81,13 +93,13 @@ LL |                     break 'blk;
    |                     ^^^^^^^^^^
 
 error: match arms that are part of a `#[loop_match]` cannot have guards
-  --> $DIR/invalid.rs:155:29
+  --> $DIR/invalid.rs:172:29
    |
 LL |                 State::B if cond => break 'a,
    |                             ^^^^
 
 error[E0004]: non-exhaustive patterns: `State::B` and `State::C` not covered
-  --> $DIR/invalid.rs:168:19
+  --> $DIR/invalid.rs:185:19
    |
 LL |             match state {
    |                   ^^^^^ patterns `State::B` and `State::C` not covered
@@ -110,12 +122,12 @@ LL ~                 State::B | State::C => todo!(),
    |
 
 error[E0579]: lower range bound must be less than upper
-  --> $DIR/invalid.rs:185:17
+  --> $DIR/invalid.rs:202:17
    |
 LL |                 4.0..3.0 => {
    |                 ^^^^^^^^
 
-error: aborting due to 14 previous errors
+error: aborting due to 16 previous errors
 
-Some errors have detailed explanations: E0004, E0308, E0579.
+Some errors have detailed explanations: E0004, E0308, E0579, E0695.
 For more information about an error, try `rustc --explain E0004`.