rustc: Wrap users of InferCtxt in an anonymous scope.

Author: eddyb

src/librustc/infer/mod.rs

@@ -385,12 +385,21 @@ impl fmt::Display for FixupError {
 }
 
 impl<'a, 'tcx> InferCtxt<'a, 'tcx, 'tcx> {
-    pub fn new(tcx: TyCtxt<'a, 'tcx, 'tcx>,
-               tables: &'a RefCell<ty::Tables<'tcx>>,
-               param_env: Option<ty::ParameterEnvironment<'tcx>>,
-               projection_mode: ProjectionMode)
-               -> Self {
-        InferCtxt {
+    pub fn enter<F, R>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
+                       tables: Option<ty::Tables<'tcx>>,
+                       param_env: Option<ty::ParameterEnvironment<'tcx>>,
+                       projection_mode: ProjectionMode,
+                       f: F) -> R
+        where F: for<'b> FnOnce(InferCtxt<'b, 'tcx, 'tcx>) -> R
+    {
+        let new_tables;
+        let tables = if let Some(tables) = tables {
+            new_tables = RefCell::new(tables);
+            &new_tables
+        } else {
+            &tcx.tables
+        };
+        f(InferCtxt {
             tcx: tcx,
             tables: tables,
             type_variables: RefCell::new(type_variable::TypeVariableTable::new()),
@@ -403,16 +412,18 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx, 'tcx> {
             projection_mode: projection_mode,
         tainted_by_errors_flag: Cell::new(false),
             err_count_on_creation: tcx.sess.err_count()
-        }
+        })
     }
 
-    pub fn normalizing(tcx: TyCtxt<'a, 'tcx, 'tcx>,
-                       tables: &'a RefCell<ty::Tables<'tcx>>,
-                       projection_mode: ProjectionMode)
-                       -> Self {
-        let mut infcx = InferCtxt::new(tcx, tables, None, projection_mode);
-        infcx.normalize = true;
-        infcx
+    pub fn enter_normalizing<F, R>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
+                                   projection_mode: ProjectionMode,
+                                   f: F) -> R
+        where F: for<'b> FnOnce(InferCtxt<'b, 'tcx, 'tcx>) -> R
+    {
+        InferCtxt::enter(tcx, None, None, projection_mode, |mut infcx| {
+            infcx.normalize = true;
+            f(infcx)
+        })
     }
 }
 
@@ -453,23 +464,23 @@ impl<'a, 'tcx> TyCtxt<'a, 'tcx, 'tcx> {
             return value;
         }
 
-        let infcx = InferCtxt::new(self, &self.tables, None, ProjectionMode::Any);
-        let mut selcx = traits::SelectionContext::new(&infcx);
-        let cause = traits::ObligationCause::dummy();
-        let traits::Normalized { value: result, obligations } =
-            traits::normalize(&mut selcx, cause, &value);
+        InferCtxt::enter(self, None, None, ProjectionMode::Any, |infcx| {
+            let mut selcx = traits::SelectionContext::new(&infcx);
+            let cause = traits::ObligationCause::dummy();
+            let traits::Normalized { value: result, obligations } =
+                traits::normalize(&mut selcx, cause, &value);
 
-        debug!("normalize_associated_type: result={:?} obligations={:?}",
-            result,
-            obligations);
+            debug!("normalize_associated_type: result={:?} obligations={:?}",
+                   result, obligations);
 
-        let mut fulfill_cx = traits::FulfillmentContext::new();
+            let mut fulfill_cx = traits::FulfillmentContext::new();
 
-        for obligation in obligations {
-            fulfill_cx.register_predicate_obligation(&infcx, obligation);
-        }
+            for obligation in obligations {
+                fulfill_cx.register_predicate_obligation(&infcx, obligation);
+            }
 
-        infcx.drain_fulfillment_cx_or_panic(DUMMY_SP, &mut fulfill_cx, &result)
+            infcx.drain_fulfillment_cx_or_panic(DUMMY_SP, &mut fulfill_cx, &result)
+        })
     }
 }
 

src/librustc/middle/intrinsicck.rs

@@ -36,13 +36,12 @@ struct ItemVisitor<'a, 'tcx: 'a> {
 impl<'a, 'tcx> ItemVisitor<'a, 'tcx> {
     fn visit_const(&mut self, item_id: ast::NodeId, expr: &hir::Expr) {
         let param_env = ty::ParameterEnvironment::for_item(self.tcx, item_id);
-        let infcx = InferCtxt::new(self.tcx, &self.tcx.tables,
-                                   Some(param_env),
-                                   ProjectionMode::Any);
-        let mut visitor = ExprVisitor {
-            infcx: &infcx
-        };
-        visitor.visit_expr(expr);
+        InferCtxt::enter(self.tcx, None, Some(param_env), ProjectionMode::Any, |infcx| {
+            let mut visitor = ExprVisitor {
+                infcx: &infcx
+            };
+            visitor.visit_expr(expr);
+        });
     }
 }
 
@@ -115,12 +114,12 @@ impl<'a, 'tcx> ExprVisitor<'a, 'tcx, 'tcx> {
 impl<'a, 'tcx, 'v> Visitor<'v> for ItemVisitor<'a, 'tcx> {
     // const, static and N in [T; N].
     fn visit_expr(&mut self, expr: &hir::Expr) {
-        let infcx = InferCtxt::new(self.tcx, &self.tcx.tables,
-                                   None, ProjectionMode::Any);
-        let mut visitor = ExprVisitor {
-            infcx: &infcx
-        };
-        visitor.visit_expr(expr);
+        InferCtxt::enter(self.tcx, None, None, ProjectionMode::Any, |infcx| {
+            let mut visitor = ExprVisitor {
+                infcx: &infcx
+            };
+            visitor.visit_expr(expr);
+        });
     }
 
     fn visit_trait_item(&mut self, item: &hir::TraitItem) {
@@ -141,21 +140,16 @@ impl<'a, 'tcx, 'v> Visitor<'v> for ItemVisitor<'a, 'tcx> {
 
     fn visit_fn(&mut self, fk: FnKind<'v>, fd: &'v hir::FnDecl,
                 b: &'v hir::Block, s: Span, id: ast::NodeId) {
-        match fk {
-            FnKind::ItemFn(..) | FnKind::Method(..) => {
-                let param_env = ty::ParameterEnvironment::for_item(self.tcx, id);
-                let infcx = InferCtxt::new(self.tcx, &self.tcx.tables,
-                                           Some(param_env),
-                                           ProjectionMode::Any);
-                let mut visitor = ExprVisitor {
-                    infcx: &infcx
-                };
-                visitor.visit_fn(fk, fd, b, s, id);
-            }
-            FnKind::Closure(..) => {
-                span_bug!(s, "intrinsicck: closure outside of function")
-            }
+        if let FnKind::Closure(..) = fk {
+            span_bug!(s, "intrinsicck: closure outside of function")
         }
+        let param_env = ty::ParameterEnvironment::for_item(self.tcx, id);
+        InferCtxt::enter(self.tcx, None, Some(param_env), ProjectionMode::Any, |infcx| {
+            let mut visitor = ExprVisitor {
+                infcx: &infcx
+            };
+            visitor.visit_fn(fk, fd, b, s, id);
+        });
     }
 }
 

src/librustc/middle/liveness.rs

@@ -1488,18 +1488,14 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
 
                 let param_env = ParameterEnvironment::for_item(self.ir.tcx, id);
                 let t_ret_subst = t_ret.subst(self.ir.tcx, &param_env.free_substs);
-                let infcx = InferCtxt::new(self.ir.tcx,
-                                           &self.ir.tcx.tables,
-                                           Some(param_env),
-                                           ProjectionMode::Any);
-                let cause = traits::ObligationCause::dummy();
-                let norm = traits::fully_normalize(&infcx,
-                                                   cause,
-                                                   &t_ret_subst);
-
-                if norm.unwrap().is_nil() {
-                    // for nil return types, it is ok to not return a value expl.
-                } else {
+                let is_nil = InferCtxt::enter(self.ir.tcx, None, Some(param_env),
+                                              ProjectionMode::Any, |infcx| {
+                    let cause = traits::ObligationCause::dummy();
+                    traits::fully_normalize(&infcx, cause, &t_ret_subst).unwrap().is_nil()
+                });
+
+                // for nil return types, it is ok to not return a value expl.
+                if !is_nil {
                     let ends_with_stmt = match body.expr {
                         None if !body.stmts.is_empty() =>
                             match body.stmts.last().unwrap().node {

src/librustc/traits/mod.rs

@@ -37,7 +37,7 @@ pub use self::object_safety::MethodViolationCode;
 pub use self::select::{EvaluationCache, SelectionContext, SelectionCache};
 pub use self::select::{MethodMatchResult, MethodMatched, MethodAmbiguous, MethodDidNotMatch};
 pub use self::select::{MethodMatchedData}; // intentionally don't export variants
-pub use self::specialize::{Overlap, specialization_graph, specializes, translate_substs};
+pub use self::specialize::{OverlapError, specialization_graph, specializes, translate_substs};
 pub use self::util::elaborate_predicates;
 pub use self::util::supertraits;
 pub use self::util::Supertraits;
@@ -422,42 +422,43 @@ pub fn normalize_param_env_or_error<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
 
     let elaborated_env = unnormalized_env.with_caller_bounds(predicates);
 
-    let infcx = InferCtxt::new(tcx, &tcx.tables, Some(elaborated_env),
-                               ProjectionMode::AnyFinal);
-    let predicates = match fully_normalize(&infcx,
-                                           cause,
-                                           &infcx.parameter_environment.caller_bounds) {
-        Ok(predicates) => predicates,
-        Err(errors) => {
-            infcx.report_fulfillment_errors(&errors);
-            return infcx.parameter_environment; // an unnormalized env is better than nothing
-        }
-    };
-
-    debug!("normalize_param_env_or_error: normalized predicates={:?}",
-           predicates);
-
-    let free_regions = FreeRegionMap::new();
-    infcx.resolve_regions_and_report_errors(&free_regions, body_id);
-    let predicates = match infcx.fully_resolve(&predicates) {
-        Ok(predicates) => predicates,
-        Err(fixup_err) => {
-            // If we encounter a fixup error, it means that some type
-            // variable wound up unconstrained. I actually don't know
-            // if this can happen, and I certainly don't expect it to
-            // happen often, but if it did happen it probably
-            // represents a legitimate failure due to some kind of
-            // unconstrained variable, and it seems better not to ICE,
-            // all things considered.
-            tcx.sess.span_err(span, &fixup_err.to_string());
-            return infcx.parameter_environment; // an unnormalized env is better than nothing
-        }
-    };
+    InferCtxt::enter(tcx, None, Some(elaborated_env), ProjectionMode::AnyFinal, |infcx| {
+        let predicates = match fully_normalize(&infcx, cause,
+                                               &infcx.parameter_environment.caller_bounds) {
+            Ok(predicates) => predicates,
+            Err(errors) => {
+                infcx.report_fulfillment_errors(&errors);
+                // An unnormalized env is better than nothing.
+                return infcx.parameter_environment;
+            }
+        };
+
+        debug!("normalize_param_env_or_error: normalized predicates={:?}",
+            predicates);
+
+        let free_regions = FreeRegionMap::new();
+        infcx.resolve_regions_and_report_errors(&free_regions, body_id);
+        let predicates = match infcx.fully_resolve(&predicates) {
+            Ok(predicates) => predicates,
+            Err(fixup_err) => {
+                // If we encounter a fixup error, it means that some type
+                // variable wound up unconstrained. I actually don't know
+                // if this can happen, and I certainly don't expect it to
+                // happen often, but if it did happen it probably
+                // represents a legitimate failure due to some kind of
+                // unconstrained variable, and it seems better not to ICE,
+                // all things considered.
+                tcx.sess.span_err(span, &fixup_err.to_string());
+                // An unnormalized env is better than nothing.
+                return infcx.parameter_environment;
+            }
+        };
 
-    debug!("normalize_param_env_or_error: resolved predicates={:?}",
-           predicates);
+        debug!("normalize_param_env_or_error: resolved predicates={:?}",
+            predicates);
 
-    infcx.parameter_environment.with_caller_bounds(predicates)
+        infcx.parameter_environment.with_caller_bounds(predicates)
+    })
 }
 
 pub fn fully_normalize<'a,'tcx,T>(infcx: &InferCtxt<'a,'tcx, 'tcx>,

src/librustc/traits/specialize/mod.rs

@@ -31,10 +31,10 @@ use syntax::codemap::DUMMY_SP;
 pub mod specialization_graph;
 
 /// Information pertinent to an overlapping impl error.
-pub struct Overlap<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
-    pub in_context: InferCtxt<'a, 'gcx, 'tcx>,
+pub struct OverlapError {
     pub with_impl: DefId,
-    pub on_trait_ref: ty::TraitRef<'tcx>,
+    pub trait_desc: String,
+    pub self_desc: Option<String>
 }
 
 /// Given a subst for the requested impl, translate it to a subst
@@ -135,8 +135,6 @@ pub fn specializes<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
         return false;
     }
 
-    let mut infcx = InferCtxt::normalizing(tcx, &tcx.tables, ProjectionMode::Topmost);
-
     // create a parameter environment corresponding to a (skolemized) instantiation of impl1
     let scheme = tcx.lookup_item_type(impl1_def_id);
     let predicates = tcx.lookup_predicates(impl1_def_id);
@@ -148,18 +146,21 @@ pub fn specializes<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                              .unwrap()
                              .subst(tcx, &penv.free_substs);
 
-    // Normalize the trait reference, adding any obligations that arise into the impl1 assumptions
-    let Normalized { value: impl1_trait_ref, obligations: normalization_obligations } = {
-        let selcx = &mut SelectionContext::new(&infcx);
-        traits::normalize(selcx, ObligationCause::dummy(), &impl1_trait_ref)
-    };
-    penv.caller_bounds.extend(normalization_obligations.into_iter().map(|o| o.predicate));
+    InferCtxt::enter_normalizing(tcx, ProjectionMode::Topmost, |mut infcx| {
+        // Normalize the trait reference, adding any obligations
+        // that arise into the impl1 assumptions.
+        let Normalized { value: impl1_trait_ref, obligations: normalization_obligations } = {
+            let selcx = &mut SelectionContext::new(&infcx);
+            traits::normalize(selcx, ObligationCause::dummy(), &impl1_trait_ref)
+        };
+        penv.caller_bounds.extend(normalization_obligations.into_iter().map(|o| o.predicate));
 
-    // Install the parameter environment, taking the predicates of impl1 as assumptions:
-    infcx.parameter_environment = penv;
+        // Install the parameter environment, taking the predicates of impl1 as assumptions:
+        infcx.parameter_environment = penv;
 
-    // Attempt to prove that impl2 applies, given all of the above.
-    fulfill_implication(&infcx, impl1_trait_ref, impl2_def_id).is_ok()
+        // Attempt to prove that impl2 applies, given all of the above.
+        fulfill_implication(&infcx, impl1_trait_ref, impl2_def_id).is_ok()
+    })
 }
 
 /// Attempt to fulfill all obligations of `target_impl` after unification with