rust/src/rustc/middle/capture.rs

125 lines
4.1 KiB
Rust
Raw Normal View History

import syntax::{ast, ast_util};
import driver::session::session;
import std::map;
import std::map::hashmap;
export capture_mode;
export capture_var;
export capture_map;
export check_capture_clause;
export compute_capture_vars;
export cap_copy;
export cap_move;
export cap_drop;
export cap_ref;
2012-01-19 16:24:03 -06:00
enum capture_mode {
2012-01-19 19:56:05 -06:00
cap_copy, //< Copy the value into the closure.
cap_move, //< Move the value into the closure.
cap_drop, //< Drop value after creating closure.
cap_ref, //< Reference directly from parent stack frame (block fn).
}
type capture_var = {
def: ast::def, //< The variable being accessed free.
mode: capture_mode //< How is the variable being accessed.
};
type capture_map = map::hashmap<ast::def_id, capture_var>;
// checks the capture clause for a fn_expr() and issues warnings or
// errors for any irregularities which we identify.
fn check_capture_clause(tcx: ty::ctxt,
fn_expr_id: ast::node_id,
fn_proto: ast::proto,
cap_clause: ast::capture_clause) {
let freevars = freevars::get_freevars(tcx, fn_expr_id);
let seen_defs = map::int_hash();
2012-05-04 14:33:04 -05:00
let check_capture_item = fn@(cap_item: ast::capture_item) {
let cap_def = tcx.def_map.get(cap_item.id);
if !vec::any(*freevars, {|fv| fv.def == cap_def}) {
tcx.sess.span_warn(
cap_item.span,
2012-03-05 18:27:27 -06:00
#fmt("captured variable '%s' not used in closure",
cap_item.name));
}
let cap_def_id = ast_util::def_id_of_def(cap_def).node;
if !seen_defs.insert(cap_def_id, ()) {
tcx.sess.span_err(
cap_item.span,
2012-03-05 18:27:27 -06:00
#fmt("variable '%s' captured more than once",
cap_item.name));
}
};
2012-05-04 14:33:04 -05:00
alt fn_proto {
ast::proto_any | ast::proto_block {
if vec::is_not_empty(cap_clause) {
let cap_item0 = vec::head(cap_clause);
tcx.sess.span_err(
cap_item0.span,
2012-03-05 18:27:27 -06:00
"cannot capture values explicitly with a block closure");
}
}
ast::proto_bare | ast::proto_box | ast::proto_uniq {
2012-05-04 14:33:04 -05:00
for cap_clause.each { |cap_item|
check_capture_item(cap_item);
}
}
}
}
fn compute_capture_vars(tcx: ty::ctxt,
fn_expr_id: ast::node_id,
fn_proto: ast::proto,
cap_clause: ast::capture_clause) -> [capture_var] {
let freevars = freevars::get_freevars(tcx, fn_expr_id);
let cap_map = map::int_hash();
2012-05-04 14:33:04 -05:00
// first add entries for anything explicitly named in the cap clause
2012-05-04 14:33:04 -05:00
for cap_clause.each { |cap_item|
let cap_def = tcx.def_map.get(cap_item.id);
let cap_def_id = ast_util::def_id_of_def(cap_def).node;
2012-05-04 14:33:04 -05:00
if cap_item.is_move {
// if we are moving the value in, but it's not actually used,
// must drop it.
if vec::any(*freevars, {|fv| fv.def == cap_def}) {
cap_map.insert(cap_def_id, { def:cap_def, mode:cap_move });
} else {
cap_map.insert(cap_def_id, { def:cap_def, mode:cap_drop });
}
} else {
2012-05-04 14:33:04 -05:00
// if we are copying the value in, but it's not actually used,
// just ignore it.
if vec::any(*freevars, {|fv| fv.def == cap_def}) {
cap_map.insert(cap_def_id, { def:cap_def, mode:cap_copy });
}
}
}
2012-05-04 14:33:04 -05:00
// now go through anything that is referenced but was not explicitly
// named and add that
let implicit_mode = alt fn_proto {
ast::proto_any | ast::proto_block { cap_ref }
ast::proto_bare | ast::proto_box | ast::proto_uniq { cap_copy }
};
vec::iter(*freevars) { |fvar|
let fvar_def_id = ast_util::def_id_of_def(fvar.def).node;
alt cap_map.find(fvar_def_id) {
option::some(_) { /* was explicitly named, do nothing */ }
option::none {
cap_map.insert(fvar_def_id, {def:fvar.def, mode:implicit_mode});
}
}
}
let mut result = [];
for cap_map.each_value { |cap_var| result += [cap_var]; }
ret result;
}