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

This leaves syntax::ast just defining the AST, which strikes me as somewhat
nicer

Author: brson

src/comp/front/attr.rs

@@ -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 {

src/comp/front/test.rs

@@ -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,15 +163,15 @@ 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)];
 
     ret @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,15 +272,15 @@ 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});
 
     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;
 }

src/comp/metadata/creader.rs

@@ -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);
         }

src/comp/metadata/decoder.rs

@@ -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. { }

src/comp/metadata/encoder.rs

@@ -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);

src/comp/metadata/tydecode.rs

@@ -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;

src/comp/middle/alias.rs

@@ -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; }
     }

src/comp/middle/ast_map.rs

@@ -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);
     }