---

yaml
---
r: 95662
b: refs/heads/dist-snap
c: 950add4
h: refs/heads/master
v: v3

Author: bors

[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: 9a773da681a92c599f7b56f66f79bc107eeadbee
+refs/heads/dist-snap: 950add4e49cc2ac5d60abd6da969392123ddcce0
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/.gitmodules

@@ -8,4 +8,4 @@
 	branch = master
 [submodule "src/gyp"]
 	path = src/gyp
-	url = https://git.chromium.org/external/gyp.git
+	url = https://github.com/brson/gyp.git

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,7 +69,6 @@ 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::io::println;
+use puts = std::rt::io::stdio::println;
 
 fn main() {
     println("println is imported per default.");
     puts("Doesn't hinder you from importing it under an different name yourself.");
-    ::std::io::println("Or from not using the automatic import.");
+    ::std::rt::io::stdio::println("Or from not using the automatic import.");
 }
 ~~~
 

branches/dist-snap/mk/install.mk

@@ -23,6 +23,10 @@ else
  INSTALL = $(Q)$(call E, install: $(2)/$(3)) && install -m755 $(1)/$(3) $(2)/$(3)
 endif
 
+# For MK_INSTALL_DIR
+# $(1) is the directory to create
+MK_INSTALL_DIR = (umask 022 && mkdir -p $(1))
+
 # For INSTALL_LIB,
 # Target-specific $(LIB_SOURCE_DIR) is the source directory
 # Target-specific $(LIB_DESTIN_DIR) is the destination directory
@@ -83,7 +87,7 @@ define INSTALL_TARGET_N
 install-target-$(1)-host-$(2): LIB_SOURCE_DIR=$$(TL$(1)$(2))
 install-target-$(1)-host-$(2): LIB_DESTIN_DIR=$$(PTL$(1)$(2))
 install-target-$(1)-host-$(2): $$(TSREQ$$(ISTAGE)_T_$(1)_H_$(2)) $$(SREQ$$(ISTAGE)_T_$(1)_H_$(2))
-	$$(Q)mkdir -p $$(PTL$(1)$(2))
+	$$(Q)$$(call MK_INSTALL_DIR,$$(PTL$(1)$(2)))
 	$$(Q)$$(call INSTALL_LIB,$$(CFG_RUNTIME_$(1)))
 	$$(Q)$$(call INSTALL_LIB,$$(STDLIB_GLOB_$(1)))
 	$$(Q)$$(call INSTALL_LIB,$$(EXTRALIB_GLOB_$(1)))
@@ -95,7 +99,7 @@ define INSTALL_HOST_N
 install-target-$(1)-host-$(2): LIB_SOURCE_DIR=$$(TL$(1)$(2))
 install-target-$(1)-host-$(2): LIB_DESTIN_DIR=$$(PTL$(1)$(2))
 install-target-$(1)-host-$(2): $$(CSREQ$$(ISTAGE)_T_$(1)_H_$(2))
-	$$(Q)mkdir -p $$(PTL$(1)$(2))
+	$$(Q)$$(call MK_INSTALL_DIR,$$(PTL$(1)$(2)))
 	$$(Q)$$(call INSTALL_LIB,$$(CFG_RUNTIME_$(1)))
 	$$(Q)$$(call INSTALL_LIB,$$(CFG_RUSTLLVM_$(1)))
 	$$(Q)$$(call INSTALL_LIB,$$(STDLIB_GLOB_$(1)))
@@ -131,9 +135,9 @@ PHL = $(PREFIX_LIB)
 install-host: LIB_SOURCE_DIR=$(HL)
 install-host: LIB_DESTIN_DIR=$(PHL)
 install-host: $(CSREQ$(ISTAGE)_T_$(CFG_BUILD_TRIPLE)_H_$(CFG_BUILD_TRIPLE))
-	$(Q)mkdir -p $(PREFIX_BIN)
-	$(Q)mkdir -p $(PREFIX_LIB)
-	$(Q)mkdir -p $(PREFIX_ROOT)/share/man/man1
+	$(Q)$(call MK_INSTALL_DIR,$(PREFIX_BIN))
+	$(Q)$(call MK_INSTALL_DIR,$(PREFIX_LIB))
+	$(Q)$(call MK_INSTALL_DIR,$(PREFIX_ROOT)/share/man/man1)
 	$(Q)$(call INSTALL,$(HB2),$(PHB),rustc$(X_$(CFG_BUILD_TRIPLE)))
 	$(Q)$(call INSTALL,$(HB2),$(PHB),rustpkg$(X_$(CFG_BUILD_TRIPLE)))
 	$(Q)$(call INSTALL,$(HB2),$(PHB),rustdoc$(X_$(CFG_BUILD_TRIPLE)))

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

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

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

@@ -10,7 +10,6 @@
 
 use common::config;
 
-use std::io;
 use std::os::getenv;
 
 /// Conversion table from triple OS name to Rust SYSNAME
@@ -64,5 +63,5 @@ pub fn path_div() -> ~str { ~";" }
 
 pub fn logv(config: &config, s: ~str) {
     debug!("{}", s);
-    if config.verbose { io::println(s); }
+    if config.verbose { 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::io::WriterUtil;\n");
-d.write("use std::io;\n");
+d.write("use std::rt::io;\n");
+d.write("use std::rt::io::Writer;\n");
 d.write("fn main() {\n");
-d.write("    let out = io::stdout();\n");
+d.write("    let mut 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_str(\"run-pass [stage2]: %s\\n\");\n" % p)
+    d.write("    out.write(\"run-pass [stage2]: %s\\n\".as_bytes());\n" % p)
     d.write("    t_%d::main();\n" % i)
     i += 1
 d.write("}\n")

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

@@ -117,10 +117,12 @@ pub struct Arc<T> { priv x: UnsafeArc<T> }
  */
 impl<T:Freeze+Send> Arc<T> {
     /// Create an atomically reference counted wrapper.
+    #[inline]
     pub fn new(data: T) -> Arc<T> {
         Arc { x: UnsafeArc::new(data) }
     }
 
+    #[inline]
     pub fn get<'a>(&'a self) -> &'a T {
         unsafe { &*self.x.get_immut() }
     }
@@ -148,6 +150,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 +170,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 +353,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() }
     }

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

@@ -136,7 +136,7 @@ pub fn rendezvous<T: Send>() -> (SyncPort<T>, SyncChan<T>) {
 #[cfg(test)]
 mod test {
     use comm::{DuplexStream, rendezvous};
-    use std::rt::test::run_in_newsched_task;
+    use std::rt::test::run_in_uv_task;
     use std::task::spawn_unlinked;
 
 
@@ -165,7 +165,7 @@ mod test {
     #[test]
     fn recv_a_lot() {
         // Rendezvous streams should be able to handle any number of messages being sent
-        do run_in_newsched_task {
+        do run_in_uv_task {
             let (port, chan) = rendezvous();
             do spawn {
                 do 1000000.times { chan.send(()) }