Split out a separate PatConstKind::Float

Unlike the other types covered by `PatConstKind::Other`, const-float patterns
can also interact with range patterns.

Author: Zalathar

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

@@ -289,7 +289,13 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     if !test.overlaps(pat, self.tcx)? { Some(TestBranch::Failure) } else { None }
                 }
             }
-            (TestKind::Range(range), &TestableCase::Constant { value, kind: _ }) => {
+            (
+                TestKind::Range(range),
+                &TestableCase::Constant {
+                    value,
+                    kind: PatConstKind::Bool | PatConstKind::IntOrChar | PatConstKind::Float,
+                },
+            ) => {
                 fully_matched = false;
                 if !range.contains(value, self.tcx)? {
                     // `value` is not contained in the testing range,
@@ -302,7 +308,10 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
             (
                 TestKind::Eq { value: test_val, .. },
-                TestableCase::Constant { value: case_val, kind: _ },
+                TestableCase::Constant {
+                    value: case_val,
+                    kind: PatConstKind::Float | PatConstKind::Other,
+                },
             ) => {
                 if test_val == case_val {
                     fully_matched = true;

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

@@ -171,6 +171,8 @@ impl<'tcx> MatchPairTree<'tcx> {
                     PatConstKind::Bool
                 } else if pat_ty.is_integral() || pat_ty.is_char() {
                     PatConstKind::IntOrChar
+                } else if pat_ty.is_floating_point() {
+                    PatConstKind::Float
                 } else {
                     // FIXME(Zalathar): This still covers several different
                     // categories (e.g. raw pointer, string, pattern-type)

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

@@ -1286,10 +1286,13 @@ enum PatConstKind {
     /// Primitive unsigned/signed integer types, plus `char`.
     /// These types interact nicely with `SwitchInt`.
     IntOrChar,
+    /// Floating-point primitives, e.g. `f32`, `f64`.
+    /// These types don't support `SwitchInt` and require an equality test,
+    /// but can also interact with range pattern tests.
+    Float,
     /// Any other constant-pattern is usually tested via some kind of equality
     /// check. Types that might be encountered here include:
     /// - `&str`
-    /// - floating-point primitives, e.g. `f32`, `f64`
     /// - raw pointers derived from integer values
     /// - pattern types, e.g. `pattern_type!(u32 is 1..)`
     Other,

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

@@ -38,6 +38,9 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             TestableCase::Constant { value: _, kind: PatConstKind::IntOrChar } => {
                 TestKind::SwitchInt
             }
+            TestableCase::Constant { value, kind: PatConstKind::Float } => {
+                TestKind::Eq { value, cast_ty: match_pair.pattern_ty }
+            }
             TestableCase::Constant { value, kind: PatConstKind::Other } => {
                 TestKind::Eq { value, cast_ty: match_pair.pattern_ty }
             }