Compute constructors on PatStack construction

All the constructed PatStacks end up having `head_ctors` called on them,
so this does not unnecessarily precompute anything.

Author: Nadrieril

src/librustc_mir/hair/pattern/_match.rs

@@ -248,7 +248,6 @@ use syntax_pos::{Span, DUMMY_SP};
 use arena::TypedArena;
 
 use smallvec::{smallvec, SmallVec};
-use std::cell::RefCell;
 use std::cmp::{self, max, min, Ordering};
 use std::convert::TryInto;
 use std::fmt;
@@ -341,25 +340,30 @@ impl PatternFolder<'tcx> for LiteralExpander<'tcx> {
 pub struct PatStack<'p, 'tcx> {
     patterns: SmallVec<[&'p Pat<'tcx>; 2]>,
     // This caches the invocation of `pat_constructors` on the head of the stack. We avoid mutating
-    // `self` to be sure we don't keep an invalid cache around.
-    head_ctors_cache: RefCell<Option<SmallVec<[Constructor<'tcx>; 1]>>>,
+    // `self` to be sure we don't keep an invalid cache around. Must be non-empty unless `patterns`
+    // is empty.
+    head_ctors_cache: SmallVec<[Constructor<'tcx>; 1]>,
 }
 
 impl<'p, 'tcx> PatStack<'p, 'tcx> {
-    pub fn from_pattern(pat: &'p Pat<'tcx>) -> Self {
-        PatStack::from_vec(smallvec![pat])
+    pub fn from_pattern(cx: &MatchCheckCtxt<'_, 'tcx>, pat: &'p Pat<'tcx>) -> Self {
+        PatStack::from_vec(cx, smallvec![pat])
     }
 
     fn empty() -> Self {
-        PatStack::from_vec(smallvec![])
+        PatStack { patterns: smallvec![], head_ctors_cache: smallvec![] }
     }
 
-    fn from_vec(vec: SmallVec<[&'p Pat<'tcx>; 2]>) -> Self {
-        PatStack { patterns: vec, head_ctors_cache: RefCell::new(None) }
+    fn from_vec(cx: &MatchCheckCtxt<'_, 'tcx>, patterns: SmallVec<[&'p Pat<'tcx>; 2]>) -> Self {
+        if patterns.is_empty() {
+            return PatStack::empty();
+        }
+        let head_ctors_cache = pat_constructors(cx.tcx, cx.param_env, patterns[0]);
+        PatStack { patterns, head_ctors_cache }
     }
 
-    fn from_slice(s: &[&'p Pat<'tcx>]) -> Self {
-        PatStack::from_vec(SmallVec::from_slice(s))
+    fn from_slice(cx: &MatchCheckCtxt<'_, 'tcx>, s: &[&'p Pat<'tcx>]) -> Self {
+        PatStack::from_vec(cx, SmallVec::from_slice(s))
     }
 
     fn is_empty(&self) -> bool {
@@ -376,16 +380,7 @@ impl<'p, 'tcx> PatStack<'p, 'tcx> {
 
     fn head_ctors(&self, cx: &MatchCheckCtxt<'_, 'tcx>) -> SmallVec<[Constructor<'tcx>; 1]> {
         let new_ctors = pat_constructors(cx.tcx, cx.param_env, self.head());
-        let borrow = self.head_ctors_cache.borrow();
-        match *borrow {
-            Some(ref cached_ctors) => {
-                assert_eq!(cached_ctors, &new_ctors);
-            }
-            None => {
-                drop(borrow);
-                *self.head_ctors_cache.borrow_mut() = Some(new_ctors.clone());
-            }
-        }
+        assert_eq!(self.head_ctors_cache, new_ctors);
         new_ctors
     }
 
@@ -410,7 +405,7 @@ impl<'p, 'tcx> PatStack<'p, 'tcx> {
             .map(|new_head| {
                 let mut pats = new_head.patterns;
                 pats.extend_from_slice(&self.patterns[1..]);
-                PatStack::from_vec(pats)
+                PatStack::from_vec(cx, pats)
             })
             .collect();
         debug!("specialize({:#?}, {:#?}) = {:#?}", self, constructor, result);
@@ -424,15 +419,6 @@ impl<'p, 'tcx> Default for PatStack<'p, 'tcx> {
     }
 }
 
-impl<'p, 'tcx> FromIterator<&'p Pat<'tcx>> for PatStack<'p, 'tcx> {
-    fn from_iter<T>(iter: T) -> Self
-    where
-        T: IntoIterator<Item = &'p Pat<'tcx>>,
-    {
-        PatStack::from_vec(iter.into_iter().collect())
-    }
-}
-
 /// A 2D matrix.
 pub struct Matrix<'p, 'tcx>(Vec<PatStack<'p, 'tcx>>);
 
@@ -1987,6 +1973,7 @@ fn constructor_intersects_pattern<'p, 'tcx>(
 }
 
 fn patterns_for_variant<'p, 'tcx>(
+    cx: &MatchCheckCtxt<'_, 'tcx>,
     subpatterns: &'p [FieldPat<'tcx>],
     ctor_wild_subpatterns: &[&'p Pat<'tcx>],
 ) -> PatStack<'p, 'tcx> {
@@ -2000,7 +1987,7 @@ fn patterns_for_variant<'p, 'tcx>(
         "patterns_for_variant({:#?}, {:#?}) = {:#?}",
         subpatterns, ctor_wild_subpatterns, result
     );
-    PatStack::from_vec(result)
+    PatStack::from_vec(cx, result)
 }
 
 /// This is the main specialization step. It expands the pattern into `arity` patterns based on the
@@ -2037,23 +2024,23 @@ fn specialize_one_pattern<'p, 'a: 'p, 'q: 'p, 'tcx>(
         PatKind::AscribeUserType { .. } => unreachable!(), // Handled above
 
         PatKind::Binding { .. } | PatKind::Wild => {
-            smallvec![PatStack::from_slice(ctor_wild_subpatterns)]
+            smallvec![PatStack::from_slice(cx, ctor_wild_subpatterns)]
         }
 
         PatKind::Variant { adt_def, variant_index, ref subpatterns, .. } => {
             let ref variant = adt_def.variants[variant_index];
             if Variant(variant.def_id) == *constructor {
-                smallvec![patterns_for_variant(subpatterns, ctor_wild_subpatterns)]
+                smallvec![patterns_for_variant(cx, subpatterns, ctor_wild_subpatterns)]
             } else {
                 smallvec![]
             }
         }
 
         PatKind::Leaf { ref subpatterns } => {
-            smallvec![patterns_for_variant(subpatterns, ctor_wild_subpatterns)]
+            smallvec![patterns_for_variant(cx, subpatterns, ctor_wild_subpatterns)]
         }
 
-        PatKind::Deref { ref subpattern } => smallvec![PatStack::from_pattern(subpattern)],
+        PatKind::Deref { ref subpattern } => smallvec![PatStack::from_pattern(cx, subpattern)],
 
         PatKind::Constant { value } if constructor.is_slice() => {
             // We extract an `Option` for the pointer because slices of zero
@@ -2098,7 +2085,7 @@ fn specialize_one_pattern<'p, 'a: 'p, 'q: 'p, 'tcx>(
                     return smallvec![];
                 };
                 let ptr = Pointer::new(AllocId(0), offset);
-                let stack: Option<PatStack<'_, '_>> = (0..n)
+                let stack: Option<SmallVec<_>> = (0..n)
                     .map(|i| {
                         let ptr = ptr.offset(layout.size * i, &cx.tcx).ok()?;
                         let scalar = alloc.read_scalar(&cx.tcx, ptr, layout.size).ok()?;
@@ -2109,7 +2096,10 @@ fn specialize_one_pattern<'p, 'a: 'p, 'q: 'p, 'tcx>(
                         Some(&*cx.pattern_arena.alloc(pattern))
                     })
                     .collect();
-                stack.into_iter().collect()
+                match stack {
+                    Some(v) => smallvec![PatStack::from_vec(cx, v)],
+                    None => smallvec![],
+                }
             } else {
                 smallvec![]
             }
@@ -2132,7 +2122,8 @@ fn specialize_one_pattern<'p, 'a: 'p, 'q: 'p, 'tcx>(
                 let pat_len = prefix.len() + suffix.len();
                 if let Some(slice_count) = ctor_wild_subpatterns.len().checked_sub(pat_len) {
                     if slice_count == 0 || slice.is_some() {
-                        smallvec![
+                        smallvec![PatStack::from_vec(
+                            cx,
                             prefix
                                 .iter()
                                 .chain(
@@ -2144,7 +2135,7 @@ fn specialize_one_pattern<'p, 'a: 'p, 'q: 'p, 'tcx>(
                                         .chain(suffix.iter()),
                                 )
                                 .collect(),
-                        ]
+                        )]
                     } else {
                         smallvec![]
                     }

src/librustc_mir/hair/pattern/check_match.rs

@@ -246,7 +246,7 @@ impl<'tcx> MatchVisitor<'_, 'tcx> {
                 .iter()
                 .filter(|&&(_, guard)| guard.is_none())
                 .flat_map(|arm| &arm.0)
-                .map(|pat| PatStack::from_pattern(pat.0))
+                .map(|pat| PatStack::from_pattern(cx, pat.0))
                 .collect();
             let scrut_ty = self.tables.node_type(scrut.hir_id);
             check_exhaustive(cx, scrut_ty, scrut.span, &matrix);
@@ -262,7 +262,7 @@ impl<'tcx> MatchVisitor<'_, 'tcx> {
             let pattern = patcx.lower_pattern(pat);
             let pattern_ty = pattern.ty;
             let pats: Matrix<'_, '_> =
-                vec![PatStack::from_pattern(expand_pattern(cx, pattern))].into_iter().collect();
+                vec![PatStack::from_pattern(cx, expand_pattern(cx, pattern))].into_iter().collect();
 
             let witnesses = match check_not_useful(cx, pattern_ty, &pats) {
                 Ok(_) => return,
@@ -406,7 +406,7 @@ fn check_arms<'tcx>(
     let mut catchall = None;
     for (arm_index, &(ref pats, guard)) in arms.iter().enumerate() {
         for &(pat, hir_pat) in pats {
-            let v = PatStack::from_pattern(pat);
+            let v = PatStack::from_pattern(cx, pat);
 
             match is_useful(cx, &seen, &v, LeaveOutWitness) {
                 NotUseful => {
@@ -487,7 +487,7 @@ fn check_not_useful(
     matrix: &Matrix<'_, 'tcx>,
 ) -> Result<(), Vec<super::Pat<'tcx>>> {
     let wild_pattern = super::Pat { ty, span: DUMMY_SP, kind: box PatKind::Wild };
-    match is_useful(cx, matrix, &PatStack::from_pattern(&wild_pattern), ConstructWitness) {
+    match is_useful(cx, matrix, &PatStack::from_pattern(cx, &wild_pattern), ConstructWitness) {
         NotUseful => Ok(()), // This is good, wildcard pattern isn't reachable.
         UsefulWithWitness(pats) => Err(if pats.is_empty() {
             vec![wild_pattern]