auto merge of #9901 : alexcrichton/rust/unix-sockets, r=brson

Large topics:

* Implemented `rt::io::net::unix`. We've got an implementation backed by "named pipes" for windows for free from libuv, so I'm not sure if these should be `cfg(unix)` or whether they'd be better placed in `rt::io::pipe` (which is currently kinda useless), or to leave in `unix`. Regardless, we probably shouldn't deny windows of functionality which it certainly has.
* Fully implemented `net::addrinfo`, or at least fully implemented in the sense of making the best attempt to wrap libuv's `getaddrinfo` api
* Moved standard I/O to a libuv TTY instead of just a plain old file descriptor. I found that this interacted better when closing stdin, and it has the added bonus of getting things like terminal dimentions (someone should make a progress bar now!)
* Migrate to `~Trait` instead of a typedef'd object where possible. There are only two more types which are blocked on this, and those are traits which have a method which takes by-value self (there's an open issue on this)
* Drop `rt::io::support::PathLike` in favor of just `ToCStr`. We recently had a lot of Path work done, but it still wasn't getting passed down to libuv (there was an intermediate string conversion), and this allows true paths to work all the way down to libuv (and anything else that can become a C string).
* Removes `extra::fileinput` and `extra::io_util`


Closes #9895 
Closes #9975
Closes #8330
Closes #6850 (ported lots of libraries away from std::io)
cc #4248 (implemented unix/dns)
cc #9128 (made everything truly trait objects)

9 files changed, 148 insertions, 108 deletions

diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
index 1d9d5512ff4..456d344b838 100644
--- a/src/libsyntax/ast_util.rs
+++ b/src/libsyntax/ast_util.rs
@@ -962,7 +962,6 @@ pub fn segments_name_eq(a : &[ast::PathSegment], b : &[ast::PathSegment]) -> boo
 mod test {
     use ast::*;
     use super::*;
-    use std::io;
     use opt_vec;
     use std::hashmap::HashMap;
 
@@ -1137,7 +1136,7 @@ mod test {
         // - two renames of the same var.. can only happen if you use
         // local-expand to prevent the inner binding from being renamed
         // during the rename-pass caused by the first:
-        io::println("about to run bad test");
+        println("about to run bad test");
         { let sc = unfold_test_sc(~[R(id(a,EMPTY_CTXT),50),
                                     R(id(a,EMPTY_CTXT),51)],
                                   EMPTY_CTXT,&mut t);
diff --git a/src/libsyntax/diagnostic.rs b/src/libsyntax/diagnostic.rs
index bbbaf2a2f60..736f92910af 100644
--- a/src/libsyntax/diagnostic.rs
+++ b/src/libsyntax/diagnostic.rs
@@ -11,7 +11,7 @@
 use codemap::{Pos, Span};
 use codemap;
 
-use std::io;
+use std::rt::io;
 use std::local_data;
 use extra::term;
 
@@ -199,9 +199,14 @@ fn diagnosticcolor(lvl: level) -> term::color::Color {
 fn print_maybe_styled(msg: &str, color: term::attr::Attr) {
     local_data_key!(tls_terminal: @Option<term::Terminal>)
 
-    let stderr = io::stderr();
+    let stderr = @mut io::stderr() as @mut io::Writer;
+    fn is_stderr_screen() -> bool {
+        #[fixed_stack_segment];
+        use std::libc;
+        unsafe { libc::isatty(libc::STDERR_FILENO) != 0 }
+    }
 
-    if stderr.get_type() == io::Screen {
+    if is_stderr_screen() {
         let t = match local_data::get(tls_terminal, |v| v.map(|k| *k)) {
             None => {
                 let t = term::Terminal::new(stderr);
@@ -218,21 +223,21 @@ fn print_maybe_styled(msg: &str, color: term::attr::Attr) {
         match t {
             &Some(ref term) => {
                 term.attr(color);
-                stderr.write_str(msg);
+                write!(stderr, "{}", msg);
                 term.reset();
             },
-            _ => stderr.write_str(msg)
+            _ => write!(stderr, "{}", msg)
         }
     } else {
-        stderr.write_str(msg);
+        write!(stderr, "{}", msg);
     }
 }
 
 fn print_diagnostic(topic: &str, lvl: level, msg: &str) {
-    let stderr = io::stderr();
+    let mut stderr = io::stderr();
 
     if !topic.is_empty() {
-        stderr.write_str(format!("{} ", topic));
+        write!(&mut stderr as &mut io::Writer, "{} ", topic);
     }
 
     print_maybe_styled(format!("{}: ", diagnosticstr(lvl)),
@@ -266,6 +271,8 @@ fn highlight_lines(cm: @codemap::CodeMap,
                    lvl: level,
                    lines: @codemap::FileLines) {
     let fm = lines.file;
+    let mut err = io::stderr();
+    let err = &mut err as &mut io::Writer;
 
     // arbitrarily only print up to six lines of the error
     let max_lines = 6u;
@@ -277,21 +284,12 @@ fn highlight_lines(cm: @codemap::CodeMap,
     }
     // Print the offending lines
     for line in display_lines.iter() {
-        io::stderr().write_str(format!("{}:{} ", fm.name, *line + 1u));
-        let s = fm.get_line(*line as int) + "\n";
-        io::stderr().write_str(s);
+        write!(err, "{}:{} {}\n", fm.name, *line + 1, fm.get_line(*line as int));
     }
     if elided {
         let last_line = display_lines[display_lines.len() - 1u];
         let s = format!("{}:{} ", fm.name, last_line + 1u);
-        let mut indent = s.len();
-        let mut out = ~"";
-        while indent > 0u {
-            out.push_char(' ');
-            indent -= 1u;
-        }
-        out.push_str("...\n");
-        io::stderr().write_str(out);
+        write!(err, "{0:1$}...\n", "", s.len());
     }
 
     // FIXME (#3260)
@@ -325,7 +323,7 @@ fn highlight_lines(cm: @codemap::CodeMap,
                 _ => s.push_char(' '),
             };
         }
-        io::stderr().write_str(s);
+        write!(err, "{}", s);
         let mut s = ~"^";
         let hi = cm.lookup_char_pos(sp.hi);
         if hi.col != lo.col {
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index 1018e79aabc..99bcb36eedb 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -1524,7 +1524,8 @@ mod test {
     }
 
     fn fake_print_crate(crate: &ast::Crate) {
-        let s = pprust::rust_printer(std::io::stderr(),get_ident_interner());
+        let out = @mut std::rt::io::stderr() as @mut std::rt::io::Writer;
+        let s = pprust::rust_printer(out, get_ident_interner());
         pprust::print_crate_(s, crate);
     }
 
@@ -1536,7 +1537,7 @@ mod test {
 
     //fn expand_and_resolve(crate_str: @str) -> ast::crate {
         //let expanded_ast = expand_crate_str(crate_str);
-        // std::io::println(format!("expanded: {:?}\n",expanded_ast));
+        // println(format!("expanded: {:?}\n",expanded_ast));
         //mtwt_resolve_crate(expanded_ast)
     //}
     //fn expand_and_resolve_and_pretty_print (crate_str : @str) -> ~str {
@@ -1645,9 +1646,9 @@ mod test {
                     let varref_marks = mtwt_marksof(varref.segments[0].identifier.ctxt,
                                                     invalid_name);
                     if (!(varref_name==binding_name)){
-                        std::io::println("uh oh, should match but doesn't:");
-                        std::io::println(format!("varref: {:?}",varref));
-                        std::io::println(format!("binding: {:?}", bindings[binding_idx]));
+                        println("uh oh, should match but doesn't:");
+                        println!("varref: {:?}",varref);
+                        println!("binding: {:?}", bindings[binding_idx]);
                         ast_util::display_sctable(get_sctable());
                     }
                     assert_eq!(varref_name,binding_name);
@@ -1665,12 +1666,12 @@ mod test {
                         println!("text of test case: \"{}\"", teststr);
                         println!("");
                         println!("uh oh, matches but shouldn't:");
-                        std::io::println(format!("varref: {:?}",varref));
+                        println!("varref: {:?}",varref);
                         // good lord, you can't make a path with 0 segments, can you?
                         println!("varref's first segment's uint: {}, and string: \"{}\"",
                                  varref.segments[0].identifier.name,
                                  ident_to_str(&varref.segments[0].identifier));
-                        std::io::println(format!("binding: {:?}", bindings[binding_idx]));
+                        println!("binding: {:?}", bindings[binding_idx]);
                         ast_util::display_sctable(get_sctable());
                     }
                     assert!(!fail);
@@ -1703,17 +1704,17 @@ foo_module!()
                                           && (@"xx" == (ident_to_str(&p.segments[0].identifier)))
                                      }).enumerate() {
             if (mtwt_resolve(v.segments[0].identifier) != resolved_binding) {
-                std::io::println("uh oh, xx binding didn't match xx varref:");
-                std::io::println(format!("this is xx varref \\# {:?}",idx));
-                std::io::println(format!("binding: {:?}",cxbind));
-                std::io::println(format!("resolves to: {:?}",resolved_binding));
-                std::io::println(format!("varref: {:?}",v.segments[0].identifier));
-                std::io::println(format!("resolves to: {:?}",
-                                         mtwt_resolve(v.segments[0].identifier)));
+                println("uh oh, xx binding didn't match xx varref:");
+                println!("this is xx varref \\# {:?}",idx);
+                println!("binding: {:?}",cxbind);
+                println!("resolves to: {:?}",resolved_binding);
+                println!("varref: {:?}",v.segments[0].identifier);
+                println!("resolves to: {:?}",
+                         mtwt_resolve(v.segments[0].identifier));
                 let table = get_sctable();
-                std::io::println("SC table:");
+                println("SC table:");
                 for (idx,val) in table.table.iter().enumerate() {
-                    std::io::println(format!("{:4u} : {:?}",idx,val));
+                    println!("{:4u} : {:?}",idx,val);
                 }
             }
             assert_eq!(mtwt_resolve(v.segments[0].identifier),resolved_binding);
diff --git a/src/libsyntax/ext/log_syntax.rs b/src/libsyntax/ext/log_syntax.rs
index 52807009073..3e07b16221e 100644
--- a/src/libsyntax/ext/log_syntax.rs
+++ b/src/libsyntax/ext/log_syntax.rs
@@ -15,15 +15,13 @@ use ext::base;
 use print;
 use parse::token::{get_ident_interner};
 
-use std::io;
-
 pub fn expand_syntax_ext(cx: @ExtCtxt,
                          sp: codemap::Span,
                          tt: &[ast::token_tree])
                       -> base::MacResult {
 
     cx.print_backtrace();
-    io::stdout().write_line(
+    println(
         print::pprust::tt_to_str(
             &ast::tt_delim(@mut tt.to_owned()),
             get_ident_interner()));
diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs
index dcfeb99365a..119a74cccd6 100644
--- a/src/libsyntax/ext/source_util.rs
+++ b/src/libsyntax/ext/source_util.rs
@@ -19,8 +19,10 @@ use parse;
 use parse::token::{get_ident_interner};
 use print::pprust;
 
-use std::io;
-use std::result;
+use std::rt::io;
+use std::rt::io::extensions::ReaderUtil;
+use std::rt::io::file::FileInfo;
+use std::str;
 
 // These macros all relate to the file system; they either return
 // the column/row/filename of the expression, or they include
@@ -89,14 +91,23 @@ pub fn expand_include(cx: @ExtCtxt, sp: Span, tts: &[ast::token_tree])
 pub fn expand_include_str(cx: @ExtCtxt, sp: Span, tts: &[ast::token_tree])
     -> base::MacResult {
     let file = get_single_str_from_tts(cx, sp, tts, "include_str!");
-    let res = io::read_whole_file_str(&res_rel_file(cx, sp, &Path::new(file)));
-    match res {
-      result::Ok(res) => {
-          base::MRExpr(cx.expr_str(sp, res.to_managed()))
-      }
-      result::Err(e) => {
-        cx.span_fatal(sp, e);
-      }
+    let file = res_rel_file(cx, sp, &Path::new(file));
+    let mut error = None;
+    let bytes = do io::io_error::cond.trap(|e| error = Some(e)).inside {
+        file.open_reader(io::Open).read_to_end()
+    };
+    match error {
+        Some(e) => {
+            cx.span_fatal(sp, format!("couldn't read {}: {}",
+                                      file.display(), e.desc));
+        }
+        None => {}
+    }
+    match str::from_utf8_owned_opt(bytes) {
+        Some(s) => base::MRExpr(cx.expr_str(sp, s.to_managed())),
+        None => {
+            cx.span_fatal(sp, format!("{} wasn't a utf-8 file", file.display()));
+        }
     }
 }
 
@@ -106,13 +117,20 @@ pub fn expand_include_bin(cx: @ExtCtxt, sp: Span, tts: &[ast::token_tree])
     use std::at_vec;
 
     let file = get_single_str_from_tts(cx, sp, tts, "include_bin!");
-    match io::read_whole_file(&res_rel_file(cx, sp, &Path::new(file))) {
-        result::Ok(src) => {
-            let v = at_vec::to_managed_move(src);
-            base::MRExpr(cx.expr_lit(sp, ast::lit_binary(v)))
+    let file = res_rel_file(cx, sp, &Path::new(file));
+
+    let mut error = None;
+    let bytes = do io::io_error::cond.trap(|e| error = Some(e)).inside {
+        file.open_reader(io::Open).read_to_end()
+    };
+    match error {
+        Some(e) => {
+            cx.span_fatal(sp, format!("couldn't read {}: {}",
+                                      file.display(), e.desc));
         }
-        result::Err(ref e) => {
-            cx.parse_sess().span_diagnostic.handler().fatal((*e))
+        None => {
+            let bytes = at_vec::to_managed_move(bytes);
+            base::MRExpr(cx.expr_lit(sp, ast::lit_binary(bytes)))
         }
     }
 }
diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs
index 38921648a2b..e9e6eb872c8 100644
--- a/src/libsyntax/parse/comments.rs
+++ b/src/libsyntax/parse/comments.rs
@@ -18,7 +18,8 @@ use parse::lexer;
 use parse::token;
 use parse::token::{get_ident_interner};
 
-use std::io;
+use std::rt::io;
+use std::rt::io::extensions::ReaderUtil;
 use std::str;
 use std::uint;
 
@@ -346,9 +347,9 @@ pub struct lit {
 pub fn gather_comments_and_literals(span_diagnostic:
                                     @mut diagnostic::span_handler,
                                     path: @str,
-                                    srdr: @io::Reader)
+                                    mut srdr: &mut io::Reader)
                                  -> (~[cmnt], ~[lit]) {
-    let src = str::from_utf8(srdr.read_whole_stream()).to_managed();
+    let src = str::from_utf8(srdr.read_to_end()).to_managed();
     let cm = CodeMap::new();
     let filemap = cm.new_filemap(path, src);
     let rdr = lexer::new_low_level_string_reader(span_diagnostic, filemap);
diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs
index c9405d72464..fad9eab7542 100644
--- a/src/libsyntax/parse/mod.rs
+++ b/src/libsyntax/parse/mod.rs
@@ -19,8 +19,11 @@ use parse::attr::parser_attr;
 use parse::lexer::reader;
 use parse::parser::Parser;
 
-use std::io;
 use std::path::Path;
+use std::rt::io;
+use std::rt::io::extensions::ReaderUtil;
+use std::rt::io::file::FileInfo;
+use std::str;
 
 pub mod lexer;
 pub mod parser;
@@ -260,16 +263,32 @@ pub fn new_parser_from_tts(sess: @mut ParseSess,
 /// add the path to the session's codemap and return the new filemap.
 pub fn file_to_filemap(sess: @mut ParseSess, path: &Path, spanopt: Option<Span>)
     -> @FileMap {
-    match io::read_whole_file_str(path) {
-        // FIXME (#9639): This needs to handle non-utf8 paths
-        Ok(src) => string_to_filemap(sess, src.to_managed(), path.as_str().unwrap().to_managed()),
-        Err(e) => {
-            match spanopt {
-                Some(span) => sess.span_diagnostic.span_fatal(span, e),
-                None => sess.span_diagnostic.handler().fatal(e)
-            }
+    let err = |msg: &str| {
+        match spanopt {
+            Some(sp) => sess.span_diagnostic.span_fatal(sp, msg),
+            None => sess.span_diagnostic.handler().fatal(msg),
+        }
+    };
+    let mut error = None;
+    let bytes = do io::io_error::cond.trap(|e| error = Some(e)).inside {
+        path.open_reader(io::Open).read_to_end()
+    };
+    match error {
+        Some(e) => {
+            err(format!("couldn't read {}: {}", path.display(), e.desc));
+        }
+        None => {}
+    }
+    match str::from_utf8_owned_opt(bytes) {
+        Some(s) => {
+            return string_to_filemap(sess, s.to_managed(),
+                                     path.as_str().unwrap().to_managed());
+        }
+        None => {
+            err(format!("{} is not UTF-8 encoded", path.display()))
         }
     }
+    unreachable!()
 }
 
 // given a session and a string, add the string to
@@ -318,7 +337,10 @@ mod test {
     use super::*;
     use extra::serialize::Encodable;
     use extra;
-    use std::io;
+    use std::rt::io;
+    use std::rt::io::Decorator;
+    use std::rt::io::mem::MemWriter;
+    use std::str;
     use codemap::{Span, BytePos, Spanned};
     use opt_vec;
     use ast;
@@ -330,10 +352,10 @@ mod test {
     use util::parser_testing::string_to_stmt;
 
     #[cfg(test)] fn to_json_str<E : Encodable<extra::json::Encoder>>(val: @E) -> ~str {
-        do io::with_str_writer |writer| {
-            let mut encoder = extra::json::Encoder(writer);
-            val.encode(&mut encoder);
-        }
+        let writer = @mut MemWriter::new();
+        let mut encoder = extra::json::Encoder(writer as @mut io::Writer);
+        val.encode(&mut encoder);
+        str::from_utf8(*writer.inner_ref())
     }
 
     // produce a codemap::span
diff --git a/src/libsyntax/print/pp.rs b/src/libsyntax/print/pp.rs
index 871584003b5..4801fa21fc4 100644
--- a/src/libsyntax/print/pp.rs
+++ b/src/libsyntax/print/pp.rs
@@ -61,7 +61,7 @@
  * avoid combining it with other lines and making matters even worse.
  */
 
-use std::io;
+use std::rt::io;
 use std::vec;
 
 #[deriving(Clone, Eq)]
@@ -148,7 +148,7 @@ pub struct print_stack_elt {
 
 pub static size_infinity: int = 0xffff;
 
-pub fn mk_printer(out: @io::Writer, linewidth: uint) -> @mut Printer {
+pub fn mk_printer(out: @mut io::Writer, linewidth: uint) -> @mut Printer {
     // Yes 3, it makes the ring buffers big enough to never
     // fall behind.
     let n: uint = 3 * linewidth;
@@ -157,7 +157,7 @@ pub fn mk_printer(out: @io::Writer, linewidth: uint) -> @mut Printer {
     let size: ~[int] = vec::from_elem(n, 0);
     let scan_stack: ~[uint] = vec::from_elem(n, 0u);
     @mut Printer {
-        out: @out,
+        out: out,
         buf_len: n,
         margin: linewidth as int,
         space: linewidth as int,
@@ -255,7 +255,7 @@ pub fn mk_printer(out: @io::Writer, linewidth: uint) -> @mut Printer {
  * called 'print'.
  */
 pub struct Printer {
-    out: @@io::Writer,
+    out: @mut io::Writer,
     buf_len: uint,
     margin: int, // width of lines we're constrained to
     space: int, // number of spaces left on line
@@ -452,7 +452,7 @@ impl Printer {
     }
     pub fn print_newline(&mut self, amount: int) {
         debug!("NEWLINE {}", amount);
-        (*self.out).write_str("\n");
+        write!(self.out, "\n");
         self.pending_indentation = 0;
         self.indent(amount);
     }
@@ -474,10 +474,10 @@ impl Printer {
     }
     pub fn print_str(&mut self, s: &str) {
         while self.pending_indentation > 0 {
-            (*self.out).write_str(" ");
+            write!(self.out, " ");
             self.pending_indentation -= 1;
         }
-        (*self.out).write_str(s);
+        write!(self.out, "{}", s);
     }
     pub fn print(&mut self, x: token, L: int) {
         debug!("print {} {} (remaining line space={})", tok_str(x), L,
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index 0e330da31e6..400ff804485 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -28,7 +28,10 @@ use print::pp;
 use print::pprust;
 
 use std::char;
-use std::io;
+use std::str;
+use std::rt::io;
+use std::rt::io::Decorator;
+use std::rt::io::mem::MemWriter;
 
 // The @ps is stored here to prevent recursive type.
 pub enum ann_node<'self> {
@@ -83,11 +86,11 @@ pub fn end(s: @ps) {
     pp::end(s.s);
 }
 
-pub fn rust_printer(writer: @io::Writer, intr: @ident_interner) -> @ps {
+pub fn rust_printer(writer: @mut io::Writer, intr: @ident_interner) -> @ps {
     return rust_printer_annotated(writer, intr, @no_ann::new() as @pp_ann);
 }
 
-pub fn rust_printer_annotated(writer: @io::Writer,
+pub fn rust_printer_annotated(writer: @mut io::Writer,
                               intr: @ident_interner,
                               ann: @pp_ann)
                               -> @ps {
@@ -118,8 +121,8 @@ pub fn print_crate(cm: @CodeMap,
                    span_diagnostic: @mut diagnostic::span_handler,
                    crate: &ast::Crate,
                    filename: @str,
-                   input: @io::Reader,
-                   out: @io::Writer,
+                   input: @mut io::Reader,
+                   out: @mut io::Writer,
                    ann: @pp_ann,
                    is_expanded: bool) {
     let (cmnts, lits) = comments::gather_comments_and_literals(
@@ -200,26 +203,26 @@ pub fn path_to_str(p: &ast::Path, intr: @ident_interner) -> ~str {
 pub fn fun_to_str(decl: &ast::fn_decl, purity: ast::purity, name: ast::Ident,
                   opt_explicit_self: Option<ast::explicit_self_>,
                   generics: &ast::Generics, intr: @ident_interner) -> ~str {
-    do io::with_str_writer |wr| {
-        let s = rust_printer(wr, intr);
-        print_fn(s, decl, Some(purity), AbiSet::Rust(),
-                 name, generics, opt_explicit_self, ast::inherited);
-        end(s); // Close the head box
-        end(s); // Close the outer box
-        eof(s.s);
-    }
+    let wr = @mut MemWriter::new();
+    let s = rust_printer(wr as @mut io::Writer, intr);
+    print_fn(s, decl, Some(purity), AbiSet::Rust(),
+             name, generics, opt_explicit_self, ast::inherited);
+    end(s); // Close the head box
+    end(s); // Close the outer box
+    eof(s.s);
+    str::from_utf8(*wr.inner_ref())
 }
 
 pub fn block_to_str(blk: &ast::Block, intr: @ident_interner) -> ~str {
-    do io::with_str_writer |wr| {
-        let s = rust_printer(wr, intr);
-        // containing cbox, will be closed by print-block at }
-        cbox(s, indent_unit);
-        // head-ibox, will be closed by print-block after {
-        ibox(s, 0u);
-        print_block(s, blk);
-        eof(s.s);
-    }
+    let wr = @mut MemWriter::new();
+    let s = rust_printer(wr as @mut io::Writer, intr);
+    // containing cbox, will be closed by print-block at }
+    cbox(s, indent_unit);
+    // head-ibox, will be closed by print-block after {
+    ibox(s, 0u);
+    print_block(s, blk);
+    eof(s.s);
+    str::from_utf8(*wr.inner_ref())
 }
 
 pub fn meta_item_to_str(mi: &ast::MetaItem, intr: @ident_interner) -> ~str {
@@ -2196,11 +2199,11 @@ pub fn print_string(s: @ps, st: &str, style: ast::StrStyle) {
 }
 
 pub fn to_str<T>(t: &T, f: &fn(@ps, &T), intr: @ident_interner) -> ~str {
-    do io::with_str_writer |wr| {
-        let s = rust_printer(wr, intr);
-        f(s, t);
-        eof(s.s);
-    }
+    let wr = @mut MemWriter::new();
+    let s = rust_printer(wr as @mut io::Writer, intr);
+    f(s, t);
+    eof(s.s);
+    str::from_utf8(*wr.inner_ref())
 }
 
 pub fn next_comment(s: @ps) -> Option<comments::cmnt> {