loop_match: suggest wrapping in a const block

if the expression cannot be evaluated in a straightforward way

Author: folkertdev

compiler/rustc_mir_build/messages.ftl

@@ -86,10 +86,13 @@ mir_build_confused = missing patterns are not covered because `{$variable}` is i
 
 mir_build_const_continue_bad_const = could not determine the target branch for this `#[const_continue]`
     .label = this value is too generic
-    .note = the value must be a literal or a monomorphic const
 
 mir_build_const_continue_missing_value = a `#[const_continue]` must break to a label with a value
 
+mir_build_const_continue_not_const = could not determine the target branch for this `#[const_continue]`
+    .label = the value must be a literal or a monomorphic const
+    .suggestion = try wrapping the expression in a `const` block
+
 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/expr/as_constant.rs

@@ -18,25 +18,31 @@ use crate::builder::{Builder, parse_float_into_constval};
 impl<'a, 'tcx> Builder<'a, 'tcx> {
     /// Compile `expr`, yielding a compile-time constant. Assumes that
     /// `expr` is a valid compile-time constant!
-    pub(crate) fn as_constant(&mut self, expr: &Expr<'tcx>) -> ConstOperand<'tcx> {
-        let this = self;
-        let tcx = this.tcx;
-        let Expr { ty, temp_lifetime: _, span, ref kind } = *expr;
-        match kind {
-            ExprKind::Scope { region_scope: _, lint_level: _, value } => {
-                this.as_constant(&this.thir[*value])
-            }
-            _ => as_constant_inner(
+    pub(crate) fn as_constant(&mut self, expr: &'a Expr<'tcx>) -> ConstOperand<'tcx> {
+        match self.try_as_constant(expr) {
+            Ok(const_operand) => const_operand,
+            Err(expr) => span_bug!(expr.span, "expression is not a valid constant {:?}", expr.kind),
+        }
+    }
+
+    pub(crate) fn try_as_constant(
+        &mut self,
+        expr: &'a Expr<'tcx>,
+    ) -> Result<ConstOperand<'tcx>, &'a Expr<'tcx>> {
+        if let ExprKind::Scope { region_scope: _, lint_level: _, value } = expr.kind {
+            self.try_as_constant(&self.thir[value])
+        } else {
+            try_as_constant_inner(
                 expr,
                 |user_ty| {
-                    Some(this.canonical_user_type_annotations.push(CanonicalUserTypeAnnotation {
-                        span,
+                    Some(self.canonical_user_type_annotations.push(CanonicalUserTypeAnnotation {
+                        span: expr.span,
                         user_ty: user_ty.clone(),
-                        inferred_ty: ty,
+                        inferred_ty: expr.ty,
                     }))
                 },
-                tcx,
-            ),
+                self.tcx,
+            )
         }
     }
 }
@@ -46,8 +52,19 @@ pub(crate) fn as_constant_inner<'tcx>(
     push_cuta: impl FnMut(&Box<CanonicalUserType<'tcx>>) -> Option<UserTypeAnnotationIndex>,
     tcx: TyCtxt<'tcx>,
 ) -> ConstOperand<'tcx> {
+    match try_as_constant_inner(expr, push_cuta, tcx) {
+        Ok(const_operand) => const_operand,
+        Err(expr) => span_bug!(expr.span, "expression is not a valid constant {:?}", expr.kind),
+    }
+}
+
+fn try_as_constant_inner<'a, 'tcx>(
+    expr: &'a Expr<'tcx>,
+    push_cuta: impl FnMut(&Box<CanonicalUserType<'tcx>>) -> Option<UserTypeAnnotationIndex>,
+    tcx: TyCtxt<'tcx>,
+) -> Result<ConstOperand<'tcx>, &'a Expr<'tcx>> {
     let Expr { ty, temp_lifetime: _, span, ref kind } = *expr;
-    match *kind {
+    Ok(match *kind {
         ExprKind::Literal { lit, neg } => {
             let const_ = lit_to_mir_constant(tcx, LitToConstInput { lit: lit.node, ty, neg });
 
@@ -93,8 +110,8 @@ pub(crate) fn as_constant_inner<'tcx>(
 
             ConstOperand { span, user_ty: None, const_ }
         }
-        _ => span_bug!(span, "expression is not a valid constant {:?}", kind),
-    }
+        _ => return Err(expr),
+    })
 }
 
 #[instrument(skip(tcx, lit_input))]

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, ConstContinueNotConst, ConstContinueNotConstSuggestConstBlock,
+    ConstContinueUnknownJumpTarget,
+};
 
 #[derive(Debug)]
 pub(crate) struct Scopes<'tcx> {
@@ -887,7 +890,19 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     ),
                 }
             }
-            _ => self.as_constant(&self.thir[value]),
+            _ => match self.try_as_constant(&self.thir[value]) {
+                Ok(const_operand) => const_operand,
+                Err(expr) => {
+                    self.tcx.dcx().emit_err(ConstContinueNotConst {
+                        span: expr.span,
+                        sub: ConstContinueNotConstSuggestConstBlock {
+                            left: expr.span.shrink_to_lo(),
+                            right: expr.span.shrink_to_hi(),
+                        },
+                    });
+                    return block.unit();
+                }
+            },
         };
 
         let break_index = self

compiler/rustc_mir_build/src/errors.rs

@@ -1213,6 +1213,26 @@ pub(crate) struct LoopMatchArmWithGuard {
     pub span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(mir_build_const_continue_not_const)]
+pub(crate) struct ConstContinueNotConst {
+    #[primary_span]
+    #[label]
+    pub span: Span,
+
+    #[subdiagnostic]
+    pub(crate) sub: ConstContinueNotConstSuggestConstBlock,
+}
+
+#[derive(Subdiagnostic)]
+#[multipart_suggestion(mir_build_suggestion, applicability = "maybe-incorrect")]
+pub(crate) struct ConstContinueNotConstSuggestConstBlock {
+    #[suggestion_part(code = "const {{ ")]
+    pub(crate) left: Span,
+    #[suggestion_part(code = " }}")]
+    pub(crate) right: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(mir_build_const_continue_bad_const)]
 pub(crate) struct ConstContinueBadConst {

tests/ui/loop-match/suggest-const-block.rs

@@ -0,0 +1,30 @@
+#![allow(incomplete_features)]
+#![feature(loop_match)]
+#![crate_type = "lib"]
+
+const fn const_fn() -> i32 {
+    1
+}
+
+#[unsafe(no_mangle)]
+fn suggest_const_block() -> i32 {
+    let mut state = 0;
+    #[loop_match]
+    loop {
+        state = 'blk: {
+            match state {
+                0 => {
+                    #[const_continue]
+                    break 'blk const_fn();
+                    //~^ ERROR could not determine the target branch for this `#[const_continue]`
+                }
+                _ => {
+                    #[const_continue]
+                    break 'blk 1 + 1;
+                    //~^ ERROR could not determine the target branch for this `#[const_continue]`
+                }
+            }
+        }
+    }
+    state
+}

tests/ui/loop-match/suggest-const-block.stderr

@@ -0,0 +1,24 @@
+error: could not determine the target branch for this `#[const_continue]`
+  --> $DIR/suggest-const-block.rs:18:32
+   |
+LL |                     break 'blk const_fn();
+   |                                ^^^^^^^^^^ the value must be a literal or a monomorphic const
+   |
+help: try wrapping the expression in a `const` block
+   |
+LL |                     break 'blk const { const_fn() };
+   |                                +++++++            +
+
+error: could not determine the target branch for this `#[const_continue]`
+  --> $DIR/suggest-const-block.rs:23:32
+   |
+LL |                     break 'blk 1 + 1;
+   |                                ^^^^^ the value must be a literal or a monomorphic const
+   |
+help: try wrapping the expression in a `const` block
+   |
+LL |                     break 'blk const { 1 + 1 };
+   |                                +++++++       +
+
+error: aborting due to 2 previous errors
+