Factor out constructing a new wildcard pattern

src/librustc_mir/hair/pattern/_match.rs

@@ -780,11 +780,7 @@ impl<'tcx> Constructor<'tcx> {
         cx: &MatchCheckCtxt<'a, 'tcx>,
         ty: Ty<'tcx>,
     ) -> impl Iterator<Item = Pat<'tcx>> + DoubleEndedIterator {
-        constructor_sub_pattern_tys(cx, self, ty).into_iter().map(|ty| Pat {
-            ty,
-            span: DUMMY_SP,
-            kind: box PatKind::Wild,
-        })
+        constructor_sub_pattern_tys(cx, self, ty).into_iter().map(Pat::wildcard_from_ty)
     }
 
     /// This computes the arity of a constructor. The arity of a constructor
@@ -862,7 +858,7 @@ impl<'tcx> Constructor<'tcx> {
                 VarLenSlice(prefix_len, _suffix_len) => {
                     let prefix = subpatterns.by_ref().take(*prefix_len as usize).collect();
                     let suffix = subpatterns.collect();
-                    let wild = Pat { ty, span: DUMMY_SP, kind: Box::new(PatKind::Wild) };
+                    let wild = Pat::wildcard_from_ty(ty);
                     PatKind::Slice { prefix, slice: Some(wild), suffix }
                 }
                 _ => bug!("bad slice pattern {:?} {:?}", self, ty),
@@ -931,7 +927,7 @@ impl<'tcx> Usefulness<'tcx> {
     fn apply_wildcard(self, ty: Ty<'tcx>) -> Self {
         match self {
             UsefulWithWitness(witnesses) => {
-                let wild = Pat { ty, span: DUMMY_SP, kind: box PatKind::Wild };
+                let wild = Pat::wildcard_from_ty(ty);
                 UsefulWithWitness(
                     witnesses
                         .into_iter()

src/librustc_mir/hair/pattern/check_match.rs

@@ -18,7 +18,7 @@ use rustc::hir::{self, Pat};
 
 use std::slice;
 
-use syntax_pos::{MultiSpan, Span, DUMMY_SP};
+use syntax_pos::{MultiSpan, Span};
 
 crate fn check_match(tcx: TyCtxt<'_>, def_id: DefId) {
     let body_id = match tcx.hir().as_local_hir_id(def_id) {
@@ -491,7 +491,7 @@ fn check_not_useful(
     matrix: &Matrix<'_, 'tcx>,
     hir_id: HirId,
 ) -> Result<(), Vec<super::Pat<'tcx>>> {
-    let wild_pattern = super::Pat { ty, span: DUMMY_SP, kind: box PatKind::Wild };
+    let wild_pattern = super::Pat::wildcard_from_ty(ty);
     match is_useful(cx, matrix, &PatStack::from_pattern(&wild_pattern), ConstructWitness, hir_id) {
         NotUseful => Ok(()), // This is good, wildcard pattern isn't reachable.
         UsefulWithWitness(pats) => Err(if pats.is_empty() {

src/librustc_mir/hair/pattern/mod.rs

@@ -26,7 +26,7 @@ use rustc_index::vec::Idx;
 use std::cmp::Ordering;
 use std::fmt;
 use syntax::ast;
-use syntax_pos::Span;
+use syntax_pos::{Span, DUMMY_SP};
 
 #[derive(Clone, Debug)]
 pub enum PatternError {
@@ -55,6 +55,11 @@ pub struct Pat<'tcx> {
     pub kind: Box<PatKind<'tcx>>,
 }
 
+impl<'tcx> Pat<'tcx> {
+    pub(crate) fn wildcard_from_ty(ty: Ty<'tcx>) -> Self {
+        Pat { ty, span: DUMMY_SP, kind: Box::new(PatKind::Wild) }
+    }
+}
 
 #[derive(Copy, Clone, Debug, PartialEq)]
 pub struct PatTyProj<'tcx> {