user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Move functions from syntax::ast to syntax::ast_util

Browse source 
This leaves syntax::ast just defining the AST, which strikes me as somewhat
nicer
This commit is contained in:
Brian Anderson 2011-08-21 21:44:41 -07:00
parent a3affaa20f
commit 152cbaade7
33 changed files with 358 additions and 314 deletions
Download patch file Download diff file Expand all files Collapse all files

3
src/comp/front/attr.rs
View file

@ -5,6 +5,7 @@ import std::str;
import std::map;
import std::option;
import syntax::ast;
import syntax::ast_util;
import util::common;
import driver::session;
@ -189,7 +190,7 @@ fn require_unique_names(sess: &session::session, metas: &[@ast::meta_item]) {
}
fn span<T>(item: &T) -> ast::spanned<T> {
ret {node: item, span: ast::mk_sp(0u, 0u)};
ret {node: item, span: ast_util::dummy_sp()};
}
fn mk_name_value_item_str(name: ast::ident, value: str) -> @ast::meta_item {

38
src/comp/front/test.rs
View file

@ -3,6 +3,8 @@
import std::option;
import std::vec;
import syntax::ast;
import syntax::ast_util;
import syntax::ast_util::dummy_sp;
import syntax::fold;
import syntax::print::pprust;
import front::attr;
@ -88,7 +90,7 @@ fn fold_item(cx: &test_ctxt, i: &@ast::item, fld: fold::ast_fold) ->
@ast::item {
cx.path += [i.ident];
log #fmt["current path: %s", ast::path_name_i(cx.path)];
log #fmt["current path: %s", ast_util::path_name_i(cx.path)];
if is_test_fn(i) {
log "this is a test function";
@ -161,7 +163,7 @@ fn mk_test_module(cx: &test_ctxt) -> @ast::item {
attrs: [],
id: cx.next_node_id(),
node: item_,
span: ast::dummy_sp()};
span: dummy_sp()};
log #fmt["Synthetic test module:\n%s\n", pprust::item_to_str(@item)];
@ -169,7 +171,7 @@ fn mk_test_module(cx: &test_ctxt) -> @ast::item {
}
fn nospan<T>(t: &T) -> ast::spanned<T> {
ret {node: t, span: ast::dummy_sp()};
ret {node: t, span: dummy_sp()};
}
fn mk_tests(cx: &test_ctxt) -> @ast::item {
@ -199,7 +201,7 @@ fn mk_tests(cx: &test_ctxt) -> @ast::item {
attrs: [],
id: cx.next_node_id(),
node: item_,
span: ast::dummy_sp()};
span: dummy_sp()};
ret @item;
}
@ -237,20 +239,20 @@ fn mk_test_desc_vec(cx: &test_ctxt) -> @ast::expr {
ret @{id: cx.next_node_id(),
node: ast::expr_vec(descs, ast::imm),
span: ast::dummy_sp()};
span: dummy_sp()};
}
fn mk_test_desc_rec(cx: &test_ctxt, test: test) -> @ast::expr {
let path = test.path;
log #fmt["encoding %s", ast::path_name_i(path)];
log #fmt["encoding %s", ast_util::path_name_i(path)];
let name_lit: ast::lit =
nospan(ast::lit_str(ast::path_name_i(path), ast::sk_rc));
nospan(ast::lit_str(ast_util::path_name_i(path), ast::sk_rc));
let name_expr: ast::expr =
{id: cx.next_node_id(),
node: ast::expr_lit(@name_lit),
span: ast::dummy_sp()};
span: dummy_sp()};
let name_field: ast::field =
nospan({mut: ast::imm, ident: "name", expr: @name_expr});
@ -260,7 +262,7 @@ fn mk_test_desc_rec(cx: &test_ctxt, test: test) -> @ast::expr {
let fn_expr: ast::expr =
{id: cx.next_node_id(),
node: ast::expr_path(fn_path),
span: ast::dummy_sp()};
span: dummy_sp()};
let fn_field: ast::field =
nospan({mut: ast::imm, ident: "fn", expr: @fn_expr});
@ -270,7 +272,7 @@ fn mk_test_desc_rec(cx: &test_ctxt, test: test) -> @ast::expr {
let ignore_expr: ast::expr =
{id: cx.next_node_id(),
node: ast::expr_lit(@ignore_lit),
span: ast::dummy_sp()};
span: dummy_sp()};
let ignore_field: ast::field =
nospan({mut: ast::imm, ident: "ignore", expr: @ignore_expr});
@ -278,7 +280,7 @@ fn mk_test_desc_rec(cx: &test_ctxt, test: test) -> @ast::expr {
let desc_rec_: ast::expr_ =
ast::expr_rec([name_field, fn_field, ignore_field], option::none);
let desc_rec: ast::expr =
{id: cx.next_node_id(), node: desc_rec_, span: ast::dummy_sp()};
{id: cx.next_node_id(), node: desc_rec_, span: dummy_sp()};
ret @desc_rec;
}
@ -307,7 +309,7 @@ fn mk_main(cx: &test_ctxt) -> @ast::item {
{stmts: [],
expr: option::some(test_main_call_expr),
id: cx.next_node_id()};
let body = {node: body_, span: ast::dummy_sp()};
let body = {node: body_, span: dummy_sp()};
let fn_ = {decl: decl, proto: proto, body: body};
@ -317,7 +319,7 @@ fn mk_main(cx: &test_ctxt) -> @ast::item {
attrs: [],
id: cx.next_node_id(),
node: item_,
span: ast::dummy_sp()};
span: dummy_sp()};
ret @item;
}
@ -330,7 +332,7 @@ fn mk_test_main_call(cx: &test_ctxt) -> @ast::expr {
let args_path_expr_: ast::expr_ = ast::expr_path(args_path);
let args_path_expr: ast::expr =
{id: cx.next_node_id(), node: args_path_expr_, span: ast::dummy_sp()};
{id: cx.next_node_id(), node: args_path_expr_, span: dummy_sp()};
// Call __test::test to generate the vector of test_descs
let test_path: ast::path =
@ -339,12 +341,12 @@ fn mk_test_main_call(cx: &test_ctxt) -> @ast::expr {
let test_path_expr_: ast::expr_ = ast::expr_path(test_path);
let test_path_expr: ast::expr =
{id: cx.next_node_id(), node: test_path_expr_, span: ast::dummy_sp()};
{id: cx.next_node_id(), node: test_path_expr_, span: dummy_sp()};
let test_call_expr_: ast::expr_ = ast::expr_call(@test_path_expr, []);
let test_call_expr: ast::expr =
{id: cx.next_node_id(), node: test_call_expr_, span: ast::dummy_sp()};
{id: cx.next_node_id(), node: test_call_expr_, span: dummy_sp()};
// Call std::test::test_main
let test_main_path: ast::path =
@ -357,7 +359,7 @@ fn mk_test_main_call(cx: &test_ctxt) -> @ast::expr {
let test_main_path_expr: ast::expr =
{id: cx.next_node_id(),
node: test_main_path_expr_,
span: ast::dummy_sp()};
span: dummy_sp()};
let test_main_call_expr_: ast::expr_ =
ast::expr_call(@test_main_path_expr,
@ -366,7 +368,7 @@ fn mk_test_main_call(cx: &test_ctxt) -> @ast::expr {
let test_main_call_expr: ast::expr =
{id: cx.next_node_id(),
node: test_main_call_expr_,
span: ast::dummy_sp()};
span: dummy_sp()};
ret @test_main_call_expr;
}

3
src/comp/metadata/creader.rs
View file

@ -2,6 +2,7 @@
import driver::session;
import syntax::ast;
import syntax::ast_util;
import lib::llvm::False;
import lib::llvm::llvm;
import lib::llvm::mk_object_file;
@ -262,7 +263,7 @@ fn resolve_crate_deps(e: env, cdata: &@[u8]) -> cstore::cnum_map {
log "need to load it";
// This is a new one so we've got to load it
// FIXME: Need better error reporting than just a bogus span
let fake_span = ast::dummy_sp();
let fake_span = ast_util::dummy_sp();
let local_cnum = resolve_crate(e, cname, [], fake_span);
cnum_map.insert(extrn_cnum, local_cnum);
}

3
src/comp/metadata/decoder.rs
View file

@ -7,6 +7,7 @@ import std::str;
import std::io;
import std::map::hashmap;
import syntax::ast;
import syntax::ast_util;
import front::attr;
import middle::ty;
import common::*;
@ -335,7 +336,7 @@ fn get_attributes(md: &ebml::doc) -> [ast::attribute] {
let meta_item = meta_items[0];
attrs +=
[{node: {style: ast::attr_outer, value: *meta_item},
span: ast::dummy_sp()}];
span: ast_util::dummy_sp()}];
}
}
option::none. { }

4
src/comp/metadata/encoder.rs
View file

@ -10,6 +10,8 @@ import std::option::none;
import std::ebml;
import std::map;
import syntax::ast::*;
import syntax::ast_util;
import syntax::ast_util::local_def;
import common::*;
import middle::trans_common::crate_ctxt;
import middle::ty;
@ -71,7 +73,7 @@ fn encode_native_module_item_paths(ebml_w: &ebml::writer, nmod: &native_mod,
fn encode_module_item_paths(ebml_w: &ebml::writer, module: &_mod,
path: &[str], index: &mutable [entry<str>]) {
for it: @item in module.items {
if !is_exported(it.ident, module) { cont; }
if !ast_util::is_exported(it.ident, module) { cont; }
alt it.node {
item_const(_, _) {
add_to_index(ebml_w, path, index, it.ident);

7
src/comp/metadata/tydecode.rs
View file

@ -8,7 +8,8 @@ import std::option::none;
import std::option::some;
import syntax::ast;
import syntax::ast::*;
import ast::respan;
import syntax::ast_util;
import syntax::ast_util::respan;
import middle::ty;
export parse_def_id;
@ -106,7 +107,7 @@ fn parse_path(st: @pstate, sd: str_def) -> ast::path {
':' { next(st); next(st); }
c {
if c == '(' {
ret respan(ast::dummy_sp(),
ret respan(ast_util::dummy_sp(),
{global: false, idents: idents, types: []});
} else { idents += [parse_ident_(st, sd, is_last)]; }
}
@ -152,7 +153,7 @@ fn parse_ty_constr_arg(st: @pstate, sd: str_def) ->
fn parse_constr<@T>(st: @pstate, sd: str_def, pser: arg_parser<T>) ->
@ty::constr_general<T> {
let sp = ast::dummy_sp(); // FIXME: use a real span
let sp = ast_util::dummy_sp(); // FIXME: use a real span
let args: [@sp_constr_arg<T>] = [];
let pth: path = parse_path(st, sd);
let ignore: char = next(st) as char;

25
src/comp/middle/alias.rs
View file

@ -1,5 +1,6 @@
import syntax::ast;
import syntax::ast_util;
import ast::ident;
import ast::fn_ident;
import ast::node_id;
@ -195,7 +196,7 @@ fn check_call(cx: &ctx, f: &@ast::expr, args: &[@ast::expr], sc: &scope) ->
if arg_t.mode == ty::mo_alias(true) {
alt path_def(cx, arg) {
some(def) {
let dnum = ast::def_id_of_def(def).node;
let dnum = ast_util::def_id_of_def(def).node;
if def_is_local(def, true) {
if is_immutable_alias(cx, sc, dnum) {
cx.tcx.sess.span_err(
@ -302,7 +303,7 @@ fn check_tail_call(cx: &ctx, call: &@ast::expr) {
alt args[i].node {
ast::expr_path(_) {
let def = cx.tcx.def_map.get(args[i].id);
let dnum = ast::def_id_of_def(def).node;
let dnum = ast_util::def_id_of_def(def).node;
alt cx.local_map.find(dnum) {
some(arg(ast::alias(mut))) {
if mut_a && !mut {
@ -352,7 +353,7 @@ fn check_alt(cx: &ctx, input: &@ast::expr, arms: &[ast::arm], sc: &scope,
}
fn arm_defnums(arm: &ast::arm) -> [node_id] {
ret ast::pat_binding_ids(arm.pats[0]);
ret ast_util::pat_binding_ids(arm.pats[0]);
}
fn check_for_each(cx: &ctx, local: &@ast::local, call: &@ast::expr,
@ -361,7 +362,7 @@ fn check_for_each(cx: &ctx, local: &@ast::local, call: &@ast::expr,
alt call.node {
ast::expr_call(f, args) {
let data = check_call(cx, f, args, sc);
let bindings = ast::pat_binding_ids(local.node.pat);
let bindings = ast_util::pat_binding_ids(local.node.pat);
let new_sc =
@{root_vars: data.root_vars,
block_defnum: bindings[vec::len(bindings) - 1u],
@ -393,7 +394,7 @@ fn check_for(cx: &ctx, local: &@ast::local, seq: &@ast::expr, blk: &ast::blk,
util::ppaux::ty_to_str(cx.tcx, seq_t));
}
}
let bindings = ast::pat_binding_ids(local.node.pat);
let bindings = ast_util::pat_binding_ids(local.node.pat);
let new_sc =
@{root_vars: root_def,
block_defnum: bindings[vec::len(bindings) - 1u],
@ -408,7 +409,7 @@ fn check_var(cx: &ctx, ex: &@ast::expr, p: &ast::path, id: ast::node_id,
assign: bool, sc: &scope) {
let def = cx.tcx.def_map.get(id);
if !def_is_local(def, true) { ret; }
let my_defnum = ast::def_id_of_def(def).node;
let my_defnum = ast_util::def_id_of_def(def).node;
let var_t = ty::expr_ty(cx.tcx, ex);
for r: restrict in *sc {
@ -429,7 +430,7 @@ fn check_var(cx: &ctx, ex: &@ast::expr, p: &ast::path, id: ast::node_id,
fn check_lval(cx: &@ctx, dest: &@ast::expr, sc: &scope, v: &vt<scope>) {
alt dest.node {
ast::expr_path(p) {
let dnum = ast::def_id_of_def(cx.tcx.def_map.get(dest.id)).node;
let dnum = ast_util::def_id_of_def(cx.tcx.def_map.get(dest.id)).node;
cx.mut_map.insert(dnum, ());
if is_immutable_alias(*cx, sc, dnum) {
cx.tcx.sess.span_err(dest.span, "assigning to immutable alias");
@ -515,15 +516,17 @@ fn test_scope(cx: &ctx, sc: &scope, r: &restrict, p: &ast::path) {
let msg =
alt prob {
overwritten(sp, wpt) {
{span: sp, msg: "overwriting " + ast::path_name(wpt)}
{span: sp, msg: "overwriting " + ast_util::path_name(wpt)}
}
val_taken(sp, vpt) {
{span: sp, msg: "taking the value of " + ast::path_name(vpt)}
{span: sp,
msg: "taking the value of " + ast_util::path_name(vpt)}
}
};
cx.tcx.sess.span_err(msg.span,
msg.msg + " will invalidate alias " +
ast::path_name(p) + ", which is still used");
ast_util::path_name(p) +
", which is still used");
}
}
@ -660,7 +663,7 @@ fn path_def(cx: &ctx, ex: &@ast::expr) -> option::t<ast::def> {
fn path_def_id(cx: &ctx, ex: &@ast::expr) -> option::t<ast::def_id> {
alt ex.node {
ast::expr_path(_) {
ret some(ast::def_id_of_def(cx.tcx.def_map.get(ex.id)));
ret some(ast_util::def_id_of_def(cx.tcx.def_map.get(ex.id)));
}
_ { ret none; }
}

10
src/comp/middle/ast_map.rs
View file

@ -125,9 +125,11 @@ fn node_span(node: &ast_node) -> codemap::span {
#[cfg(test)]
mod test {
import syntax::ast_util;
#[test]
fn test_node_span_item() {
let expected: codemap::span = mk_sp(20u, 30u);
let expected: codemap::span = ast_util::mk_sp(20u, 30u);
let node =
node_item(@{ident: "test",
attrs: [],
@ -139,7 +141,7 @@ mod test {
#[test]
fn test_node_span_obj_ctor() {
let expected: codemap::span = mk_sp(20u, 30u);
let expected: codemap::span = ast_util::mk_sp(20u, 30u);
let node =
node_obj_ctor(@{ident: "test",
attrs: [],
@ -151,7 +153,7 @@ mod test {
#[test]
fn test_node_span_native_item() {
let expected: codemap::span = mk_sp(20u, 30u);
let expected: codemap::span = ast_util::mk_sp(20u, 30u);
let node =
node_native_item(@{ident: "test",
attrs: [],
@ -163,7 +165,7 @@ mod test {
#[test]
fn test_node_span_expr() {
let expected: codemap::span = mk_sp(20u, 30u);
let expected: codemap::span = ast_util::mk_sp(20u, 30u);
let node = node_expr(@{id: 0, node: expr_break, span: expected});
assert (node_span(node) == expected);
}

2
src/comp/middle/check_alt.rs
View file

@ -1,4 +1,6 @@
import syntax::ast::*;
import syntax::ast_util::variant_def_ids;
import syntax::ast_util::dummy_sp;
import syntax::visit;
fn check_crate(tcx: &ty::ctxt, crate: &@crate) {

9
src/comp/middle/freevars.rs
View file

@ -7,6 +7,7 @@ import std::option;
import std::int;
import std::option::*;
import syntax::ast;
import syntax::ast_util;
import syntax::visit;
import driver::session;
import middle::resolve;
@ -69,7 +70,7 @@ fn collect_freevars(def_map: &resolve::def_map, sess: &session::session,
};
let walk_local =
lambda (local: &@ast::local) {
for each b: @ast::pat in ast::pat_bindings(local.node.pat) {
for each b: @ast::pat in ast_util::pat_bindings(local.node.pat) {
set_add(decls, b.id);
}
};
@ -91,7 +92,7 @@ fn collect_freevars(def_map: &resolve::def_map, sess: &session::session,
let defs = new_int_hash();
for ref_id_: ast::node_id in *refs {
let ref_id = ref_id_;
let def_id = ast::def_id_of_def(def_map.get(ref_id)).node;
let def_id = ast_util::def_id_of_def(def_map.get(ref_id)).node;
if !decls.contains_key(def_id) && !defs.contains_key(def_id) {
canonical_refs += [ref_id];
set_add(defs, def_id);
@ -127,7 +128,7 @@ fn annotate_freevars(sess: &session::session, def_map: &resolve::def_map,
lambda (v: &visit::vt<()>) {
v.visit_block(body, (), v);
};
let bound = ast::pat_binding_ids(local.node.pat);
let bound = ast_util::pat_binding_ids(local.node.pat);
let vars = collect_freevars(def_map, sess, start_walk, bound);
freevars.insert(body.node.id, vars);
}
@ -166,7 +167,7 @@ fn def_lookup(tcx: &ty::ctxt, f: ast::node_id, id: ast::node_id) ->
alt tcx.def_map.find(id) {
none. { ret none; }
some(d) {
let did = ast::def_id_of_def(d);
let did = ast_util::def_id_of_def(d);
if f != -1 && is_freevar_of(tcx, did.node, f) {
ret some(ast::def_upvar(did, @d));
} else { ret some(d); }

4
src/comp/middle/kind.rs
View file

@ -72,6 +72,7 @@
import syntax::ast;
import syntax::ast_util;
import syntax::visit;
import std::vec;
@ -142,7 +143,8 @@ fn check_expr(tcx: &ty::ctxt, e: &@ast::expr) {
// that all the types we're supplying as typarams conform to the
// typaram kind constraints on that item.
if vec::len(tpt.params) != 0u {
let callee_def = ast::def_id_of_def(tcx.def_map.get(callee.id));
let callee_def = ast_util::def_id_of_def(
tcx.def_map.get(callee.id));
let item_tk = ty::lookup_item_type(tcx, callee_def);
let i = 0;
assert (vec::len(item_tk.kinds) == vec::len(tpt.params));

20
src/comp/middle/resolve.rs
View file

@ -1,13 +1,14 @@
import syntax::ast;
import syntax::ast::*;
import syntax::ast_util;
import syntax::codemap;
import ast::ident;
import ast::fn_ident;
import ast::def;
import ast::def_id;
import ast::node_id;
import ast::local_def;
import syntax::ast_util::local_def;
import metadata::csearch;
import metadata::cstore;
@ -16,7 +17,7 @@ import util::common::*;
import std::map::new_int_hash;
import std::map::new_str_hash;
import syntax::codemap::span;
import syntax::ast::respan;
import syntax::ast_util::respan;
import middle::ty::constr_table;
import syntax::visit;
import visit::vt;
@ -321,7 +322,8 @@ fn resolve_names(e: &@env, c: &@ast::crate) {
}
_ {
e.sess.span_err(p.span,
"not a tag variant: " + ast::path_name(p));
"not a tag variant: " +
ast_util::path_name(p));
}
}
}
@ -739,7 +741,7 @@ fn lookup_in_ty_params(name: &ident, ty_params: &[ast::ty_param]) ->
fn lookup_in_pat(name: &ident, pat: &@ast::pat) -> option::t<def_id> {
let found = none;
for each bound in ast::pat_bindings(pat) {
for each bound in ast_util::pat_bindings(pat) {
let p_name = alt bound.node { ast::pat_bind(n) { n } };
if str::eq(p_name, name) { found = some(local_def(bound.id)); }
}
@ -891,7 +893,7 @@ fn lookup_in_mod_strict(e: &env, sc: &scopes, m: def, sp: &span, name: &ident,
fn lookup_in_mod(e: &env, m: &def, sp: &span, name: &ident, ns: namespace,
dr: dir) -> option::t<def> {
let defid = ast::def_id_of_def(m);
let defid = ast_util::def_id_of_def(m);
if defid.crate != ast::local_crate {
// examining a module in an external crate
@ -946,7 +948,7 @@ fn lookup_in_local_native_mod(e: &env, node_id: node_id, sp: &span,
fn lookup_in_local_mod(e: &env, node_id: node_id, sp: &span, id: &ident,
ns: namespace, dr: dir) -> option::t<def> {
let info = e.mod_map.get(node_id);
if dr == outside && !ast::is_exported(id, option::get(info.m)) {
if dr == outside && !ast_util::is_exported(id, option::get(info.m)) {
// if we're in a native mod, then dr==inside, so info.m is some _mod
ret none::<def>; // name is not visible
@ -1173,7 +1175,7 @@ fn ns_for_def(d: def) -> namespace {
fn lookup_external(e: &env, cnum: int, ids: &[ident], ns: namespace) ->
option::t<def> {
for d: def in csearch::lookup_defs(e.sess.get_cstore(), cnum, ids) {
e.ext_map.insert(ast::def_id_of_def(d), ids);
e.ext_map.insert(ast_util::def_id_of_def(d), ids);
if ns == ns_for_def(d) { ret some(d); }
}
ret none::<def>;
@ -1273,7 +1275,7 @@ fn check_item(e: &@env, i: &@ast::item, x: &(), v: &vt<()>) {
}
fn check_pat(ch: checker, p: &@ast::pat) {
for each p in ast::pat_bindings(p) {
for each p in ast_util::pat_bindings(p) {
let ident = alt p.node { pat_bind(n) { n } };
add_name(ch, p.span, ident);
}
@ -1321,7 +1323,7 @@ fn check_block(e: &@env, b: &ast::blk, x: &(), v: &vt<()>) {
ast::decl_local(locs) {
let local_values = checker(*e, "value");
for loc in locs {
for each p in ast::pat_bindings(loc.node.pat) {
for each p in ast_util::pat_bindings(loc.node.pat) {
let ident = alt p.node { pat_bind(n) { n } };
add_name(local_values, p.span, ident);
check_name(values, p.span, ident);

2
src/comp/middle/shape.rs
View file

@ -21,7 +21,7 @@ import middle::ty;
import middle::ty::field;
import middle::ty::mt;
import syntax::ast;
import syntax::ast::dummy_sp;
import syntax::ast_util::dummy_sp;
import syntax::codemap::span;
import syntax::util::interner;
import util::common;

14
src/comp/middle/trans.rs
View file

@ -25,6 +25,7 @@ import std::fs;
import std::time;
import std::vec;
import syntax::ast;
import syntax::ast_util;
import driver::session;
import middle::ty;
import middle::freevars::*;
@ -3478,7 +3479,7 @@ fn trans_if(cx: &@block_ctxt, cond: &@ast::expr, thn: &ast::blk,
some(elexpr) {
alt elexpr.node {
ast::expr_if(_, _, _) {
let elseif_blk = ast::block_from_expr(elexpr);
let elseif_blk = ast_util::block_from_expr(elexpr);
trans_block(else_cx, elseif_blk, output)
}
ast::expr_block(blk) { trans_block(else_cx, blk, output) }
@ -3722,7 +3723,8 @@ fn load_environment(enclosing_cx: &@block_ctxt, fcx: &@fn_ctxt, envty: ty::t,
bcx = upvarptr.bcx;
let llupvarptr = upvarptr.val;
if !copying { llupvarptr = bcx.build.Load(llupvarptr); }
let def_id = ast::def_id_of_def(bcx_tcx(bcx).def_map.get(upvar_id));
let def_id = ast_util::def_id_of_def(bcx_tcx(bcx).
def_map.get(upvar_id));
fcx.llupvars.insert(def_id.node, llupvarptr);
i += 1u;
}
@ -4980,7 +4982,7 @@ fn trans_expr_out(cx: &@block_ctxt, e: &@ast::expr, output: out_method) ->
output);
}
ast::expr_ternary(_, _, _) {
ret trans_expr_out(cx, ast::ternary_to_if(e), output);
ret trans_expr_out(cx, ast_util::ternary_to_if(e), output);
}
ast::expr_for(decl, seq, body) { ret trans_for(cx, decl, seq, body); }
ast::expr_for_each(decl, seq, body) {
@ -5463,7 +5465,7 @@ fn build_return(bcx: &@block_ctxt) { bcx.build.Br(bcx_fcx(bcx).llreturn); }
fn trans_be(cx: &@block_ctxt, e: &@ast::expr) -> result {
// FIXME: This should be a typestate precondition
assert (ast::is_call_expr(e));
assert (ast_util::is_call_expr(e));
// FIXME: Turn this into a real tail call once
// calling convention issues are settled
@ -6208,8 +6210,8 @@ fn trans_tag_variant(cx: @local_ctxt, tag_id: ast::node_id,
i = 0u;
for va: ast::variant_arg in variant.node.args {
let rslt =
GEP_tag(bcx, llblobptr, ast::local_def(tag_id),
ast::local_def(variant.node.id), ty_param_substs,
GEP_tag(bcx, llblobptr, ast_util::local_def(tag_id),
ast_util::local_def(variant.node.id), ty_param_substs,
i as int);
bcx = rslt.bcx;
let lldestptr = rslt.val;

12
src/comp/middle/trans_alt.rs
View file

@ -14,7 +14,8 @@ import trans::new_scope_block_ctxt;
import trans::load_if_immediate;
import ty::pat_ty;
import syntax::ast;
import syntax::ast::dummy_sp;
import syntax::ast_util;
import syntax::ast_util::dummy_sp;
import syntax::ast::def_id;
import syntax::codemap::span;
import util::common::lit_eq;
@ -44,7 +45,7 @@ fn trans_opt(bcx: &@block_ctxt, o: &opt) -> result {
}
fn variant_opt(ccx: &@crate_ctxt, pat_id: ast::node_id) -> opt {
let vdef = ast::variant_def_ids(ccx.tcx.def_map.get(pat_id));
let vdef = ast_util::variant_def_ids(ccx.tcx.def_map.get(pat_id));
let variants = ty::tag_variants(ccx.tcx, vdef.tg);
let i = 0u;
for v: ty::variant_info in variants {
@ -500,7 +501,7 @@ fn trans_alt(cx: &@block_ctxt, expr: &@ast::expr, arms: &[ast::arm],
for a: ast::arm in arms {
let body = new_scope_block_ctxt(cx, "case_body");
let id_map = ast::pat_id_map(a.pats[0]);
let id_map = ast_util::pat_id_map(a.pats[0]);
bodies += [body];
for p: @ast::pat in a.pats {
match += [@{pats: [p],
@ -532,7 +533,8 @@ fn trans_alt(cx: &@block_ctxt, expr: &@ast::expr, arms: &[ast::arm],
let arm_results = [];
for a: ast::arm in arms {
let body_cx = bodies[i];
if make_phi_bindings(body_cx, exit_map, ast::pat_id_map(a.pats[0])) {
if make_phi_bindings(body_cx, exit_map,
ast_util::pat_id_map(a.pats[0])) {
let block_res = trans::trans_block(body_cx, a.body, output);
arm_results += [block_res];
} else { // Unreachable
@ -562,7 +564,7 @@ fn bind_irrefutable_pat(bcx: @block_ctxt, pat: &@ast::pat, val: ValueRef,
}
ast::pat_tag(_, sub) {
if vec::len(sub) == 0u { ret bcx; }
let vdefs = ast::variant_def_ids(ccx.tcx.def_map.get(pat.id));
let vdefs = ast_util::variant_def_ids(ccx.tcx.def_map.get(pat.id));
let args = extract_variant_args(bcx, pat.id, vdefs, val);
let i = 0;
for argval: ValueRef in args.vals {

3
src/comp/middle/trans_objects.rs
View file

@ -15,6 +15,7 @@ import back::abi;
import back::link::mangle_internal_name_by_path;
import back::link::mangle_internal_name_by_path_and_seq;
import syntax::ast;
import syntax::ast_util;
import syntax::codemap::span;
import trans_common::*;
@ -231,7 +232,7 @@ fn trans_anon_obj(bcx: @block_ctxt, sp: &span, anon_obj: &ast::anon_obj,
// methods, not inner ones.
let wrapper_obj: ast::_obj =
{fields:
std::vec::map(ast::obj_field_from_anon_obj_field,
std::vec::map(ast_util::obj_field_from_anon_obj_field,
additional_fields),
methods: anon_obj.methods};

1
src/comp/middle/tstate/annotate.rs
View file

@ -5,6 +5,7 @@ import std::option::none;
import std::int;
import std::uint;
import syntax::ast::*;
import syntax::ast_util::pat_binding_ids;
import syntax::visit;
import syntax::codemap::span;
import std::map::new_str_hash;

1
src/comp/middle/tstate/auxiliary.rs
View file

@ -6,6 +6,7 @@ import std::option::*;
import std::int;
import std::uint;
import syntax::ast::*;
import syntax::ast_util::*;
import syntax::codemap::span;
import syntax::visit;
import util::common;

2
src/comp/middle/tstate/ck.rs
View file

@ -11,7 +11,7 @@ import ast::ident;
import ast::fn_ident;
import ast::node_id;
import ast::def_id;
import ast::local_def;
import syntax::ast_util::local_def;
import ast::ty_param;
import ast::crate;
import ast::return;

3
src/comp/middle/tstate/collect_locals.rs
View file

@ -2,6 +2,7 @@ import std::uint;
import std::int;
import std::vec;
import syntax::ast::*;
import syntax::ast_util::*;
import util::ppaux::fn_ident_to_string;
import std::option::*;
import syntax::visit;
@ -9,7 +10,7 @@ import aux::*;
import std::map::new_int_hash;
import util::common::new_def_hash;
import syntax::codemap::span;
import syntax::ast::respan;
import syntax::ast_util::respan;
type ctxt = {cs: @mutable [sp_constr], tcx: ty::ctxt};

1
src/comp/middle/tstate/pre_post_conditions.rs
View file

@ -17,6 +17,7 @@ import bitvectors::relax_precond_block;
import bitvectors::gen;
import tritv::*;
import syntax::ast::*;
import syntax::ast_util::*;
import syntax::visit;
import std::map::new_int_hash;
import util::common::new_def_hash;

1
src/comp/middle/tstate/states.rs
View file

@ -15,6 +15,7 @@ import tritv::ttrue;
import bitvectors::*;
import syntax::ast::*;
import syntax::ast_util::*;
import middle::ty::expr_ty;
import middle::ty::type_is_nil;
import middle::ty::type_is_bot;

12
src/comp/middle/ty.rs
View file

@ -13,6 +13,7 @@ import std::smallintmap;
import driver::session;
import syntax::ast;
import syntax::ast::*;
import syntax::ast_util;
import syntax::codemap::span;
import metadata::csearch;
import util::common::*;
@ -416,7 +417,8 @@ fn mk_ctxt(s: session::session, dm: resolve::def_map,
has_pointer_cache: map::mk_hashmap(ty::hash_ty, ty::eq_ty),
kind_cache: map::mk_hashmap(ty::hash_ty, ty::eq_ty),
owns_heap_mem_cache: map::mk_hashmap(ty::hash_ty, ty::eq_ty),
ast_ty_to_ty_cache: map::mk_hashmap(ast::hash_ty, ast::eq_ty)};
ast_ty_to_ty_cache: map::mk_hashmap(ast_util::hash_ty,
ast_util::eq_ty)};
populate_type_store(cx);
ret cx;
}
@ -2716,7 +2718,7 @@ fn tag_variants(cx: &ctxt, id: &ast::def_id) -> [variant_info] {
result +=
[{args: arg_tys,
ctor_ty: ctor_ty,
id: ast::local_def(did)}];
id: ast_util::local_def(did)}];
}
ret result;
}
@ -2873,8 +2875,10 @@ fn ast_constr_to_constr<T>(tcx: ty::ctxt, c: &@ast::constr_general<T>) ->
@ty::constr_general<T> {
alt tcx.def_map.find(c.node.id) {
some(ast::def_fn(pred_id, ast::pure_fn.)) {
ret @respan(c.span,
{path: c.node.path, args: c.node.args, id: pred_id});
ret @ast_util::respan(c.span,
{path: c.node.path,
args: c.node.args,
id: pred_id});
}
_ {
tcx.sess.span_fatal(c.span,

27
src/comp/middle/typeck.rs
View file

@ -1,7 +1,8 @@
import syntax::ast;
import syntax::ast_util;
import ast::mutability;
import ast::local_def;
import ast::respan;
import syntax::ast_util::local_def;
import syntax::ast_util::respan;
import ast::spanned;
import syntax::visit;
import metadata::csearch;
@ -708,14 +709,14 @@ mod collect {
let convert = bind ast_ty_to_ty(cx.tcx, get, _);
let f = bind ty_of_arg(cx, _);
ret ty_of_native_fn_decl(cx, convert, f, fn_decl, abi, params,
ast::local_def(it.id));
ast_util::local_def(it.id));
}
ast::native_item_ty. {
alt cx.tcx.tcache.find(local_def(it.id)) {
some(tpt) { ret tpt; }
none. { }
}
let t = ty::mk_native(cx.tcx, ast::local_def(it.id));
let t = ty::mk_native(cx.tcx, ast_util::local_def(it.id));
let tpt = {kinds: no_kinds, ty: t};
cx.tcx.tcache.insert(local_def(it.id), tpt);
ret tpt;
@ -1329,7 +1330,7 @@ fn check_pat(fcx: &@fn_ctxt, map: &ast::pat_id_map, pat: &@ast::pat,
ast::pat_tag(path, subpats) {
// Typecheck the path.
let v_def = lookup_def(fcx, path.span, pat.id);
let v_def_ids = ast::variant_def_ids(v_def);
let v_def_ids = ast_util::variant_def_ids(v_def);
let tag_tpt = ty::lookup_item_type(fcx.ccx.tcx, v_def_ids.tg);
let path_tpot = instantiate_path(fcx, path, tag_tpt, pat.span);
@ -1727,7 +1728,7 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr, unify: &unifier,
}
}
for operand: @ast::expr in operands {
if !ast::is_constraint_arg(operand) {
if !ast_util::is_constraint_arg(operand) {
let s =
"Constraint args must be \
slot variables or literals";
@ -1776,7 +1777,7 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr, unify: &unifier,
binop: ast::binop) {
let resolved_t = resolve_type_vars_if_possible(fcx, ty);
if !ty::is_binopable(fcx.ccx.tcx, resolved_t, binop) {
let binopstr = ast::binop_to_str(binop);
let binopstr = ast_util::binop_to_str(binop);
let t_str = ty_to_str(fcx.ccx.tcx, resolved_t);
let errmsg =
"binary operation " + binopstr +
@ -1798,7 +1799,7 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr, unify: &unifier,
bot = check_expr_with(fcx, lhs, lhs_t);
let rhs_bot = check_expr_with(fcx, rhs, lhs_t);
if !ast::lazy_binop(binop) { bot |= rhs_bot; }
if !ast_util::lazy_binop(binop) { bot |= rhs_bot; }
check_binop_type_compat(fcx, expr.span, lhs_t, binop);
@ -1928,7 +1929,7 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr, unify: &unifier,
}
ast::expr_be(e) {
// FIXME: prove instead of assert
assert (ast::is_call_expr(e));
assert (ast_util::is_call_expr(e));
check_expr_with(fcx, e, fcx.ret_ty);
bot = true;
write::nil_ty(tcx, id);
@ -1947,7 +1948,7 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr, unify: &unifier,
check_then_else(fcx, thn, elsopt, id, expr.span);
}
ast::expr_ternary(_, _, _) {
bot = check_expr(fcx, ast::ternary_to_if(expr));
bot = check_expr(fcx, ast_util::ternary_to_if(expr));
}
ast::expr_assert(e) {
bot = check_expr_with(fcx, e, ty::mk_bool(tcx));
@ -2029,7 +2030,7 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr, unify: &unifier,
// bindings.
let pattern_ty = ty::expr_ty(tcx, expr);
for arm: ast::arm in arms {
let id_map = ast::pat_id_map(arm.pats[0]);
let id_map = ast_util::pat_id_map(arm.pats[0]);
for p: @ast::pat in arm.pats {
check_pat(fcx, id_map, p, pattern_ty);
}
@ -2392,7 +2393,7 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr, unify: &unifier,
}
fcx.ccx.obj_infos +=
[anon_obj(vec::map(ast::obj_field_from_anon_obj_field,
[anon_obj(vec::map(ast_util::obj_field_from_anon_obj_field,
fields), inner_obj_sty)];
// Whenever an outer method overrides an inner, we need to remove
@ -2499,7 +2500,7 @@ fn check_decl_local(fcx: &@fn_ctxt, local: &@ast::local) -> bool {
}
_ {/* fall through */ }
}
let id_map = ast::pat_id_map(local.node.pat);
let id_map = ast_util::pat_id_map(local.node.pat);
check_pat(fcx, id_map, local.node.pat, t);
}
}

1
src/comp/rustc.rc
View file

@ -45,6 +45,7 @@ mod middle {
mod syntax {
mod ast;
mod ast_util;
mod fold;
mod visit;

203
src/comp/syntax/ast.rs
View file

@ -6,15 +6,6 @@ import codemap::span;
import codemap::filename;
type spanned<T> = {node: T, span: span};
fn respan<T>(sp: &span, t: &T) -> spanned<T> { ret {node: t, span: sp}; }
/* assuming that we're not in macro expansion */
fn mk_sp(lo: uint, hi: uint) -> span {
ret {lo: lo, hi: hi, expanded_from: codemap::os_none};
}
// make this a const, once the compiler supports it
fn dummy_sp() -> span { ret mk_sp(0u, 0u); }
type ident = str;
// Functions may or may not have names.
@ -27,16 +18,11 @@ type path_ = {global: bool, idents: [ident], types: [@ty]};
type path = spanned<path_>;
fn path_name(p: &path) -> str { path_name_i(p.node.idents) }
fn path_name_i(idents: &[ident]) -> str { str::connect(idents, "::") }
type crate_num = int;
type node_id = int;
type def_id = {crate: crate_num, node: node_id};
const local_crate: crate_num = 0;
fn local_def(id: node_id) -> def_id { ret {crate: local_crate, node: id}; }
type ty_param = {ident: ident, kind: kind};
@ -64,30 +50,6 @@ tag def {
def_upvar(def_id, @def);
}
fn variant_def_ids(d: &def) -> {tg: def_id, var: def_id} {
alt d { def_variant(tag_id, var_id) { ret {tg: tag_id, var: var_id}; } }
}
fn def_id_of_def(d: def) -> def_id {
alt d {
def_fn(id, _) { ret id; }
def_obj_field(id) { ret id; }
def_mod(id) { ret id; }
def_native_mod(id) { ret id; }
def_const(id) { ret id; }
def_arg(id) { ret id; }
def_local(id) { ret id; }
def_variant(_, id) { ret id; }
def_ty(id) { ret id; }
def_ty_arg(_, _) { fail; }
def_binding(id) { ret id; }
def_use(id) { ret id; }
def_native_ty(id) { ret id; }
def_native_fn(id) { ret id; }
def_upvar(id, _) { ret id; }
}
}
// The set of meta_items that define the compilation environment of the crate,
// used to drive conditional compilation
type crate_cfg = [@meta_item];
@ -138,41 +100,6 @@ tag pat_ {
type pat_id_map = std::map::hashmap<str, ast::node_id>;
// This is used because same-named variables in alternative patterns need to
// use the node_id of their namesake in the first pattern.
fn pat_id_map(pat: &@pat) -> pat_id_map {
let map = std::map::new_str_hash::<node_id>();
for each bound in pat_bindings(pat) {
let name = alt bound.node { pat_bind(n) { n } };
map.insert(name, bound.id);
}
ret map;
}
// FIXME: could return a constrained type
iter pat_bindings(pat: &@pat) -> @pat {
alt pat.node {
pat_bind(_) { put pat; }
pat_tag(_, sub) {
for p in sub { for each b in pat_bindings(p) { put b; } }
}
pat_rec(fields, _) {
for f in fields { for each b in pat_bindings(f.pat) { put b; } }
}
pat_tup(elts) {
for elt in elts { for each b in pat_bindings(elt) { put b; } }
}
pat_box(sub) { for each b in pat_bindings(sub) { put b; } }
pat_wild. | pat_lit(_) { }
}
}
fn pat_binding_ids(pat: &@pat) -> [node_id] {
let found = [];
for each b in pat_bindings(pat) { found += [b.id]; }
ret found;
}
tag mutability { mut; imm; maybe_mut; }
tag kind { kind_pinned; kind_shared; kind_unique; }
@ -203,45 +130,8 @@ tag binop {
gt;
}
fn binop_to_str(op: binop) -> str {
alt op {
add. { ret "+"; }
sub. { ret "-"; }
mul. { ret "*"; }
div. { ret "/"; }
rem. { ret "%"; }
and. { ret "&&"; }
or. { ret "||"; }
bitxor. { ret "^"; }
bitand. { ret "&"; }
bitor. { ret "|"; }
lsl. { ret "<<"; }
lsr. { ret ">>"; }
asr. { ret ">>>"; }
eq. { ret "=="; }
lt. { ret "<"; }
le. { ret "<="; }
ne. { ret "!="; }
ge. { ret ">="; }
gt. { ret ">"; }
}
}
pred lazy_binop(b: binop) -> bool {
alt b { and. { true } or. { true } _ { false } }
}
tag unop { box(mutability); deref; not; neg; }
fn unop_to_str(op: unop) -> str {
alt op {
box(mt) { if mt == mut { ret "@mutable "; } ret "@"; }
deref. { ret "*"; }
not. { ret "!"; }
neg. { ret "-"; }
}
}
tag mode { val; alias(bool); move; }
type stmt = spanned<stmt_>;
@ -358,11 +248,6 @@ tag lit_ {
lit_bool(bool);
}
fn is_path(e: &@expr) -> bool {
ret alt e.node { expr_path(_) { true } _ { false } };
}
// NB: If you change this, you'll probably want to change the corresponding
// type structure in middle/ty.rs as well.
type mt = {ty: @ty, mut: mutability};
@ -398,21 +283,6 @@ tag ty_mach {
ty_f64;
}
fn ty_mach_to_str(tm: ty_mach) -> str {
alt tm {
ty_u8. { ret "u8"; }
ty_u16. { ret "u16"; }
ty_u32. { ret "u32"; }
ty_u64. { ret "u64"; }
ty_i8. { ret "i8"; }
ty_i16. { ret "i16"; }
ty_i32. { ret "i32"; }
ty_i64. { ret "i64"; }
ty_f32. { ret "f32"; }
ty_f64. { ret "f64"; }
}
}
type ty = spanned<ty_>;
tag ty_ {
@ -618,79 +488,6 @@ tag native_item_ {
native_item_fn(option::t<str>, fn_decl, [ty_param]);
}
fn is_exported(i: ident, m: _mod) -> bool {
let nonlocal = true;
for it: @ast::item in m.items {
if it.ident == i { nonlocal = false; }
alt it.node {
item_tag(variants, _) {
for v: variant in variants {
if v.node.name == i { nonlocal = false; }
}
}
_ { }
}
if !nonlocal { break; }
}
let count = 0u;
for vi: @ast::view_item in m.view_items {
alt vi.node {
ast::view_item_export(ids, _) {
for id in ids { if str::eq(i, id) { ret true; } }
count += 1u;
}
_ {/* fall through */ }
}
}
// If there are no declared exports then
// everything not imported is exported
// even if it's nonlocal (since it's explicit)
ret count == 0u && !nonlocal;
}
fn is_call_expr(e: @expr) -> bool {
alt e.node { expr_call(_, _) { ret true; } _ { ret false; } }
}
fn is_constraint_arg(e: @expr) -> bool {
alt e.node {
expr_lit(_) { ret true; }
expr_path(_) { ret true; }
_ { ret false; }
}
}
fn eq_ty(a: &@ty, b: &@ty) -> bool { ret std::box::ptr_eq(a, b); }
fn hash_ty(t: &@ty) -> uint { ret t.span.lo << 16u + t.span.hi; }
fn block_from_expr(e: @expr) -> blk {
let blk_ = {stmts: [], expr: option::some::<@expr>(e), id: e.id};
ret {node: blk_, span: e.span};
}
fn obj_field_from_anon_obj_field(f: &anon_obj_field) -> obj_field {
ret {mut: f.mut, ty: f.ty, ident: f.ident, id: f.id};
}
// This is a convenience function to transfor ternary expressions to if
// expressions so that they can be treated the same
fn ternary_to_if(e: &@expr) -> @ast::expr {
alt e.node {
expr_ternary(cond, then, els) {
let then_blk = block_from_expr(then);
let els_blk = block_from_expr(els);
let els_expr =
@{id: els.id, node: expr_block(els_blk), span: els.span};
ret @{id: e.id,
node: expr_if(cond, then_blk, option::some(els_expr)),
span: e.span};
}
_ { fail; }
}
}
//
// Local Variables:
// mode: rust

209
src/comp/syntax/ast_util.rs Normal file
View file

@ -0,0 +1,209 @@
import std::str;
import std::option;
import codemap::span;
import ast::*;
fn respan<T>(sp: &span, t: &T) -> spanned<T> { ret {node: t, span: sp}; }
/* assuming that we're not in macro expansion */
fn mk_sp(lo: uint, hi: uint) -> span {
ret {lo: lo, hi: hi, expanded_from: codemap::os_none};
}
// make this a const, once the compiler supports it
fn dummy_sp() -> span { ret mk_sp(0u, 0u); }
fn path_name(p: &path) -> str { path_name_i(p.node.idents) }
fn path_name_i(idents: &[ident]) -> str { str::connect(idents, "::") }
fn local_def(id: node_id) -> def_id { ret {crate: local_crate, node: id}; }
fn variant_def_ids(d: &def) -> {tg: def_id, var: def_id} {
alt d { def_variant(tag_id, var_id) { ret {tg: tag_id, var: var_id}; } }
}
fn def_id_of_def(d: def) -> def_id {
alt d {
def_fn(id, _) { ret id; }
def_obj_field(id) { ret id; }
def_mod(id) { ret id; }
def_native_mod(id) { ret id; }
def_const(id) { ret id; }
def_arg(id) { ret id; }
def_local(id) { ret id; }
def_variant(_, id) { ret id; }
def_ty(id) { ret id; }
def_ty_arg(_, _) { fail; }
def_binding(id) { ret id; }
def_use(id) { ret id; }
def_native_ty(id) { ret id; }
def_native_fn(id) { ret id; }
def_upvar(id, _) { ret id; }
}
}
// This is used because same-named variables in alternative patterns need to
// use the node_id of their namesake in the first pattern.
fn pat_id_map(pat: &@pat) -> pat_id_map {
let map = std::map::new_str_hash::<node_id>();
for each bound in pat_bindings(pat) {
let name = alt bound.node { pat_bind(n) { n } };
map.insert(name, bound.id);
}
ret map;
}
// FIXME: could return a constrained type
iter pat_bindings(pat: &@pat) -> @pat {
alt pat.node {
pat_bind(_) { put pat; }
pat_tag(_, sub) {
for p in sub { for each b in pat_bindings(p) { put b; } }
}
pat_rec(fields, _) {
for f in fields { for each b in pat_bindings(f.pat) { put b; } }
}
pat_tup(elts) {
for elt in elts { for each b in pat_bindings(elt) { put b; } }
}
pat_box(sub) { for each b in pat_bindings(sub) { put b; } }
pat_wild. | pat_lit(_) { }
}
}
fn pat_binding_ids(pat: &@pat) -> [node_id] {
let found = [];
for each b in pat_bindings(pat) { found += [b.id]; }
ret found;
}
fn binop_to_str(op: binop) -> str {
alt op {
add. { ret "+"; }
sub. { ret "-"; }
mul. { ret "*"; }
div. { ret "/"; }
rem. { ret "%"; }
and. { ret "&&"; }
or. { ret "||"; }
bitxor. { ret "^"; }
bitand. { ret "&"; }
bitor. { ret "|"; }
lsl. { ret "<<"; }
lsr. { ret ">>"; }
asr. { ret ">>>"; }
eq. { ret "=="; }
lt. { ret "<"; }
le. { ret "<="; }
ne. { ret "!="; }
ge. { ret ">="; }
gt. { ret ">"; }
}
}
pred lazy_binop(b: binop) -> bool {
alt b { and. { true } or. { true } _ { false } }
}
fn unop_to_str(op: unop) -> str {
alt op {
box(mt) { if mt == mut { ret "@mutable "; } ret "@"; }
deref. { ret "*"; }
not. { ret "!"; }
neg. { ret "-"; }
}
}
fn is_path(e: &@expr) -> bool {
ret alt e.node { expr_path(_) { true } _ { false } };
}
fn ty_mach_to_str(tm: ty_mach) -> str {
alt tm {
ty_u8. { ret "u8"; }
ty_u16. { ret "u16"; }
ty_u32. { ret "u32"; }
ty_u64. { ret "u64"; }
ty_i8. { ret "i8"; }
ty_i16. { ret "i16"; }
ty_i32. { ret "i32"; }
ty_i64. { ret "i64"; }
ty_f32. { ret "f32"; }
ty_f64. { ret "f64"; }
}
}
fn is_exported(i: ident, m: _mod) -> bool {
let nonlocal = true;
for it: @ast::item in m.items {
if it.ident == i { nonlocal = false; }
alt it.node {
item_tag(variants, _) {
for v: variant in variants {
if v.node.name == i { nonlocal = false; }
}
}
_ { }
}
if !nonlocal { break; }
}
let count = 0u;
for vi: @ast::view_item in m.view_items {
alt vi.node {
ast::view_item_export(ids, _) {
for id in ids { if str::eq(i, id) { ret true; } }
count += 1u;
}
_ {/* fall through */ }
}
}
// If there are no declared exports then
// everything not imported is exported
// even if it's nonlocal (since it's explicit)
ret count == 0u && !nonlocal;
}
fn is_call_expr(e: @expr) -> bool {
alt e.node { expr_call(_, _) { ret true; } _ { ret false; } }
}
fn is_constraint_arg(e: @expr) -> bool {
alt e.node {
expr_lit(_) { ret true; }
expr_path(_) { ret true; }
_ { ret false; }
}
}
fn eq_ty(a: &@ty, b: &@ty) -> bool { ret std::box::ptr_eq(a, b); }
fn hash_ty(t: &@ty) -> uint { ret t.span.lo << 16u + t.span.hi; }
fn block_from_expr(e: @expr) -> blk {
let blk_ = {stmts: [], expr: option::some::<@expr>(e), id: e.id};
ret {node: blk_, span: e.span};
}
fn obj_field_from_anon_obj_field(f: &anon_obj_field) -> obj_field {
ret {mut: f.mut, ty: f.ty, ident: f.ident, id: f.id};
}
// This is a convenience function to transfor ternary expressions to if
// expressions so that they can be treated the same
fn ternary_to_if(e: &@expr) -> @ast::expr {
alt e.node {
expr_ternary(cond, then, els) {
let then_blk = block_from_expr(then);
let els_blk = block_from_expr(els);
let els_expr =
@{id: els.id, node: expr_block(els_blk), span: els.span};
ret @{id: e.id,
node: expr_if(cond, then_blk, option::some(els_expr)),
span: e.span};
}
_ { fail; }
}
}

2
src/comp/syntax/ext/simplext.rs
View file

@ -16,7 +16,7 @@ import base::expr_to_ident;
import fold::*;
import ast::node_id;
import ast::respan;
import ast_util::respan;
import ast::ident;
import ast::path;
import ast::ty;

2
src/comp/syntax/parse/lexer.rs
View file

@ -78,7 +78,7 @@ fn new_reader(cm: &codemap::codemap, src: str, filemap: codemap::filemap,
fn get_col() -> uint { ret col; }
fn get_filemap() -> codemap::filemap { ret fm; }
fn err(m: str) {
codemap::emit_error(some(ast::mk_sp(chpos, chpos)), m, cm);
codemap::emit_error(some(ast_util::mk_sp(chpos, chpos)), m, cm);
}
}
let strs: [str] = [];

31
src/comp/syntax/parse/parser.rs
View file

@ -90,7 +90,7 @@ fn new_parser(sess: parse_sess, cfg: ast::crate_cfg, rdr: lexer::reader,
if vec::len(buffer) == 0u {
let next = lexer::next_token(rdr);
tok = next.tok;
tok_span = ast::mk_sp(next.chpos, rdr.get_chpos());
tok_span = ast_util::mk_sp(next.chpos, rdr.get_chpos());
} else {
let next = vec::pop(buffer);
tok = next.tok;
@ -99,12 +99,12 @@ fn new_parser(sess: parse_sess, cfg: ast::crate_cfg, rdr: lexer::reader,
}
fn swap(next: token::token, lo: uint, hi: uint) {
tok = next;
tok_span = ast::mk_sp(lo, hi);
tok_span = ast_util::mk_sp(lo, hi);
}
fn look_ahead(distance: uint) -> token::token {
while vec::len(buffer) < distance {
let next = lexer::next_token(rdr);
let sp = ast::mk_sp(next.chpos, rdr.get_chpos());
let sp = ast_util::mk_sp(next.chpos, rdr.get_chpos());
buffer = [{tok: next.tok, span: sp}] + buffer;
}
ret buffer[distance - 1u].tok;
@ -139,7 +139,7 @@ fn new_parser(sess: parse_sess, cfg: ast::crate_cfg, rdr: lexer::reader,
}
let tok0 = lexer::next_token(rdr);
let span0 = ast::mk_sp(tok0.chpos, rdr.get_chpos());
let span0 = ast_util::mk_sp(tok0.chpos, rdr.get_chpos());
ret stdio_parser(sess, cfg, ftype, tok0.tok, span0, span0, [],
UNRESTRICTED, rdr, prec_table(), bad_expr_word_table());
}
@ -223,7 +223,7 @@ fn expect_gt(p: &parser) {
}
fn spanned<T>(lo: uint, hi: uint, node: &T) -> spanned<T> {
ret {node: node, span: ast::mk_sp(lo, hi)};
ret {node: node, span: ast_util::mk_sp(lo, hi)};
}
fn parse_ident(p: &parser) -> ast::ident {
@ -792,13 +792,13 @@ fn parse_field(p: &parser, sep: &token::token) -> ast::field {
}
fn mk_expr(p: &parser, lo: uint, hi: uint, node: &ast::expr_) -> @ast::expr {
ret @{id: p.get_id(), node: node, span: ast::mk_sp(lo, hi)};
ret @{id: p.get_id(), node: node, span: ast_util::mk_sp(lo, hi)};
}
fn mk_mac_expr(p: &parser, lo: uint, hi: uint, m: &ast::mac_) -> @ast::expr {
ret @{id: p.get_id(),
node: ast::expr_mac({node: m, span: ast::mk_sp(lo, hi)}),
span: ast::mk_sp(lo, hi)};
node: ast::expr_mac({node: m, span: ast_util::mk_sp(lo, hi)}),
span: ast_util::mk_sp(lo, hi)};
}
fn parse_bottom_expr(p: &parser) -> @ast::expr {
@ -999,7 +999,7 @@ fn parse_bottom_expr(p: &parser) -> @ast::expr {
let e = parse_expr(p);
// FIXME: Is this the right place for this check?
if /*check*/ast::is_call_expr(e) {
if /*check*/ast_util::is_call_expr(e) {
hi = e.span.hi;
ex = ast::expr_be(e);
} else { p.fatal("Non-call expression in tail call"); }
@ -1460,7 +1460,7 @@ fn parse_pat(p: &parser) -> @ast::pat {
subpat =
@{id: p.get_id(),
node: ast::pat_bind(fieldname),
span: ast::mk_sp(lo, hi)};
span: ast_util::mk_sp(lo, hi)};
}
fields += [{ident: fieldname, pat: subpat}];
}
@ -1474,7 +1474,8 @@ fn parse_pat(p: &parser) -> @ast::pat {
hi = p.get_hi_pos();
p.bump();
pat =
ast::pat_lit(@{node: ast::lit_nil, span: ast::mk_sp(lo, hi)});
ast::pat_lit(@{node: ast::lit_nil,
span: ast_util::mk_sp(lo, hi)});
} else {
let fields = [parse_pat(p)];
while p.peek() == token::COMMA {
@ -1520,7 +1521,7 @@ fn parse_pat(p: &parser) -> @ast::pat {
}
}
}
ret @{id: p.get_id(), node: pat, span: ast::mk_sp(lo, hi)};
ret @{id: p.get_id(), node: pat, span: ast_util::mk_sp(lo, hi)};
}
fn parse_local(p: &parser, allow_init: bool) -> @ast::local {
@ -1808,7 +1809,7 @@ fn mk_item(p: &parser, lo: uint, hi: uint, ident: &ast::ident,
attrs: attrs,
id: p.get_id(),
node: node,
span: ast::mk_sp(lo, hi)};
span: ast_util::mk_sp(lo, hi)};
}
fn parse_item_fn_or_iter(p: &parser, purity: ast::purity, proto: ast::proto,
@ -1945,7 +1946,7 @@ fn parse_item_native_type(p: &parser, attrs: &[ast::attribute]) ->
attrs: attrs,
node: ast::native_item_ty,
id: p.get_id(),
span: ast::mk_sp(t.lo, hi)};
span: ast_util::mk_sp(t.lo, hi)};
}
fn parse_item_native_fn(p: &parser, attrs: &[ast::attribute]) ->
@ -1961,7 +1962,7 @@ fn parse_item_native_fn(p: &parser, attrs: &[ast::attribute]) ->
attrs: attrs,
node: ast::native_item_fn(link_name, decl, t.tps),
id: p.get_id(),
span: ast::mk_sp(lo, hi)};
span: ast_util::mk_sp(lo, hi)};
}
fn parse_native_item(p: &parser, attrs: &[ast::attribute]) ->

2
src/comp/syntax/parse/token.rs
View file

@ -1,6 +1,6 @@
import ast::ty_mach;
import ast::ty_mach_to_str;
import ast_util::ty_mach_to_str;
import std::map::new_str_hash;
import util::interner;
import std::int;

13
src/comp/syntax/print/pprust.rs
View file

@ -9,6 +9,7 @@ import parse::lexer;
import syntax::codemap::codemap;
import syntax::visit;
import ast;
import ast_util;
import option::some;
import option::none;
import pp::printer;
@ -271,7 +272,7 @@ fn print_type(s: &ps, ty: &@ast::ty) {
ast::ty_int. { word(s.s, "int"); }
ast::ty_uint. { word(s.s, "uint"); }
ast::ty_float. { word(s.s, "float"); }
ast::ty_machine(tm) { word(s.s, ast::ty_mach_to_str(tm)); }
ast::ty_machine(tm) { word(s.s, ast_util::ty_mach_to_str(tm)); }
ast::ty_char. { word(s.s, "char"); }
ast::ty_str. { word(s.s, "str"); }
ast::ty_istr. { word(s.s, "istr"); }
@ -831,11 +832,11 @@ fn print_expr(s: &ps, expr: &@ast::expr) {
let prec = operator_prec(op);
print_maybe_parens(s, lhs, prec);
space(s.s);
word_space(s, ast::binop_to_str(op));
word_space(s, ast_util::binop_to_str(op));
print_maybe_parens(s, rhs, prec + 1);
}
ast::expr_unary(op, expr) {
word(s.s, ast::unop_to_str(op));
word(s.s, ast_util::unop_to_str(op));
print_maybe_parens(s, expr, parse::parser::unop_prec);
}
ast::expr_lit(lit) { print_literal(s, lit); }
@ -967,7 +968,7 @@ fn print_expr(s: &ps, expr: &@ast::expr) {
ast::expr_assign_op(op, lhs, rhs) {
print_expr(s, lhs);
space(s.s);
word(s.s, ast::binop_to_str(op));
word(s.s, ast_util::binop_to_str(op));
word_space(s, "=");
print_expr(s, rhs);
}
@ -1486,12 +1487,12 @@ fn print_literal(s: &ps, lit: &@ast::lit) {
ast::lit_float(fstr) { word(s.s, fstr); }
ast::lit_mach_int(mach, val) {
word(s.s, int::str(val as int));
word(s.s, ast::ty_mach_to_str(mach));
word(s.s, ast_util::ty_mach_to_str(mach));
}
ast::lit_mach_float(mach, val) {
// val is already a str
word(s.s, val);
word(s.s, ast::ty_mach_to_str(mach));
word(s.s, ast_util::ty_mach_to_str(mach));
}
ast::lit_nil. { word(s.s, "()"); }
ast::lit_bool(val) {

2
src/comp/util/ppaux.rs
View file

@ -16,7 +16,7 @@ import pp::word;
import pp::eof;
import pp::zerobreak;
import pp::hardbreak;
import ast::ty_mach_to_str;
import syntax::ast_util::ty_mach_to_str;
import syntax::ast;
import middle::ast_map;
import metadata::csearch;