Replace an unnecessary slice pattern with has_dot_dot: bool

Author: Zalathar

compiler/rustc_pattern_analysis/src/rustc.rs

@@ -872,7 +872,7 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
                 match slice.kind {
                     SliceKind::FixedLen(_) => PatKind::Slice {
                         prefix: subpatterns.collect(),
-                        slice: None,
+                        has_dot_dot: false,
                         suffix: Box::new([]),
                     },
                     SliceKind::VarLen(prefix, _) => {
@@ -893,10 +893,9 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
                             }
                         }
                         let suffix: Box<[_]> = subpatterns.collect();
-                        let wild = Pat { ty: pat.ty().inner(), kind: PatKind::Wild };
                         PatKind::Slice {
                             prefix: prefix.into_boxed_slice(),
-                            slice: Some(Box::new(wild)),
+                            has_dot_dot: true,
                             suffix,
                         }
                     }

compiler/rustc_pattern_analysis/src/rustc/print.rs

@@ -50,7 +50,9 @@ pub(crate) enum PatKind<'tcx> {
 
     Slice {
         prefix: Box<[Box<Pat<'tcx>>]>,
-        slice: Option<Box<Pat<'tcx>>>,
+        /// True if this slice-like pattern should include a `..` between the
+        /// prefix and suffix.
+        has_dot_dot: bool,
         suffix: Box<[Box<Pat<'tcx>>]>,
     },
 
@@ -68,8 +70,8 @@ impl<'tcx> fmt::Display for Pat<'tcx> {
             PatKind::Deref { ref subpattern } => write_ref_like(f, self.ty, subpattern),
             PatKind::Constant { value } => write!(f, "{value}"),
             PatKind::Range(ref range) => write!(f, "{range}"),
-            PatKind::Slice { ref prefix, ref slice, ref suffix } => {
-                write_slice_like(f, prefix, slice, suffix)
+            PatKind::Slice { ref prefix, has_dot_dot, ref suffix } => {
+                write_slice_like(f, prefix, has_dot_dot, suffix)
             }
         }
     }
@@ -194,21 +196,16 @@ fn write_ref_like<'tcx>(
 fn write_slice_like<'tcx>(
     f: &mut impl fmt::Write,
     prefix: &[Box<Pat<'tcx>>],
-    slice: &Option<Box<Pat<'tcx>>>,
+    has_dot_dot: bool,
     suffix: &[Box<Pat<'tcx>>],
 ) -> fmt::Result {
     let mut start_or_comma = start_or_comma();
     write!(f, "[")?;
     for p in prefix.iter() {
         write!(f, "{}{}", start_or_comma(), p)?;
     }
-    if let Some(ref slice) = *slice {
-        write!(f, "{}", start_or_comma())?;
-        match slice.kind {
-            PatKind::Wild => {}
-            _ => write!(f, "{slice}")?,
-        }
-        write!(f, "..")?;
+    if has_dot_dot {
+        write!(f, "{}..", start_or_comma())?;
     }
     for p in suffix.iter() {
         write!(f, "{}{}", start_or_comma(), p)?;