2012-12-03 18:48:01 -06:00
|
|
|
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
|
|
|
|
// file at the top-level directory of this distribution and at
|
|
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
|
|
// option. This file may not be copied, modified, or distributed
|
|
|
|
// except according to those terms.
|
|
|
|
|
2011-07-18 21:14:01 -05:00
|
|
|
// A pass that annotates for each loops and functions with the free
|
|
|
|
// variables that they contain.
|
2011-07-18 19:26:37 -05:00
|
|
|
|
2012-12-23 16:41:37 -06:00
|
|
|
use middle::resolve;
|
|
|
|
use middle::ty;
|
|
|
|
|
2013-04-03 08:28:36 -05:00
|
|
|
use core::hashmap::HashMap;
|
2012-09-04 13:54:36 -05:00
|
|
|
use syntax::codemap::span;
|
2012-12-23 16:41:37 -06:00
|
|
|
use syntax::{ast, ast_util, visit};
|
2011-07-18 19:26:37 -05:00
|
|
|
|
2011-09-01 07:35:00 -05:00
|
|
|
// A vector of defs representing the free variables referred to in a function.
|
|
|
|
// (The def_upvar will already have been stripped).
|
2012-12-17 21:31:04 -06:00
|
|
|
#[auto_encode]
|
|
|
|
#[auto_decode]
|
2013-01-30 15:44:24 -06:00
|
|
|
pub struct freevar_entry {
|
2011-12-16 18:07:54 -06:00
|
|
|
def: ast::def, //< The variable being accessed free.
|
|
|
|
span: span //< First span where it is accessed (there can be multiple)
|
2013-01-16 21:24:10 -06:00
|
|
|
}
|
2013-01-30 15:44:24 -06:00
|
|
|
pub type freevar_info = @~[@freevar_entry];
|
2013-04-03 08:28:36 -05:00
|
|
|
pub type freevar_map = @mut HashMap<ast::node_id, freevar_info>;
|
2011-07-18 19:26:37 -05:00
|
|
|
|
|
|
|
// Searches through part of the AST for all references to locals or
|
|
|
|
// upvars in this frame and returns the list of definition IDs thus found.
|
|
|
|
// Since we want to be able to collect upvars in some arbitrary piece
|
|
|
|
// of the AST, we take a walker function that we invoke with a visitor
|
|
|
|
// in order to start the search.
|
2013-02-18 00:20:36 -06:00
|
|
|
fn collect_freevars(def_map: resolve::DefMap, blk: &ast::blk)
|
2011-12-20 13:03:21 -06:00
|
|
|
-> freevar_info {
|
2013-04-03 08:28:36 -05:00
|
|
|
let seen = @mut HashMap::new();
|
2012-06-29 18:26:56 -05:00
|
|
|
let refs = @mut ~[];
|
2011-07-18 19:26:37 -05:00
|
|
|
|
2013-04-17 11:15:37 -05:00
|
|
|
fn ignore_item(_i: @ast::item, _depth: int, _v: visit::vt<int>) { }
|
2011-09-01 07:35:00 -05:00
|
|
|
|
2013-04-17 11:15:37 -05:00
|
|
|
let walk_expr: @fn(expr: @ast::expr, depth: int, v: visit::vt<int>) =
|
2013-03-01 14:11:07 -06:00
|
|
|
|expr, depth, v| {
|
2012-08-06 14:34:08 -05:00
|
|
|
match expr.node {
|
2013-03-01 18:59:46 -06:00
|
|
|
ast::expr_fn_block(*) => visit::visit_expr(expr, depth + 1, v),
|
2013-05-10 17:15:06 -05:00
|
|
|
ast::expr_path(*) | ast::expr_self => {
|
2012-03-15 08:47:03 -05:00
|
|
|
let mut i = 0;
|
2013-02-05 21:41:45 -06:00
|
|
|
match def_map.find(&expr.id) {
|
2013-05-05 17:18:51 -05:00
|
|
|
None => fail!("path not found"),
|
2013-03-22 21:26:41 -05:00
|
|
|
Some(&df) => {
|
2012-03-15 08:47:03 -05:00
|
|
|
let mut def = df;
|
2012-01-05 13:33:22 -06:00
|
|
|
while i < depth {
|
2013-03-20 00:17:42 -05:00
|
|
|
match def {
|
2012-08-20 18:53:33 -05:00
|
|
|
ast::def_upvar(_, inner, _, _) => { def = *inner; }
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => break
|
2012-01-05 13:33:22 -06:00
|
|
|
}
|
|
|
|
i += 1;
|
|
|
|
}
|
|
|
|
if i == depth { // Made it to end of loop
|
|
|
|
let dnum = ast_util::def_id_of_def(def).node;
|
2013-02-08 16:08:02 -06:00
|
|
|
if !seen.contains_key(&dnum) {
|
2013-01-16 21:24:10 -06:00
|
|
|
refs.push(@freevar_entry {
|
|
|
|
def: def,
|
|
|
|
span: expr.span,
|
|
|
|
});
|
2012-06-28 17:00:03 -05:00
|
|
|
seen.insert(dnum, ());
|
2012-01-05 13:33:22 -06:00
|
|
|
}
|
|
|
|
}
|
2011-09-02 17:34:58 -05:00
|
|
|
}
|
2012-01-05 13:33:22 -06:00
|
|
|
}
|
2011-09-02 17:34:58 -05:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => visit::visit_expr(expr, depth, v)
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2011-09-02 17:34:58 -05:00
|
|
|
};
|
2011-09-01 07:35:00 -05:00
|
|
|
|
2013-01-08 16:00:45 -06:00
|
|
|
let v = visit::mk_vt(@visit::Visitor {visit_item: ignore_item,
|
|
|
|
visit_expr: walk_expr,
|
|
|
|
.. *visit::default_visitor()});
|
2012-11-29 19:51:16 -06:00
|
|
|
(v.visit_block)(blk, 1, v);
|
2013-01-07 16:16:52 -06:00
|
|
|
return @/*bad*/copy *refs;
|
2011-07-18 19:26:37 -05:00
|
|
|
}
|
|
|
|
|
2011-07-18 21:14:01 -05:00
|
|
|
// Build a map from every function and for-each body to a set of the
|
|
|
|
// freevars contained in it. The implementation is not particularly
|
|
|
|
// efficient as it fully recomputes the free variables at every
|
|
|
|
// node of interest rather than building up the free variables in
|
|
|
|
// one pass. This could be improved upon if it turns out to matter.
|
2013-01-30 15:44:24 -06:00
|
|
|
pub fn annotate_freevars(def_map: resolve::DefMap, crate: @ast::crate) ->
|
2011-09-02 17:34:58 -05:00
|
|
|
freevar_map {
|
2013-04-03 08:28:36 -05:00
|
|
|
let freevars = @mut HashMap::new();
|
2011-07-18 21:14:01 -05:00
|
|
|
|
2013-03-01 14:11:07 -06:00
|
|
|
let walk_fn: @fn(&visit::fn_kind,
|
|
|
|
&ast::fn_decl,
|
|
|
|
&ast::blk,
|
|
|
|
span,
|
|
|
|
ast::node_id) = |_, _, blk, _, nid| {
|
2011-12-20 13:03:21 -06:00
|
|
|
let vars = collect_freevars(def_map, blk);
|
|
|
|
freevars.insert(nid, vars);
|
|
|
|
};
|
2011-07-18 21:14:01 -05:00
|
|
|
|
2011-07-27 07:19:39 -05:00
|
|
|
let visitor =
|
2013-01-08 16:00:45 -06:00
|
|
|
visit::mk_simple_visitor(@visit::SimpleVisitor {
|
|
|
|
visit_fn: walk_fn,
|
|
|
|
.. *visit::default_simple_visitor()});
|
2013-04-17 11:15:37 -05:00
|
|
|
visit::visit_crate(crate, (), visitor);
|
2011-07-18 21:14:01 -05:00
|
|
|
|
2012-08-01 19:30:05 -05:00
|
|
|
return freevars;
|
2011-07-18 21:14:01 -05:00
|
|
|
}
|
|
|
|
|
2013-01-30 15:44:24 -06:00
|
|
|
pub fn get_freevars(tcx: ty::ctxt, fid: ast::node_id) -> freevar_info {
|
2013-02-05 21:41:45 -06:00
|
|
|
match tcx.freevars.find(&fid) {
|
2013-05-05 17:18:51 -05:00
|
|
|
None => fail!("get_freevars: %d has no freevars", fid),
|
2013-03-22 21:26:41 -05:00
|
|
|
Some(&d) => return d
|
2011-07-21 16:49:58 -05:00
|
|
|
}
|
|
|
|
}
|
2013-01-10 12:59:58 -06:00
|
|
|
|
2013-01-30 15:44:24 -06:00
|
|
|
pub fn has_freevars(tcx: ty::ctxt, fid: ast::node_id) -> bool {
|
2012-08-01 19:30:05 -05:00
|
|
|
return vec::len(*get_freevars(tcx, fid)) != 0u;
|
2011-07-21 16:49:58 -05:00
|
|
|
}
|