Major clean-up of std::io

Use ifaces instead of objs, stop wrapping everything in two (or three)
layers of no-value-added indirection, and remove some of the more
pointless/outdated idioms from the code.

Author: marijnh

src/cargo/cargo.rs

@@ -10,6 +10,7 @@ import rustc::util::filesearch::get_cargo_root;
 import std::fs;
 import std::generic_os;
 import std::io;
+import io::writer_util;
 import std::json;
 import option;
 import option::{none, some};

src/comp/driver/driver.rs

@@ -1,5 +1,4 @@
 
-
 // -*- rust -*-
 import metadata::{creader, cstore};
 import syntax::parse::{parser};
@@ -13,6 +12,7 @@ import back::link;
 import core::{option, str, int, result};
 import result::{ok, err};
 import std::{fs, io, getopts};
+import io::reader_util;
 import option::{some, none};
 import getopts::{optopt, optmulti, optflag, optflagopt, opt_present};
 import back::{x86, x86_64};
@@ -84,7 +84,7 @@ fn parse_input(sess: session::session, cfg: ast::crate_cfg, input: str) ->
 
 fn parse_input_src(sess: session::session, cfg: ast::crate_cfg, infile: str)
    -> {crate: @ast::crate, src: str} {
-    let srcbytes = if infile != "-" {
+    let src_stream = if infile != "-" {
         alt io::file_reader(infile) {
           result::ok(reader) { reader }
           result::err(e) {
@@ -93,7 +93,8 @@ fn parse_input_src(sess: session::session, cfg: ast::crate_cfg, infile: str)
         }
     } else {
         io::stdin()
-    }.read_whole_stream();
+    };
+    let srcbytes = src_stream.read_whole_stream();
     let src = str::unsafe_from_bytes(srcbytes);
     let crate =
         parser::parse_crate_from_source_str(infile, src, cfg,

src/comp/driver/rustc.rs

@@ -5,6 +5,7 @@ use rustc;
 import core::{option, str, vec, result};
 import result::{ok, err};
 import std::{io, getopts};
+import io::writer_util;
 import option::{some, none};
 import getopts::{opt_present};
 import rustc::driver::driver::*;

src/comp/metadata/creader.rs

@@ -7,8 +7,8 @@ import front::attr;
 import syntax::visit;
 import syntax::codemap::span;
 import util::{filesearch};
-import core::{either, vec, str, option};
 import std::{io, fs};
+import io::writer_util;
 import option::{none, some};
 import std::map::{hashmap, new_int_hash};
 import syntax::print::pprust;

src/comp/metadata/decoder.rs

@@ -1,6 +1,7 @@
 // Decoding metadata from a single crate's metadata
 
 import std::{ebml, io};
+import io::writer_util;
 import syntax::{ast, ast_util};
 import front::attr;
 import middle::ty;

src/comp/metadata/encoder.rs

@@ -1,7 +1,7 @@
 // Metadata encoding
 
-import core::{vec, str, uint};
 import std::{io, ebml, map};
+import io::writer_util;
 import syntax::ast::*;
 import syntax::ast_util;
 import syntax::ast_util::local_def;
@@ -191,7 +191,7 @@ fn encode_type_param_bounds(ebml_w: ebml::writer, ecx: @encode_ctxt,
     for param in params {
         ebml::start_tag(ebml_w, tag_items_data_item_ty_param_bounds);
         let bs = ecx.ccx.tcx.ty_param_bounds.get(param.id);
-        tyencode::enc_bounds(io::new_writer(ebml_w.writer), ty_str_ctxt, bs);
+        tyencode::enc_bounds(ebml_w.writer, ty_str_ctxt, bs);
         ebml::end_tag(ebml_w);
     }
 }
@@ -207,7 +207,7 @@ fn write_type(ecx: @encode_ctxt, ebml_w: ebml::writer, typ: ty::t) {
         @{ds: def_to_str,
           tcx: ecx.ccx.tcx,
           abbrevs: tyencode::ac_use_abbrevs(ecx.type_abbrevs)};
-    tyencode::enc_ty(io::new_writer(ebml_w.writer), ty_str_ctxt, typ);
+    tyencode::enc_ty(ebml_w.writer, ty_str_ctxt, typ);
 }
 
 fn encode_type(ecx: @encode_ctxt, ebml_w: ebml::writer, typ: ty::t) {
@@ -522,7 +522,7 @@ fn create_index<T: copy>(index: [entry<T>], hash_fn: fn(T) -> uint) ->
 
 fn encode_index<T>(ebml_w: ebml::writer, buckets: [@[entry<T>]],
                    write_fn: fn(io::writer, T)) {
-    let writer = io::new_writer(ebml_w.writer);
+    let writer = ebml_w.writer;
     ebml::start_tag(ebml_w, tag_index);
     let bucket_locs: [uint] = [];
     ebml::start_tag(ebml_w, tag_index_buckets);
@@ -702,8 +702,8 @@ fn encode_metadata(cx: @crate_ctxt, crate: @crate) -> str {
     let abbrevs = ty::new_ty_hash();
     let ecx = @{ccx: cx, type_abbrevs: abbrevs};
 
-    let string_w = io::string_writer();
-    let buf_w = string_w.get_writer().get_buf_writer();
+    let buf = io::mk_mem_buffer();
+    let buf_w = io::mem_buffer_writer(buf);
     let ebml_w = ebml::create_writer(buf_w);
 
     encode_hash(ebml_w, cx.link_meta.extras_hash);
@@ -714,32 +714,31 @@ fn encode_metadata(cx: @crate_ctxt, crate: @crate) -> str {
     encode_crate_deps(ebml_w, cx.sess.get_cstore());
 
     // Encode and index the paths.
-
     ebml::start_tag(ebml_w, tag_paths);
     let paths_index = encode_item_paths(ebml_w, ecx, crate);
     let paths_buckets = create_index(paths_index, hash_path);
     encode_index(ebml_w, paths_buckets, write_str);
     ebml::end_tag(ebml_w);
-    // Encode and index the items.
 
+    // Encode and index the items.
     ebml::start_tag(ebml_w, tag_items);
     let items_index = encode_info_for_items(ecx, ebml_w, crate.node.module);
     let items_buckets = create_index(items_index, hash_node_id);
     encode_index(ebml_w, items_buckets, write_int);
     ebml::end_tag(ebml_w);
+
     // Pad this, since something (LLVM, presumably) is cutting off the
     // remaining % 4 bytes.
-
     buf_w.write([0u8, 0u8, 0u8, 0u8]);
-    ret string_w.get_str();
+    io::mem_buffer_str(buf)
 }
 
 // Get the encoded string for a type
 fn encoded_ty(tcx: ty::ctxt, t: ty::t) -> str {
     let cx = @{ds: def_to_str, tcx: tcx, abbrevs: tyencode::ac_no_abbrevs};
-    let sw = io::string_writer();
-    tyencode::enc_ty(sw.get_writer(), cx, t);
-    ret sw.get_str();
+    let buf = io::mk_mem_buffer();
+    tyencode::enc_ty(io::mem_buffer_writer(buf), cx, t);
+    ret io::mem_buffer_str(buf);
 }
 
 

src/comp/metadata/tyencode.rs

@@ -1,7 +1,7 @@
 // Type encoding
 
-import core::{int, uint};
 import std::io;
+import io::writer_util;
 import std::map::hashmap;
 import option::{some, none};
 import syntax::ast::*;
@@ -37,25 +37,24 @@ fn cx_uses_abbrevs(cx: @ctxt) -> bool {
 fn enc_ty(w: io::writer, cx: @ctxt, t: ty::t) {
     alt cx.abbrevs {
       ac_no_abbrevs. {
-        let result_str: @str;
-        alt cx.tcx.short_names_cache.find(t) {
-          some(s) { result_str = s; }
+        let result_str = alt cx.tcx.short_names_cache.find(t) {
+          some(s) { *s }
           none. {
-            let sw = io::string_writer();
-            enc_sty(sw.get_writer(), cx, ty::struct(cx.tcx, t));
-            result_str = @sw.get_str();
-            cx.tcx.short_names_cache.insert(t, result_str);
+            let buf = io::mk_mem_buffer();
+            enc_sty(io::mem_buffer_writer(buf), cx, ty::struct(cx.tcx, t));
+            cx.tcx.short_names_cache.insert(t, @io::mem_buffer_str(buf));
+            io::mem_buffer_str(buf)
           }
-        }
-        w.write_str(*result_str);
+        };
+        w.write_str(result_str);
       }
       ac_use_abbrevs(abbrevs) {
         alt abbrevs.find(t) {
           some(a) { w.write_str(*a.s); ret; }
           none. {
-            let pos = w.get_buf_writer().tell();
+            let pos = w.tell();
             enc_sty(w, cx, ty::struct(cx.tcx, t));
-            let end = w.get_buf_writer().tell();
+            let end = w.tell();
             let len = end - pos;
             fn estimate_sz(u: uint) -> uint {
                 let n = u;

src/comp/syntax/codemap.rs

@@ -1,5 +1,6 @@
 import core::{vec, uint, str, option, result};
 import std::{term, io};
+import io::writer_util;
 import option::{some, none};
 
 type filename = str;
@@ -126,11 +127,11 @@ fn print_diagnostic(topic: str, t: diagnostictype, msg: str) {
         io::stdout().write_str(#fmt["%s ", topic]);
     }
     if term::color_supported() {
-        term::fg(io::stdout().get_buf_writer(), diagnosticcolor(t));
+        term::fg(io::stdout(), diagnosticcolor(t));
     }
     io::stdout().write_str(#fmt["%s:", diagnosticstr(t)]);
     if term::color_supported() {
-        term::reset(io::stdout().get_buf_writer());
+        term::reset(io::stdout());
     }
     io::stdout().write_str(#fmt[" %s\n", msg]);
 }

src/comp/syntax/ext/log_syntax.rs

@@ -1,6 +1,6 @@
-import option;
 import base::*;
 import syntax::ast;
+import std::io::writer_util;
 
 fn expand_syntax_ext(cx: ext_ctxt, sp: codemap::span, arg: @ast::expr,
                      _body: option::t<str>) -> @ast::expr {

src/comp/syntax/parse/lexer.rs

@@ -1,6 +1,7 @@
 
 import core::{vec, str, option, either};
 import std::io;
+import io::reader_util;
 import option::{some, none};
 import util::interner;
 import util::interner::intern;

src/comp/syntax/print/pp.rs

@@ -1,6 +1,7 @@
 
 import core::{vec, str};
 import std::io;
+import io::writer_util;
 
 /*
  * This pretty-printer is a direct reimplementation of Philip Karlton's

src/comp/syntax/print/pprust.rs

@@ -93,25 +93,23 @@ fn path_to_str(&&p: @ast::path) -> str {
 
 fn fun_to_str(decl: ast::fn_decl, name: ast::ident,
               params: [ast::ty_param]) -> str {
-    let writer = io::string_writer();
-    let s = rust_printer(writer.get_writer());
+    let buffer = io::mk_mem_buffer();
+    let s = rust_printer(io::mem_buffer_writer(buffer));
     print_fn(s, decl, name, params);
     eof(s.s);
-    ret writer.get_str();
+    io::mem_buffer_str(buffer)
 }
 
 fn block_to_str(blk: ast::blk) -> str {
-    let writer = io::string_writer();
-    let s = rust_printer(writer.get_writer());
+    let buffer = io::mk_mem_buffer();
+    let s = rust_printer(io::mem_buffer_writer(buffer));
     // 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);
-    ret writer.get_str();
+    io::mem_buffer_str(buffer)
 }
 
 fn meta_item_to_str(mi: ast::meta_item) -> str {
@@ -1597,11 +1595,11 @@ fn escape_str(st: str, to_escape: char) -> str {
 }
 
 fn to_str<T>(t: T, f: fn@(ps, T)) -> str {
-    let writer = io::string_writer();
-    let s = rust_printer(writer.get_writer());
+    let buffer = io::mk_mem_buffer();
+    let s = rust_printer(io::mem_buffer_writer(buffer));
     f(s, t);
     eof(s.s);
-    ret writer.get_str();
+    io::mem_buffer_str(buffer)
 }
 
 fn next_comment(s: ps) -> option::t<lexer::cmnt> {

src/compiletest/errors.rs

@@ -1,6 +1,5 @@
-import option;
-import str;
 import std::io;
+import io::reader_util;
 import std::fs;
 
 import common::config;

src/compiletest/header.rs

@@ -1,6 +1,7 @@
 import option;
 import str;
 import std::io;
+import io::reader_util;
 import std::fs;
 
 import common::config;

src/compiletest/procsrv.rs

@@ -4,16 +4,12 @@
 // child process. Because of that we have to use a complicated scheme with a
 // dedicated server for spawning processes.
 
-import core::comm;
-import core::option;
-import task;
 import std::generic_os::setenv;
 import std::generic_os::getenv;
-import vec;
 import std::os;
 import std::run;
 import std::io;
-import str;
+import io::writer_util;
 import comm::chan;
 import comm::port;
 import comm::send;
@@ -75,7 +71,7 @@ fn run(handle: handle, lib_path: str, prog: str, args: [str],
 
 fn writeclose(fd: fd_t, s: option::t<str>) {
     if option::is_some(s) {
-        let writer = io::new_writer(io::fd_buf_writer(fd, option::none));
+        let writer = io::fd_writer(fd, false);
         writer.write_str(option::get(s));
     }
 
@@ -85,7 +81,7 @@ fn writeclose(fd: fd_t, s: option::t<str>) {
 fn readclose(fd: fd_t) -> str {
     // Copied from run::program_output
     let file = os::fd_FILE(fd);
-    let reader = io::new_reader(io::FILE_buf_reader(file, option::none));
+    let reader = io::FILE_reader(file, false);
     let buf = "";
     while !reader.eof() {
         let bytes = reader.read_bytes(4096u);

src/compiletest/runtest.rs

@@ -1,10 +1,7 @@
 import std::io;
-import str;
-import option;
+import io::writer_util;
 import std::fs;
 import std::os;
-import vec;
-import result;
 
 import common::mode_run_pass;
 import common::mode_run_fail;

src/compiletest/util.rs

@@ -36,5 +36,5 @@ fn path_div() -> str { ";" }
 
 fn logv(config: config, s: str) {
     log(debug, s);
-    if config.verbose { io::stdout().write_line(s); }
+    if config.verbose { io::println(s); }
 }

src/fuzzer/fuzzer.rs

@@ -1,4 +1,5 @@
 import std::{fs, io};
+import io::writer_util;
 
 import rustc::syntax::{ast, ast_util, fold, visit, codemap};
 import rustc::syntax::parse::parser;
@@ -212,12 +213,12 @@ fn under(n: uint, it: block(uint)) {
     while i < n { it(i); i += 1u; }
 }
 
-fn devnull() -> io::writer { std::io::string_writer().get_writer() }
+fn devnull() -> io::writer { io::mem_buffer_writer(io::mk_mem_buffer()) }
 
 fn as_str(f: fn@(io::writer)) -> str {
-    let w = std::io::string_writer();
-    f(w.get_writer());
-    ret w.get_str();
+    let buf = io::mk_mem_buffer();
+    f(io::mem_buffer_writer(buf));
+    io::mem_buffer_str(buf)
 }
 
 fn check_variants_of_ast(crate: ast::crate, codemap: codemap::codemap,