Don't hardcode stack growth in stack growing function name

Author: oli-obk

src/librustc/hir/lowering.rs

@@ -50,7 +50,7 @@ use hir::GenericArg;
 use lint::builtin::{self, PARENTHESIZED_PARAMS_IN_TYPES_AND_MODULES,
                     ELIDED_LIFETIMES_IN_PATHS};
 use middle::cstore::CrateStore;
-use middle::recursion_limit::guarantee_one_mb_stack_left;
+use middle::recursion_limit::ensure_sufficient_stack;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_data_structures::indexed_vec::IndexVec;
 use rustc_data_structures::thin_vec::ThinVec;
@@ -4267,7 +4267,7 @@ impl<'a> LoweringContext<'a> {
         // just lowered from the expression
         let kind = match e.node {
             ExprKind::Paren(ref ex) => {
-                let mut ex = guarantee_one_mb_stack_left(|| self.lower_expr(ex));
+                let mut ex = ensure_sufficient_stack(|| self.lower_expr(ex));
                 // include parens in span, but only if it is a super-span.
                 if e.span.contains(ex.span) {
                     ex.span = e.span;
@@ -4446,7 +4446,7 @@ impl<'a> LoweringContext<'a> {
                 // add the attributes to the outer returned expr node
                 return self.expr_block(block, e.attrs.clone());
             },
-            _ => guarantee_one_mb_stack_left(|| self.lower_expr_kind(e)),
+            _ => ensure_sufficient_stack(|| self.lower_expr_kind(e)),
         };
 
         let LoweredNodeId { node_id, hir_id } = self.lower_node_id(e.id);

src/librustc/middle/recursion_limit.rs

@@ -28,7 +28,7 @@ const STACK_PER_RECURSION: usize = 1 * 1024 * 1024; // 1MB
 /// from this.
 ///
 /// Should not be sprinkled around carelessly, as it causes a little bit of overhead.
-pub fn guarantee_one_mb_stack_left<R, F: FnOnce() -> R>(
+pub fn ensure_sufficient_stack<R, F: FnOnce() -> R>(
     f: F
 ) -> R {
     stacker::maybe_grow(RED_ZONE, STACK_PER_RECURSION, f)

src/librustc/traits/project.rs

@@ -33,7 +33,7 @@ use ty::subst::{Subst, Substs};
 use ty::{self, ToPredicate, ToPolyTraitRef, Ty, TyCtxt};
 use ty::fold::{TypeFoldable, TypeFolder};
 use util::common::FN_OUTPUT_NAME;
-use middle::recursion_limit::guarantee_one_mb_stack_left;
+use middle::recursion_limit::ensure_sufficient_stack;
 
 /// Depending on the stage of compilation, we want projection to be
 /// more or less conservative.
@@ -299,7 +299,7 @@ pub fn normalize_with_depth<'a, 'b, 'gcx, 'tcx, T>(
 {
     debug!("normalize_with_depth(depth={}, value={:?})", depth, value);
     let mut normalizer = AssociatedTypeNormalizer::new(selcx, param_env, cause, depth);
-    let result = guarantee_one_mb_stack_left(|| normalizer.fold(value));
+    let result = ensure_sufficient_stack(|| normalizer.fold(value));
     debug!("normalize_with_depth: depth={} result={:?} with {} obligations",
            depth, result, normalizer.obligations.len());
     debug!("normalize_with_depth: depth={} obligations={:?}",
@@ -384,7 +384,7 @@ impl<'a, 'b, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for AssociatedTypeNormalizer<'a,
                         let generic_ty = self.tcx().type_of(def_id);
                         let concrete_ty = generic_ty.subst(self.tcx(), substs);
                         self.depth += 1;
-                        let folded_ty = guarantee_one_mb_stack_left(|| self.fold_ty(concrete_ty));
+                        let folded_ty = ensure_sufficient_stack(|| self.fold_ty(concrete_ty));
                         self.depth -= 1;
                         folded_ty
                     }

src/librustc/traits/query/normalize.rs

@@ -21,7 +21,7 @@ use traits::{Obligation, ObligationCause, PredicateObligation, Reveal};
 use ty::fold::{TypeFoldable, TypeFolder};
 use ty::subst::{Subst, Substs};
 use ty::{self, Ty, TyCtxt};
-use middle::recursion_limit::guarantee_one_mb_stack_left;
+use middle::recursion_limit::ensure_sufficient_stack;
 
 use super::NoSolution;
 
@@ -132,7 +132,7 @@ impl<'cx, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for QueryNormalizer<'cx, 'gcx, 'tcx
                                 ty
                             );
                         }
-                        let folded_ty = guarantee_one_mb_stack_left(|| self.fold_ty(concrete_ty));
+                        let folded_ty = ensure_sufficient_stack(|| self.fold_ty(concrete_ty));
                         self.anon_depth -= 1;
                         folded_ty
                     }

src/librustc/traits/select.rs

@@ -42,7 +42,7 @@ use hir::def_id::DefId;
 use infer;
 use infer::{InferCtxt, InferOk, TypeFreshener};
 use middle::lang_items;
-use middle::recursion_limit::guarantee_one_mb_stack_left;
+use middle::recursion_limit::ensure_sufficient_stack;
 use mir::interpret::GlobalId;
 use ty::fast_reject;
 use ty::relate::TypeRelation;
@@ -2856,7 +2856,7 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
             };
 
             let cause = obligation.derived_cause(BuiltinDerivedObligation);
-            guarantee_one_mb_stack_left(|| {
+            ensure_sufficient_stack(|| {
                 self.collect_predicates_for_types(
                     obligation.param_env,
                     cause,
@@ -2906,7 +2906,7 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
         nested: ty::Binder<Vec<Ty<'tcx>>>,
     ) -> VtableAutoImplData<PredicateObligation<'tcx>> {
         debug!("vtable_auto_impl: nested={:?}", nested);
-        guarantee_one_mb_stack_left(|| {
+        ensure_sufficient_stack(|| {
 
             let cause = obligation.derived_cause(BuiltinDerivedObligation);
             let mut obligations = self.collect_predicates_for_types(
@@ -2959,7 +2959,7 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
             let (substs, placeholder_map) = this.rematch_impl(impl_def_id, obligation, snapshot);
             debug!("confirm_impl_candidate: substs={:?}", substs);
             let cause = obligation.derived_cause(ImplDerivedObligation);
-            guarantee_one_mb_stack_left(|| this.vtable_impl(
+            ensure_sufficient_stack(|| this.vtable_impl(
                 impl_def_id,
                 substs,
                 cause,
@@ -3092,7 +3092,7 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
         let Normalized {
             value: trait_ref,
             obligations,
-        } = guarantee_one_mb_stack_left(|| project::normalize_with_depth(
+        } = ensure_sufficient_stack(|| project::normalize_with_depth(
             self,
             obligation.param_env,
             obligation.cause.clone(),
@@ -3175,7 +3175,7 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
         let Normalized {
             value: trait_ref,
             mut obligations,
-        } = guarantee_one_mb_stack_left(|| normalize_with_depth(
+        } = ensure_sufficient_stack(|| normalize_with_depth(
             self,
             obligation.param_env,
             obligation.cause.clone(),
@@ -3228,7 +3228,7 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
         let Normalized {
             value: trait_ref,
             mut obligations,
-        } = guarantee_one_mb_stack_left(|| normalize_with_depth(
+        } = ensure_sufficient_stack(|| normalize_with_depth(
             self,
             obligation.param_env,
             obligation.cause.clone(),
@@ -3486,7 +3486,7 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
                 nested.extend(obligations);
 
                 // Construct the nested Field<T>: Unsize<Field<U>> predicate.
-                nested.push(guarantee_one_mb_stack_left(|| {
+                nested.push(ensure_sufficient_stack(|| {
                     tcx.predicate_for_trait_def(
                         obligation.param_env,
                         obligation.cause.clone(),
@@ -3520,7 +3520,7 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
                 nested.extend(obligations);
 
                 // Construct the nested T: Unsize<U> predicate.
-                nested.push(guarantee_one_mb_stack_left(|| {
+                nested.push(ensure_sufficient_stack(|| {
                     tcx.predicate_for_trait_def(
                         obligation.param_env,
                         obligation.cause.clone(),
@@ -3602,7 +3602,7 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
         let Normalized {
             value: impl_trait_ref,
             obligations: mut nested_obligations,
-        } = guarantee_one_mb_stack_left(|| project::normalize_with_depth(
+        } = ensure_sufficient_stack(|| project::normalize_with_depth(
             self,
             obligation.param_env,
             obligation.cause.clone(),

src/librustc/ty/inhabitedness/mod.rs

@@ -14,7 +14,7 @@ use ty::{AdtDef, VariantDef, FieldDef, Ty, TyS};
 use ty::{DefId, Substs};
 use ty::{AdtKind, Visibility};
 use ty::TyKind::*;
-use middle::recursion_limit::guarantee_one_mb_stack_left;
+use middle::recursion_limit::ensure_sufficient_stack;
 
 pub use self::def_id_forest::DefIdForest;
 
@@ -250,7 +250,7 @@ impl<'a, 'gcx, 'tcx> TyS<'tcx> {
                         tcx.sess.fatal(&error);
                     }
                 }
-                let ret = guarantee_one_mb_stack_left(|| {
+                let ret = ensure_sufficient_stack(|| {
                     def.uninhabited_from(visited, tcx, substs)
                 });
                 let substs_set = visited.get_mut(&def.did).unwrap();

src/librustc/ty/query/plumbing.rs

@@ -540,7 +540,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
             p.record_query(Q::CATEGORY);
         });
 
-        let res = ::middle::recursion_limit::guarantee_one_mb_stack_left(|| job.start(self, |tcx| {
+        let res = ::middle::recursion_limit::ensure_sufficient_stack(|| job.start(self, |tcx| {
             if dep_node.kind.is_eval_always() {
                 tcx.dep_graph.with_eval_always_task(dep_node,
                                                     tcx,

src/librustc_mir/build/expr/as_temp.rs

@@ -14,7 +14,7 @@ use build::{BlockAnd, BlockAndExtension, BlockFrame, Builder};
 use hair::*;
 use rustc::middle::region;
 use rustc::mir::*;
-use rustc::middle::recursion_limit::guarantee_one_mb_stack_left;
+use rustc::middle::recursion_limit::ensure_sufficient_stack;
 
 impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
     /// Compile `expr` into a fresh temporary. This is used when building
@@ -34,7 +34,7 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
         // this is the only place in mir building that we need to truly need to worry about
         // infinite recursion. Everything else does recurse, too, but it always gets broken up
         // at some point by inserting an intermediate temporary
-        guarantee_one_mb_stack_left(|| self.expr_as_temp(block, temp_lifetime, expr, mutability))
+        ensure_sufficient_stack(|| self.expr_as_temp(block, temp_lifetime, expr, mutability))
     }
 
     fn expr_as_temp(

src/librustc_mir/monomorphize/collector.rs

@@ -409,7 +409,7 @@ fn collect_items_rec<'a, 'tcx: 'a>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                                                                recursion_depths));
             check_type_length_limit(tcx, instance);
 
-            rustc::middle::recursion_limit::guarantee_one_mb_stack_left(|| {
+            rustc::middle::recursion_limit::ensure_sufficient_stack(|| {
                 collect_neighbours(tcx, instance, &mut neighbors);
             });
         }
@@ -1180,7 +1180,7 @@ fn collect_miri<'a, 'tcx>(
         Some(AllocType::Memory(alloc)) => {
             trace!("collecting {:?} with {:#?}", alloc_id, alloc);
             for &((), inner) in alloc.relocations.values() {
-                rustc::middle::recursion_limit::guarantee_one_mb_stack_left(|| {
+                rustc::middle::recursion_limit::ensure_sufficient_stack(|| {
                     collect_miri(tcx, inner, output);
                 });
             }

src/librustc_traits/dropck_outlives.rs

@@ -193,20 +193,20 @@ fn dtorck_constraint_for_ty<'a, 'gcx, 'tcx>(
 
         ty::Array(ety, _) | ty::Slice(ety) => {
             // single-element containers, behave like their element
-            rustc::middle::recursion_limit::guarantee_one_mb_stack_left(|| {
+            rustc::middle::recursion_limit::ensure_sufficient_stack(|| {
                 dtorck_constraint_for_ty(tcx, span, for_ty, depth + 1, ety)
             })
         }
 
         ty::Tuple(tys) => tys.iter()
-            .map(|ty| rustc::middle::recursion_limit::guarantee_one_mb_stack_left(|| {
+            .map(|ty| rustc::middle::recursion_limit::ensure_sufficient_stack(|| {
                 dtorck_constraint_for_ty(tcx, span, for_ty, depth + 1, ty)
             }))
             .collect(),
 
         ty::Closure(def_id, substs) => substs
             .upvar_tys(def_id, tcx)
-            .map(|ty| rustc::middle::recursion_limit::guarantee_one_mb_stack_left(|| {
+            .map(|ty| rustc::middle::recursion_limit::ensure_sufficient_stack(|| {
                 dtorck_constraint_for_ty(tcx, span, for_ty, depth + 1, ty)
             }))
             .collect(),

src/librustc_typeck/check/mod.rs

@@ -94,7 +94,7 @@ use rustc::infer::{self, InferCtxt, InferOk, RegionVariableOrigin};
 use rustc::infer::opaque_types::OpaqueTypeDecl;
 use rustc::infer::type_variable::{TypeVariableOrigin};
 use rustc::middle::region;
-use rustc::middle::recursion_limit::guarantee_one_mb_stack_left;
+use rustc::middle::recursion_limit::ensure_sufficient_stack;
 use rustc::mir::interpret::{ConstValue, GlobalId};
 use rustc::ty::subst::{CanonicalUserSubsts, UnpackedKind, Subst, Substs,
                        UserSelfTy, UserSubsts};
@@ -3752,7 +3752,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
         self.diverges.set(Diverges::Maybe);
         self.has_errors.set(false);
 
-        let ty = guarantee_one_mb_stack_left(|| self.check_expr_kind(expr, expected, needs));
+        let ty = ensure_sufficient_stack(|| self.check_expr_kind(expr, expected, needs));
 
         // Warn for non-block expressions with diverging children.
         match expr.node {