From 3146ee86723e329ccfb23c6b72594dc96d8e9497 Mon Sep 17 00:00:00 2001 From: Eduard-Mihai Burtescu Date: Mon, 13 Feb 2017 23:26:32 +0200 Subject: [PATCH] rustc: simplify tcx.closure_type(...) as it can copy the cached values. --- src/librustc/infer/mod.rs | 12 ++++-------- src/librustc/middle/liveness.rs | 12 ++++++++---- src/librustc/traits/project.rs | 3 ++- src/librustc/traits/select.rs | 3 ++- src/librustc/ty/mod.rs | 12 ++---------- src/librustc_metadata/encoder.rs | 2 +- src/librustc_trans/callee.rs | 4 ++-- src/librustc_trans/common.rs | 3 ++- src/librustc_trans/mir/constant.rs | 5 +++-- src/librustc_trans/mir/rvalue.rs | 5 +++-- src/librustc_typeck/check/callee.rs | 3 ++- src/librustc_typeck/check/coercion.rs | 3 ++- 12 files changed, 33 insertions(+), 34 deletions(-) diff --git a/src/librustc/infer/mod.rs b/src/librustc/infer/mod.rs index c9abcd38b95ad..d7f254df7538a 100644 --- a/src/librustc/infer/mod.rs +++ b/src/librustc/infer/mod.rs @@ -1649,20 +1649,16 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> { 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 28f9a23d4593c..a8c1559ae2373 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -1432,12 +1432,16 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { 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 0d498ce1aa3f3..448a3166bd860 100644 --- 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 98f814a54f848..e12ebb6d51576 100644 --- a/src/librustc/traits/select.rs +++ b/src/librustc/traits/select.rs @@ -2779,7 +2779,8 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> { 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 c1f372a1c2970..01be42881462a 100644 --- a/src/librustc/ty/mod.rs +++ b/src/librustc/ty/mod.rs @@ -2467,16 +2467,8 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { 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 e101dc8cb5892..ed1cff31f2ff9 100644 --- a/src/librustc_metadata/encoder.rs +++ b/src/librustc_metadata/encoder.rs @@ -1096,7 +1096,7 @@ impl<'a, 'tcx> EncodeContext<'a, '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 6a9531547c023..4925c9d547e9d 100644 --- a/src/librustc_trans/callee.rs +++ b/src/librustc_trans/callee.rs @@ -18,7 +18,7 @@ pub use self::CalleeData::*; 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 5e858ce0e0cd3..1032da7ef75bb 100644 --- a/src/librustc_trans/common.rs +++ b/src/librustc_trans/common.rs @@ -29,6 +29,7 @@ use type_::Type; 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 a4e74f72a10eb..1f595cae6a805 100644 --- a/src/librustc_trans/mir/constant.rs +++ b/src/librustc_trans/mir/constant.rs @@ -20,7 +20,7 @@ use rustc::mir; 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 @@ impl<'a, 'tcx> MirConstContext<'a, '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 4036d5152bb91..037c771c97b06 100644 --- a/src/librustc_trans/mir/rvalue.rs +++ b/src/librustc_trans/mir/rvalue.rs @@ -12,7 +12,7 @@ use llvm::{self, ValueRef}; 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 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> { .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 a253b223ef6ea..4b88f5acf42da 100644 --- a/src/librustc_typeck/check/callee.rs +++ b/src/librustc_typeck/check/callee.rs @@ -14,6 +14,7 @@ use hir::def::Def; 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 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { // 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 ecde2e1afe9d8..53759cc115d1c 100644 --- a/src/librustc_typeck/check/coercion.rs +++ b/src/librustc_typeck/check/coercion.rs @@ -72,6 +72,7 @@ use rustc::ty::{self, LvaluePreference, TypeAndMut, 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 @@ impl<'f, 'gcx, 'tcx> Coerce<'f, 'gcx, 'tcx> { // `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, _) => {