Consolidate formatting functions a bit more.

7 files changed, 132 insertions, 209 deletions

diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs
index a6d8560ee67..a8da7294928 100644
--- a/src/comp/front/parser.rs
+++ b/src/comp/front/parser.rs
@@ -1597,7 +1597,7 @@ fn stmt_to_expr(@ast::stmt stmt) -> option::t[@ast::expr] {
     ret none[@ast::expr];
 }
 
-fn stmt_ends_with_semi(@ast::stmt stmt) -> bool {
+fn stmt_ends_with_semi(&ast::stmt stmt) -> bool {
     alt (stmt.node) {
         case (ast::stmt_decl(?d,_)) {
             alt (d.node) {
@@ -1675,7 +1675,7 @@ fn parse_block(&parser p) -> ast::block {
                             }
                             case (token::RBRACE) { expr = some(e); }
                             case (?t) {
-                                if (stmt_ends_with_semi(stmt)) {
+                                if (stmt_ends_with_semi(*stmt)) {
                                     p.err("expected ';' or '}' after " +
                                           "expression but found " +
                                           token::to_str(p.get_reader(), t));
@@ -1692,7 +1692,7 @@ fn parse_block(&parser p) -> ast::block {
                         // used in branches and binary expressions in rustboot
                         // means we cannot use && here. I know, right?
                         if (p.get_file_type() == SOURCE_FILE) {
-                            if (stmt_ends_with_semi(stmt)) {
+                            if (stmt_ends_with_semi(*stmt)) {
                                 expect(p, token::SEMI);
                             }
                         }
diff --git a/src/comp/middle/trans.rs b/src/comp/middle/trans.rs
index 625db8d4c71..eb44641b311 100644
--- a/src/comp/middle/trans.rs
+++ b/src/comp/middle/trans.rs
@@ -4642,8 +4642,8 @@ fn trans_lval(&@block_ctxt cx, &@ast::expr e) -> lval_result {
         }
         case (_) {
             cx.fcx.lcx.ccx.sess.span_unimpl(e.span,
-                                            "expr variant in trans_lval: " 
-                                            + util::common::expr_to_str(e));
+                                            "expr variant in trans_lval: "
+                                            + pretty::pprust::expr_to_str(e));
         }
     }
     fail;
@@ -5784,7 +5784,7 @@ fn trans_log(int lvl, &@block_ctxt cx, &@ast::expr e) -> result {
 fn trans_check_expr(&@block_ctxt cx, &@ast::expr e) -> result {
     auto cond_res = trans_expr(cx, e);
 
-    auto expr_str = util::common::expr_to_str(e);
+    auto expr_str = pretty::pprust::expr_to_str(e);
     auto fail_cx = new_sub_block_ctxt(cx, "fail");
     auto fail_res = trans_fail(fail_cx, some[common::span](e.span), expr_str);
 
@@ -6004,9 +6004,9 @@ fn trans_spawn(&@block_ctxt cx,
     // Make the task name
     auto tname = alt(name) {
         case(none) {
-            auto argss = vec::map(common::expr_to_str, args);
+            auto argss = vec::map(pretty::pprust::expr_to_str, args);
             #fmt("%s(%s)",
-                 common::expr_to_str(func),
+                 pretty::pprust::expr_to_str(func),
                  str::connect(argss, ", "))
         }
         case(some(?n)) {
diff --git a/src/comp/middle/tstate/ck.rs b/src/comp/middle/tstate/ck.rs
index 1aa7b24b47f..02da5d01bc8 100644
--- a/src/comp/middle/tstate/ck.rs
+++ b/src/comp/middle/tstate/ck.rs
@@ -55,7 +55,7 @@ import aux::fixed_point_states;
 import aux::bitv_to_str;
 import aux::first_difference_string;
 
-import util::common::ty_to_str;
+import pretty::pprust::ty_to_str;
 import util::common::log_stmt_err;
 import aux::log_bitv_err;
 import bitvectors::promises;
@@ -74,7 +74,7 @@ fn check_states_expr(&fn_ctxt fcx, @expr e) -> () {
         auto diff = first_difference_string(fcx, prec, pres);
         s += ("Unsatisfied precondition constraint (for example, "
               + diff + ") for expression:\n");
-        s += util::common::expr_to_str(e);
+        s += pretty::pprust::expr_to_str(e);
         s += ("\nPrecondition:\n");
         s += bitv_to_str(fcx, prec);
         s += ("\nPrestate:\n");
@@ -102,7 +102,7 @@ fn check_states_stmt(&fn_ctxt fcx, &stmt s) -> () {
         auto diff = first_difference_string(fcx, prec, pres);
         ss += ("Unsatisfied precondition constraint (for example, "
               + diff + ") for statement:\n");
-        ss += util::common::stmt_to_str(s);
+        ss += pretty::pprust::stmt_to_str(s);
         ss += ("\nPrecondition:\n");
         ss += bitv_to_str(fcx, prec);
         ss += ("\nPrestate: \n");
diff --git a/src/comp/middle/ty.rs b/src/comp/middle/ty.rs
index 892d444c7b4..38283d1f754 100644
--- a/src/comp/middle/ty.rs
+++ b/src/comp/middle/ty.rs
@@ -513,7 +513,9 @@ fn cname(&ctxt cx, &t typ) -> option::t[str] {
 fn path_to_str(&ast::path pth) -> str {
     auto result = str::connect(pth.node.idents,  "::");
     if (vec::len[@ast::ty](pth.node.types) > 0u) {
-        auto f = pretty::pprust::ty_to_str;
+        fn f(&@ast::ty t) -> str {
+            ret pretty::pprust::ty_to_str(*t);
+        }
         result += "[";
         result += str::connect(vec::map(f, pth.node.types), ",");
         result += "]";
diff --git a/src/comp/middle/typeck.rs b/src/comp/middle/typeck.rs
index 1be5472257e..d0bf818b827 100644
--- a/src/comp/middle/typeck.rs
+++ b/src/comp/middle/typeck.rs
@@ -1517,7 +1517,7 @@ mod pushdown {
             case (_) {
                 scx.fcx.ccx.tcx.sess.span_unimpl(e.span,
                     #fmt("type unification for expression variant: %s",
-                         util::common::expr_to_str(e)));
+                         pretty::pprust::expr_to_str(e)));
                 fail;
             }
         }
@@ -1803,7 +1803,7 @@ fn require_pure_function(@crate_ctxt ccx, &ast::def_id d_id, &span sp) -> () {
 
 fn check_expr(&@stmt_ctxt scx, &@ast::expr expr) {
     // scx.fcx.ccx.tcx.sess.span_warn(expr.span, "typechecking expr " +
-    //                                util::common::expr_to_str(expr));
+    //                                pretty::pprust::expr_to_str(expr));
 
     // A generic function to factor out common logic from call and bind
     // expressions.
diff --git a/src/comp/pretty/pprust.rs b/src/comp/pretty/pprust.rs
index 10940c29661..104beee7db4 100644
--- a/src/comp/pretty/pprust.rs
+++ b/src/comp/pretty/pprust.rs
@@ -41,6 +41,22 @@ type ps = @rec(pp::printer s,
                mutable uint cur_cmnt,
                mode mode);
 
+fn rust_printer(io::writer writer) -> ps {
+    ret @rec(s=pp::mk_printer(writer, default_columns),
+             cm=option::none[codemap],
+             comments=option::none[vec[lexer::cmnt]],
+             mutable cur_cmnt=0u,
+             mode=mo_untyped);
+}
+
+fn to_str[T](&T t, fn(&ps s, &T s) f) -> str {
+    auto writer = io::string_writer();
+    auto s = rust_printer(writer.get_writer());
+    f(s, t);
+    eof(s.s);
+    ret writer.get_str();
+}
+
 fn print_file(session sess, ast::_mod _mod, str filename, io::writer out,
               mode mode) {
     auto cmnts = lexer::gather_comments(sess, filename);
@@ -53,25 +69,24 @@ fn print_file(session sess, ast::_mod _mod, str filename, io::writer out,
     eof(s.s);
 }
 
-fn ty_to_str(&@ast::ty ty) -> str {
+fn ty_to_str(&ast::ty ty) -> str { be to_str(ty, print_type); }
+fn pat_to_str(&@ast::pat ty) -> str { be to_str(ty, print_pat); }
+fn expr_to_str(&@ast::expr ty) -> str { be to_str(ty, print_expr); }
+fn stmt_to_str(&ast::stmt ty) -> str { be to_str(ty, print_stmt); }
+fn item_to_str(&@ast::item ty) -> str { be to_str(ty, print_item); }
+
+fn fun_to_str(&ast::_fn f, str name, vec[ast::ty_param] params) -> str {
     auto writer = io::string_writer();
-    auto s = @rec(s=pp::mk_printer(writer.get_writer(), default_columns),
-                  cm=option::none[codemap],
-                  comments=option::none[vec[lexer::cmnt]],
-                  mutable cur_cmnt=0u,
-                  mode=mo_untyped);
-    print_type(s, ty);
+    auto s = rust_printer(writer.get_writer());
+    print_fn(s, f.decl, name, params);
     eof(s.s);
     ret writer.get_str();
 }
 
 fn block_to_str(&ast::block blk) -> str {
     auto writer = io::string_writer();
-    auto s = @rec(s=pp::mk_printer(writer.get_writer(), default_columns),
-                  cm=option::none[codemap],
-                  comments=option::none[vec[lexer::cmnt]],
-                  mutable cur_cmnt=0u,
-                  mode=mo_untyped);
+    auto s = rust_printer(writer.get_writer());
+
     // containing cbox, will be closed by print-block at }
     cbox(s.s, indent_unit);
 
@@ -82,37 +97,25 @@ fn block_to_str(&ast::block blk) -> str {
     ret writer.get_str();
 }
 
-fn pat_to_str(&@ast::pat p) -> str {
-    auto writer = io::string_writer();
-    auto s = @rec(s=pp::mk_printer(writer.get_writer(), default_columns),
-                  cm=option::none[codemap],
-                  comments=option::none[vec[lexer::cmnt]],
-                  mutable cur_cmnt=0u,
-                  mode=mo_untyped);
-    print_pat(s, p);
-    eof(s.s);
-    ret writer.get_str();
-}
-
-fn word_nbsp(ps s, str w) {
+fn word_nbsp(&ps s, str w) {
     word(s.s, w);
     word(s.s, " ");
 }
 
-fn word_space(ps s, str w) {
+fn word_space(&ps s, str w) {
     word(s.s, w);
     space(s.s);
 }
 
-fn popen(ps s) {
+fn popen(&ps s) {
     word(s.s, "(");
 }
 
-fn pclose(ps s) {
+fn pclose(&ps s) {
     word(s.s, ")");
 }
 
-fn head(ps s, str w) {
+fn head(&ps s, str w) {
     // outer-box is consistent
     cbox(s.s, indent_unit);
     // head-box is inconsistent
@@ -121,19 +124,19 @@ fn head(ps s, str w) {
     word_nbsp(s, w);
 }
 
-fn bopen(ps s) {
+fn bopen(&ps s) {
     word(s.s, "{");
     end(s.s); // close the head-box
 }
 
-fn bclose(ps s, common::span span) {
+fn bclose(&ps s, common::span span) {
     maybe_print_comment(s, span.hi);
     break_offset(s.s, 1u, -(indent_unit as int));
     word(s.s, "}");
     end(s.s); // close the outer-box
 }
 
-fn commasep[IN](ps s, breaks b, vec[IN] elts, fn(ps, &IN) op) {
+fn commasep[IN](&ps s, breaks b, vec[IN] elts, fn(&ps, &IN) op) {
     box(s.s, 0u, b);
     auto first = true;
     for (IN elt in elts) {
@@ -144,7 +147,7 @@ fn commasep[IN](ps s, breaks b, vec[IN] elts, fn(ps, &IN) op) {
     end(s.s);
 }
 
-fn commasep_cmnt[IN](ps s, breaks b, vec[IN] elts, fn(ps, &IN) op,
+fn commasep_cmnt[IN](&ps s, breaks b, vec[IN] elts, fn(&ps, &IN) op,
                      fn(&IN) -> common::span get_span) {
     box(s.s, 0u, b);
     auto len = vec::len[IN](elts);
@@ -162,14 +165,14 @@ fn commasep_cmnt[IN](ps s, breaks b, vec[IN] elts, fn(ps, &IN) op,
     end(s.s);
 }
 
-fn commasep_exprs(ps s, breaks b, vec[@ast::expr] exprs) {
+fn commasep_exprs(&ps s, breaks b, vec[@ast::expr] exprs) {
     fn expr_span(&@ast::expr expr) -> common::span {ret expr.span;}
     auto f = print_expr;
     auto gs = expr_span;
     commasep_cmnt[@ast::expr](s, b, exprs, f, gs);
 }
 
-fn print_mod(ps s, ast::_mod _mod) {
+fn print_mod(&ps s, ast::_mod _mod) {
     for (@ast::view_item vitem in _mod.view_items) {
         print_view_item(s, vitem);
     }
@@ -181,7 +184,8 @@ fn print_mod(ps s, ast::_mod _mod) {
     print_remaining_comments(s);
 }
 
-fn print_type(ps s, &@ast::ty ty) {
+fn print_boxed_type(&ps s, &@ast::ty ty) { print_type(s, *ty); }
+fn print_type(&ps s, &ast::ty ty) {
 
     maybe_print_comment(s, ty.span.lo);
     ibox(s.s, 0u);
@@ -200,10 +204,10 @@ fn print_type(ps s, &@ast::ty ty) {
             word(s.s, "vec["); print_mt(s, mt); word(s.s, "]");
         }
         case (ast::ty_port(?t)) {
-            word(s.s, "port["); print_type(s, t); word(s.s, "]");
+            word(s.s, "port["); print_type(s, *t); word(s.s, "]");
         }
         case (ast::ty_chan(?t)) {
-            word(s.s, "chan["); print_type(s, t); word(s.s, "]");
+            word(s.s, "chan["); print_type(s, *t); word(s.s, "]");
         }
         case (ast::ty_type) {word(s.s, "type");}
         case (ast::ty_tup(?elts)) {
@@ -216,7 +220,7 @@ fn print_type(ps s, &@ast::ty ty) {
         case (ast::ty_rec(?fields)) {
             word(s.s, "rec");
             popen(s);
-            fn print_field(ps s, &ast::ty_field f) {
+            fn print_field(&ps s, &ast::ty_field f) {
                 cbox(s.s, indent_unit);
                 print_mt(s, f.mt);
                 space(s.s);
@@ -257,14 +261,14 @@ fn print_type(ps s, &@ast::ty ty) {
     end(s.s);
 }
 
-fn print_item(ps s, @ast::item item) {
+fn print_item(&ps s, &@ast::item item) {
 
     hardbreak(s.s);
     maybe_print_comment(s, item.span.lo);
     alt (item.node) {
         case (ast::item_const(?id, ?ty, ?expr, _, _)) {
             head(s, "const");
-            print_type(s, ty);
+            print_type(s, *ty);
             space(s.s);
             word_space(s, id);
             end(s.s); // end the head-ibox
@@ -330,7 +334,7 @@ fn print_item(ps s, @ast::item item) {
             end(s.s); // end the inner ibox
             space(s.s);
             word_space(s, "=");
-            print_type(s, ty);
+            print_type(s, *ty);
             word(s.s, ";");
             end(s.s); // end the outer ibox
             break_offset(s.s, 0u, 0);
@@ -347,8 +351,8 @@ fn print_item(ps s, @ast::item item) {
                 word(s.s, v.node.name);
                 if (vec::len[ast::variant_arg](v.node.args) > 0u) {
                     popen(s);
-                    fn print_variant_arg(ps s, &ast::variant_arg arg) {
-                        print_type(s, arg.ty);
+                    fn print_variant_arg(&ps s, &ast::variant_arg arg) {
+                        print_type(s, *arg.ty);
                     }
                     auto f = print_variant_arg;
                     commasep[ast::variant_arg](s, consistent, v.node.args, f);
@@ -364,9 +368,9 @@ fn print_item(ps s, @ast::item item) {
             word(s.s, id);
             print_type_params(s, params);
             popen(s);
-            fn print_field(ps s, &ast::obj_field field) {
+            fn print_field(&ps s, &ast::obj_field field) {
                 ibox(s.s, indent_unit);
-                print_type(s, field.ty);
+                print_type(s, *field.ty);
                 space(s.s);
                 word(s.s, field.ident);
                 end(s.s);
@@ -398,23 +402,28 @@ fn print_item(ps s, @ast::item item) {
     }
 }
 
-fn print_block(ps s, ast::block blk) {
+fn print_stmt(&ps s, &ast::stmt st) {
+    maybe_print_comment(s, st.span.lo);
+    alt (st.node) {
+        case (ast::stmt_decl(?decl,_)) {
+            print_decl(s, decl);
+        }
+        case (ast::stmt_expr(?expr,_)) {
+            space(s.s);
+            print_expr(s, expr);
+        }
+    }
+    if (front::parser::stmt_ends_with_semi(st)) {word(s.s, ";");}
+    maybe_print_trailing_comment(s, st.span);
+}
+
+fn print_block(&ps s, ast::block blk) {
     maybe_print_comment(s, blk.span.lo);
     bopen(s);
     auto first = true;
     for (@ast::stmt st in blk.node.stmts) {
-        maybe_print_comment(s, st.span.lo);
-        alt (st.node) {
-          case (ast::stmt_decl(?decl,_)) {
-              print_decl(s, decl);
-          }
-          case (ast::stmt_expr(?expr,_)) {
-              space(s.s);
-              print_expr(s, expr);
-          }
-        }
-        if (front::parser::stmt_ends_with_semi(st)) {word(s.s, ";");}
-        maybe_print_trailing_comment(s, st.span);
+        print_stmt(s, *st)
+
     }
     alt (blk.node.expr) {
         case (option::some[@ast::expr](?expr)) {
@@ -427,7 +436,7 @@ fn print_block(ps s, ast::block blk) {
     bclose(s, blk.span);
 }
 
-fn print_literal(ps s, @ast::lit lit) {
+fn print_literal(&ps s, &@ast::lit lit) {
     maybe_print_comment(s, lit.span.lo);
     alt (lit.node) {
         case (ast::lit_str(?st)) {print_string(s, st);}
@@ -460,7 +469,7 @@ fn print_literal(ps s, @ast::lit lit) {
     }
 }
 
-fn print_expr(ps s, &@ast::expr expr) {
+fn print_expr(&ps s, &@ast::expr expr) {
     maybe_print_comment(s, expr.span.lo);
     ibox(s.s, indent_unit);
 
@@ -481,7 +490,7 @@ fn print_expr(ps s, &@ast::expr expr) {
             end(s.s);
         }
         case (ast::expr_tup(?exprs,_)) {
-            fn printElt(ps s, &ast::elt elt) {
+            fn printElt(&ps s, &ast::elt elt) {
                 ibox(s.s, indent_unit);
                 if (elt.mut == ast::mut) {word_nbsp(s, "mutable");}
                 print_expr(s, elt.expr);
@@ -496,7 +505,7 @@ fn print_expr(ps s, &@ast::expr expr) {
             pclose(s);
         }
         case (ast::expr_rec(?fields,?wth,_)) {
-            fn print_field(ps s, &ast::field field) {
+            fn print_field(&ps s, &ast::field field) {
                 ibox(s.s, indent_unit);
                 if (field.node.mut == ast::mut) {word_nbsp(s, "mutable");}
                 word(s.s, field.node.ident);
@@ -535,7 +544,7 @@ fn print_expr(ps s, &@ast::expr expr) {
             print_ident(s, ident);
         }
         case (ast::expr_bind(?func,?args,_)) {
-            fn print_opt(ps s, &option::t[@ast::expr] expr) {
+            fn print_opt(&ps s, &option::t[@ast::expr] expr) {
                 alt (expr) {
                     case (option::some[@ast::expr](?expr)) {
                         print_expr(s, expr);
@@ -575,7 +584,7 @@ fn print_expr(ps s, &@ast::expr expr) {
             print_maybe_parens(s, expr, front::parser::as_prec);
             space(s.s);
             word_space(s, "as");
-            print_type(s, ty);
+            print_type(s, *ty);
         }
         case (ast::expr_if(?test,?block,?elseopt,_)) {
             head(s, "if");
@@ -802,7 +811,7 @@ fn print_expr(ps s, &@ast::expr expr) {
     end(s.s);
 }
 
-fn print_decl(ps s, @ast::decl decl) {
+fn print_decl(&ps s, &@ast::decl decl) {
     maybe_print_comment(s, decl.span.lo);
     alt (decl.node) {
         case (ast::decl_local(?loc)) {
@@ -811,7 +820,7 @@ fn print_decl(ps s, @ast::decl decl) {
             alt (loc.ty) {
                 case (option::some[@ast::ty](?ty)) {
                     word_nbsp(s, "let");
-                    print_type(s, ty);
+                    print_type(s, *ty);
                     space(s.s);
                 }
                 case (_) {
@@ -852,21 +861,21 @@ fn print_decl(ps s, @ast::decl decl) {
     }
 }
 
-fn print_ident(ps s, ast::ident ident) {
+fn print_ident(&ps s, &ast::ident ident) {
     word(s.s, ident);
 }
 
-fn print_for_decl(ps s, @ast::decl decl) {
+fn print_for_decl(&ps s, @ast::decl decl) {
     alt (decl.node) {
         case (ast::decl_local(?loc)) {
-            print_type(s, option::get[@ast::ty](loc.ty));
+            print_type(s, *option::get[@ast::ty](loc.ty));
             space(s.s);
             word(s.s, loc.ident);
         }
     }
 }
 
-fn print_path(ps s, ast::path path) {
+fn print_path(&ps s, &ast::path path) {
     maybe_print_comment(s, path.span.lo);
     auto first = true;
     for (str id in path.node.idents) {
@@ -876,13 +885,13 @@ fn print_path(ps s, ast::path path) {
     }
     if (vec::len[@ast::ty](path.node.types) > 0u) {
         word(s.s, "[");
-        auto f = print_type;
+        auto f = print_boxed_type;
         commasep[@ast::ty](s, inconsistent, path.node.types, f);
         word(s.s, "]");
     }
 }
 
-fn print_pat(ps s, &@ast::pat pat) {
+fn print_pat(&ps s, &@ast::pat pat) {
     maybe_print_comment(s, pat.span.lo);
     alt (pat.node) {
         case (ast::pat_wild(_)) {word(s.s, "_");}
@@ -900,8 +909,8 @@ fn print_pat(ps s, &@ast::pat pat) {
     }
 }
 
-fn print_fn(ps s, ast::fn_decl decl, str name,
-                   vec[ast::ty_param] typarams) {
+fn print_fn(&ps s, ast::fn_decl decl, str name,
+            vec[ast::ty_param] typarams) {
     alt (decl.purity) {
         case (ast::impure_fn) {
             head(s, "fn");
@@ -913,10 +922,10 @@ fn print_fn(ps s, ast::fn_decl decl, str name,
     word(s.s, name);
     print_type_params(s, typarams);
     popen(s);
-    fn print_arg(ps s, &ast::arg x) {
+    fn print_arg(&ps s, &ast::arg x) {
         ibox(s.s, indent_unit);
         if (x.mode == ast::alias) {word(s.s, "&");}
-        print_type(s, x.ty);
+        print_type(s, *x.ty);
         space(s.s);
         word(s.s, x.ident);
         end(s.s);
@@ -928,14 +937,14 @@ fn print_fn(ps s, ast::fn_decl decl, str name,
     if (decl.output.node != ast::ty_nil) {
         space(s.s);
         word_space(s, "->");
-        print_type(s, decl.output);
+        print_type(s, *decl.output);
     }
 }
 
-fn print_type_params(ps s, vec[ast::ty_param] params) {
+fn print_type_params(&ps s, &vec[ast::ty_param] params) {
     if (vec::len[ast::ty_param](params) > 0u) {
         word(s.s, "[");
-        fn printParam(ps s, &ast::ty_param param) {
+        fn printParam(&ps s, &ast::ty_param param) {
             word(s.s, param);
         }
         auto f = printParam;
@@ -944,7 +953,7 @@ fn print_type_params(ps s, vec[ast::ty_param] params) {
     }
 }
 
-fn print_view_item(ps s, @ast::view_item item) {
+fn print_view_item(&ps s, &@ast::view_item item) {
     hardbreak(s.s);
     maybe_print_comment(s, item.span.lo);
     alt (item.node) {
@@ -953,7 +962,7 @@ fn print_view_item(ps s, @ast::view_item item) {
             word(s.s, id);
             if (vec::len[@ast::meta_item](mta) > 0u) {
                 popen(s);
-                fn print_meta(ps s, &@ast::meta_item item) {
+                fn print_meta(&ps s, &@ast::meta_item item) {
                     ibox(s.s, indent_unit);
                     word_space(s, item.node.name);
                     word_space(s, "=");
@@ -997,7 +1006,7 @@ fn operator_prec(ast::binop op) -> int {
     fail;
 }
 
-fn print_maybe_parens(ps s, @ast::expr expr, int outer_prec) {
+fn print_maybe_parens(&ps s, &@ast::expr expr, int outer_prec) {
     auto add_them;
     alt (expr.node) {
         case (ast::expr_binary(?op,_,_,_)) {
@@ -1036,22 +1045,22 @@ fn escape_str(str st, char to_escape) -> str {
     ret out;
 }
 
-fn print_mt(ps s, &ast::mt mt) {
+fn print_mt(&ps s, &ast::mt mt) {
     alt (mt.mut) {
         case (ast::mut)       { word_nbsp(s, "mutable");  }
         case (ast::maybe_mut) { word_nbsp(s, "mutable?"); }
         case (ast::imm)       { /* nothing */        }
     }
-    print_type(s, mt.ty);
+    print_type(s, *mt.ty);
 }
 
-fn print_string(ps s, str st) {
+fn print_string(&ps s, &str st) {
     word(s.s, "\""); word(s.s, escape_str(st, '"')); word(s.s, "\"");
 }
 
-fn print_ty_fn(ps s, ast::proto proto, option::t[str] id,
-               vec[ast::ty_arg] inputs, @ast::ty output,
-               ast::controlflow cf) {
+fn print_ty_fn(&ps s, &ast::proto proto, &option::t[str] id,
+               &vec[ast::ty_arg] inputs, &@ast::ty output,
+               &ast::controlflow cf) {
     ibox(s.s, indent_unit);
     if (proto == ast::proto_fn) {word(s.s, "fn");}
     else {word(s.s, "iter");}
@@ -1060,9 +1069,9 @@ fn print_ty_fn(ps s, ast::proto proto, option::t[str] id,
         case (_) {}
     }
     popen(s);
-    fn print_arg(ps s, &ast::ty_arg input) {
+    fn print_arg(&ps s, &ast::ty_arg input) {
         if (input.mode == ast::alias) {word(s.s, "&");}
-        print_type(s, input.ty);
+        print_type(s, *input.ty);
     }
     auto f = print_arg;
     commasep[ast::ty_arg](s, inconsistent, inputs, f);
@@ -1074,7 +1083,7 @@ fn print_ty_fn(ps s, ast::proto proto, option::t[str] id,
         word_space(s, "->");
         alt (cf) {
             case (ast::return) {
-                print_type(s, output);
+                print_type(s, *output);
             }
             case (ast::noreturn) {
                 word_nbsp(s, "!");
@@ -1085,7 +1094,7 @@ fn print_ty_fn(ps s, ast::proto proto, option::t[str] id,
     end(s.s);
 }
 
-fn next_comment(ps s) -> option::t[lexer::cmnt] {
+fn next_comment(&ps s) -> option::t[lexer::cmnt] {
     alt (s.comments) {
         case (option::some[vec[lexer::cmnt]](?cmnts)) {
             if (s.cur_cmnt < vec::len[lexer::cmnt](cmnts)) {
@@ -1096,7 +1105,7 @@ fn next_comment(ps s) -> option::t[lexer::cmnt] {
     }
 }
 
-fn maybe_print_comment(ps s, uint pos) {
+fn maybe_print_comment(&ps s, uint pos) {
     auto first = true;
     while (true) {
         alt (next_comment(s)) {
@@ -1115,7 +1124,7 @@ fn maybe_print_comment(ps s, uint pos) {
     }
 }
 
-fn maybe_print_trailing_comment(ps s, common::span span) {
+fn maybe_print_trailing_comment(&ps s, common::span span) {
     auto cm;
     alt (s.cm) {
         case (option::some[codemap](?ccm)) {
@@ -1139,7 +1148,7 @@ fn maybe_print_trailing_comment(ps s, common::span span) {
     }
 }
 
-fn print_remaining_comments(ps s) {
+fn print_remaining_comments(&ps s) {
     while (true) {
         alt (next_comment(s)) {
             case (option::some[lexer::cmnt](?cmnt)) {
@@ -1151,7 +1160,7 @@ fn print_remaining_comments(ps s) {
     }
 }
 
-fn print_comment(ps s, lexer::cmnt cmnt) {
+fn print_comment(&ps s, lexer::cmnt cmnt) {
     alt (cmnt.style) {
         case (lexer::isolated) {
             hardbreak(s.s);
diff --git a/src/comp/util/common.rs b/src/comp/util/common.rs
index 4a63dfcffe7..a8e1046cc91 100644
--- a/src/comp/util/common.rs
+++ b/src/comp/util/common.rs
@@ -126,136 +126,48 @@ fn field_exprs(vec[ast::field] fields) -> vec [@ast::expr] {
     ret vec::map[ast::field, @ast::expr](f, fields);
 }
 
-fn expr_to_str(&@ast::expr e) -> str {
-  let str_writer s = string_writer();
-  auto out_ = mk_printer(s.get_writer(), 80u);
-  auto out = @rec(s=out_,
-                  cm=none[codemap],
-                  comments=none[vec[front::lexer::cmnt]],
-                  mutable cur_cmnt=0u,
-                  mode=mo_untyped);
-  print_expr(out, e);
-  pretty::pp::eof(out_);
-  ret s.get_str();
-}
-
-fn ty_to_str(&ty t) -> str {
-  let str_writer s = string_writer();
-  auto out_ = mk_printer(s.get_writer(), 80u);
-  auto out = @rec(s=out_,
-                  cm=none[codemap],
-                  comments=none[vec[front::lexer::cmnt]],
-                  mutable cur_cmnt=0u,
-                  mode=mo_untyped);
-  print_type(out, @t);
-  pretty::pp::eof(out_);
-  ret s.get_str();
-}
-
 fn log_expr(&ast::expr e) -> () {
-    log(expr_to_str(@e));
+    log(pretty::pprust::expr_to_str(@e));
 }
 
 fn log_expr_err(&ast::expr e) -> () {
-    log_err(expr_to_str(@e));
+    log_err(pretty::pprust::expr_to_str(@e));
 }
 
 fn log_ty_err(&ty t) -> () {
-    log_err(ty_to_str(t));
+    log_err(pretty::pprust::ty_to_str(t));
 }
 
 fn log_pat_err(&@pat p) -> () {
     log_err(pretty::pprust::pat_to_str(p));
 }
 
-fn block_to_str(&ast::block b) -> str {
-  let str_writer s = string_writer();
-  auto out_ = mk_printer(s.get_writer(), 80u);
-  auto out = @rec(s=out_,
-                  cm=none[codemap],
-                  comments=none[vec[front::lexer::cmnt]],
-                  mutable cur_cmnt=0u,
-                  mode=mo_untyped);
-
-  print_block(out, b);
-  pretty::pp::eof(out_);
-  ret s.get_str();
-}
-
-fn item_to_str(&@ast::item i) -> str {
-  let str_writer s = string_writer();
-  auto out_ = mk_printer(s.get_writer(), 80u);
-  auto out = @rec(s=out_,
-                  cm=none[codemap],
-                  comments=none[vec[front::lexer::cmnt]],
-                  mutable cur_cmnt=0u,
-                  mode=mo_untyped);
-  print_item(out, i);
-  pretty::pp::eof(out_);
-  ret s.get_str();
-}
-
 fn log_block(&ast::block b) -> () {
-    log(block_to_str(b));
+    log(pretty::pprust::block_to_str(b));
 }
 
 fn log_block_err(&ast::block b) -> () {
-    log_err(block_to_str(b));
+    log_err(pretty::pprust::block_to_str(b));
 }
 
 fn log_item_err(&@ast::item i) -> () {
-    log_err(item_to_str(i));
-}
-
-fn fun_to_str(&ast::_fn f, str name, vec[ast::ty_param] params) -> str {
- let str_writer s = string_writer();
-  auto out_ = mk_printer(s.get_writer(), 80u);
-  auto out = @rec(s=out_,
-                  cm=none[codemap],
-                  comments=none[vec[front::lexer::cmnt]],
-                  mutable cur_cmnt=0u,
-                  mode=mo_untyped);
-
-  print_fn(out, f.decl, name, params);
-  pretty::pp::eof(out_);
-  ret s.get_str();
+    log_err(pretty::pprust::item_to_str(i));
 }
 
 fn log_fn(&ast::_fn f, str name, vec[ast::ty_param] params) -> () {
-    log(fun_to_str(f, name, params));
+    log(pretty::pprust::fun_to_str(f, name, params));
 }
 
 fn log_fn_err(&ast::_fn f, str name, vec[ast::ty_param] params) -> () {
-    log_err(fun_to_str(f, name, params));
-}
-
-fn stmt_to_str(&ast::stmt st) -> str {
-  let str_writer s = string_writer();
-  auto out_ = mk_printer(s.get_writer(), 80u);
-  auto out = @rec(s=out_,
-                  cm=none[codemap],
-                  comments=none[vec[front::lexer::cmnt]],
-                  mutable cur_cmnt=0u,
-                  mode=mo_untyped);
-  alt (st.node) {
-    case (ast::stmt_decl(?decl,_)) {
-      print_decl(out, decl);
-    }
-    case (ast::stmt_expr(?ex,_)) {
-      print_expr(out, ex);
-    }
-    case (_) { /* do nothing */ }
-  }
-  pretty::pp::eof(out_);
-  ret s.get_str();
+    log_err(pretty::pprust::fun_to_str(f, name, params));
 }
 
 fn log_stmt(&ast::stmt st) -> () {
-    log(stmt_to_str(st));
+    log(pretty::pprust::stmt_to_str(st));
 }
 
 fn log_stmt_err(&ast::stmt st) -> () {
-    log_err(stmt_to_str(st));
+    log_err(pretty::pprust::stmt_to_str(st));
 }
 
 fn decl_lhs(@ast::decl d) -> ast::def_id {