Propagate half-open ranges through THIR

Author: Nadrieril

compiler/rustc_middle/src/thir.rs

@@ -834,17 +834,21 @@ impl<'tcx> PatRange<'tcx> {
         //
         // Also, for performance, it's important to only do the second `try_to_bits` if necessary.
         let lo_is_min = match self.lo {
+            PatRangeBoundary::NegInfinity => true,
             PatRangeBoundary::Finite(value) => {
                 let lo = value.try_to_bits(size).unwrap() ^ bias;
                 lo <= min
             }
+            PatRangeBoundary::PosInfinity => false,
         };
         if lo_is_min {
             let hi_is_max = match self.hi {
+                PatRangeBoundary::NegInfinity => false,
                 PatRangeBoundary::Finite(value) => {
                     let hi = value.try_to_bits(size).unwrap() ^ bias;
                     hi > max || hi == max && self.end == RangeEnd::Included
                 }
+                PatRangeBoundary::PosInfinity => true,
             };
             if hi_is_max {
                 return Some(true);
@@ -903,11 +907,13 @@ impl<'tcx> PatRange<'tcx> {
 
 impl<'tcx> fmt::Display for PatRange<'tcx> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let PatRangeBoundary::Finite(value) = &self.lo;
-        write!(f, "{value}")?;
+        if let PatRangeBoundary::Finite(value) = &self.lo {
+            write!(f, "{value}")?;
+        }
         write!(f, "{}", self.end)?;
-        let PatRangeBoundary::Finite(value) = &self.hi;
-        write!(f, "{value}")?;
+        if let PatRangeBoundary::Finite(value) = &self.hi {
+            write!(f, "{value}")?;
+        }
         Ok(())
     }
 }
@@ -917,38 +923,49 @@ impl<'tcx> fmt::Display for PatRange<'tcx> {
 #[derive(Copy, Clone, Debug, PartialEq, HashStable, TypeVisitable)]
 pub enum PatRangeBoundary<'tcx> {
     Finite(mir::Const<'tcx>),
+    NegInfinity,
+    PosInfinity,
 }
 
 impl<'tcx> PatRangeBoundary<'tcx> {
     #[inline]
-    pub fn lower_bound(ty: Ty<'tcx>, tcx: TyCtxt<'tcx>) -> Self {
-        // Unwrap is ok because the type is known to be numeric.
-        let c = ty.numeric_min_val(tcx).unwrap();
-        let value = mir::Const::from_ty_const(c, tcx);
-        Self::Finite(value)
+    pub fn is_finite(self) -> bool {
+        matches!(self, Self::Finite(..))
     }
     #[inline]
-    pub fn upper_bound(ty: Ty<'tcx>, tcx: TyCtxt<'tcx>) -> Self {
-        // Unwrap is ok because the type is known to be numeric.
-        let c = ty.numeric_max_val(tcx).unwrap();
-        let value = mir::Const::from_ty_const(c, tcx);
-        Self::Finite(value)
+    pub fn as_finite(self) -> Option<mir::Const<'tcx>> {
+        match self {
+            Self::Finite(value) => Some(value),
+            Self::NegInfinity | Self::PosInfinity => None,
+        }
     }
-
     #[inline]
-    pub fn to_const(self, _ty: Ty<'tcx>, _tcx: TyCtxt<'tcx>) -> mir::Const<'tcx> {
+    pub fn to_const(self, ty: Ty<'tcx>, tcx: TyCtxt<'tcx>) -> mir::Const<'tcx> {
         match self {
             Self::Finite(value) => value,
+            Self::NegInfinity => {
+                // Unwrap is ok because the type is known to be numeric.
+                let c = ty.numeric_min_val(tcx).unwrap();
+                mir::Const::from_ty_const(c, tcx)
+            }
+            Self::PosInfinity => {
+                // Unwrap is ok because the type is known to be numeric.
+                let c = ty.numeric_max_val(tcx).unwrap();
+                mir::Const::from_ty_const(c, tcx)
+            }
         }
     }
-    pub fn eval_bits(
-        self,
-        _ty: Ty<'tcx>,
-        tcx: TyCtxt<'tcx>,
-        param_env: ty::ParamEnv<'tcx>,
-    ) -> u128 {
+    pub fn eval_bits(self, ty: Ty<'tcx>, tcx: TyCtxt<'tcx>, param_env: ty::ParamEnv<'tcx>) -> u128 {
         match self {
             Self::Finite(value) => value.eval_bits(tcx, param_env),
+            Self::NegInfinity => {
+                // Unwrap is ok because the type is known to be numeric.
+                ty.numeric_min_and_max_as_bits(tcx).unwrap().0
+            }
+            Self::PosInfinity => {
+                // Unwrap is ok because the type is known to be numeric.
+                ty.numeric_min_and_max_as_bits(tcx).unwrap().1
+            }
         }
     }
 
@@ -962,6 +979,12 @@ impl<'tcx> PatRangeBoundary<'tcx> {
     ) -> Option<Ordering> {
         use PatRangeBoundary::*;
         match (self, other) {
+            // When comparing with infinities, we must remember that `0u8..` and `0u8..=255`
+            // describe the same range. These two shortcuts are ok, but for the rest we must check
+            // bit values.
+            (PosInfinity, PosInfinity) => return Some(Ordering::Equal),
+            (NegInfinity, NegInfinity) => return Some(Ordering::Equal),
+
             // This code is hot when compiling matches with many ranges. So we
             // special-case extraction of evaluated scalars for speed, for types where
             // raw data comparisons are appropriate. E.g. `unicode-normalization` has

compiler/rustc_mir_build/src/thir/pattern/mod.rs

@@ -180,24 +180,25 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
         let (lo, lo_ascr) = self.lower_pattern_range_endpoint(lo_expr)?;
         let (hi, hi_ascr) = self.lower_pattern_range_endpoint(hi_expr)?;
 
-        let lo = lo.unwrap_or_else(|| PatRangeBoundary::lower_bound(ty, self.tcx));
-        let hi = hi.unwrap_or_else(|| PatRangeBoundary::upper_bound(ty, self.tcx));
+        let lo = lo.unwrap_or(PatRangeBoundary::NegInfinity);
+        let hi = hi.unwrap_or(PatRangeBoundary::PosInfinity);
 
         let cmp = lo.compare_with(hi, ty, self.tcx, self.param_env);
-        let mut kind = match (end, cmp) {
+        let mut kind = PatKind::Range(Box::new(PatRange { lo, hi, end, ty }));
+        match (end, cmp) {
             // `x..y` where `x < y`.
-            // Non-empty because the range includes at least `x`.
-            (RangeEnd::Excluded, Some(Ordering::Less)) => {
-                PatKind::Range(Box::new(PatRange { lo, hi, end, ty }))
-            }
-            // `x..=y` where `x == y`.
-            (RangeEnd::Included, Some(Ordering::Equal)) => {
-                PatKind::Constant { value: lo.to_const(ty, self.tcx) }
-            }
+            (RangeEnd::Excluded, Some(Ordering::Less)) => {}
             // `x..=y` where `x < y`.
-            (RangeEnd::Included, Some(Ordering::Less)) => {
-                PatKind::Range(Box::new(PatRange { lo, hi, end, ty }))
-            }
+            (RangeEnd::Included, Some(Ordering::Less)) => {}
+            // `x..=y` where `x == y` and `x` and `y` are finite.
+            (RangeEnd::Included, Some(Ordering::Equal)) if lo.is_finite() && hi.is_finite() => {
+                kind = PatKind::Constant { value: lo.as_finite().unwrap() };
+            }
+            // `..=x` where `x == ty::MIN`.
+            (RangeEnd::Included, Some(Ordering::Equal)) if !lo.is_finite() => {}
+            // `x..` where `x == ty::MAX` (yes, `x..` gives `RangeEnd::Included` since it is meant
+            // to include `ty::MAX`).
+            (RangeEnd::Included, Some(Ordering::Equal)) if !hi.is_finite() => {}
             // `x..y` where `x >= y`, or `x..=y` where `x > y`. The range is empty => error.
             _ => {
                 // Emit a more appropriate message if there was overflow.
@@ -216,7 +217,7 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
                 };
                 return Err(e);
             }
-        };
+        }
 
         // If we are handling a range with associated constants (e.g.
         // `Foo::<'a>::A..=Foo::B`), we need to put the ascriptions for the associated