enc_substs(w, cx, substs);
mywrite!(w, "]");
}
- ty::TyClosure(def, substs, ref tys) => {
+ ty::TyClosure(def, ref substs) => {
mywrite!(w, "k[{}|", (cx.ds)(def));
- enc_substs(w, cx, substs);
- for ty in tys {
+ enc_substs(w, cx, &substs.func_substs);
+ for ty in &substs.upvar_tys {
enc_ty(w, cx, ty);
}
mywrite!(w, ".");
Err(msg) => tcx.sess.fatal(&msg),
}
}
- ty::TyClosure(def_id, _, _) => {
+ ty::TyClosure(def_id, _) => {
Some(ClosureSimplifiedType(def_id))
}
ty::TyTuple(ref tys) => {
pub enum Implication<'tcx> {
RegionSubRegion(Option<Ty<'tcx>>, ty::Region, ty::Region),
RegionSubGeneric(Option<Ty<'tcx>>, ty::Region, GenericKind<'tcx>),
- RegionSubClosure(Option<Ty<'tcx>>, ty::Region, ast::DefId, &'tcx Substs<'tcx>),
+ RegionSubClosure(Option<Ty<'tcx>>, ty::Region, ast::DefId, &'tcx ty::ClosureSubsts<'tcx>),
Predicate(ast::DefId, ty::Predicate<'tcx>),
}
// No borrowed content reachable here.
}
- ty::TyClosure(def_id, substs, _) => {
+ ty::TyClosure(def_id, ref substs) => {
// TODO remove RegionSubClosure
let &(r_a, opt_ty) = self.stack.last().unwrap();
self.out.push(Implication::RegionSubClosure(opt_ty, r_a, def_id, substs));
}
pub fn closure_type(&self,
- def_id: ast::DefId,
- substs: &subst::Substs<'tcx>)
- -> ty::ClosureTy<'tcx>
+ def_id: ast::DefId,
+ substs: &ty::ClosureSubsts<'tcx>)
+ -> ty::ClosureTy<'tcx>
{
-
let closure_ty = self.tables
.borrow()
.closure_tys
.get(&def_id)
.unwrap()
- .subst(self.tcx, substs);
+ .subst(self.tcx, &substs.func_substs);
if self.normalize {
normalize_associated_type(&self.tcx, &closure_ty)
pub fn closure_upvars(&self,
def_id: ast::DefId,
- substs: &Substs<'tcx>)
+ substs: &ty::ClosureSubsts<'tcx>)
-> Option<Vec<ty::ClosureUpvar<'tcx>>>
{
let result = ty::ctxt::closure_upvars(self, def_id, substs);
fn fn_ret(&self, id: NodeId) -> ty::PolyFnOutput<'tcx> {
let fn_ty = self.ir.tcx.node_id_to_type(id);
match fn_ty.sty {
- ty::TyClosure(closure_def_id, substs, _) =>
+ ty::TyClosure(closure_def_id, ref substs) =>
self.ir.tcx.closure_type(closure_def_id, substs).sig.output(),
_ => fn_ty.fn_ret()
}
def::DefUpvar(var_id, fn_node_id) => {
let ty = try!(self.node_ty(fn_node_id));
match ty.sty {
- ty::TyClosure(closure_id, _, _) => {
+ ty::TyClosure(closure_id, _) => {
match self.typer.closure_kind(closure_id) {
Some(kind) => {
self.cat_upvar(id, span, var_id, fn_node_id, kind)
#[derive(Clone, PartialEq, Eq)]
pub struct VtableClosureData<'tcx, N> {
pub closure_def_id: ast::DefId,
- pub substs: subst::Substs<'tcx>,
- pub upvar_tys: Vec<Ty<'tcx>>,
+ pub substs: ty::ClosureSubsts<'tcx>,
/// Nested obligations. This can be non-empty if the closure
/// signature contains associated types.
pub nested: Vec<N>
closure_def_id: c.closure_def_id,
substs: c.substs,
nested: c.nested.into_iter().map(f).collect(),
- upvar_tys: c.upvar_tys,
})
}
}
debug!("consider_unification_despite_ambiguity: self_ty.sty={:?}",
self_ty.sty);
match self_ty.sty {
- ty::TyClosure(closure_def_id, substs, _) => {
+ ty::TyClosure(closure_def_id, ref substs) => {
let closure_typer = selcx.closure_typer();
let closure_type = closure_typer.closure_type(closure_def_id, substs);
let ty::Binder((_, ret_type)) =
/// Implementation of a `Fn`-family trait by one of the
/// anonymous types generated for a `||` expression.
- ClosureCandidate(/* closure */ ast::DefId, &'tcx Substs<'tcx>, &'tcx Vec<Ty<'tcx>>),
+ ClosureCandidate(/* closure */ ast::DefId, &'tcx ty::ClosureSubsts<'tcx>),
/// Implementation of a `Fn`-family trait by one of the anonymous
/// types generated for a fn pointer type (e.g., `fn(int)->int`)
// lifetimes can appear inside the self-type.
let self_ty = self.infcx.shallow_resolve(*obligation.self_ty().skip_binder());
let (closure_def_id, substs) = match self_ty.sty {
- ty::TyClosure(id, ref substs, _) => (id, substs.clone()),
+ ty::TyClosure(id, ref substs) => (id, substs),
_ => { return; }
};
assert!(!substs.has_escaping_regions());
// touch bound regions, they just capture the in-scope
// type/region parameters
let self_ty = self.infcx.shallow_resolve(*obligation.self_ty().skip_binder());
- let (closure_def_id, substs, upvar_tys) = match self_ty.sty {
- ty::TyClosure(id, substs, ref upvar_tys) => (id, substs, upvar_tys),
+ let (closure_def_id, substs) = match self_ty.sty {
+ ty::TyClosure(id, ref substs) => (id, substs),
ty::TyInfer(ty::TyVar(_)) => {
debug!("assemble_unboxed_closure_candidates: ambiguous self-type");
candidates.ambiguous = true;
Some(closure_kind) => {
debug!("assemble_unboxed_candidates: closure_kind = {:?}", closure_kind);
if closure_kind.extends(kind) {
- candidates.vec.push(ClosureCandidate(closure_def_id, substs, upvar_tys));
+ candidates.vec.push(ClosureCandidate(closure_def_id, substs));
}
}
None => {
// (T1, ..., Tn) -- meets any bound that all of T1...Tn meet
ty::TyTuple(ref tys) => ok_if(tys.clone()),
- ty::TyClosure(def_id, substs, _) => {
+ ty::TyClosure(def_id, ref substs) => {
// FIXME -- This case is tricky. In the case of by-ref
// closures particularly, we need the results of
// inference to decide how to reflect the type of each
Some(tys.clone())
}
- ty::TyClosure(def_id, substs, _) => {
+ ty::TyClosure(def_id, ref substs) => {
assert_eq!(def_id.krate, ast::LOCAL_CRATE);
// TODO
Ok(VtableImpl(vtable_impl))
}
- ClosureCandidate(closure_def_id, substs, upvar_tys) => {
+ ClosureCandidate(closure_def_id, substs) => {
let vtable_closure =
- try!(self.confirm_closure_candidate(obligation, closure_def_id,
- &substs, upvar_tys));
+ try!(self.confirm_closure_candidate(obligation, closure_def_id, substs));
Ok(VtableClosure(vtable_closure))
}
fn confirm_closure_candidate(&mut self,
obligation: &TraitObligation<'tcx>,
closure_def_id: ast::DefId,
- substs: &Substs<'tcx>,
- upvar_tys: &'tcx Vec<Ty<'tcx>>)
+ substs: &ty::ClosureSubsts<'tcx>)
-> Result<VtableClosureData<'tcx, PredicateObligation<'tcx>>,
SelectionError<'tcx>>
{
Ok(VtableClosureData {
closure_def_id: closure_def_id,
substs: substs.clone(),
- upvar_tys: upvar_tys.clone(),
nested: obligations
})
}
fn closure_trait_ref_unnormalized(&mut self,
obligation: &TraitObligation<'tcx>,
closure_def_id: ast::DefId,
- substs: &Substs<'tcx>)
+ substs: &ty::ClosureSubsts<'tcx>)
-> ty::PolyTraitRef<'tcx>
{
let closure_type = self.infcx.closure_type(closure_def_id, substs);
fn closure_trait_ref(&mut self,
obligation: &TraitObligation<'tcx>,
closure_def_id: ast::DefId,
- substs: &Substs<'tcx>)
+ substs: &ty::ClosureSubsts<'tcx>)
-> Normalized<'tcx, ty::PolyTraitRef<'tcx>>
{
let trait_ref = self.closure_trait_ref_unnormalized(
/// The anonymous type of a closure. Used to represent the type of
/// `|a| a`.
- TyClosure(DefId, &'tcx Substs<'tcx>, Vec<Ty<'tcx>>),
+ TyClosure(DefId, Box<ClosureSubsts<'tcx>>),
/// A tuple type. For example, `(i32, bool)`.
TyTuple(Vec<Ty<'tcx>>),
TyError,
}
+/// A closure can be modeled as a struct that looks like:
+///
+/// struct Closure<'l0...'li, T0...Tj, U0...Uk> {
+/// upvar0: U0,
+/// ...
+/// upvark: Uk
+/// }
+///
+/// where 'l0...'li and T0...Tj are the lifetime and type parameters
+/// in scope on the function that defined the closure, and U0...Uk are
+/// type parameters representing the types of its upvars (borrowed, if
+/// appropriate).
+///
+/// So, for example, given this function:
+///
+/// fn foo<'a, T>(data: &'a mut T) {
+/// do(|| data.count += 1)
+/// }
+///
+/// the type of the closure would be something like:
+///
+/// struct Closure<'a, T, U0> {
+/// data: U0
+/// }
+///
+/// Note that the type of the upvar is not specified in the struct.
+/// You may wonder how the impl would then be able to use the upvar,
+/// if it doesn't know it's type? The answer is that the impl is
+/// (conceptually) not fully generic over Closure but rather tied to
+/// instances with the expected upvar types:
+///
+/// impl<'b, 'a, T> FnMut() for Closure<'a, T, &'b mut &'a mut T> {
+/// ...
+/// }
+///
+/// You can see that the *impl* fully specified the type of the upvar
+/// and thus knows full well that `data` has type `&'b mut &'a mut T`.
+/// (Here, I am assuming that `data` is mut-borrowed.)
+///
+/// Now, the last question you may ask is: Why include the upvar types
+/// as extra type parameters? The reason for this design is that the
+/// upvar types can reference lifetimes that are internal to the
+/// creating function. In my example above, for example, the lifetime
+/// `'b` represents the extent of the closure itself; this is some
+/// subset of `foo`, probably just the extent of the call to the to
+/// `do()`. If we just had the lifetime/type parameters from the
+/// enclosing function, we couldn't name this lifetime `'b`. Note that
+/// there can also be lifetimes in the types of the upvars themselves,
+/// if one of them happens to be a reference to something that the
+/// creating fn owns.
+///
+/// OK, you say, so why not create a more minimal set of parameters
+/// that just includes the extra lifetime parameters? The answer is
+/// primarily that it would be hard --- we don't know at the time when
+/// we create the closure type what the full types of the upvars are,
+/// nor do we know which are borrowed and which are not. In this
+/// design, we can just supply a fresh type parameter and figure that
+/// out later.
+///
+/// All right, you say, but why include the type parameters from the
+/// original function then? The answer is that trans may need them
+/// when monomorphizing, and they may not appear in the upvars. A
+/// closure could capture no variables but still make use of some
+/// in-scope type parameter with a bound (e.g., if our example above
+/// had an extra `U: Default`, and the closure called `U::default()`).
+///
+/// There is another reason. This design (implicitly) prohibits
+/// closures from capturing themselves (except via a trait
+/// object). This simplifies closure inference considerably, since it
+/// means that when we infer the kind of a closure or its upvars, we
+/// don't have to handles cycles where the decisions we make wind up
+/// for closure C wind up influencing the decisions we ought to make
+/// for closure C (which would then require fixed point iteration to
+/// handle). Plus it fixes an ICE. :P
+#[derive(Clone, PartialEq, Eq, Hash, Debug)]
+pub struct ClosureSubsts<'tcx> {
+ /// Lifetime and type parameters from the enclosing function.
+ /// These are separated out because trans wants to pass them around
+ /// when monomorphizing.
+ pub func_substs: &'tcx Substs<'tcx>,
+
+ /// The types of the upvars. The list parallels the freevars and
+ /// `upvar_borrows` lists. These are kept distinct so that we can
+ /// easily index into them.
+ pub upvar_tys: Vec<Ty<'tcx>>
+}
+
#[derive(Clone, PartialEq, Eq, Hash)]
pub struct TraitTy<'tcx> {
pub principal: ty::PolyTraitRef<'tcx>,
}
}
- &TyClosure(_, substs, ref tys) => {
+ &TyClosure(_, ref substs) => {
self.add_flags(TypeFlags::HAS_TY_CLOSURE);
self.add_flags(TypeFlags::HAS_LOCAL_NAMES);
- self.add_substs(substs);
- self.add_tys(tys);
+ self.add_substs(&substs.func_substs);
+ self.add_tys(&substs.upvar_tys);
}
&TyInfer(_) => {
pub fn closure_type(&self,
def_id: ast::DefId,
- substs: &subst::Substs<'tcx>)
+ substs: &ClosureSubsts<'tcx>)
-> ty::ClosureTy<'tcx>
{
- self.tables.borrow().closure_tys.get(&def_id).unwrap().subst(self, substs)
+ self.tables.borrow().closure_tys.get(&def_id).unwrap().subst(self, &substs.func_substs)
}
pub fn type_parameter_def(&self,
substs: &'tcx Substs<'tcx>,
tys: Vec<Ty<'tcx>>)
-> Ty<'tcx> {
- self.mk_ty(TyClosure(closure_id, substs, tys))
+ self.mk_closure_from_closure_substs(closure_id, Box::new(ClosureSubsts {
+ func_substs: substs,
+ upvar_tys: tys
+ }))
+ }
+
+ pub fn mk_closure_from_closure_substs(&self,
+ closure_id: ast::DefId,
+ closure_substs: Box<ClosureSubsts<'tcx>>)
+ -> Ty<'tcx> {
+ self.mk_ty(TyClosure(closure_id, closure_substs))
}
pub fn mk_var(&self, v: TyVid) -> Ty<'tcx> {
TyTrait(ref tt) => Some(tt.principal_def_id()),
TyStruct(id, _) |
TyEnum(id, _) |
- TyClosure(id, _, _) => Some(id),
+ TyClosure(id, _) => Some(id),
_ => None
}
}
apply_lang_items(cx, did, res)
}
- TyClosure(did, substs, _) => {
+ TyClosure(did, ref substs) => {
+ // TODO
let param_env = cx.empty_parameter_environment();
let infcx = infer::new_infer_ctxt(cx, &cx.tables, Some(param_env), false);
let upvars = infcx.closure_upvars(did, substs).unwrap();
// Returns a list of `ClosureUpvar`s for each upvar.
pub fn closure_upvars<'a>(typer: &infer::InferCtxt<'a, 'tcx>,
- closure_id: ast::DefId,
- substs: &Substs<'tcx>)
- -> Option<Vec<ClosureUpvar<'tcx>>>
+ closure_id: ast::DefId,
+ substs: &ClosureSubsts<'tcx>)
+ -> Option<Vec<ClosureUpvar<'tcx>>>
{
// Presently an unboxed closure type cannot "escape" out of a
// function, so we will only encounter ones that originated in the
Ok(t) => { t }
Err(()) => { return None; }
};
- let freevar_ty = freevar_ty.subst(tcx, substs);
+ let freevar_ty = freevar_ty.subst(tcx, &substs.func_substs);
let upvar_id = ty::UpvarId {
var_id: freevar_def_id.node,
}
TyInfer(_) => unreachable!(),
TyError => byte!(21),
- TyClosure(d, _, _) => {
+ TyClosure(d, _) => {
byte!(22);
did(state, d);
}
}
}
+impl<'tcx> RegionEscape for ClosureSubsts<'tcx> {
+ fn has_regions_escaping_depth(&self, depth: u32) -> bool {
+ self.func_substs.has_regions_escaping_depth(depth) ||
+ self.upvar_tys.iter().any(|t| t.has_regions_escaping_depth(depth))
+ }
+}
+
impl<T:RegionEscape> RegionEscape for Vec<T> {
fn has_regions_escaping_depth(&self, depth: u32) -> bool {
self.iter().any(|t| t.has_regions_escaping_depth(depth))
}
}
+impl<'tcx> HasTypeFlags for ClosureSubsts<'tcx> {
+ fn has_type_flags(&self, flags: TypeFlags) -> bool {
+ self.func_substs.has_type_flags(flags) ||
+ self.upvar_tys.iter().any(|t| t.has_type_flags(flags))
+ }
+}
+
+
+
impl<'tcx> fmt::Debug for ClosureTy<'tcx> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "ClosureTy({},{:?},{})",
}
}
+impl<'tcx> TypeFoldable<'tcx> for ty::ClosureSubsts<'tcx> {
+ fn fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> ty::ClosureSubsts<'tcx> {
+ let func_substs = self.func_substs.fold_with(folder);
+ ty::ClosureSubsts {
+ func_substs: folder.tcx().mk_substs(func_substs),
+ upvar_tys: self.upvar_tys.fold_with(folder),
+ }
+ }
+}
+
impl<'tcx> TypeFoldable<'tcx> for ty::ItemSubsts<'tcx> {
fn fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> ty::ItemSubsts<'tcx> {
ty::ItemSubsts {
closure_def_id: self.closure_def_id,
substs: self.substs.fold_with(folder),
nested: self.nested.fold_with(folder),
- upvar_tys: self.upvar_tys.fold_with(folder),
}
}
}
let substs = substs.fold_with(this);
ty::TyStruct(did, this.tcx().mk_substs(substs))
}
- ty::TyClosure(did, ref substs, ref tys) => {
+ ty::TyClosure(did, ref substs) => {
let s = substs.fold_with(this);
- let tys = tys.fold_with(this);
- ty::TyClosure(did, this.tcx().mk_substs(s), tys)
+ ty::TyClosure(did, s)
}
ty::TyProjection(ref data) => {
ty::TyProjection(data.fold_with(this))
Ok(tcx.mk_struct(a_id, tcx.mk_substs(substs)))
}
- (&ty::TyClosure(a_id, a_substs, ref a_tys),
- &ty::TyClosure(b_id, b_substs, ref b_tys))
+ (&ty::TyClosure(a_id, ref a_substs),
+ &ty::TyClosure(b_id, ref b_substs))
if a_id == b_id =>
{
// All TyClosure types with the same id represent
// the (anonymous) type of the same closure expression. So
// all of their regions should be equated.
- let substs = try!(relate_substs(relation, None, a_substs, b_substs));
- let tys = try!(relation.relate_zip(a_tys, b_tys));
- Ok(tcx.mk_closure(a_id, tcx.mk_substs(substs), tys))
+ let substs = try!(relation.relate(a_substs, b_substs));
+ Ok(tcx.mk_closure_from_closure_substs(a_id, substs))
}
(&ty::TyBox(a_inner), &ty::TyBox(b_inner)) =>
}
}
+impl<'a,'tcx:'a> Relate<'a,'tcx> for ty::ClosureSubsts<'tcx> {
+ fn relate<R>(relation: &mut R,
+ a: &ty::ClosureSubsts<'tcx>,
+ b: &ty::ClosureSubsts<'tcx>)
+ -> RelateResult<'tcx, ty::ClosureSubsts<'tcx>>
+ where R: TypeRelation<'a,'tcx>
+ {
+ let func_substs = try!(relate_substs(relation, None, a.func_substs, b.func_substs));
+ let upvar_tys = try!(relation.relate_zip(&a.upvar_tys, &b.upvar_tys));
+ Ok(ty::ClosureSubsts { func_substs: relation.tcx().mk_substs(func_substs),
+ upvar_tys: upvar_tys })
+ }
+}
+
impl<'a,'tcx:'a> Relate<'a,'tcx> for ty::Region {
fn relate<R>(relation: &mut R,
a: &ty::Region,
ty::TyStruct(_, ref substs) => {
push_reversed(stack, substs.types.as_slice());
}
- ty::TyClosure(_, ref substs, ref tys) => {
- push_reversed(stack, substs.types.as_slice());
- push_reversed(stack, tys);
+ ty::TyClosure(_, ref substs) => {
+ push_reversed(stack, substs.func_substs.types.as_slice());
+ push_reversed(stack, &substs.upvar_tys);
}
ty::TyTuple(ref ts) => {
push_reversed(stack, ts);
TyTrait(ref data) => write!(f, "{}", data),
ty::TyProjection(ref data) => write!(f, "{}", data),
TyStr => write!(f, "str"),
- TyClosure(ref did, substs, _) => ty::tls::with(|tcx| {
+ TyClosure(ref did, ref substs) => ty::tls::with(|tcx| {
try!(write!(f, "[closure"));
+
+ // TODO consider changing this to print out the upvar types instead
+
let closure_tys = &tcx.tables.borrow().closure_tys;
try!(closure_tys.get(did).map(|cty| &cty.sig).and_then(|sig| {
- tcx.lift(&substs).map(|substs| sig.subst(tcx, substs))
+ tcx.lift(&substs.func_substs).map(|substs| sig.subst(tcx, substs))
}).map(|sig| {
fn_sig(f, &sig.0.inputs, false, sig.0.output)
}).unwrap_or_else(|| {
match dtor_self_type.sty {
ty::TyEnum(self_type_did, _) |
ty::TyStruct(self_type_did, _) |
- ty::TyClosure(self_type_did, _, _) => {
+ ty::TyClosure(self_type_did, _) => {
let hints = ctx.tcx.lookup_repr_hints(self_type_did);
if hints.iter().any(|attr| *attr == attr::ReprExtern) &&
ctx.tcx.ty_dtor(self_type_did).has_drop_flag() {
Univariant(mk_struct(cx, &ftys[..], packed, t), dtor_to_init_u8(dtor))
}
- ty::TyClosure(def_id, substs, _) => {
+ ty::TyClosure(def_id, ref substs) => {
let infcx = infer::normalizing_infer_ctxt(cx.tcx(), &cx.tcx().tables);
let upvars = infcx.closure_upvars(def_id, substs).unwrap(); // TODO
let upvar_types = upvars.iter().map(|u| u.ty).collect::<Vec<_>>();
// Perhaps one of the upvars of this struct is non-zero
// Let's recurse and find out!
- ty::TyClosure(def_id, substs, _) => {
+ ty::TyClosure(def_id, ref substs) => {
let infcx = infer::normalizing_infer_ctxt(tcx, &tcx.tables);
let upvars = infcx.closure_upvars(def_id, substs).unwrap(); // TODO
let upvar_types = upvars.iter().map(|u| u.ty).collect::<Vec<_>>();
let function_type;
let (fn_sig, abi, env_ty) = match fn_type.sty {
ty::TyBareFn(_, ref f) => (&f.sig, f.abi, None),
- ty::TyClosure(closure_did, substs, _) => {
+ ty::TyClosure(closure_did, ref substs) => {
let infcx = infer::normalizing_infer_ctxt(ccx.tcx(), &ccx.tcx().tables);
function_type = infcx.closure_type(closure_did, substs);
let self_type = base::self_type_for_closure(ccx, closure_did, fn_type);
}
})
}
- ty::TyClosure(def_id, substs, _) => { // TODO
+ ty::TyClosure(def_id, ref substs) => { // TODO
let repr = adt::represent_type(cx.ccx(), t);
let infcx = infer::normalizing_infer_ctxt(cx.tcx(), &cx.tcx().tables);
let upvars = infcx.closure_upvars(def_id, substs).unwrap();
use trans::callee;
use trans::cleanup;
use trans::cleanup::CleanupMethods;
-use trans::closure;
use trans::common::{self, Block, Result, NodeIdAndSpan, ExprId, CrateContext,
ExprOrMethodCall, FunctionContext, MethodCallKey};
use trans::consts;
}
};
- // If this is a closure, redirect to it.
- match closure::get_or_create_declaration_if_closure(ccx, def_id, substs) {
- None => {}
- Some(llfn) => return llfn,
- }
-
// Check whether this fn has an inlined copy and, if so, redirect
// def_id to the local id of the inlined copy.
let def_id = inline::maybe_instantiate_inline(ccx, def_id);
use back::link::{self, mangle_internal_name_by_path_and_seq};
use llvm::{ValueRef, get_params};
use middle::infer;
-use middle::ty::Ty;
use trans::adt;
use trans::attributes;
use trans::base::*;
use trans::debuginfo::{self, DebugLoc};
use trans::declare;
use trans::expr;
-use trans::monomorphize::{self, MonoId};
+use trans::monomorphize::{MonoId};
use trans::type_of::*;
use middle::ty;
-use middle::subst::Substs;
use session::config::FullDebugInfo;
use syntax::abi::RustCall;
/// Returns the LLVM function declaration for a closure, creating it if
/// necessary. If the ID does not correspond to a closure ID, returns None.
-pub fn get_or_create_declaration_if_closure<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
- closure_id: ast::DefId,
- substs: &Substs<'tcx>)
- -> Option<Datum<'tcx, Rvalue>> {
- if !ccx.tcx().tables.borrow().closure_kinds.contains_key(&closure_id) {
- // Not a closure.
- return None
- }
-
- let function_type = ccx.tcx().node_id_to_type(closure_id.node);
- let function_type = monomorphize::apply_param_substs(ccx.tcx(), substs, &function_type);
-
+pub fn get_or_create_closure_declaration<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
+ closure_id: ast::DefId,
+ substs: &ty::ClosureSubsts<'tcx>)
+ -> ValueRef {
// Normalize type so differences in regions and typedefs don't cause
// duplicate declarations
- let function_type = erase_regions(ccx.tcx(), &function_type);
- let params = match function_type.sty {
- ty::TyClosure(_, substs, _) => &substs.types,
- _ => unreachable!()
- };
+ let substs = erase_regions(ccx.tcx(), substs);
let mono_id = MonoId {
def: closure_id,
- params: params
+ params: &substs.func_substs.types
};
- match ccx.closure_vals().borrow().get(&mono_id) {
- Some(&llfn) => {
- debug!("get_or_create_declaration_if_closure(): found closure {:?}: {:?}",
- mono_id, ccx.tn().val_to_string(llfn));
- return Some(Datum::new(llfn, function_type, Rvalue::new(ByValue)))
- }
- None => {}
+ if let Some(&llfn) = ccx.closure_vals().borrow().get(&mono_id) {
+ debug!("get_or_create_declaration_if_closure(): found closure {:?}: {:?}",
+ mono_id, ccx.tn().val_to_string(llfn));
+ return llfn;
}
let symbol = ccx.tcx().map.with_path(closure_id.node, |path| {
mangle_internal_name_by_path_and_seq(path, "closure")
});
- // Currently there’s only a single user of
- // get_or_create_declaration_if_closure and it unconditionally defines the
- // function, therefore we use define_* here.
- let llfn = declare::define_internal_rust_fn(ccx, &symbol[..], function_type);
+ let function_type = ccx.tcx().mk_closure_from_closure_substs(closure_id, Box::new(substs));
+ let llfn = declare::define_internal_rust_fn(ccx, &symbol[..], function_type).unwrap_or_else(||{
+ ccx.sess().bug(&format!("symbol `{}` already defined", symbol));
+ });
// set an inline hint for all closures
attributes::inline(llfn, attributes::InlineAttr::Hint);
ccx.tn().val_to_string(llfn));
ccx.closure_vals().borrow_mut().insert(mono_id, llfn);
- Some(Datum::new(llfn, function_type, Rvalue::new(ByValue)))
+ llfn
}
pub enum Dest<'a, 'tcx: 'a> {
decl: &ast::FnDecl,
body: &ast::Block,
id: ast::NodeId,
- param_substs: &'tcx Substs<'tcx>)
+ closure_substs: &'tcx ty::ClosureSubsts<'tcx>)
-> Option<Block<'a, 'tcx>>
{
+ let param_substs = closure_substs.func_substs;
+
let ccx = match dest {
Dest::SaveIn(bcx, _) => bcx.ccx(),
Dest::Ignore(ccx) => ccx
debug!("trans_closure_expr()");
let closure_id = ast_util::local_def(id);
- let llfn = get_or_create_declaration_if_closure(
- ccx,
- closure_id,
- param_substs).unwrap();
+ let llfn = get_or_create_closure_declaration(ccx, closure_id, closure_substs);
// Get the type of this closure. Use the current `param_substs` as
// the closure substitutions. This makes sense because the closure
// of the closure expression.
let infcx = infer::normalizing_infer_ctxt(ccx.tcx(), &ccx.tcx().tables);
- let function_type = infcx.closure_type(closure_id, param_substs);
+ let function_type = infcx.closure_type(closure_id, closure_substs);
let freevars: Vec<ty::Freevar> =
tcx.with_freevars(id, |fv| fv.iter().cloned().collect());
trans_closure(ccx,
decl,
body,
- llfn.val,
+ llfn,
param_substs,
id,
&[],
pub fn trans_closure_method<'a, 'tcx>(ccx: &'a CrateContext<'a, 'tcx>,
closure_def_id: ast::DefId,
- substs: Substs<'tcx>,
- upvar_tys: Vec<Ty<'tcx>>,
- node: ExprOrMethodCall,
- param_substs: &'tcx Substs<'tcx>,
+ substs: ty::ClosureSubsts<'tcx>,
trait_closure_kind: ty::ClosureKind)
-> ValueRef
{
- // The substitutions should have no type parameters remaining
- // after passing through fulfill_obligation
- let llfn = callee::trans_fn_ref_with_substs(ccx,
- closure_def_id,
- node,
- param_substs,
- substs.clone()).val;
+ // If this is a closure, redirect to it.
+ let llfn = get_or_create_closure_declaration(ccx, closure_def_id, &substs);
// If the closure is a Fn closure, but a FnOnce is needed (etc),
// then adapt the self type
trans_closure_adapter_shim(ccx,
closure_def_id,
substs,
- upvar_tys,
closure_kind,
trait_closure_kind,
llfn)
fn trans_closure_adapter_shim<'a, 'tcx>(
ccx: &'a CrateContext<'a, 'tcx>,
closure_def_id: ast::DefId,
- substs: Substs<'tcx>,
- upvar_tys: Vec<Ty<'tcx>>,
+ substs: ty::ClosureSubsts<'tcx>,
llfn_closure_kind: ty::ClosureKind,
trait_closure_kind: ty::ClosureKind,
llfn: ValueRef)
// fn call_once(mut self, ...) { call_mut(&mut self, ...) }
//
// These are both the same at trans time.
- trans_fn_once_adapter_shim(ccx, closure_def_id, substs, upvar_tys, llfn)
+ trans_fn_once_adapter_shim(ccx, closure_def_id, substs, llfn)
}
_ => {
tcx.sess.bug(&format!("trans_closure_adapter_shim: cannot convert {:?} to {:?}",
fn trans_fn_once_adapter_shim<'a, 'tcx>(
ccx: &'a CrateContext<'a, 'tcx>,
closure_def_id: ast::DefId,
- substs: Substs<'tcx>,
- upvar_tys: Vec<Ty<'tcx>>,
+ substs: ty::ClosureSubsts<'tcx>,
llreffn: ValueRef)
-> ValueRef
{
// Find a version of the closure type. Substitute static for the
// region since it doesn't really matter.
- let substs = tcx.mk_substs(substs);
- let closure_ty = tcx.mk_closure(closure_def_id, substs, upvar_tys);
+ let closure_ty = tcx.mk_closure_from_closure_substs(closure_def_id, Box::new(substs.clone()));
let ref_closure_ty = tcx.mk_imm_ref(tcx.mk_region(ty::ReStatic), closure_ty);
// Make a version with the type of by-ref closure.
- let ty::ClosureTy { unsafety, abi, mut sig } = infcx.closure_type(closure_def_id, substs);
+ let ty::ClosureTy { unsafety, abi, mut sig } = infcx.closure_type(closure_def_id, &substs);
sig.0.inputs.insert(0, ref_closure_ty); // sig has no self type as of yet
let llref_bare_fn_ty = tcx.mk_bare_fn(ty::BareFnTy { unsafety: unsafety,
abi: abi,
ast::DUMMY_NODE_ID,
false,
sig.output,
- substs,
+ substs.func_substs,
None,
&block_arena);
let mut bcx = init_function(&fcx, false, sig.output);
}
},
ast::ExprClosure(_, ref decl, ref body) => {
- closure::trans_closure_expr(closure::Dest::Ignore(cx),
- decl,
- body,
- e.id,
- param_substs);
+ match ety.sty {
+ ty::TyClosure(_, ref substs) => {
+ closure::trans_closure_expr(closure::Dest::Ignore(cx), decl,
+ body, e.id, substs);
+ }
+ _ =>
+ cx.sess().span_bug(
+ e.span,
+ &format!("bad type for closure expr: {:?}", ety))
+ }
C_null(type_of::type_of(cx, ety))
},
_ => cx.sess().span_bug(e.span,
}
}
},
- ty::TyClosure(def_id, substs, _) => {
+ ty::TyClosure(def_id, ref substs) => {
let infcx = infer::normalizing_infer_ctxt(cx.tcx(), &cx.tcx().tables);
let closure_ty = infcx.closure_type(def_id, substs);
self.get_unique_type_id_of_closure_type(cx,
MetadataCreationResult::new(pointer_type_metadata(cx, t, fn_metadata), false)
}
- ty::TyClosure(def_id, substs, _) => {
+ ty::TyClosure(def_id, ref substs) => {
let infcx = infer::normalizing_infer_ctxt(cx.tcx(), &cx.tcx().tables);
let upvars = infcx.closure_upvars(def_id, substs).unwrap();
let upvar_types = upvars.iter().map(|u| u.ty).collect::<Vec<_>>();
ty::TyBareFn(_, ref f) => {
(&f.sig, f.abi, None)
}
- ty::TyClosure(closure_did, substs, _) => {
+ ty::TyClosure(closure_did, ref substs) => {
let infcx = infer::normalizing_infer_ctxt(ccx.tcx(), &ccx.tcx().tables);
function_type = infcx.closure_type(closure_did, substs);
let self_type = base::self_type_for_closure(ccx, closure_did, fn_type);
SaveIn(lldest) => closure::Dest::SaveIn(bcx, lldest),
Ignore => closure::Dest::Ignore(bcx.ccx())
};
- closure::trans_closure_expr(dest, decl, body, expr.id, bcx.fcx.param_substs)
- .unwrap_or(bcx)
+ let substs = match expr_ty(bcx, expr).sty {
+ ty::TyClosure(_, ref substs) => substs,
+ ref t =>
+ bcx.tcx().sess.span_bug(
+ expr.span,
+ &format!("closure expr without closure type: {:?}", t)),
+ };
+ closure::trans_closure_expr(dest, decl, body, expr.id, substs).unwrap_or(bcx)
}
ast::ExprCall(ref f, ref args) => {
if bcx.tcx().is_method_call(expr.id) {
let llfn = closure::trans_closure_method(bcx.ccx(),
vtable_closure.closure_def_id,
vtable_closure.substs,
- vtable_closure.upvar_tys,
- MethodCallKey(method_call),
- bcx.fcx.param_substs,
trait_closure_kind);
Callee {
bcx: bcx,
traits::VtableClosureData {
closure_def_id,
substs,
- upvar_tys,
nested: _ }) => {
let trait_closure_kind = tcx.lang_items.fn_trait_kind(trait_ref.def_id()).unwrap();
let llfn = closure::trans_closure_method(ccx,
closure_def_id,
substs,
- upvar_tys,
- ExprId(0),
- param_substs,
trait_closure_kind);
vec![llfn].into_iter()
}
return Some(CallStep::Builtin);
}
- ty::TyClosure(def_id, substs, _) => {
+ ty::TyClosure(def_id, ref substs) => {
assert_eq!(def_id.krate, ast::LOCAL_CRATE);
// Check whether this is a call to a closure where we
let dtor_predicates = tcx.lookup_predicates(drop_impl_did);
match dtor_self_type.sty {
ty::TyEnum(self_type_did, self_to_impl_substs) |
- ty::TyStruct(self_type_did, self_to_impl_substs) |
- ty::TyClosure(self_type_did, self_to_impl_substs, _) => {
+ ty::TyStruct(self_type_did, self_to_impl_substs) => {
try!(ensure_drop_params_and_item_params_correspond(tcx,
drop_impl_did,
dtor_generics,
}
ty::TyEnum(did, _) |
ty::TyStruct(did, _) |
- ty::TyClosure(did, _, _) => {
+ ty::TyClosure(did, _) => {
self.assemble_inherent_impl_candidates_for_type(did);
}
ty::TyBox(_) => {
let steps = self.steps.clone();
for step in steps.iter() {
let closure_def_id = match step.self_ty.sty {
- ty::TyClosure(a, _, _) => a,
+ ty::TyClosure(a, _) => a,
_ => continue,
};
use middle::implicator;
use middle::mem_categorization as mc;
use middle::region::CodeExtent;
-use middle::subst::Substs;
use middle::traits;
use middle::ty::{self, ReScope, Ty, MethodCall, HasTypeFlags};
use middle::infer::{self, GenericKind};
origin: infer::SubregionOrigin<'tcx>,
region: ty::Region,
def_id: ast::DefId,
- substs: &'tcx Substs<'tcx>) {
+ substs: &'tcx ty::ClosureSubsts<'tcx>) {
debug!("closure_must_outlive(region={:?}, def_id={:?}, substs={:?})",
region, def_id, substs);
match self_type.ty.sty {
ty::TyEnum(type_def_id, _) |
ty::TyStruct(type_def_id, _) |
- ty::TyClosure(type_def_id, _, _) => {
+ ty::TyClosure(type_def_id, _) => {
tcx.destructor_for_type
.borrow_mut()
.insert(type_def_id, method_def_id.def_id());
projects / rust.git / commitdiff