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)

3 files changed, 52 insertions, 35 deletions

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