support boolean and character patterns

Author: folkertdev

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

@@ -255,7 +255,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
                 fn is_supported_loop_match_type(ty: Ty<'_>) -> bool {
                     match ty.kind() {
-                        ty::Uint(_) | ty::Int(_) => true,
+                        ty::Uint(_) | ty::Int(_) | ty::Bool | ty::Char => true,
                         ty::Adt(adt_def, _) => match adt_def.adt_kind() {
                             ty::AdtKind::Struct | ty::AdtKind::Union => false,
                             ty::AdtKind::Enum => {

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

@@ -2972,6 +2972,10 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 };
                 IntRange::from_singleton(actual_int).is_subrange(int_range)
             }
+            Constructor::Bool(pattern_value) => match valtree.unwrap_leaf().try_to_bool() {
+                Ok(actual_value) => *pattern_value == actual_value,
+                Err(()) => bug!("bool value with invalid bits"),
+            },
             Constructor::Wildcard => true,
 
             // these we may eventually support
@@ -2980,7 +2984,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             | Constructor::Slice(_)
             | Constructor::UnionField
             | Constructor::Or
-            | Constructor::Bool(_)
             | Constructor::F16Range(..)
             | Constructor::F32Range(..)
             | Constructor::F64Range(..)

compiler/rustc_mir_build/src/builder/scope.rs

@@ -864,15 +864,13 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
         let state_decl = &self.local_decls[scope.state_place.as_local().unwrap()];
         let state_ty = state_decl.ty;
-        let discriminant_ty = match state_ty {
-            ty if ty.is_enum() => ty.discriminant_ty(self.tcx),
-            ty if ty.is_integral() => ty,
-            _ => span_bug!(state_decl.source_info.span, "unsupported #[loop_match] state"),
-        };
-
-        let rvalue = match state_ty {
-            ty if ty.is_enum() => Rvalue::Discriminant(scope.state_place),
-            ty if ty.is_integral() => Rvalue::Use(Operand::Copy(scope.state_place)),
+        let (discriminant_ty, rvalue) = match state_ty.kind() {
+            ty::Adt(adt_def, _) if adt_def.is_enum() => {
+                (state_ty.discriminant_ty(self.tcx), Rvalue::Discriminant(scope.state_place))
+            }
+            ty::Uint(_) | ty::Int(_) | ty::Bool | ty::Char => {
+                (state_ty, Rvalue::Use(Operand::Copy(scope.state_place)))
+            }
             _ => span_bug!(state_decl.source_info.span, "unsupported #[loop_match] state"),
         };
 

tests/ui/loop-match/integer-patterns.rs

@@ -6,7 +6,20 @@
 #![feature(loop_match)]
 
 fn main() {
-    let mut state = 0i32;
+    assert_eq!(integer(0), 2);
+    assert_eq!(integer(-1), 2);
+    assert_eq!(integer(2), 2);
+
+    assert_eq!(boolean(true), false);
+    assert_eq!(boolean(false), false);
+
+    assert_eq!(character('a'), 'b');
+    assert_eq!(character('b'), 'b');
+    assert_eq!(character('c'), 'd');
+    assert_eq!(character('d'), 'd');
+}
+
+fn integer(mut state: i32) -> i32 {
     #[loop_match]
     'a: loop {
         state = 'blk: {
@@ -24,5 +37,41 @@ fn main() {
             }
         }
     }
-    assert_eq!(state, 2);
+
+    state
+}
+
+fn boolean(mut state: bool) -> bool {
+    #[loop_match]
+    loop {
+        state = 'blk: {
+            match state {
+                true => {
+                    #[const_continue]
+                    break 'blk false;
+                }
+                false => return state,
+            }
+        }
+    }
+}
+
+fn character(mut state: char) -> char {
+    #[loop_match]
+    loop {
+        state = 'blk: {
+            match state {
+                'a' => {
+                    #[const_continue]
+                    break 'blk 'b';
+                }
+                'b' => return state,
+                'c' => {
+                    #[const_continue]
+                    break 'blk 'd';
+                }
+                _ => return state,
+            }
+        }
+    }
 }