error on unsupported state type

Author: folkertdev

compiler/rustc_mir_build/messages.ftl

@@ -237,6 +237,10 @@ mir_build_loop_match_invalid_update =
 mir_build_loop_match_missing_assignment =
     expected a single assignment expression
 
+mir_build_loop_match_unsupported_type =
+    this `#[loop_match]` state value has type `{$ty}`, which is not supported
+    .note = only integers and enums without fields are supported
+
 mir_build_lower_range_bound_must_be_less_than_or_equal_to_upper =
     lower range bound must be less than or equal to upper
     .label = lower bound larger than upper bound

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

@@ -8,7 +8,7 @@ use rustc_hir::lang_items::LangItem;
 use rustc_middle::mir::*;
 use rustc_middle::span_bug;
 use rustc_middle::thir::*;
-use rustc_middle::ty::{CanonicalUserTypeAnnotation, Ty};
+use rustc_middle::ty::{self, CanonicalUserTypeAnnotation, Ty};
 use rustc_span::DUMMY_SP;
 use rustc_span::source_map::Spanned;
 use rustc_trait_selection::infer::InferCtxtExt;
@@ -17,7 +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;
+use crate::errors::{LoopMatchArmWithGuard, LoopMatchUnsupportedType};
 
 impl<'a, 'tcx> Builder<'a, 'tcx> {
     /// Compile `expr`, storing the result into `destination`, which
@@ -253,6 +253,34 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 // `in_const_continuable_scope`, which makes the match arms and their target basic
                 // block available to the lowering of `#[const_continue]`.
 
+                fn is_supported_loop_match_type(ty: Ty<'_>) -> bool {
+                    if ty.is_integral() {
+                        return true;
+                    }
+
+                    if let Some(adt_def) = ty.ty_adt_def() {
+                        if adt_def.adt_kind() != ty::AdtKind::Enum {
+                            return false;
+                        }
+
+                        for variant in adt_def.variants() {
+                            if !variant.fields.is_empty() {
+                                return false;
+                            }
+                        }
+
+                        return true;
+                    }
+
+                    false
+                }
+
+                let state_ty = this.thir.exprs[state].ty;
+                if !is_supported_loop_match_type(state_ty) {
+                    let span = this.thir.exprs[state].span;
+                    this.tcx.dcx().emit_fatal(LoopMatchUnsupportedType { span, ty: state_ty })
+                }
+
                 let loop_block = this.cfg.start_new_block();
 
                 // Start the loop.

compiler/rustc_mir_build/src/builder/matches/mod.rs

@@ -2972,8 +2972,29 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 IntRange::from_singleton(actual_int).is_subrange(int_range)
             }
             Constructor::Wildcard => true,
-            // FIXME error out before static_pattern_match gets run and replace this with bug!()
-            _ => false,
+
+            // these we may eventually support
+            Constructor::Struct
+            | Constructor::Ref
+            | Constructor::Slice(_)
+            | Constructor::UnionField
+            | Constructor::Or
+            | Constructor::Bool(_)
+            | Constructor::F16Range(..)
+            | Constructor::F32Range(..)
+            | Constructor::F64Range(..)
+            | Constructor::F128Range(..)
+            | Constructor::Str(_) => bug!("unsupported pattern constructor {:?}", pat.ctor()),
+
+            // these should never occur here
+            Constructor::Opaque(_)
+            | Constructor::Never
+            | Constructor::NonExhaustive
+            | Constructor::Hidden
+            | Constructor::Missing
+            | Constructor::PrivateUninhabited => {
+                bug!("unsupported pattern constructor {:?}", pat.ctor())
+            }
         }
     }
 }

compiler/rustc_mir_build/src/errors.rs

@@ -1179,6 +1179,15 @@ pub(crate) struct LoopMatchInvalidMatch {
     pub span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(mir_build_loop_match_unsupported_type)]
+#[note]
+pub(crate) struct LoopMatchUnsupportedType<'tcx> {
+    #[primary_span]
+    pub span: Span,
+    pub ty: Ty<'tcx>,
+}
+
 #[derive(Diagnostic)]
 #[diag(mir_build_loop_match_bad_statements)]
 pub(crate) struct LoopMatchBadStatements {

tests/ui/loop-match/unsupported-type.rs

@@ -0,0 +1,25 @@
+// Test that a good error is emitted when the #[loop_match] state is an unsupported type
+#![allow(incomplete_features)]
+#![feature(loop_match)]
+#![crate_type = "lib"]
+
+fn unsupported_type() {
+    let mut state = Some(false);
+    #[loop_match]
+    'a: loop {
+        state = 'blk: {
+            //~^ ERROR this `#[loop_match]` state value has type `Option<bool>`, which is not supported
+            match state {
+                Some(false) => {
+                    #[const_continue]
+                    break 'blk Some(true);
+                }
+                Some(true) => {
+                    #[const_continue]
+                    break 'blk None;
+                }
+                None => break 'a,
+            }
+        }
+    }
+}

tests/ui/loop-match/unsupported-type.stderr

@@ -0,0 +1,10 @@
+error: this `#[loop_match]` state value has type `Option<bool>`, which is not supported
+  --> $DIR/unsupported-type.rs:10:9
+   |
+LL |         state = 'blk: {
+   |         ^^^^^
+   |
+   = note: only integers and enums without fields are supported
+
+error: aborting due to 1 previous error
+