shrink TestBranch::Constant

Author: RalfJung

compiler/rustc_middle/src/thir.rs

@@ -955,11 +955,10 @@ impl<'tcx> PatRange<'tcx> {
     }
 
     #[inline]
-    pub fn contains(&self, value: ty::Value<'tcx>, tcx: TyCtxt<'tcx>) -> Option<bool> {
+    pub fn contains(&self, valtree: ty::ValTree<'tcx>, tcx: TyCtxt<'tcx>) -> Option<bool> {
         use Ordering::*;
-        debug_assert_eq!(self.ty, value.ty);
         let ty = self.ty;
-        let value = PatRangeBoundary::Finite(value);
+        let value = PatRangeBoundary::Finite(ty::Value { ty, valtree });
         // For performance, it's important to only do the second comparison if necessary.
         Some(
             match self.lo.compare_with(value, ty, tcx)? {

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

@@ -1373,15 +1373,15 @@ enum TestBranch<'tcx> {
     /// Success branch, used for tests with two possible outcomes.
     Success,
     /// Branch corresponding to this constant.
-    Constant(ty::Value<'tcx>, u128),
+    Constant(ty::ValTree<'tcx>, u128),
     /// Branch corresponding to this variant.
     Variant(VariantIdx),
     /// Failure branch for tests with two possible outcomes, and "otherwise" branch for other tests.
     Failure,
 }
 
 impl<'tcx> TestBranch<'tcx> {
-    fn as_constant(&self) -> Option<ty::Value<'tcx>> {
+    fn as_constant(&self) -> Option<ty::ValTree<'tcx>> {
         if let Self::Constant(v, _) = self { Some(*v) } else { None }
     }
 }

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

@@ -558,7 +558,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 // not to add such values here.
                 let is_covering_range = |test_case: &TestCase<'tcx>| {
                     test_case.as_range().is_some_and(|range| {
-                        matches!(range.contains(value, self.tcx), None | Some(true))
+                        matches!(range.contains(value.valtree, self.tcx), None | Some(true))
                     })
                 };
                 let is_conflicting_candidate = |candidate: &&mut Candidate<'tcx>| {
@@ -576,7 +576,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 } else {
                     fully_matched = true;
                     let bits = value.try_to_scalar_int().unwrap().to_bits_unchecked();
-                    Some(TestBranch::Constant(value, bits))
+                    Some(TestBranch::Constant(value.valtree, bits))
                 }
             }
             (TestKind::SwitchInt, TestCase::Range(range)) => {
@@ -684,7 +684,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             }
             (TestKind::Range(range), &TestCase::Constant { value }) => {
                 fully_matched = false;
-                if !range.contains(value, self.tcx)? {
+                if !range.contains(value.valtree, self.tcx)? {
                     // `value` is not contained in the testing range,
                     // so `value` can be matched only if this test fails.
                     Some(TestBranch::Failure)