---

yaml
---
r: 95638
b: refs/heads/dist-snap
c: 76287cc
h: refs/heads/master
v: v3

Author: pcwalton

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 3f5b2219cc893b30863f9136703166f306fcc684
+refs/heads/dist-snap: 76287ccbb097d9b351657de8f514c5dd7c5955d5
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/doc/tutorial-conditions.md

@@ -43,7 +43,7 @@ $ ./example numbers.txt
 
 An example program that does this task reads like this:
 
-~~~~{.xfail-test}
+~~~~
 # #[allow(unused_imports)];
 extern mod extra;
 use extra::fileinput::FileInput;
@@ -430,7 +430,7 @@ To trap a condition, use `Condition::trap` in some caller of the site that calls
 For example, this version of the program traps the `malformed_line` condition
 and replaces bad input lines with the pair `(-1,-1)`:
 
-~~~~{.xfail-test}
+~~~~
 # #[allow(unused_imports)];
 extern mod extra;
 use extra::fileinput::FileInput;
@@ -507,7 +507,7 @@ In the example program, the first form of the `malformed_line` API implicitly as
 This assumption may not be correct; some callers may wish to skip malformed lines, for example.
 Changing the condition's return type from `(int,int)` to `Option<(int,int)>` will suffice to support this type of recovery:
 
-~~~~{.xfail-test}
+~~~~
 # #[allow(unused_imports)];
 extern mod extra;
 use extra::fileinput::FileInput;
@@ -594,7 +594,7 @@ until all relevant combinations encountered in practice are encoded.
 In the example, suppose a third possible recovery form arose: reusing the previous value read.
 This can be encoded in the handler API by introducing a helper type: `enum MalformedLineFix`.
 
-~~~~{.xfail-test}
+~~~~
 # #[allow(unused_imports)];
 extern mod extra;
 use extra::fileinput::FileInput;
@@ -720,7 +720,7 @@ task <unnamed> failed at 'called `Option::unwrap()` on a `None` value', .../libs
 To make the program robust -- or at least flexible -- in the face of this potential failure,
 a second condition and a helper function will suffice:
 
-~~~~{.xfail-test}
+~~~~
 # #[allow(unused_imports)];
 extern mod extra;
 use extra::fileinput::FileInput;

branches/dist-snap/doc/tutorial-tasks.md

@@ -69,6 +69,7 @@ calling the `spawn` function with a closure argument. `spawn` executes the
 closure in the new task.
 
 ~~~~
+# use std::io::println;
 # use std::task::spawn;
 
 // Print something profound in a different task using a named function

branches/dist-snap/doc/tutorial.md

@@ -2907,12 +2907,12 @@ you just have to import it with an `use` statement.
 For example, it re-exports `println` which is defined in `std::io::println`:
 
 ~~~
-use puts = std::rt::io::stdio::println;
+use puts = std::io::println;
 
 fn main() {
     println("println is imported per default.");
     puts("Doesn't hinder you from importing it under an different name yourself.");
-    ::std::rt::io::stdio::println("Or from not using the automatic import.");
+    ::std::io::println("Or from not using the automatic import.");
 }
 ~~~
 

branches/dist-snap/src/compiletest/runtest.rs

@@ -21,10 +21,7 @@ use util;
 use util::logv;
 
 use std::cell::Cell;
-use std::rt::io;
-use std::rt::io::Writer;
-use std::rt::io::extensions::ReaderUtil;
-use std::rt::io::file::FileInfo;
+use std::io;
 use std::os;
 use std::str;
 use std::task::{spawn_sched, SingleThreaded};
@@ -63,7 +60,7 @@ pub fn run(config: config, testfile: ~str) {
 pub fn run_metrics(config: config, testfile: ~str, mm: &mut MetricMap) {
     if config.verbose {
         // We're going to be dumping a lot of info. Start on a new line.
-        print!("\n\n");
+        io::stdout().write_str("\n\n");
     }
     let testfile = Path::new(testfile);
     debug!("running {}", testfile.display());
@@ -173,9 +170,7 @@ fn run_pretty_test(config: &config, props: &TestProps, testfile: &Path) {
     let rounds =
         match props.pp_exact { Some(_) => 1, None => 2 };
 
-    let src = testfile.open_reader(io::Open).read_to_end();
-    let src = str::from_utf8_owned(src);
-    let mut srcs = ~[src];
+    let mut srcs = ~[io::read_whole_file_str(testfile).unwrap()];
 
     let mut round = 0;
     while round < rounds {
@@ -195,8 +190,7 @@ fn run_pretty_test(config: &config, props: &TestProps, testfile: &Path) {
     let mut expected = match props.pp_exact {
         Some(ref file) => {
             let filepath = testfile.dir_path().join(file);
-            let s = filepath.open_reader(io::Open).read_to_end();
-            str::from_utf8_owned(s)
+            io::read_whole_file_str(&filepath).unwrap()
           }
           None => { srcs[srcs.len() - 2u].clone() }
         };
@@ -234,7 +228,8 @@ fn run_pretty_test(config: &config, props: &TestProps, testfile: &Path) {
     fn compare_source(expected: &str, actual: &str) {
         if expected != actual {
             error(~"pretty-printed source does not match expected source");
-            println!("\n\
+            let msg =
+                format!("\n\
 expected:\n\
 ------------------------------------------\n\
 {}\n\
@@ -245,6 +240,7 @@ actual:\n\
 ------------------------------------------\n\
 \n",
                      expected, actual);
+            io::stdout().write_str(msg);
             fail!();
         }
     }
@@ -745,7 +741,9 @@ fn dump_output(config: &config, testfile: &Path, out: &str, err: &str) {
 fn dump_output_file(config: &config, testfile: &Path,
                     out: &str, extension: &str) {
     let outfile = make_out_name(config, testfile, extension);
-    outfile.open_writer(io::CreateOrTruncate).write(out.as_bytes());
+    let writer =
+        io::file_writer(&outfile, [io::Create, io::Truncate]).unwrap();
+    writer.write_str(out);
 }
 
 fn make_out_name(config: &config, testfile: &Path, extension: &str) -> Path {
@@ -773,20 +771,24 @@ fn output_base_name(config: &config, testfile: &Path) -> Path {
 
 fn maybe_dump_to_stdout(config: &config, out: &str, err: &str) {
     if config.verbose {
-        println!("------{}------------------------------", "stdout");
-        println!("{}", out);
-        println!("------{}------------------------------", "stderr");
-        println!("{}", err);
-        println!("------------------------------------------");
+        let sep1 = format!("------{}------------------------------", "stdout");
+        let sep2 = format!("------{}------------------------------", "stderr");
+        let sep3 = ~"------------------------------------------";
+        io::stdout().write_line(sep1);
+        io::stdout().write_line(out);
+        io::stdout().write_line(sep2);
+        io::stdout().write_line(err);
+        io::stdout().write_line(sep3);
     }
 }
 
-fn error(err: ~str) { println!("\nerror: {}", err); }
+fn error(err: ~str) { io::stdout().write_line(format!("\nerror: {}", err)); }
 
 fn fatal(err: ~str) -> ! { error(err); fail!(); }
 
 fn fatal_ProcRes(err: ~str, ProcRes: &ProcRes) -> ! {
-    print!("\n\
+    let msg =
+        format!("\n\
 error: {}\n\
 command: {}\n\
 stdout:\n\
@@ -799,6 +801,7 @@ stderr:\n\
 ------------------------------------------\n\
 \n",
              err, ProcRes.cmdline, ProcRes.stdout, ProcRes.stderr);
+    io::stdout().write_str(msg);
     fail!();
 }
 
@@ -818,9 +821,9 @@ fn _arm_exec_compiled_test(config: &config, props: &TestProps,
         ~[(~"",~"")], Some(~""));
 
     if config.verbose {
-        println!("push ({}) {} {} {}",
+        io::stdout().write_str(format!("push ({}) {} {} {}",
             config.target, args.prog,
-            copy_result.out, copy_result.err);
+            copy_result.out, copy_result.err));
     }
 
     logv(config, format!("executing ({}) {}", config.target, cmdline));
@@ -910,9 +913,9 @@ fn _arm_push_aux_shared_library(config: &config, testfile: &Path) {
                 ~[(~"",~"")], Some(~""));
 
             if config.verbose {
-                println!("push ({}) {} {} {}",
+                io::stdout().write_str(format!("push ({}) {} {} {}",
                     config.target, file.display(),
-                    copy_result.out, copy_result.err);
+                    copy_result.out, copy_result.err));
             }
         }
     }
@@ -996,8 +999,7 @@ fn disassemble_extract(config: &config, _props: &TestProps,
 
 
 fn count_extracted_lines(p: &Path) -> uint {
-    let x = p.with_extension("ll").open_reader(io::Open).read_to_end();
-    let x = str::from_utf8_owned(x);
+    let x = io::read_whole_file_str(&p.with_extension("ll")).unwrap();
     x.line_iter().len()
 }
 

branches/dist-snap/src/compiletest/util.rs

@@ -10,6 +10,7 @@
 
 use common::config;
 
+use std::io;
 use std::os::getenv;
 
 /// Conversion table from triple OS name to Rust SYSNAME
@@ -63,5 +64,5 @@ pub fn path_div() -> ~str { ~";" }
 
 pub fn logv(config: &config, s: ~str) {
     debug!("{}", s);
-    if config.verbose { println(s); }
+    if config.verbose { io::println(s); }
 }

branches/dist-snap/src/etc/combine-tests.py

@@ -56,15 +56,15 @@ def scrub(b):
 d.write("extern mod extra;\n")
 d.write("extern mod run_pass_stage2;\n")
 d.write("use run_pass_stage2::*;\n")
-d.write("use std::rt::io;\n");
-d.write("use std::rt::io::Writer;\n");
+d.write("use std::io::WriterUtil;\n");
+d.write("use std::io;\n");
 d.write("fn main() {\n");
-d.write("    let mut out = io::stdout();\n");
+d.write("    let out = io::stdout();\n");
 i = 0
 for t in stage2_tests:
     p = os.path.join("test", "run-pass", t)
     p = p.replace("\\", "\\\\")
-    d.write("    out.write(\"run-pass [stage2]: %s\\n\".as_bytes());\n" % p)
+    d.write("    out.write_str(\"run-pass [stage2]: %s\\n\");\n" % p)
     d.write("    t_%d::main();\n" % i)
     i += 1
 d.write("}\n")

branches/dist-snap/src/libextra/arc.rs

@@ -148,6 +148,7 @@ impl<T:Freeze + Send> Clone for Arc<T> {
     * object. However, one of the `arc` objects can be sent to another task,
     * allowing them to share the underlying data.
     */
+    #[inline]
     fn clone(&self) -> Arc<T> {
         Arc { x: self.x.clone() }
     }
@@ -167,6 +168,7 @@ pub struct MutexArc<T> { priv x: UnsafeArc<MutexArcInner<T>> }
 
 impl<T:Send> Clone for MutexArc<T> {
     /// Duplicate a mutex-protected Arc. See arc::clone for more details.
+    #[inline]
     fn clone(&self) -> MutexArc<T> {
         // NB: Cloning the underlying mutex is not necessary. Its reference
         // count would be exactly the same as the shared state's.
@@ -349,6 +351,7 @@ pub struct RWArc<T> {
 
 impl<T:Freeze + Send> Clone for RWArc<T> {
     /// Duplicate a rwlock-protected Arc. See arc::clone for more details.
+    #[inline]
     fn clone(&self) -> RWArc<T> {
         RWArc { x: self.x.clone() }
     }