perf: Reuse the Elaborator used in outlives/ty.rs

Profiling the build of https://github.com/Marwes/combine shows that
~1.3% of the time were spent resizing and rehashing the hash set used in
`Elaborator`. By reusing the `Elaborator` between calls this should
be mostly eliminated.

It does result in some awkwardness since the `RefCell` needs to be
borrowed in the returned `Iterator` but it works fine for the current
code.

Author: Marwes

src/librustc/infer/outlives/verify.rs

@@ -1,3 +1,5 @@
+use std::cell::RefCell;
+
 use crate::infer::outlives::env::RegionBoundPairs;
 use crate::infer::{GenericKind, VerifyBound};
 use crate::traits;
@@ -17,6 +19,7 @@ pub struct VerifyBoundCx<'cx, 'tcx> {
     region_bound_pairs: &'cx RegionBoundPairs<'tcx>,
     implicit_region_bound: Option<ty::Region<'tcx>>,
     param_env: ty::ParamEnv<'tcx>,
+    elaborator: RefCell<traits::Elaborator<'tcx>>,
 }
 
 impl<'cx, 'tcx> VerifyBoundCx<'cx, 'tcx> {
@@ -26,7 +29,13 @@ impl<'cx, 'tcx> VerifyBoundCx<'cx, 'tcx> {
         implicit_region_bound: Option<ty::Region<'tcx>>,
         param_env: ty::ParamEnv<'tcx>,
     ) -> Self {
-        Self { tcx, region_bound_pairs, implicit_region_bound, param_env }
+        Self {
+            tcx,
+            region_bound_pairs,
+            implicit_region_bound,
+            param_env,
+            elaborator: RefCell::new(traits::Elaborator::new(tcx)),
+        }
     }
 
     /// Returns a "verify bound" that encodes what we know about
@@ -113,10 +122,10 @@ impl<'cx, 'tcx> VerifyBoundCx<'cx, 'tcx> {
             self.tcx.mk_projection(projection_ty.item_def_id, projection_ty.substs);
 
         // Search the env for where clauses like `P: 'a`.
-        let env_bounds = self
-            .projection_approx_declared_bounds_from_env(projection_ty)
-            .into_iter()
-            .map(|ty::OutlivesPredicate(ty, r)| {
+        let mut bounds = Vec::new();
+
+        bounds.extend(self.projection_approx_declared_bounds_from_env(projection_ty).map(
+            |ty::OutlivesPredicate(ty, r)| {
                 let vb = VerifyBound::OutlivedBy(r);
                 if ty == projection_ty_as_ty {
                     // Micro-optimize if this is an exact match (this
@@ -126,18 +135,20 @@ impl<'cx, 'tcx> VerifyBoundCx<'cx, 'tcx> {
                 } else {
                     VerifyBound::IfEq(ty, Box::new(vb))
                 }
-            });
+            },
+        ));
 
         // Extend with bounds that we can find from the trait.
-        let trait_bounds = self
-            .projection_declared_bounds_from_trait(projection_ty)
-            .map(|r| VerifyBound::OutlivedBy(r));
+        bounds.extend(
+            self.projection_declared_bounds_from_trait(projection_ty)
+                .map(|r| VerifyBound::OutlivedBy(r)),
+        );
 
         // see the extensive comment in projection_must_outlive
         let ty = self.tcx.mk_projection(projection_ty.item_def_id, projection_ty.substs);
         let recursive_bound = self.recursive_type_bound(ty);
 
-        VerifyBound::AnyBound(env_bounds.chain(trait_bounds).collect()).or(recursive_bound)
+        VerifyBound::AnyBound(bounds).or(recursive_bound)
     }
 
     fn recursive_type_bound(&self, ty: Ty<'tcx>) -> VerifyBound<'tcx> {
@@ -154,7 +165,11 @@ impl<'cx, 'tcx> VerifyBoundCx<'cx, 'tcx> {
             .filter(|b| !b.must_hold())
             .collect::<Vec<_>>();
 
-        if bounds.len() == 1 { bounds.pop().unwrap() } else { VerifyBound::AllBounds(bounds) }
+        if bounds.len() == 1 {
+            bounds.pop().unwrap()
+        } else {
+            VerifyBound::AllBounds(bounds)
+        }
     }
 
     /// Searches the environment for where-clauses like `G: 'a` where
@@ -281,13 +296,16 @@ impl<'cx, 'tcx> VerifyBoundCx<'cx, 'tcx> {
         let tcx = self.tcx;
         let assoc_item = tcx.associated_item(assoc_item_def_id);
         let trait_def_id = assoc_item.container.assert_trait();
-        let trait_predicates =
-            tcx.predicates_of(trait_def_id).predicates.iter().map(|(p, _)| *p).collect();
+        let trait_predicates = tcx.predicates_of(trait_def_id).predicates.iter().map(|(p, _)| *p);
+        let mut elaborator = self.elaborator.borrow_mut();
+        elaborator.clear();
+        elaborator.extend(trait_predicates);
         let identity_substs = InternalSubsts::identity_for_item(tcx, assoc_item_def_id);
         let identity_proj = tcx.mk_projection(assoc_item_def_id, identity_substs);
+
         self.collect_outlives_from_predicate_list(
             move |ty| ty == identity_proj,
-            traits::elaborate_predicates(tcx, trait_predicates),
+            std::iter::from_fn(move || elaborator.next()),
         )
         .map(|b| b.1)
     }

src/librustc/traits/util.rs

@@ -120,6 +120,15 @@ pub fn elaborate_predicates<'tcx>(
 }
 
 impl Elaborator<'tcx> {
+    pub fn new(tcx: TyCtxt<'tcx>) -> Self {
+        Self { stack: Vec::new(), visited: PredicateSet::new(tcx) }
+    }
+
+    pub fn clear(&mut self) {
+        self.stack.clear();
+        self.visited.set.clear();
+    }
+
     pub fn filter_to_traits(self) -> FilterToTraits<Self> {
         FilterToTraits::new(self)
     }
@@ -137,14 +146,7 @@ impl Elaborator<'tcx> {
                     .map(|(pred, _)| pred.subst_supertrait(tcx, &data.to_poly_trait_ref()));
                 debug!("super_predicates: data={:?} predicates={:?}", data, predicates.clone());
 
-                // Only keep those bounds that we haven't already seen.
-                // This is necessary to prevent infinite recursion in some
-                // cases. One common case is when people define
-                // `trait Sized: Sized { }` rather than `trait Sized { }`.
-                let visited = &mut self.visited;
-                let predicates = predicates.filter(|pred| visited.insert(pred));
-
-                self.stack.extend(predicates);
+                self.extend(predicates);
             }
             ty::Predicate::WellFormed(..) => {
                 // Currently, we do not elaborate WF predicates,
@@ -192,46 +194,51 @@ impl Elaborator<'tcx> {
                     return;
                 }
 
-                let visited = &mut self.visited;
                 let mut components = smallvec![];
                 tcx.push_outlives_components(ty_max, &mut components);
-                self.stack.extend(
-                    components
-                        .into_iter()
-                        .filter_map(|component| match component {
-                            Component::Region(r) => {
-                                if r.is_late_bound() {
-                                    None
-                                } else {
-                                    Some(ty::Predicate::RegionOutlives(ty::Binder::dummy(
-                                        ty::OutlivesPredicate(r, r_min),
-                                    )))
-                                }
-                            }
-
-                            Component::Param(p) => {
-                                let ty = tcx.mk_ty_param(p.index, p.name);
-                                Some(ty::Predicate::TypeOutlives(ty::Binder::dummy(
-                                    ty::OutlivesPredicate(ty, r_min),
-                                )))
-                            }
-
-                            Component::UnresolvedInferenceVariable(_) => None,
-
-                            Component::Projection(_) | Component::EscapingProjection(_) => {
-                                // We can probably do more here. This
-                                // corresponds to a case like `<T as
-                                // Foo<'a>>::U: 'b`.
-                                None
-                            }
-                        })
-                        .filter(|p| visited.insert(p)),
-                );
+                self.extend(components.into_iter().filter_map(|component| match component {
+                    Component::Region(r) => {
+                        if r.is_late_bound() {
+                            None
+                        } else {
+                            Some(ty::Predicate::RegionOutlives(ty::Binder::dummy(
+                                ty::OutlivesPredicate(r, r_min),
+                            )))
+                        }
+                    }
+
+                    Component::Param(p) => {
+                        let ty = tcx.mk_ty_param(p.index, p.name);
+                        Some(ty::Predicate::TypeOutlives(ty::Binder::dummy(ty::OutlivesPredicate(
+                            ty, r_min,
+                        ))))
+                    }
+
+                    Component::UnresolvedInferenceVariable(_) => None,
+
+                    Component::Projection(_) | Component::EscapingProjection(_) => {
+                        // We can probably do more here. This
+                        // corresponds to a case like `<T as
+                        // Foo<'a>>::U: 'b`.
+                        None
+                    }
+                }));
             }
         }
     }
 }
 
+impl<'tcx> Extend<ty::Predicate<'tcx>> for Elaborator<'tcx> {
+    fn extend<I: IntoIterator<Item = ty::Predicate<'tcx>>>(&mut self, iter: I) {
+        let visited = &mut self.visited;
+        // Only keep those bounds that we haven't already seen.
+        // This is necessary to prevent infinite recursion in some
+        // cases. One common case is when people define
+        // `trait Sized: Sized { }` rather than `trait Sized { }`.
+        self.stack.extend(iter.into_iter().filter(|pred| visited.insert(pred)));
+    }
+}
+
 impl Iterator for Elaborator<'tcx> {
     type Item = ty::Predicate<'tcx>;