support float patterns

Author: folkertdev

compiler/rustc_mir_build/messages.ftl

@@ -239,7 +239,7 @@ mir_build_loop_match_missing_assignment =
 
 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
+    .note = only integers, floats, bool, char, 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

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(_) | ty::Bool | ty::Char => true,
+                        ty::Uint(_) | ty::Int(_) | ty::Float(_) | 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

@@ -21,6 +21,7 @@ use rustc_middle::ty::{
     self, CanonicalUserTypeAnnotation, Ty, TypeVisitableExt, ValTree, ValTreeKind,
 };
 use rustc_middle::{bug, span_bug};
+use rustc_pattern_analysis::constructor::RangeEnd;
 use rustc_pattern_analysis::rustc::{DeconstructedPat, RustcPatCtxt};
 use rustc_span::{BytePos, Pos, Span, Symbol, sym};
 use tracing::{debug, instrument};
@@ -1892,7 +1893,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         debug!("expanding or-pattern: candidate={:#?}\npats={:#?}", candidate, pats);
         candidate.or_span = Some(match_pair.pattern_span);
         candidate.subcandidates = pats
-            .into_vec()
             .into_iter()
             .map(|flat_pat| Candidate::from_flat_pat(flat_pat, candidate.has_guard))
             .collect();
@@ -2976,6 +2976,34 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 Ok(actual_value) => *pattern_value == actual_value,
                 Err(()) => bug!("bool value with invalid bits"),
             },
+            Constructor::F16Range(l, h, end) => {
+                let actual = valtree.unwrap_leaf().to_f16();
+                match end {
+                    RangeEnd::Included => (*l..=*h).contains(&actual),
+                    RangeEnd::Excluded => (*l..*h).contains(&actual),
+                }
+            }
+            Constructor::F32Range(l, h, end) => {
+                let actual = valtree.unwrap_leaf().to_f32();
+                match end {
+                    RangeEnd::Included => (*l..=*h).contains(&actual),
+                    RangeEnd::Excluded => (*l..*h).contains(&actual),
+                }
+            }
+            Constructor::F64Range(l, h, end) => {
+                let actual = valtree.unwrap_leaf().to_f64();
+                match end {
+                    RangeEnd::Included => (*l..=*h).contains(&actual),
+                    RangeEnd::Excluded => (*l..*h).contains(&actual),
+                }
+            }
+            Constructor::F128Range(l, h, end) => {
+                let actual = valtree.unwrap_leaf().to_f128();
+                match end {
+                    RangeEnd::Included => (*l..=*h).contains(&actual),
+                    RangeEnd::Excluded => (*l..*h).contains(&actual),
+                }
+            }
             Constructor::Wildcard => true,
 
             // These we may eventually support:
@@ -2984,10 +3012,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             | Constructor::Slice(_)
             | Constructor::UnionField
             | Constructor::Or
-            | Constructor::F16Range(..)
-            | Constructor::F32Range(..)
-            | Constructor::F64Range(..)
-            | Constructor::F128Range(..)
             | Constructor::Str(_) => bug!("unsupported pattern constructor {:?}", pat.ctor()),
 
             // These should never occur here:

compiler/rustc_mir_build/src/builder/scope.rs

@@ -866,7 +866,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             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 => {
+            ty::Uint(_) | ty::Int(_) | ty::Float(_) | 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/unsupported-type.stderr

@@ -4,7 +4,7 @@ error: this `#[loop_match]` state value has type `Option<bool>`, which is not su
 LL |         state = 'blk: {
    |         ^^^^^
    |
-   = note: only integers and enums without fields are supported
+   = note: only integers, floats, bool, char, and enums without fields are supported
 
 error: aborting due to 1 previous error
 

tests/ui/loop-match/integer-patterns.rs renamed to tests/ui/loop-match/valid-patterns.rs

@@ -17,6 +17,14 @@ fn main() {
     assert_eq!(character('b'), 'b');
     assert_eq!(character('c'), 'd');
     assert_eq!(character('d'), 'd');
+
+    assert_eq!(test_f32(1.0), core::f32::consts::PI);
+    assert_eq!(test_f32(2.5), core::f32::consts::PI);
+    assert_eq!(test_f32(4.0), 4.0);
+
+    assert_eq!(test_f64(1.0), core::f64::consts::PI);
+    assert_eq!(test_f64(2.5), core::f64::consts::PI);
+    assert_eq!(test_f64(4.0), 4.0);
 }
 
 fn integer(mut state: i32) -> i32 {
@@ -75,3 +83,35 @@ fn character(mut state: char) -> char {
         }
     }
 }
+
+fn test_f32(mut state: f32) -> f32 {
+    #[loop_match]
+    loop {
+        state = 'blk: {
+            match state {
+                1.0 => {
+                    #[const_continue]
+                    break 'blk 2.5;
+                }
+                2.0..3.0 => return core::f32::consts::PI,
+                _ => return state,
+            }
+        }
+    }
+}
+
+fn test_f64(mut state: f64) -> f64 {
+    #[loop_match]
+    loop {
+        state = 'blk: {
+            match state {
+                1.0 => {
+                    #[const_continue]
+                    break 'blk 2.5;
+                }
+                2.0..3.0 => return core::f64::consts::PI,
+                _ => return state,
+            }
+        }
+    }
+}