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

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

7 files changed, 235 insertions, 227 deletions

diff --git a/src/comp/syntax/ast.rs b/src/comp/syntax/ast.rs
index 5c3ec015e5a..ec38c349ce3 100644
--- a/src/comp/syntax/ast.rs
+++ b/src/comp/syntax/ast.rs
@@ -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
diff --git a/src/comp/syntax/ast_util.rs b/src/comp/syntax/ast_util.rs
new file mode 100644
index 00000000000..e3b16702b76
--- /dev/null
+++ b/src/comp/syntax/ast_util.rs
@@ -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; }
+    }
+}
diff --git a/src/comp/syntax/ext/simplext.rs b/src/comp/syntax/ext/simplext.rs
index e5dd343203a..fb4402732ae 100644
--- a/src/comp/syntax/ext/simplext.rs
+++ b/src/comp/syntax/ext/simplext.rs
@@ -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;
diff --git a/src/comp/syntax/parse/lexer.rs b/src/comp/syntax/parse/lexer.rs
index 6e4cc10abb7..c39cd75db3b 100644
--- a/src/comp/syntax/parse/lexer.rs
+++ b/src/comp/syntax/parse/lexer.rs
@@ -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] = [];
diff --git a/src/comp/syntax/parse/parser.rs b/src/comp/syntax/parse/parser.rs
index b20c7905013..527f6927010 100644
--- a/src/comp/syntax/parse/parser.rs
+++ b/src/comp/syntax/parse/parser.rs
@@ -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]) ->
diff --git a/src/comp/syntax/parse/token.rs b/src/comp/syntax/parse/token.rs
index c974dc915c4..cf20e0a328e 100644
--- a/src/comp/syntax/parse/token.rs
+++ b/src/comp/syntax/parse/token.rs
@@ -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;
diff --git a/src/comp/syntax/print/pprust.rs b/src/comp/syntax/print/pprust.rs
index 8ecbfd58405..f0848fbdce5 100644
--- a/src/comp/syntax/print/pprust.rs
+++ b/src/comp/syntax/print/pprust.rs
@@ -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) {