Skip to content

Commit 0676c3b

Browse files
author
Jorge Aparicio
committed
librustc_trans: use unboxed closures
1 parent 0d4d8b9 commit 0676c3b

File tree

11 files changed

+140
-107
lines changed

11 files changed

+140
-107
lines changed

‎src/librustc_trans/back/write.rs‎

Lines changed: 6 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -488,8 +488,12 @@ unsafe fn optimize_and_codegen(cgcx: &CodegenContext,
488488
// pass manager passed to the closure should be ensured to not
489489
// escape the closure itself, and the manager should only be
490490
// used once.
491-
unsafe fn with_codegen(tm: TargetMachineRef, llmod: ModuleRef,
492-
no_builtins: bool, f: |PassManagerRef|) {
491+
unsafe fn with_codegen<F>(tm: TargetMachineRef,
492+
llmod: ModuleRef,
493+
no_builtins: bool,
494+
f: F) where
495+
F: FnOnce(PassManagerRef),
496+
{
493497
let cpm = llvm::LLVMCreatePassManager();
494498
llvm::LLVMRustAddAnalysisPasses(tm, cpm, llmod);
495499
llvm::LLVMRustAddLibraryInfo(cpm, llmod, no_builtins);

‎src/librustc_trans/save/mod.rs‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -79,7 +79,9 @@ struct DxrVisitor<'l, 'tcx: 'l> {
7979
}
8080

8181
impl <'l, 'tcx> DxrVisitor<'l, 'tcx> {
82-
fn nest(&mut self, scope_id: NodeId, f: |&mut DxrVisitor<'l, 'tcx>|) {
82+
fn nest<F>(&mut self, scope_id: NodeId, f: F) where
83+
F: FnOnce(&mut DxrVisitor<'l, 'tcx>),
84+
{
8385
let parent_scope = self.cur_scope;
8486
self.cur_scope = scope_id;
8587
f(self);

‎src/librustc_trans/trans/_match.rs‎

Lines changed: 9 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -1578,14 +1578,15 @@ pub fn store_for_loop_binding<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
15781578
bind_irrefutable_pat(bcx, pat, llvalue, body_scope)
15791579
}
15801580

1581-
fn mk_binding_alloca<'blk, 'tcx, A>(bcx: Block<'blk, 'tcx>,
1582-
p_id: ast::NodeId,
1583-
ident: &ast::Ident,
1584-
cleanup_scope: cleanup::ScopeId,
1585-
arg: A,
1586-
populate: |A, Block<'blk, 'tcx>, ValueRef, Ty<'tcx>|
1587-
-> Block<'blk, 'tcx>)
1588-
-> Block<'blk, 'tcx> {
1581+
fn mk_binding_alloca<'blk, 'tcx, A, F>(bcx: Block<'blk, 'tcx>,
1582+
p_id: ast::NodeId,
1583+
ident: &ast::Ident,
1584+
cleanup_scope: cleanup::ScopeId,
1585+
arg: A,
1586+
populate: F)
1587+
-> Block<'blk, 'tcx> where
1588+
F: FnOnce(A, Block<'blk, 'tcx>, ValueRef, Ty<'tcx>) -> Block<'blk, 'tcx>,
1589+
{
15891590
let var_ty = node_id_type(bcx, p_id);
15901591

15911592
// Allocate memory on stack for the binding.

‎src/librustc_trans/trans/adt.rs‎

Lines changed: 7 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -858,10 +858,13 @@ pub fn struct_field_ptr<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, st: &Struct<'tcx>, v
858858
GEPi(bcx, val, &[0, ix])
859859
}
860860

861-
pub fn fold_variants<'blk, 'tcx>(
862-
bcx: Block<'blk, 'tcx>, r: &Repr<'tcx>, value: ValueRef,
863-
f: |Block<'blk, 'tcx>, &Struct<'tcx>, ValueRef| -> Block<'blk, 'tcx>)
864-
-> Block<'blk, 'tcx> {
861+
pub fn fold_variants<'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>,
862+
r: &Repr<'tcx>,
863+
value: ValueRef,
864+
mut f: F)
865+
-> Block<'blk, 'tcx> where
866+
F: FnMut(Block<'blk, 'tcx>, &Struct<'tcx>, ValueRef) -> Block<'blk, 'tcx>,
867+
{
865868
let fcx = bcx.fcx;
866869
match *r {
867870
Univariant(ref st, _) => {

‎src/librustc_trans/trans/base.rs‎

Lines changed: 20 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -107,9 +107,11 @@ thread_local!(static TASK_LOCAL_INSN_KEY: RefCell<Option<Vec<&'static str>>> = {
107107
RefCell::new(None)
108108
})
109109

110-
pub fn with_insn_ctxt(blk: |&[&'static str]|) {
111-
TASK_LOCAL_INSN_KEY.with(|slot| {
112-
slot.borrow().as_ref().map(|s| blk(s.as_slice()));
110+
pub fn with_insn_ctxt<F>(blk: F) where
111+
F: FnOnce(&[&'static str]),
112+
{
113+
TASK_LOCAL_INSN_KEY.with(move |slot| {
114+
slot.borrow().as_ref().map(move |s| blk(s.as_slice()));
113115
})
114116
}
115117

@@ -841,12 +843,15 @@ pub fn cast_shift_const_rhs(op: ast::BinOp,
841843
|a, b| unsafe { llvm::LLVMConstZExt(a, b.to_ref()) })
842844
}
843845

844-
pub fn cast_shift_rhs(op: ast::BinOp,
845-
lhs: ValueRef,
846-
rhs: ValueRef,
847-
trunc: |ValueRef, Type| -> ValueRef,
848-
zext: |ValueRef, Type| -> ValueRef)
849-
-> ValueRef {
846+
pub fn cast_shift_rhs<F, G>(op: ast::BinOp,
847+
lhs: ValueRef,
848+
rhs: ValueRef,
849+
trunc: F,
850+
zext: G)
851+
-> ValueRef where
852+
F: FnOnce(ValueRef, Type) -> ValueRef,
853+
G: FnOnce(ValueRef, Type) -> ValueRef,
854+
{
850855
// Shifts may have any size int on the rhs
851856
unsafe {
852857
if ast_util::is_shift_binop(op) {
@@ -1101,10 +1106,12 @@ pub fn raw_block<'blk, 'tcx>(fcx: &'blk FunctionContext<'blk, 'tcx>,
11011106
common::BlockS::new(llbb, is_lpad, None, fcx)
11021107
}
11031108

1104-
pub fn with_cond<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
1105-
val: ValueRef,
1106-
f: |Block<'blk, 'tcx>| -> Block<'blk, 'tcx>)
1107-
-> Block<'blk, 'tcx> {
1109+
pub fn with_cond<'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>,
1110+
val: ValueRef,
1111+
f: F)
1112+
-> Block<'blk, 'tcx> where
1113+
F: FnOnce(Block<'blk, 'tcx>) -> Block<'blk, 'tcx>,
1114+
{
11081115
let _icx = push_ctxt("with_cond");
11091116
let fcx = bcx.fcx;
11101117
let next_cx = fcx.new_temp_block("next");

‎src/librustc_trans/trans/cabi_x86_64.rs‎

Lines changed: 7 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -342,11 +342,13 @@ pub fn compute_abi_info(ccx: &CrateContext,
342342
atys: &[Type],
343343
rty: Type,
344344
ret_def: bool) -> FnType {
345-
fn x86_64_ty(ccx: &CrateContext,
346-
ty: Type,
347-
is_mem_cls: |cls: &[RegClass]| -> bool,
348-
ind_attr: Attribute)
349-
-> ArgType {
345+
fn x86_64_ty<F>(ccx: &CrateContext,
346+
ty: Type,
347+
is_mem_cls: F,
348+
ind_attr: Attribute)
349+
-> ArgType where
350+
F: FnOnce(&[RegClass]) -> bool,
351+
{
350352
if !ty.is_reg_ty() {
351353
let cls = classify_ty(ty);
352354
if is_mem_cls(cls.as_slice()) {

‎src/librustc_trans/trans/callee.rs‎

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -781,15 +781,15 @@ pub fn trans_lang_call<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
781781
///
782782
/// For non-lang items, `dest` is always Some, and hence the result is written into memory
783783
/// somewhere. Nonetheless we return the actual return value of the function.
784-
pub fn trans_call_inner<'a, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
785-
call_info: Option<NodeInfo>,
786-
callee_ty: Ty<'tcx>,
787-
get_callee: |bcx: Block<'blk, 'tcx>,
788-
arg_cleanup_scope: cleanup::ScopeId|
789-
-> Callee<'blk, 'tcx>,
790-
args: CallArgs<'a, 'tcx>,
791-
dest: Option<expr::Dest>)
792-
-> Result<'blk, 'tcx> {
784+
pub fn trans_call_inner<'a, 'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>,
785+
call_info: Option<NodeInfo>,
786+
callee_ty: Ty<'tcx>,
787+
get_callee: F,
788+
args: CallArgs<'a, 'tcx>,
789+
dest: Option<expr::Dest>)
790+
-> Result<'blk, 'tcx> where
791+
F: FnOnce(Block<'blk, 'tcx>, cleanup::ScopeId) -> Callee<'blk, 'tcx>,
792+
{
793793
// Introduce a temporary cleanup scope that will contain cleanups
794794
// for the arguments while they are being evaluated. The purpose
795795
// this cleanup is to ensure that, should a panic occur while

‎src/librustc_trans/trans/cleanup.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -527,7 +527,7 @@ impl<'blk, 'tcx> CleanupHelperMethods<'blk, 'tcx> for FunctionContext<'blk, 'tcx
527527
self.scopes.borrow_mut().pop().unwrap()
528528
}
529529

530-
fn top_scope<R>(&self, f: |&CleanupScope<'blk, 'tcx>| -> R) -> R {
530+
fn top_scope<R, F>(&self, f: F) -> R where F: FnOnce(&CleanupScope<'blk, 'tcx>) -> R {
531531
f(self.scopes.borrow().last().unwrap())
532532
}
533533

@@ -1145,5 +1145,5 @@ trait CleanupHelperMethods<'blk, 'tcx> {
11451145
fn scopes_len(&self) -> uint;
11461146
fn push_scope(&self, scope: CleanupScope<'blk, 'tcx>);
11471147
fn pop_scope(&self) -> CleanupScope<'blk, 'tcx>;
1148-
fn top_scope<R>(&self, f: |&CleanupScope<'blk, 'tcx>| -> R) -> R;
1148+
fn top_scope<R, F>(&self, f: F) -> R where F: FnOnce(&CleanupScope<'blk, 'tcx>) -> R;
11491149
}

‎src/librustc_trans/trans/datum.rs‎

Lines changed: 19 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -113,15 +113,16 @@ pub fn immediate_rvalue_bcx<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
113113
/// it. The memory will be dropped upon exit from `scope`. The callback `populate` should
114114
/// initialize the memory. If `zero` is true, the space will be zeroed when it is allocated; this
115115
/// is not necessary unless `bcx` does not dominate the end of `scope`.
116-
pub fn lvalue_scratch_datum<'blk, 'tcx, A>(bcx: Block<'blk, 'tcx>,
117-
ty: Ty<'tcx>,
118-
name: &str,
119-
zero: bool,
120-
scope: cleanup::ScopeId,
121-
arg: A,
122-
populate: |A, Block<'blk, 'tcx>, ValueRef|
123-
-> Block<'blk, 'tcx>)
124-
-> DatumBlock<'blk, 'tcx, Lvalue> {
116+
pub fn lvalue_scratch_datum<'blk, 'tcx, A, F>(bcx: Block<'blk, 'tcx>,
117+
ty: Ty<'tcx>,
118+
name: &str,
119+
zero: bool,
120+
scope: cleanup::ScopeId,
121+
arg: A,
122+
populate: F)
123+
-> DatumBlock<'blk, 'tcx, Lvalue> where
124+
F: FnOnce(A, Block<'blk, 'tcx>, ValueRef) -> Block<'blk, 'tcx>,
125+
{
125126
let scratch = if zero {
126127
alloca_zeroed(bcx, ty, name)
127128
} else {
@@ -339,10 +340,10 @@ impl<'tcx> Datum<'tcx, Rvalue> {
339340
/// here since we can `match self.kind` rather than having to implement
340341
/// generic methods in `KindOps`.)
341342
impl<'tcx> Datum<'tcx, Expr> {
342-
fn match_kind<R>(self,
343-
if_lvalue: |Datum<'tcx, Lvalue>| -> R,
344-
if_rvalue: |Datum<'tcx, Rvalue>| -> R)
345-
-> R {
343+
fn match_kind<R, F, G>(self, if_lvalue: F, if_rvalue: G) -> R where
344+
F: FnOnce(Datum<'tcx, Lvalue>) -> R,
345+
G: FnOnce(Datum<'tcx, Rvalue>) -> R,
346+
{
346347
let Datum { val, ty, kind } = self;
347348
match kind {
348349
LvalueExpr => if_lvalue(Datum::new(val, ty, Lvalue)),
@@ -455,9 +456,11 @@ impl<'tcx> Datum<'tcx, Lvalue> {
455456
// datum may also be unsized _without the size information_. It is the
456457
// callers responsibility to package the result in some way to make a valid
457458
// datum in that case (e.g., by making a fat pointer or opened pair).
458-
pub fn get_element<'blk>(&self, bcx: Block<'blk, 'tcx>, ty: Ty<'tcx>,
459-
gep: |ValueRef| -> ValueRef)
460-
-> Datum<'tcx, Lvalue> {
459+
pub fn get_element<'blk, F>(&self, bcx: Block<'blk, 'tcx>, ty: Ty<'tcx>,
460+
gep: F)
461+
-> Datum<'tcx, Lvalue> where
462+
F: FnOnce(ValueRef) -> ValueRef,
463+
{
461464
let val = match self.ty.sty {
462465
_ if ty::type_is_sized(bcx.tcx(), self.ty) => gep(self.val),
463466
ty::ty_open(_) => {

‎src/librustc_trans/trans/debuginfo.rs‎

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -3212,13 +3212,13 @@ fn populate_scope_map(cx: &CrateContext,
32123212
});
32133213

32143214
// local helper functions for walking the AST.
3215-
fn with_new_scope(cx: &CrateContext,
3216-
scope_span: Span,
3217-
scope_stack: &mut Vec<ScopeStackEntry> ,
3218-
scope_map: &mut NodeMap<DIScope>,
3219-
inner_walk: |&CrateContext,
3220-
&mut Vec<ScopeStackEntry> ,
3221-
&mut NodeMap<DIScope>|) {
3215+
fn with_new_scope<F>(cx: &CrateContext,
3216+
scope_span: Span,
3217+
scope_stack: &mut Vec<ScopeStackEntry> ,
3218+
scope_map: &mut NodeMap<DIScope>,
3219+
inner_walk: F) where
3220+
F: FnOnce(&CrateContext, &mut Vec<ScopeStackEntry>, &mut NodeMap<DIScope>),
3221+
{
32223222
// Create a new lexical scope and push it onto the stack
32233223
let loc = cx.sess().codemap().lookup_char_pos(scope_span.lo);
32243224
let file_metadata = file_metadata(cx, loc.file.name.as_slice());

0 commit comments

Comments
 (0)