Allow range pattern types to allow the entire range (heh) of possible ranges

Author: oli-obk

compiler/rustc_hir_analysis/src/variance/constraints.rs

@@ -233,9 +233,13 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
 
             ty::Pat(typ, pat) => {
                 match *pat {
-                    ty::PatternKind::Range { start, end } => {
-                        self.add_constraints_from_const(current, start, variance);
-                        self.add_constraints_from_const(current, end, variance);
+                    ty::PatternKind::Range { start, end, include_end: _ } => {
+                        if let Some(start) = start {
+                            self.add_constraints_from_const(current, start, variance);
+                        }
+                        if let Some(end) = end {
+                            self.add_constraints_from_const(current, end, variance);
+                        }
                     }
                 }
                 self.add_constraints_from_ty(current, typ, variance);

compiler/rustc_middle/src/ty/pattern.rs

@@ -44,5 +44,5 @@ impl<'tcx> fmt::Debug for PatternKind<'tcx> {
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[derive(HashStable, TyEncodable, TyDecodable, TypeVisitable, TypeFoldable)]
 pub enum PatternKind<'tcx> {
-    Range { start: ty::Const<'tcx>, end: ty::Const<'tcx> },
+    Range { start: Option<ty::Const<'tcx>>, end: Option<ty::Const<'tcx>>, include_end: bool },
 }

compiler/rustc_middle/src/ty/walk.rs

@@ -153,9 +153,9 @@ fn push_inner<'tcx>(stack: &mut TypeWalkerStack<'tcx>, parent: GenericArg<'tcx>)
 
             ty::Pat(ty, pat) => {
                 match *pat {
-                    ty::PatternKind::Range { start, end } => {
-                        stack.push(start.into());
-                        stack.push(end.into());
+                    ty::PatternKind::Range { start, end, include_end: _ } => {
+                        stack.extend(start.map(Into::into));
+                        stack.extend(end.map(Into::into));
                     }
                 }
                 stack.push(ty.into());

compiler/rustc_symbol_mangling/src/typeid/typeid_itanium_cxx_abi.rs

@@ -525,12 +525,7 @@ fn encode_ty<'tcx>(
             // u3patI<element-type><pattern>E as vendor extended type
             let mut s = String::from("u3patI");
             s.push_str(&encode_ty(tcx, *ty0, dict, options));
-            match **pat {
-                ty::PatternKind::Range { start, end } => {
-                    s.push_str(&encode_const(tcx, start, dict, options));
-                    s.push_str(&encode_const(tcx, end, dict, options));
-                }
-            }
+            write!(s, "{:?}", **pat).unwrap();
             s.push('E');
             compress(dict, DictKey::Ty(ty, TyQ::None), &mut s);
             typeid.push_str(&s);

compiler/rustc_symbol_mangling/src/v0.rs

@@ -423,9 +423,16 @@ impl<'tcx> Printer<'tcx> for &mut SymbolMangler<'tcx> {
                 self.push("T");
                 self = ty.print(self)?;
                 match *pat {
-                    ty::PatternKind::Range { start, end } => {
-                        self = self.print_const(start)?;
-                        self = self.print_const(end)?;
+                    ty::PatternKind::Range { start, end, include_end } => {
+                        if let Some(start) = start {
+                            self = self.print_const(start)?;
+                        }
+                        let _ = write!(self.out, "_");
+                        if let Some(end) = end {
+                            self = self.print_const(end)?;
+                        }
+
+                        let _ = write!(self.out, "{:x}_", include_end as u8);
                     }
                 }
                 self.push("E");

compiler/rustc_ty_utils/src/layout.rs

@@ -116,11 +116,19 @@ fn layout_of_uncached<'tcx>(
             let layout = cx.layout_of(ty)?.layout;
             let mut abi = layout.abi();
             match *pat {
-                ty::PatternKind::Range { start, end } => {
+                ty::PatternKind::Range { start, end, include_end } => {
                     if let Abi::Scalar(scalar) | Abi::ScalarPair(scalar, _) = &mut abi {
-                        scalar.valid_range_mut().start =
-                            start.eval_bits(tcx, param_env, start.ty());
-                        scalar.valid_range_mut().end = end.eval_bits(tcx, param_env, end.ty());
+                        if let Some(start) = start {
+                            scalar.valid_range_mut().start =
+                                start.eval_bits(tcx, param_env, start.ty());
+                        }
+                        if let Some(end) = end {
+                            let mut end = end.eval_bits(tcx, param_env, end.ty());
+                            if !include_end {
+                                end = end.wrapping_sub(1);
+                            }
+                            scalar.valid_range_mut().end = end;
+                        }
 
                         tcx.intern_layout(LayoutS { abi, ..LayoutS::clone(&layout.0) })
                     } else {