rustc: simplify tcx.closure_type(...) as it can copy the cached values.

diff --git a/src/librustc/infer/mod.rs b/src/librustc/infer/mod.rs
index c9abcd38b95ad88da2351317942d5535ccdc6334..d7f254df7538a6b878e0e9faf2f4850d40a278e8 100644 (file)
--- a/src/librustc/infer/mod.rs
+++ b/src/librustc/infer/mod.rs
@@ -1649,20 +1649,16 @@ pub fn closure_kind(&self,
         Some(self.tcx.closure_kind(def_id))
     }
 
-    pub fn closure_type(&self,
-                        def_id: DefId,
-                        substs: ty::ClosureSubsts<'tcx>)
-                        -> ty::PolyFnSig<'tcx>
-    {
+    pub fn closure_type(&self, def_id: DefId) -> ty::PolyFnSig<'tcx> {
         if let InferTables::InProgress(tables) = self.tables {
             if let Some(id) = self.tcx.hir.as_local_node_id(def_id) {
-                if let Some(ty) = tables.borrow().closure_tys.get(&id) {
-                    return ty.subst(self.tcx, substs.substs);
+                if let Some(&ty) = tables.borrow().closure_tys.get(&id) {
+                    return ty;
                 }
             }
         }
 
-        self.tcx.closure_type(def_id, substs)
+        self.tcx.closure_type(def_id)
     }
 }
 

diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs
index 28f9a23d4593c3ce7c1acf39a71027587e62e53a..a8c1559ae2373b309ca0072d0c0ec90790d1f917 100644 (file)
--- a/src/librustc/middle/liveness.rs
+++ b/src/librustc/middle/liveness.rs
@@ -1432,12 +1432,16 @@ fn check_ret(&self,
                  body: &hir::Body)
     {
         let fn_ty = self.ir.tcx.item_type(self.ir.tcx.hir.local_def_id(id));
-        let fn_ret = match fn_ty.sty {
-            ty::TyClosure(closure_def_id, substs) =>
-                self.ir.tcx.closure_type(closure_def_id, substs).output(),
-            _ => fn_ty.fn_ret()
+        let fn_sig = match fn_ty.sty {
+            ty::TyClosure(closure_def_id, substs) => {
+                self.ir.tcx.closure_type(closure_def_id)
+                    .subst(self.ir.tcx, substs.substs)
+            }
+            _ => fn_ty.fn_sig()
         };
 
+        let fn_ret = fn_sig.output();
+
         // within the fn body, late-bound regions are liberated
         // and must outlive the *call-site* of the function.
         let fn_ret =

diff --git a/src/librustc/traits/project.rs b/src/librustc/traits/project.rs
index 0d498ce1aa3f36011d76103c1fd31a5001c920dc..448a3166bd8609ec1db82482a6f75ba31edd0451 100644 (file)
--- a/src/librustc/traits/project.rs
+++ b/src/librustc/traits/project.rs
@@ -1208,7 +1208,8 @@ fn confirm_closure_candidate<'cx, 'gcx, 'tcx>(
     -> Progress<'tcx>
 {
     let closure_typer = selcx.closure_typer();
-    let closure_type = closure_typer.closure_type(vtable.closure_def_id, vtable.substs);
+    let closure_type = closure_typer.closure_type(vtable.closure_def_id)
+        .subst(selcx.tcx(), vtable.substs.substs);
     let Normalized {
         value: closure_type,
         obligations

diff --git a/src/librustc/traits/select.rs b/src/librustc/traits/select.rs
index 98f814a54f8482760120ee0dec985e3a99f7fab2..e12ebb6d5157678b933c999d7d7cebeeb8f8062d 100644 (file)
--- a/src/librustc/traits/select.rs
+++ b/src/librustc/traits/select.rs
@@ -2779,7 +2779,8 @@ fn closure_trait_ref_unnormalized(&mut self,
                                       substs: ty::ClosureSubsts<'tcx>)
                                       -> ty::PolyTraitRef<'tcx>
     {
-        let closure_type = self.infcx.closure_type(closure_def_id, substs);
+        let closure_type = self.infcx.closure_type(closure_def_id)
+            .subst(self.tcx(), substs.substs);
         let ty::Binder((trait_ref, _)) =
             self.tcx().closure_trait_ref_and_return_type(obligation.predicate.def_id(),
                                                          obligation.predicate.0.self_ty(), // (1)

diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs
index c1f372a1c2970acf5a41547bd9e8bd1ff21d14a4..01be42881462a157cf48dfc745d5e77bc90e73ab 100644 (file)
--- a/src/librustc/ty/mod.rs
+++ b/src/librustc/ty/mod.rs
@@ -2467,16 +2467,8 @@ pub fn closure_kind(self, def_id: DefId) -> ty::ClosureKind {
         self.maps.closure_kind(self, def_id)
     }
 
-    pub fn closure_type(self,
-                        def_id: DefId,
-                        substs: ClosureSubsts<'tcx>)
-                        -> ty::PolyFnSig<'tcx>
-    {
-        if let Some(ty) = self.maps.closure_type.borrow().get(&def_id) {
-            return ty.subst(self, substs.substs);
-        }
-
-        self.maps.closure_type(self, def_id).subst(self, substs.substs)
+    pub fn closure_type(self, def_id: DefId) -> ty::PolyFnSig<'tcx> {
+        self.maps.closure_type(self, def_id)
     }
 
     /// Given the def_id of an impl, return the def_id of the trait it implements.

diff --git a/src/librustc_metadata/encoder.rs b/src/librustc_metadata/encoder.rs
index e101dc8cb5892314df5f9564a41e7df82e9b24cf..ed1cff31f2ff93f0f48f65a2f4bbbb0aea7d0284 100644 (file)
--- a/src/librustc_metadata/encoder.rs
+++ b/src/librustc_metadata/encoder.rs
@@ -1096,7 +1096,7 @@ fn encode_info_for_closure(&mut self, def_id: DefId) -> Entry<'tcx> {
 
         let data = ClosureData {
             kind: tcx.closure_kind(def_id),
-            ty: self.lazy(&tcx.maps.closure_type.borrow()[&def_id]),
+            ty: self.lazy(&tcx.closure_type(def_id)),
         };
 
         Entry {

diff --git a/src/librustc_trans/callee.rs b/src/librustc_trans/callee.rs
index 6a9531547c02397a17da5e77b1cdc97080db09c9..4925c9d547e9d19ac45108ae6479dcedc2b3b2b0 100644 (file)
--- a/src/librustc_trans/callee.rs
+++ b/src/librustc_trans/callee.rs
@@ -18,7 +18,7 @@
 
 use llvm::{self, ValueRef, get_params};
 use rustc::hir::def_id::DefId;
-use rustc::ty::subst::Substs;
+use rustc::ty::subst::{Substs, Subst};
 use rustc::traits;
 use abi::{Abi, FnType};
 use attributes;
@@ -306,7 +306,7 @@ fn trans_fn_once_adapter_shim<'a, 'tcx>(
     let ref_closure_ty = tcx.mk_imm_ref(tcx.mk_region(ty::ReErased), closure_ty);
 
     // Make a version with the type of by-ref closure.
-    let sig = tcx.closure_type(def_id, substs);
+    let sig = tcx.closure_type(def_id).subst(tcx, substs.substs);
     let sig = tcx.erase_late_bound_regions_and_normalize(&sig);
     assert_eq!(sig.abi, Abi::RustCall);
     let llref_fn_ty = tcx.mk_fn_ptr(ty::Binder(tcx.mk_fn_sig(

diff --git a/src/librustc_trans/common.rs b/src/librustc_trans/common.rs
index 5e858ce0e0cd32b90ff8710d59e2feab919d6b47..1032da7ef75bb4ff9f66d87f67388b01afc14eb9 100644 (file)
--- a/src/librustc_trans/common.rs
+++ b/src/librustc_trans/common.rs
@@ -29,6 +29,7 @@
 use value::Value;
 use rustc::ty::{self, Ty, TyCtxt};
 use rustc::ty::layout::Layout;
+use rustc::ty::subst::Subst;
 use rustc::traits::{self, SelectionContext, Reveal};
 use rustc::hir;
 
@@ -579,7 +580,7 @@ pub fn ty_fn_sig<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
         ty::TyFnPtr(sig) => sig,
         ty::TyClosure(def_id, substs) => {
             let tcx = ccx.tcx();
-            let sig = tcx.closure_type(def_id, substs);
+            let sig = tcx.closure_type(def_id).subst(tcx, substs.substs);
 
             let env_region = ty::ReLateBound(ty::DebruijnIndex::new(1), ty::BrEnv);
             let env_ty = match tcx.closure_kind(def_id) {

diff --git a/src/librustc_trans/mir/constant.rs b/src/librustc_trans/mir/constant.rs
index a4e74f72a10eb2f84a568f37cd9d96e755846bb2..1f595cae6a805425787974ddbef65cd8c0e4d8a1 100644 (file)
--- a/src/librustc_trans/mir/constant.rs
+++ b/src/librustc_trans/mir/constant.rs
@@ -20,7 +20,7 @@
 use rustc::mir::tcx::LvalueTy;
 use rustc::ty::{self, layout, Ty, TyCtxt, TypeFoldable};
 use rustc::ty::cast::{CastTy, IntTy};
-use rustc::ty::subst::{Kind, Substs};
+use rustc::ty::subst::{Kind, Substs, Subst};
 use rustc_data_structures::indexed_vec::{Idx, IndexVec};
 use {abi, adt, base, Disr, machine};
 use callee::Callee;
@@ -588,7 +588,8 @@ fn const_rvalue(&self, rvalue: &mir::Rvalue<'tcx>,
                                     .find(|it| it.kind == ty::AssociatedKind::Method)
                                     .unwrap().def_id;
                                 // Now create its substs [Closure, Tuple]
-                                let input = tcx.closure_type(def_id, substs).input(0);
+                                let input = tcx.closure_type(def_id)
+                                    .subst(tcx, substs.substs).input(0);
                                 let substs = tcx.mk_substs([operand.ty, input.skip_binder()]
                                     .iter().cloned().map(Kind::from));
                                 Callee::def(self.ccx, call_once, substs)

diff --git a/src/librustc_trans/mir/rvalue.rs b/src/librustc_trans/mir/rvalue.rs
index 4036d5152bb912179ae96d8f6d403b4e40a0b35b..037c771c97b066d52987a7248dcec1042afc1712 100644 (file)
--- a/src/librustc_trans/mir/rvalue.rs
+++ b/src/librustc_trans/mir/rvalue.rs
@@ -12,7 +12,7 @@
 use rustc::ty::{self, Ty};
 use rustc::ty::cast::{CastTy, IntTy};
 use rustc::ty::layout::Layout;
-use rustc::ty::subst::Kind;
+use rustc::ty::subst::{Kind, Subst};
 use rustc::mir::tcx::LvalueTy;
 use rustc::mir;
 use middle::lang_items::ExchangeMallocFnLangItem;
@@ -201,7 +201,8 @@ pub fn trans_rvalue_operand(&mut self,
                                     .find(|it| it.kind == ty::AssociatedKind::Method)
                                     .unwrap().def_id;
                                 // Now create its substs [Closure, Tuple]
-                                let input = bcx.tcx().closure_type(def_id, substs).input(0);
+                                let input = bcx.tcx().closure_type(def_id)
+                                    .subst(bcx.tcx(), substs.substs).input(0);
                                 let substs = bcx.tcx().mk_substs([operand.ty, input.skip_binder()]
                                     .iter().cloned().map(Kind::from));
                                 OperandValue::Immediate(

diff --git a/src/librustc_typeck/check/callee.rs b/src/librustc_typeck/check/callee.rs
index a253b223ef6ea67af946f9d221f716e7b83327d6..4b88f5acf42da2415ea3442fec3c06440ef307b2 100644 (file)
--- a/src/librustc_typeck/check/callee.rs
+++ b/src/librustc_typeck/check/callee.rs
@@ -14,6 +14,7 @@
 use hir::def_id::{DefId, LOCAL_CRATE};
 use rustc::{infer, traits};
 use rustc::ty::{self, TyCtxt, LvaluePreference, Ty};
+use rustc::ty::subst::Subst;
 use syntax::abi;
 use syntax::symbol::Symbol;
 use syntax_pos::Span;
@@ -110,7 +111,7 @@ fn try_overloaded_call_step(&self,
                 // haven't yet decided on whether the closure is fn vs
                 // fnmut vs fnonce. If so, we have to defer further processing.
                 if self.closure_kind(def_id).is_none() {
-                    let closure_ty = self.closure_type(def_id, substs);
+                    let closure_ty = self.closure_type(def_id).subst(self.tcx, substs.substs);
                     let fn_sig = self.replace_late_bound_regions_with_fresh_var(call_expr.span,
                                                                    infer::FnCall,
                                                                    &closure_ty)

diff --git a/src/librustc_typeck/check/coercion.rs b/src/librustc_typeck/check/coercion.rs
index ecde2e1afe9d80550942c060f295c706c7c18fe9..53759cc115d1cb69039a9473cdb2fc04c5b1446b 100644 (file)
--- a/src/librustc_typeck/check/coercion.rs
+++ b/src/librustc_typeck/check/coercion.rs
@@ -72,6 +72,7 @@
 use rustc::ty::fold::TypeFoldable;
 use rustc::ty::error::TypeError;
 use rustc::ty::relate::RelateResult;
+use rustc::ty::subst::Subst;
 use syntax::abi;
 use syntax::feature_gate;
 use util::common::indent;
@@ -587,7 +588,7 @@ fn coerce_closure_to_fn(&self,
                 //     `extern "rust-call" fn((arg0,arg1,...)) -> _`
                 // to
                 //     `fn(arg0,arg1,...) -> _`
-                let sig = self.closure_type(def_id_a, substs_a);
+                let sig = self.closure_type(def_id_a).subst(self.tcx, substs_a.substs);
                 let converted_sig = sig.map_bound(|s| {
                     let params_iter = match s.inputs()[0].sty {
                         ty::TyTuple(params, _) => {