811 lines
27 KiB
Rust
811 lines
27 KiB
Rust
import front::ast;
|
|
import front::ast::ident;
|
|
import front::ast::def;
|
|
import front::ast::def_id;
|
|
import front::ast::ann;
|
|
import front::creader;
|
|
import driver::session::session;
|
|
import util::common::new_def_hash;
|
|
import util::common::new_int_hash;
|
|
import util::common::new_uint_hash;
|
|
import util::common::new_str_hash;
|
|
import util::common::span;
|
|
import util::typestate_ann::ts_ann;
|
|
import std::map::hashmap;
|
|
import std::list::list;
|
|
import std::list::nil;
|
|
import std::list::cons;
|
|
import std::option;
|
|
import std::option::some;
|
|
import std::option::none;
|
|
import std::_str;
|
|
import std::_vec;
|
|
|
|
// Resolving happens in two passes. The first pass collects defids of all
|
|
// (internal) imports and modules, so that they can be looked up when needed,
|
|
// and then uses this information to resolve the imports. The second pass
|
|
// locates all names (in expressions, types, and alt patterns) and resolves
|
|
// them, storing the resulting def in the AST nodes.
|
|
|
|
// This module internally uses -1 as a def_id for the top_level module in a
|
|
// crate. The parser doesn't assign a def_id to this module.
|
|
// (FIXME See https://github.com/graydon/rust/issues/358 for the reason this
|
|
// isn't a const.)
|
|
|
|
tag scope {
|
|
scope_crate(@ast::crate);
|
|
scope_item(@ast::item);
|
|
scope_native_item(@ast::native_item);
|
|
scope_loop(@ast::decl); // there's only 1 decl per loop.
|
|
scope_block(ast::block);
|
|
scope_arm(ast::arm);
|
|
}
|
|
|
|
tag import_state {
|
|
todo(@ast::view_item, list[scope]);
|
|
resolving(span);
|
|
resolved(option::t[def] /* value */, option::t[def] /* type */);
|
|
}
|
|
|
|
type ext_hash = hashmap[tup(def_id,str),def];
|
|
fn new_ext_hash() -> ext_hash {
|
|
fn hash(&tup(def_id,str) v) -> uint {
|
|
ret _str::hash(v._1) + util::common::hash_def(v._0);
|
|
}
|
|
fn eq(&tup(def_id,str) v1, &tup(def_id,str) v2) -> bool {
|
|
ret util::common::def_eq(v1._0, v2._0) &&
|
|
_str::eq(v1._1, v2._1);
|
|
}
|
|
ret std::map::mk_hashmap[tup(def_id,str),def](hash, eq);
|
|
}
|
|
|
|
tag mod_index_entry {
|
|
mie_view_item(@ast::view_item);
|
|
mie_item(@ast::item);
|
|
mie_tag_variant(@ast::item /* tag item */, uint /* variant index */);
|
|
}
|
|
type mod_index = hashmap[ident,mod_index_entry];
|
|
type indexed_mod = rec(ast::_mod m, mod_index index);
|
|
|
|
tag native_mod_index_entry {
|
|
nmie_view_item(@ast::view_item);
|
|
nmie_item(@ast::native_item);
|
|
}
|
|
type nmod_index = hashmap[ident,native_mod_index_entry];
|
|
type indexed_nmod = rec(ast::native_mod m, nmod_index index);
|
|
|
|
type def_map = hashmap[uint,def];
|
|
|
|
type env = rec(def_map def_map,
|
|
hashmap[ast::def_num,import_state] imports,
|
|
hashmap[ast::def_num,@indexed_mod] mod_map,
|
|
hashmap[ast::def_num,@indexed_nmod] nmod_map,
|
|
hashmap[def_id,vec[ident]] ext_map,
|
|
ext_hash ext_cache,
|
|
session sess);
|
|
|
|
// Used to distinguish between lookups from outside and from inside modules,
|
|
// since export restrictions should only be applied for the former.
|
|
tag dir { inside; outside; }
|
|
|
|
tag namespace {
|
|
ns_value;
|
|
ns_type;
|
|
}
|
|
|
|
fn resolve_crate(session sess, @ast::crate crate)
|
|
-> tup(@ast::crate, def_map) {
|
|
auto e = @rec(def_map = new_uint_hash[def](),
|
|
imports = new_int_hash[import_state](),
|
|
mod_map = new_int_hash[@indexed_mod](),
|
|
nmod_map = new_int_hash[@indexed_nmod](),
|
|
ext_map = new_def_hash[vec[ident]](),
|
|
ext_cache = new_ext_hash(),
|
|
sess = sess);
|
|
map_crate(e, *crate);
|
|
resolve_imports(*e);
|
|
ret tup(resolve_names(e, *crate), e.def_map);
|
|
}
|
|
|
|
// Locate all modules and imports and index them, so that the next passes can
|
|
// resolve through them.
|
|
|
|
fn map_crate(&@env e, &ast::crate c) {
|
|
auto cell = @mutable nil[scope];
|
|
auto v = rec(visit_crate_pre = bind push_env_for_crate(cell, _),
|
|
visit_crate_post = bind pop_env_for_crate(cell, _),
|
|
visit_view_item_pre = bind visit_view_item(e, cell, _),
|
|
visit_item_pre = bind push_env_for_item_map_mod(e, cell, _),
|
|
visit_item_post = bind pop_env_for_item(cell, _)
|
|
with walk::default_visitor());
|
|
// Register the top-level mod
|
|
e.mod_map.insert(-1, @rec(m=c.node.module,
|
|
index=index_mod(c.node.module)));
|
|
walk::walk_crate(v, c);
|
|
|
|
// Helpers for this pass.
|
|
fn push_env_for_crate(@mutable list[scope] sc, &ast::crate c) {
|
|
*sc = cons[scope](scope_crate(@c), @*sc);
|
|
}
|
|
fn pop_env_for_crate(@mutable list[scope] sc, &ast::crate c) {
|
|
*sc = std::list::cdr(*sc);
|
|
}
|
|
fn push_env_for_item_map_mod(@env e, @mutable list[scope] sc,
|
|
&@ast::item i) {
|
|
*sc = cons[scope](scope_item(i), @*sc);
|
|
alt (i.node) {
|
|
case (ast::item_mod(_, ?md, ?defid)) {
|
|
auto index = index_mod(md);
|
|
e.mod_map.insert(defid._1, @rec(m=md, index=index));
|
|
}
|
|
case (ast::item_native_mod(_, ?nmd, ?defid)) {
|
|
auto index = index_nmod(nmd);
|
|
e.nmod_map.insert(defid._1, @rec(m=nmd, index=index));
|
|
}
|
|
case (_) {}
|
|
}
|
|
}
|
|
fn pop_env_for_item(@mutable list[scope] sc, &@ast::item i) {
|
|
*sc = std::list::cdr(*sc);
|
|
}
|
|
fn visit_view_item(@env e, @mutable list[scope] sc, &@ast::view_item i) {
|
|
alt (i.node) {
|
|
case (ast::view_item_import(_, ?ids, ?defid)) {
|
|
e.imports.insert(defid._1, todo(i, *sc));
|
|
}
|
|
case (_) {}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn resolve_imports(&env e) {
|
|
for each (@tup(ast::def_num, import_state) it in e.imports.items()) {
|
|
alt (it._1) {
|
|
case (todo(?item, ?sc)) {
|
|
resolve_import(e, item, sc);
|
|
}
|
|
case (resolved(_, _)) {}
|
|
}
|
|
}
|
|
}
|
|
|
|
// FIXME this should use walk (will need to add walk_arm)
|
|
fn resolve_names(&@env e, &ast::crate c) -> @ast::crate {
|
|
auto fld = @rec(fold_pat_tag = bind fold_pat_tag(e,_,_,_,_,_),
|
|
fold_expr_path = bind fold_expr_path(e,_,_,_,_),
|
|
fold_ty_path = bind fold_ty_path(e,_,_,_,_),
|
|
update_env_for_crate = bind update_env_for_crate(_,_),
|
|
update_env_for_item = bind update_env_for_item(_,_),
|
|
update_env_for_native_item =
|
|
bind update_env_for_native_item(_,_),
|
|
update_env_for_block = bind update_env_for_block(_,_),
|
|
update_env_for_arm = bind update_env_for_arm(_,_),
|
|
update_env_for_expr = bind update_env_for_expr(_,_)
|
|
with *fold::new_identity_fold[list[scope]]());
|
|
ret fold::fold_crate(nil[scope], fld, @c);
|
|
|
|
// Helpers for this pass
|
|
|
|
fn update_env_for_crate(&list[scope] sc, &@ast::crate c) -> list[scope] {
|
|
ret cons[scope](scope_crate(c), @sc);
|
|
}
|
|
fn update_env_for_item(&list[scope] sc, &@ast::item i) -> list[scope] {
|
|
ret cons[scope](scope_item(i), @sc);
|
|
}
|
|
fn update_env_for_native_item(&list[scope] sc, &@ast::native_item i)
|
|
-> list[scope] {
|
|
ret cons[scope](scope_native_item(i), @sc);
|
|
}
|
|
fn update_env_for_block(&list[scope] sc, &ast::block b) -> list[scope] {
|
|
ret cons[scope](scope_block(b), @sc);
|
|
}
|
|
fn update_env_for_expr(&list[scope] sc, &@ast::expr x) -> list[scope] {
|
|
alt (x.node) {
|
|
case (ast::expr_for(?d, _, _, _)) {
|
|
ret cons[scope](scope_loop(d), @sc);
|
|
}
|
|
case (ast::expr_for_each(?d, _, _, _)) {
|
|
ret cons[scope](scope_loop(d), @sc);
|
|
}
|
|
case (_) { ret sc; }
|
|
}
|
|
}
|
|
fn update_env_for_arm(&list[scope] sc, &ast::arm p) -> list[scope] {
|
|
ret cons[scope](scope_arm(p), @sc);
|
|
}
|
|
}
|
|
|
|
fn lookup_import(&env e, def_id defid, namespace ns) -> option::t[def] {
|
|
alt (e.imports.get(defid._1)) {
|
|
case (todo(?item, ?sc)) {
|
|
resolve_import(e, item, sc);
|
|
ret lookup_import(e, defid, ns);
|
|
}
|
|
case (resolving(?sp)) {
|
|
e.sess.span_err(sp, "cyclic import");
|
|
}
|
|
case (resolved(?val, ?typ)) {
|
|
ret alt (ns) { case (ns_value) { val }
|
|
case (ns_type) { typ } };
|
|
}
|
|
}
|
|
}
|
|
|
|
fn resolve_import(&env e, &@ast::view_item it, &list[scope] sc) {
|
|
auto defid; auto ids;
|
|
alt (it.node) {
|
|
case (ast::view_item_import(_, ?_ids, ?_defid)) {
|
|
defid = _defid; ids = _ids;
|
|
}
|
|
}
|
|
e.imports.insert(defid._1, resolving(it.span));
|
|
|
|
auto n_idents = _vec::len(ids);
|
|
auto end_id = ids.(n_idents - 1u);
|
|
|
|
if (n_idents == 1u) {
|
|
register(e, defid, it.span, end_id,
|
|
lookup_in_scope(e, sc, end_id, ns_value),
|
|
lookup_in_scope(e, sc, end_id, ns_type));
|
|
} else {
|
|
auto dcur = lookup_in_scope_strict(e, sc, it.span, ids.(0), ns_value);
|
|
auto i = 1u;
|
|
while (true) {
|
|
if (!is_module(dcur)) {
|
|
e.sess.span_err(it.span, ids.(i-1u) +
|
|
" is not a module or crate");
|
|
}
|
|
if (i == n_idents - 1u) {
|
|
register(e, defid, it.span, end_id,
|
|
lookup_in_mod(e, dcur, end_id, ns_value, outside),
|
|
lookup_in_mod(e, dcur, end_id, ns_type, outside));
|
|
break;
|
|
} else {
|
|
dcur = lookup_in_mod_strict(e, dcur, it.span, ids.(i),
|
|
ns_value, outside);
|
|
i += 1u;
|
|
}
|
|
}
|
|
}
|
|
|
|
fn register(&env e, def_id defid, &span sp, ident id,
|
|
option::t[def] val, option::t[def] typ) {
|
|
if (val == none[def] && typ == none[def]) {
|
|
unresolved(e, sp, id, "import");
|
|
}
|
|
e.imports.insert(defid._1, resolved(val, typ));
|
|
}
|
|
}
|
|
|
|
fn fold_expr_path(@env e, &list[scope] sc, &span sp, &ast::path p, &ann a)
|
|
-> @ast::expr {
|
|
auto df = lookup_path_strict(*e, sc, sp, p.node.idents, ns_value);
|
|
e.def_map.insert(ast::ann_tag(a), df);
|
|
ret @fold::respan(sp, ast::expr_path(p, a));
|
|
}
|
|
|
|
|
|
fn fold_pat_tag(@env e, &list[scope] sc, &span sp, &ast::path p,
|
|
&vec[@ast::pat] args, &ann a) -> @ast::pat {
|
|
alt (lookup_path_strict(*e, sc, sp, p.node.idents, ns_value)) {
|
|
case (ast::def_variant(?did, ?vid)) {
|
|
e.def_map.insert(ast::ann_tag(a), ast::def_variant(did, vid));
|
|
ret @fold::respan[ast::pat_](sp, ast::pat_tag(p, args, a));
|
|
}
|
|
case (_) {
|
|
e.sess.span_err(sp, "not a tag variant: " +
|
|
_str::connect(p.node.idents, "::"));
|
|
fail;
|
|
}
|
|
}
|
|
}
|
|
|
|
fn fold_ty_path(@env e, &list[scope] sc, &span sp, &ast::path p,
|
|
&ast::ann a) -> @ast::ty {
|
|
auto new_def = lookup_path_strict(*e, sc, sp, p.node.idents, ns_type);
|
|
e.def_map.insert(ast::ann_tag(a), new_def);
|
|
ret @fold::respan[ast::ty_](sp, ast::ty_path(p, a));
|
|
}
|
|
|
|
fn is_module(def d) -> bool {
|
|
alt (d) {
|
|
case (ast::def_mod(_)) { ret true; }
|
|
case (ast::def_native_mod(_)) { ret true; }
|
|
case (_) { ret false; }
|
|
}
|
|
}
|
|
|
|
fn ns_name(namespace ns) -> str {
|
|
alt (ns) {
|
|
case (ns_type) { ret "typename"; }
|
|
case (ns_value) { ret "name"; }
|
|
}
|
|
}
|
|
|
|
fn unresolved(&env e, &span sp, ident id, str kind) {
|
|
e.sess.span_err(sp, "unresolved " + kind + ": " + id);
|
|
}
|
|
|
|
fn lookup_path_strict(&env e, &list[scope] sc, &span sp, vec[ident] idents,
|
|
namespace ns) -> def {
|
|
auto n_idents = _vec::len(idents);
|
|
auto dcur = lookup_in_scope_strict(e, sc, sp, idents.(0), ns);
|
|
auto i = 1u;
|
|
while (i < n_idents) {
|
|
if (!is_module(dcur)) {
|
|
e.sess.span_err(sp, idents.(i-1u) +
|
|
" can't be dereferenced as a module");
|
|
}
|
|
dcur = lookup_in_mod_strict(e, dcur, sp, idents.(i), ns, outside);
|
|
i += 1u;
|
|
}
|
|
if (is_module(dcur)) {
|
|
e.sess.span_err(sp, _str::connect(idents, "::") +
|
|
" is a module, not a " + ns_name(ns));
|
|
}
|
|
ret dcur;
|
|
}
|
|
|
|
fn lookup_in_scope_strict(&env e, list[scope] sc, &span sp, ident id,
|
|
namespace ns) -> def {
|
|
alt (lookup_in_scope(e, sc, id, ns)) {
|
|
case (none[def]) {
|
|
unresolved(e, sp, id, ns_name(ns));
|
|
fail;
|
|
}
|
|
case (some[def](?d)) {
|
|
ret d;
|
|
}
|
|
}
|
|
}
|
|
|
|
fn lookup_in_scope(&env e, list[scope] sc, ident id, namespace ns)
|
|
-> option::t[def] {
|
|
fn in_scope(&env e, ident id, &scope s, namespace ns)
|
|
-> option::t[def] {
|
|
alt (s) {
|
|
case (scope_crate(?c)) {
|
|
auto defid = tup(ast::local_crate, -1);
|
|
ret lookup_in_regular_mod(e, defid, id, ns, inside);
|
|
}
|
|
case (scope_item(?it)) {
|
|
alt (it.node) {
|
|
case (ast::item_fn(_, ?f, ?ty_params, _, _)) {
|
|
ret lookup_in_fn(id, f.decl, ty_params, ns);
|
|
}
|
|
case (ast::item_obj(_, ?ob, ?ty_params, _, _)) {
|
|
ret lookup_in_obj(id, ob, ty_params, ns);
|
|
}
|
|
case (ast::item_tag(_, _, ?ty_params, _, _)) {
|
|
if (ns == ns_type) {
|
|
ret lookup_in_ty_params(id, ty_params);
|
|
}
|
|
}
|
|
case (ast::item_mod(_, _, ?defid)) {
|
|
ret lookup_in_regular_mod(e, defid, id, ns, inside);
|
|
}
|
|
case (ast::item_native_mod(_, ?m, ?defid)) {
|
|
ret lookup_in_native_mod(e, defid, id, ns);
|
|
}
|
|
case (ast::item_ty(_, _, ?ty_params, _, _)) {
|
|
if (ns == ns_type) {
|
|
ret lookup_in_ty_params(id, ty_params);
|
|
}
|
|
}
|
|
case (_) {}
|
|
}
|
|
}
|
|
|
|
case (scope_native_item(?it)) {
|
|
alt (it.node) {
|
|
case (ast::native_item_fn(_, _, ?decl, ?ty_params, _, _)){
|
|
ret lookup_in_fn(id, decl, ty_params, ns);
|
|
}
|
|
}
|
|
}
|
|
|
|
case (scope_loop(?d)) {
|
|
if (ns == ns_value) {
|
|
alt (d.node) {
|
|
case (ast::decl_local(?local)) {
|
|
if (_str::eq(local.ident, id)) {
|
|
ret some(ast::def_local(local.id));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
case (scope_block(?b)) {
|
|
ret lookup_in_block(id, b.node, ns);
|
|
}
|
|
|
|
case (scope_arm(?a)) {
|
|
if (ns == ns_value) {
|
|
ret lookup_in_pat(id, *a.pat);
|
|
}
|
|
}
|
|
}
|
|
ret none[def];
|
|
}
|
|
|
|
while (true) {
|
|
alt (sc) {
|
|
case (nil[scope]) {
|
|
ret none[def];
|
|
}
|
|
case (cons[scope](?hd, ?tl)) {
|
|
alt (in_scope(e, id, hd, ns)) {
|
|
case (some[def](?x)) { ret some(x); }
|
|
case (_) { sc = *tl; }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn lookup_in_ty_params(ident id, &vec[ast::ty_param] ty_params)
|
|
-> option::t[def] {
|
|
auto i = 0u;
|
|
for (ast::ty_param tp in ty_params) {
|
|
if (_str::eq(tp, id)) {
|
|
ret some(ast::def_ty_arg(i));
|
|
}
|
|
i += 1u;
|
|
}
|
|
ret none[def];
|
|
}
|
|
|
|
fn lookup_in_pat(ident id, &ast::pat pat) -> option::t[def] {
|
|
alt (pat.node) {
|
|
case (ast::pat_bind(?name, ?defid, _)) {
|
|
if (_str::eq(name, id)) { ret some(ast::def_binding(defid)); }
|
|
}
|
|
case (ast::pat_wild(_)) {}
|
|
case (ast::pat_lit(_, _)) {}
|
|
case (ast::pat_tag(_, ?pats, _)) {
|
|
for (@ast::pat p in pats) {
|
|
auto found = lookup_in_pat(id, *p);
|
|
if (found != none[def]) { ret found; }
|
|
}
|
|
}
|
|
}
|
|
ret none[def];
|
|
}
|
|
|
|
|
|
fn lookup_in_fn(ident id, &ast::fn_decl decl, &vec[ast::ty_param] ty_params,
|
|
namespace ns) -> option::t[def] {
|
|
if (ns == ns_value) {
|
|
for (ast::arg a in decl.inputs) {
|
|
if (_str::eq(a.ident, id)) {
|
|
ret some(ast::def_arg(a.id));
|
|
}
|
|
}
|
|
ret none[def];
|
|
} else {
|
|
ret lookup_in_ty_params(id, ty_params);
|
|
}
|
|
}
|
|
|
|
fn lookup_in_obj(ident id, &ast::_obj ob, &vec[ast::ty_param] ty_params,
|
|
namespace ns) -> option::t[def] {
|
|
if (ns == ns_value) {
|
|
for (ast::obj_field f in ob.fields) {
|
|
if (_str::eq(f.ident, id)) {
|
|
ret some(ast::def_obj_field(f.id));
|
|
}
|
|
}
|
|
ret none[def];
|
|
} else {
|
|
ret lookup_in_ty_params(id, ty_params);
|
|
}
|
|
}
|
|
|
|
fn lookup_in_block(ident id, &ast::block_ b, namespace ns)
|
|
-> option::t[def] {
|
|
for (@ast::stmt st in b.stmts) {
|
|
alt (st.node) {
|
|
case (ast::stmt_decl(?d,_)) {
|
|
alt (d.node) {
|
|
case (ast::decl_local(?loc)) {
|
|
if (ns == ns_value && _str::eq(id, loc.ident)) {
|
|
ret some(ast::def_local(loc.id));
|
|
}
|
|
}
|
|
case (ast::decl_item(?it)) {
|
|
alt (it.node) {
|
|
case (ast::item_tag(?name, ?variants, _,
|
|
?defid, _)) {
|
|
if (ns == ns_type) {
|
|
if (_str::eq(name, id)) {
|
|
ret some(ast::def_ty(defid));
|
|
}
|
|
} else {
|
|
for (ast::variant v in variants) {
|
|
if (_str::eq(v.node.name, id)) {
|
|
ret some(ast::def_variant(
|
|
defid, v.node.id));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
case (_) {
|
|
if (_str::eq(ast::item_ident(it), id)) {
|
|
auto found = found_def_item(it, ns);
|
|
if (found != none[def]) { ret found; }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
case (_) {}
|
|
}
|
|
}
|
|
ret none[def];
|
|
}
|
|
|
|
fn found_def_item(@ast::item i, namespace ns) -> option::t[def] {
|
|
alt (i.node) {
|
|
case (ast::item_const(_, _, _, ?defid, _)) {
|
|
if (ns == ns_value) { ret some(ast::def_const(defid)); }
|
|
}
|
|
case (ast::item_fn(_, _, _, ?defid, _)) {
|
|
if (ns == ns_value) { ret some(ast::def_fn(defid)); }
|
|
}
|
|
case (ast::item_mod(_, _, ?defid)) {
|
|
ret some(ast::def_mod(defid));
|
|
}
|
|
case (ast::item_native_mod(_, _, ?defid)) {
|
|
ret some(ast::def_native_mod(defid));
|
|
}
|
|
case (ast::item_ty(_, _, _, ?defid, _)) {
|
|
if (ns == ns_type) { ret some(ast::def_ty(defid)); }
|
|
}
|
|
case (ast::item_tag(_, _, _, ?defid, _)) {
|
|
if (ns == ns_type) { ret some(ast::def_ty(defid)); }
|
|
}
|
|
case (ast::item_obj(_, _, _, ?odid, _)) {
|
|
if (ns == ns_value) { ret some(ast::def_obj(odid.ctor)); }
|
|
else { ret some(ast::def_obj(odid.ty)); }
|
|
}
|
|
case (_) { }
|
|
}
|
|
ret none[def];
|
|
}
|
|
|
|
fn lookup_in_mod_strict(&env e, def m, &span sp, ident id,
|
|
namespace ns, dir dr) -> def {
|
|
alt (lookup_in_mod(e, m, id, ns, dr)) {
|
|
case (none[def]) {
|
|
unresolved(e, sp, id, ns_name(ns));
|
|
fail;
|
|
}
|
|
case (some[def](?d)) {
|
|
ret d;
|
|
}
|
|
}
|
|
}
|
|
|
|
fn lookup_in_mod(&env e, def m, ident id, namespace ns, dir dr)
|
|
-> option::t[def] {
|
|
auto defid = ast::def_id_of_def(m);
|
|
if (defid._0 != ast::local_crate) { // Not in this crate
|
|
auto cached = e.ext_cache.find(tup(defid,id));
|
|
if (cached != none[def] && check_def_by_ns(option::get(cached), ns)) {
|
|
ret cached;
|
|
}
|
|
auto path = vec(id);
|
|
if (defid._1 != -1) {
|
|
path = e.ext_map.get(defid) + path;
|
|
}
|
|
auto fnd = lookup_external(e, defid._0, path, ns);
|
|
if (fnd != none[def]) {
|
|
e.ext_cache.insert(tup(defid,id), option::get(fnd));
|
|
}
|
|
ret fnd;
|
|
}
|
|
alt (m) {
|
|
case (ast::def_mod(?defid)) {
|
|
ret lookup_in_regular_mod(e, defid, id, ns, dr);
|
|
}
|
|
case (ast::def_native_mod(?defid)) {
|
|
ret lookup_in_native_mod(e, defid, id, ns);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn found_view_item(&env e, @ast::view_item vi, namespace ns)
|
|
-> option::t[def] {
|
|
alt (vi.node) {
|
|
case (ast::view_item_use(_, _, _, ?cnum)) {
|
|
ret some(ast::def_mod(tup(option::get(cnum), -1)));
|
|
}
|
|
case (ast::view_item_import(_, _, ?defid)) {
|
|
ret lookup_import(e, defid, ns);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn lookup_in_regular_mod(&env e, def_id defid, ident id, namespace ns, dir dr)
|
|
-> option::t[def] {
|
|
auto info = e.mod_map.get(defid._1);
|
|
auto found = info.index.find(id);
|
|
if (found == none[mod_index_entry] ||
|
|
(dr == outside && !ast::is_exported(id, info.m))) {
|
|
ret none[def];
|
|
}
|
|
alt (option::get(found)) {
|
|
case (mie_view_item(?view_item)) {
|
|
ret found_view_item(e, view_item, ns);
|
|
}
|
|
case (mie_item(?item)) {
|
|
ret found_def_item(item, ns);
|
|
}
|
|
case (mie_tag_variant(?item, ?variant_idx)) {
|
|
alt (item.node) {
|
|
case (ast::item_tag(_, ?variants, _, ?tid, _)) {
|
|
if (ns == ns_value) {
|
|
auto vid = variants.(variant_idx).node.id;
|
|
ret some(ast::def_variant(tid, vid));
|
|
} else {
|
|
ret none[def];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn lookup_in_native_mod(&env e, def_id defid, ident id, namespace ns)
|
|
-> option::t[def] {
|
|
auto info = e.nmod_map.get(defid._1);
|
|
auto found = info.index.find(id);
|
|
if (found == none[native_mod_index_entry]) {
|
|
ret none[def];
|
|
}
|
|
alt (option::get(found)) {
|
|
case (nmie_view_item(?view_item)) {
|
|
ret found_view_item(e, view_item, ns);
|
|
}
|
|
case (nmie_item(?item)) {
|
|
alt (item.node) {
|
|
case (ast::native_item_ty(_, ?id)) {
|
|
if (ns == ns_type) {
|
|
ret some(ast::def_native_ty(id));
|
|
}
|
|
}
|
|
case (ast::native_item_fn(_, _, _, _, ?id, _)) {
|
|
if (ns == ns_value) {
|
|
ret some(ast::def_native_fn(id));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
case (_) {}
|
|
}
|
|
ret none[def];
|
|
}
|
|
|
|
// Module indexing
|
|
|
|
fn index_mod(&ast::_mod md) -> mod_index {
|
|
auto index = new_str_hash[mod_index_entry]();
|
|
|
|
for (@ast::view_item it in md.view_items) {
|
|
alt (it.node) {
|
|
case(ast::view_item_use(?id, _, _, _)) {
|
|
index.insert(id, mie_view_item(it));
|
|
}
|
|
case(ast::view_item_import(?def_ident,_,_)) {
|
|
index.insert(def_ident, mie_view_item(it));
|
|
}
|
|
case(ast::view_item_export(_)) {}
|
|
}
|
|
}
|
|
|
|
for (@ast::item it in md.items) {
|
|
alt (it.node) {
|
|
case (ast::item_const(?id, _, _, _, _)) {
|
|
index.insert(id, mie_item(it));
|
|
}
|
|
case (ast::item_fn(?id, _, _, _, _)) {
|
|
index.insert(id, mie_item(it));
|
|
}
|
|
case (ast::item_mod(?id, _, _)) {
|
|
index.insert(id, mie_item(it));
|
|
}
|
|
case (ast::item_native_mod(?id, _, _)) {
|
|
index.insert(id, mie_item(it));
|
|
}
|
|
case (ast::item_ty(?id, _, _, _, _)) {
|
|
index.insert(id, mie_item(it));
|
|
}
|
|
case (ast::item_tag(?id, ?variants, _, _, _)) {
|
|
index.insert(id, mie_item(it));
|
|
let uint variant_idx = 0u;
|
|
for (ast::variant v in variants) {
|
|
index.insert(v.node.name,
|
|
mie_tag_variant(it, variant_idx));
|
|
variant_idx += 1u;
|
|
}
|
|
}
|
|
case (ast::item_obj(?id, _, _, _, _)) {
|
|
index.insert(id, mie_item(it));
|
|
}
|
|
}
|
|
}
|
|
|
|
ret index;
|
|
}
|
|
|
|
fn index_nmod(&ast::native_mod md) -> nmod_index {
|
|
auto index = new_str_hash[native_mod_index_entry]();
|
|
|
|
for (@ast::view_item it in md.view_items) {
|
|
alt (it.node) {
|
|
case(ast::view_item_import(?def_ident,_,_)) {
|
|
index.insert(def_ident, nmie_view_item(it));
|
|
}
|
|
case(ast::view_item_export(_)) {}
|
|
}
|
|
}
|
|
|
|
for (@ast::native_item it in md.items) {
|
|
alt (it.node) {
|
|
case (ast::native_item_ty(?id, _)) {
|
|
index.insert(id, nmie_item(it));
|
|
}
|
|
case (ast::native_item_fn(?id, _, _, _, _, _)) {
|
|
index.insert(id, nmie_item(it));
|
|
}
|
|
}
|
|
}
|
|
|
|
ret index;
|
|
}
|
|
|
|
// External lookups
|
|
|
|
// FIXME creader should handle multiple namespaces
|
|
fn check_def_by_ns(def d, namespace ns) -> bool {
|
|
ret alt (d) {
|
|
case (ast::def_fn(?id)) { ns == ns_value }
|
|
case (ast::def_obj(?id)) { ns == ns_value }
|
|
case (ast::def_obj_field(?id)) { ns == ns_value }
|
|
case (ast::def_mod(?id)) { true }
|
|
case (ast::def_native_mod(?id)) { true }
|
|
case (ast::def_const(?id)) { ns == ns_value }
|
|
case (ast::def_arg(?id)) { ns == ns_value }
|
|
case (ast::def_local(?id)) { ns == ns_value }
|
|
case (ast::def_upvar(?id)) { ns == ns_value }
|
|
case (ast::def_variant(_, ?id)) { ns == ns_value }
|
|
case (ast::def_ty(?id)) { ns == ns_type }
|
|
case (ast::def_binding(?id)) { ns == ns_type }
|
|
case (ast::def_use(?id)) { true }
|
|
case (ast::def_native_ty(?id)) { ns == ns_type }
|
|
case (ast::def_native_fn(?id)) { ns == ns_value }
|
|
};
|
|
}
|
|
|
|
fn lookup_external(&env e, int cnum, vec[ident] ids, namespace ns)
|
|
-> option::t[def] {
|
|
auto found = creader::lookup_def(e.sess, cnum, ids);
|
|
if (found != none[def]) {
|
|
auto d = option::get(found);
|
|
if (!check_def_by_ns(d, ns)) { ret none[def]; }
|
|
e.ext_map.insert(ast::def_id_of_def(d), ids);
|
|
}
|
|
ret found;
|
|
}
|
|
|
|
// Local Variables:
|
|
// mode: rust
|
|
// fill-column: 78;
|
|
// indent-tabs-mode: nil
|
|
// c-basic-offset: 4
|
|
// buffer-file-coding-system: utf-8-unix
|
|
// compile-command: "make -k -C $RBUILD 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
|
|
// End:
|