---

yaml
---
r: 141207
b: refs/heads/try2
c: 248a669
h: refs/heads/master
i:
  141205: 022ae92
  141203: 4fbac0b
  141199: 84f81ac
v: v3

Author: catamorphism

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: ed9a793d244c42e77e40f18a5f243ff58dec07f7
+refs/heads/try2: 248a66938181e67855ac6f330ff626a509611a9b
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/rust.md

@@ -2435,10 +2435,11 @@ match x {
 }
 ~~~~
 
-Patterns that bind variables default to binding to a copy of the matched value. This can be made
-explicit using the ```copy``` keyword, changed to bind to a borrowed pointer by using the ```ref```
-keyword, or to a mutable borrowed pointer using ```ref mut```, or the value can be moved into
-the new binding using ```move```.
+Patterns that bind variables default to binding to a copy or move of the matched value
+(depending on the matched value's type).
+This can be made explicit using the ```copy``` keyword,
+changed to bind to a borrowed pointer by using the ```ref``` keyword,
+or to a mutable borrowed pointer using ```ref mut```.
 
 A pattern that's just an identifier,
 like `Nil` in the previous answer,

branches/try2/doc/tutorial.md

@@ -1480,6 +1480,7 @@ This code creates a closure that adds a given string to its argument,
 returns it from a function, and then calls it:
 
 ~~~~
+# extern mod std;
 fn mk_appender(suffix: ~str) -> @fn(~str) -> ~str {
     // The compiler knows that we intend this closure to be of type @fn
     return |s| s + suffix;
@@ -2291,7 +2292,7 @@ let nonsense = mycircle.radius() * mycircle.area();
 
 ## Deriving implementations for traits
 
-A small number of traits in `std` and `extra` can have implementations
+A small number of traits in `std` and `std` can have implementations
 that can be automatically derived. These instances are specified by
 placing the `deriving` attribute on a data type declaration. For
 example, the following will mean that `Circle` has an implementation
@@ -2540,9 +2541,9 @@ as well as an inscrutable string of alphanumerics. These are both
 part of Rust's library versioning scheme. The alphanumerics are
 a hash representing the crate metadata.
 
-## The standard library
+## The std library
 
-The Rust standard library provides runtime features required by the language,
+The Rust std library provides runtime features required by the language,
 including the task scheduler and memory allocators, as well as library
 support for Rust built-in types, platform abstractions, and other commonly
 used features.
@@ -2558,7 +2559,7 @@ I/O abstractions ([`io`]), [containers] like [`hashmap`],
 common traits ([`kinds`], [`ops`], [`cmp`], [`num`],
 [`to_str`], [`clone`]), and complete bindings to the C standard library ([`libc`]).
 
-### Standard Library injection and the Rust prelude
+### Core injection and the Rust prelude
 
 `std` is imported at the topmost level of every crate by default, as
 if the first line of each crate was
@@ -2570,7 +2571,7 @@ with the `std::` path prefix, as in `use std::vec`, `use std::task::spawn`,
 etc.
 
 Additionally, `std` contains a `prelude` module that reexports many of the
-most common standard modules, types and traits. The contents of the prelude are
+most common std modules, types and traits. The contents of the prelude are
 imported into every *module* by default.  Implicitly, all modules behave as if
 they contained the following prologue:
 

branches/try2/src/compiletest/compiletest.rc

@@ -50,20 +50,20 @@ pub fn main() {
 
 pub fn parse_config(args: ~[~str]) -> config {
     let opts =
-        ~[getopts::reqopt("compile-lib-path"),
-          getopts::reqopt("run-lib-path"),
-          getopts::reqopt("rustc-path"), getopts::reqopt("src-base"),
-          getopts::reqopt("build-base"), getopts::reqopt("aux-base"),
-          getopts::reqopt("stage-id"),
-          getopts::reqopt("mode"), getopts::optflag("ignored"),
-          getopts::optopt("runtool"), getopts::optopt("rustcflags"),
-          getopts::optflag("verbose"),
-          getopts::optopt("logfile"),
-          getopts::optflag("jit"),
-          getopts::optflag("newrt"),
-          getopts::optopt("target"),
-          getopts::optopt("adb-path"),
-          getopts::optopt("adb-test-dir")
+        ~[getopts::reqopt(~"compile-lib-path"),
+          getopts::reqopt(~"run-lib-path"),
+          getopts::reqopt(~"rustc-path"), getopts::reqopt(~"src-base"),
+          getopts::reqopt(~"build-base"), getopts::reqopt(~"aux-base"),
+          getopts::reqopt(~"stage-id"),
+          getopts::reqopt(~"mode"), getopts::optflag(~"ignored"),
+          getopts::optopt(~"runtool"), getopts::optopt(~"rustcflags"),
+          getopts::optflag(~"verbose"),
+          getopts::optopt(~"logfile"),
+          getopts::optflag(~"jit"),
+          getopts::optflag(~"newrt"),
+          getopts::optopt(~"target"),
+          getopts::optopt(~"adb-path"),
+          getopts::optopt(~"adb-test-dir")
          ];
 
     assert!(!args.is_empty());
@@ -74,43 +74,43 @@ pub fn parse_config(args: ~[~str]) -> config {
           Err(f) => fail!(getopts::fail_str(f))
         };
 
-    fn opt_path(m: &getopts::Matches, nm: &str) -> Path {
+    fn opt_path(m: &getopts::Matches, nm: ~str) -> Path {
         Path(getopts::opt_str(m, nm))
     }
 
     config {
-        compile_lib_path: getopts::opt_str(matches, "compile-lib-path"),
-        run_lib_path: getopts::opt_str(matches, "run-lib-path"),
-        rustc_path: opt_path(matches, "rustc-path"),
-        src_base: opt_path(matches, "src-base"),
-        build_base: opt_path(matches, "build-base"),
-        aux_base: opt_path(matches, "aux-base"),
-        stage_id: getopts::opt_str(matches, "stage-id"),
-        mode: str_mode(getopts::opt_str(matches, "mode")),
-        run_ignored: getopts::opt_present(matches, "ignored"),
+        compile_lib_path: getopts::opt_str(matches, ~"compile-lib-path"),
+        run_lib_path: getopts::opt_str(matches, ~"run-lib-path"),
+        rustc_path: opt_path(matches, ~"rustc-path"),
+        src_base: opt_path(matches, ~"src-base"),
+        build_base: opt_path(matches, ~"build-base"),
+        aux_base: opt_path(matches, ~"aux-base"),
+        stage_id: getopts::opt_str(matches, ~"stage-id"),
+        mode: str_mode(getopts::opt_str(matches, ~"mode")),
+        run_ignored: getopts::opt_present(matches, ~"ignored"),
         filter:
              if vec::len(matches.free) > 0u {
                  option::Some(copy matches.free[0])
              } else { option::None },
-        logfile: getopts::opt_maybe_str(matches, "logfile").map(|s| Path(*s)),
-        runtool: getopts::opt_maybe_str(matches, "runtool"),
-        rustcflags: getopts::opt_maybe_str(matches, "rustcflags"),
-        jit: getopts::opt_present(matches, "jit"),
-        newrt: getopts::opt_present(matches, "newrt"),
-        target: opt_str2(getopts::opt_maybe_str(matches, "target")).to_str(),
-        adb_path: opt_str2(getopts::opt_maybe_str(matches, "adb-path")).to_str(),
+        logfile: getopts::opt_maybe_str(matches, ~"logfile").map(|s| Path(*s)),
+        runtool: getopts::opt_maybe_str(matches, ~"runtool"),
+        rustcflags: getopts::opt_maybe_str(matches, ~"rustcflags"),
+        jit: getopts::opt_present(matches, ~"jit"),
+        newrt: getopts::opt_present(matches, ~"newrt"),
+        target: opt_str2(getopts::opt_maybe_str(matches, ~"target")).to_str(),
+        adb_path: opt_str2(getopts::opt_maybe_str(matches, ~"adb-path")).to_str(),
         adb_test_dir:
-            opt_str2(getopts::opt_maybe_str(matches, "adb-test-dir")).to_str(),
+            opt_str2(getopts::opt_maybe_str(matches, ~"adb-test-dir")).to_str(),
         adb_device_status:
-            if (opt_str2(getopts::opt_maybe_str(matches, "target")) ==
+            if (opt_str2(getopts::opt_maybe_str(matches, ~"target")) ==
                 ~"arm-linux-androideabi") {
-                if (opt_str2(getopts::opt_maybe_str(matches, "adb-test-dir")) !=
+                if (opt_str2(getopts::opt_maybe_str(matches, ~"adb-test-dir")) !=
                     ~"(none)" &&
-                    opt_str2(getopts::opt_maybe_str(matches, "adb-test-dir")) !=
+                    opt_str2(getopts::opt_maybe_str(matches, ~"adb-test-dir")) !=
                     ~"") { true }
                 else { false }
             } else { false },
-        verbose: getopts::opt_present(matches, "verbose")
+        verbose: getopts::opt_present(matches, ~"verbose")
     }
 }
 

branches/try2/src/compiletest/header.rs

@@ -87,10 +87,10 @@ pub fn load_props(testfile: &Path) -> TestProps {
 
 pub fn is_test_ignored(config: &config, testfile: &Path) -> bool {
     for iter_header(testfile) |ln| {
-        if parse_name_directive(ln, "xfail-test") { return true; }
+        if parse_name_directive(ln, ~"xfail-test") { return true; }
         if parse_name_directive(ln, xfail_target()) { return true; }
         if config.mode == common::mode_pretty &&
-           parse_name_directive(ln, "xfail-pretty") { return true; }
+           parse_name_directive(ln, ~"xfail-pretty") { return true; }
     };
     return false;
 
@@ -107,7 +107,8 @@ fn iter_header(testfile: &Path, it: &fn(~str) -> bool) -> bool {
         // Assume that any directives will be found before the first
         // module or function. This doesn't seem to be an optimization
         // with a warm page cache. Maybe with a cold one.
-        if str::starts_with(ln, "fn") || str::starts_with(ln, "mod") {
+        if str::starts_with(ln, ~"fn")
+            || str::starts_with(ln, ~"mod") {
             return false;
         } else { if !(it(ln)) { return false; } }
     }

branches/try2/src/compiletest/runtest.rs

@@ -25,7 +25,7 @@ use util::logv;
 pub fn run(config: config, testfile: ~str) {
     if config.verbose {
         // We're going to be dumping a lot of info. Start on a new line.
-        io::stdout().write_str("\n\n");
+        io::stdout().write_str(~"\n\n");
     }
     let testfile = Path(testfile);
     debug!("running %s", testfile.to_str());
@@ -231,7 +231,7 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
     // do not optimize debuginfo tests
     let mut config = match config.rustcflags {
         Some(ref flags) => config {
-            rustcflags: Some(str::replace(*flags, "-O", "")),
+            rustcflags: Some(str::replace(*flags, ~"-O", ~"")),
             .. copy *config
         },
         None => copy *config
@@ -249,19 +249,19 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
     // write debugger script
     let script_str = str::append(cmds, "\nquit\n");
     debug!("script_str = %s", script_str);
-    dump_output_file(config, testfile, script_str, "debugger.script");
+    dump_output_file(config, testfile, script_str, ~"debugger.script");
 
     // run debugger script with gdb
     #[cfg(windows)]
     fn debugger() -> ~str { ~"gdb.exe" }
     #[cfg(unix)]
     fn debugger() -> ~str { ~"gdb" }
-    let debugger_script = make_out_name(config, testfile, "debugger.script");
+    let debugger_script = make_out_name(config, testfile, ~"debugger.script");
     let debugger_opts = ~[~"-quiet", ~"-batch", ~"-nx",
                           ~"-command=" + debugger_script.to_str(),
                           make_exe_name(config, testfile).to_str()];
     let ProcArgs = ProcArgs {prog: debugger(), args: debugger_opts};
-    ProcRes = compose_and_run(config, testfile, ProcArgs, ~[], "", None);
+    ProcRes = compose_and_run(config, testfile, ProcArgs, ~[], ~"", None);
     if ProcRes.status != 0 {
         fatal(~"gdb failed to execute");
     }
@@ -368,7 +368,7 @@ fn check_expected_errors(expected_errors: ~[errors::ExpectedError],
         }
 
         // ignore this msg which gets printed at the end
-        if str::contains(line, "aborting due to") {
+        if str::contains(line, ~"aborting due to") {
             was_expected = true;
         }
 
@@ -643,7 +643,7 @@ fn program_output(config: &config, testfile: &Path, lib_path: &str, prog: ~str,
 #[cfg(target_os = "macos")]
 #[cfg(target_os = "freebsd")]
 fn make_cmdline(_libpath: &str, prog: &str, args: &[~str]) -> ~str {
-    fmt!("%s %s", prog, str::connect(args, " "))
+    fmt!("%s %s", prog, str::connect(args, ~" "))
 }
 
 #[cfg(target_os = "win32")]
@@ -668,7 +668,7 @@ 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]).get();
+        io::file_writer(&outfile, ~[io::Create, io::Truncate]).get();
     writer.write_str(out);
 }
 
@@ -692,8 +692,8 @@ 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 = fmt!("------%s------------------------------", "stdout");
-        let sep2 = fmt!("------%s------------------------------", "stderr");
+        let sep1 = fmt!("------%s------------------------------", ~"stdout");
+        let sep2 = fmt!("------%s------------------------------", ~"stderr");
         let sep3 = ~"------------------------------------------";
         io::stdout().write_line(sep1);
         io::stdout().write_line(out);
@@ -781,10 +781,10 @@ fn _arm_exec_compiled_test(config: &config, props: &TestProps,
     newargs_err.push(newcmd_err);
 
     let procsrv::Result{ out: out_out, err: _out_err, status: out_status } =
-            procsrv::run("", config.adb_path, newargs_out, ~[(~"",~"")],
+            procsrv::run(~"", config.adb_path, newargs_out, ~[(~"",~"")],
                          Some(~""));
     let procsrv::Result{ out: err_out, err: _err_err, status: _err_status } =
-            procsrv::run("", config.adb_path, newargs_err, ~[(~"",~"")],
+            procsrv::run(~"", config.adb_path, newargs_err, ~[(~"",~"")],
                          Some(~""));
 
     dump_output(config, testfile, out_out, err_out);
@@ -818,8 +818,8 @@ fn _arm_push_aux_shared_library(config: &config, testfile: &Path) {
 
         if (file.filetype() == Some(~".so")) {
 
-            let copy_result = procsrv::run("", config.adb_path,
-                [~"push", file.to_str(), copy config.adb_test_dir],
+            let copy_result = procsrv::run(~"", config.adb_path,
+                ~[~"push", file.to_str(), copy config.adb_test_dir],
                 ~[(~"",~"")], Some(~""));
 
             if config.verbose {

branches/try2/src/libextra/base64.rs

@@ -12,6 +12,10 @@
 
 use core::prelude::*;
 
+use core::old_iter;
+use core::str;
+use core::vec;
+
 pub trait ToBase64 {
     fn to_base64(&self) -> ~str;
 }
@@ -238,12 +242,12 @@ mod tests {
 
     #[test]
     fn test_from_base64() {
-        assert_eq!((~"").from_base64(), str::to_bytes(""));
-        assert!((~"Zg==").from_base64() == str::to_bytes("f"));
-        assert_eq!((~"Zm8=").from_base64(), str::to_bytes("fo"));
-        assert_eq!((~"Zm9v").from_base64(), str::to_bytes("foo"));
-        assert!((~"Zm9vYg==").from_base64() == str::to_bytes("foob"));
-        assert_eq!((~"Zm9vYmE=").from_base64(), str::to_bytes("fooba"))
-        assert_eq!((~"Zm9vYmFy").from_base64(), str::to_bytes("foobar"));
+        assert_eq!((~"").from_base64(), str::to_bytes(~""));
+        assert!((~"Zg==").from_base64() == str::to_bytes(~"f"));
+        assert_eq!((~"Zm8=").from_base64(), str::to_bytes(~"fo"));
+        assert_eq!((~"Zm9v").from_base64(), str::to_bytes(~"foo"));
+        assert!((~"Zm9vYg==").from_base64() == str::to_bytes(~"foob"));
+        assert_eq!((~"Zm9vYmE=").from_base64(), str::to_bytes(~"fooba"))
+        assert_eq!((~"Zm9vYmFy").from_base64(), str::to_bytes(~"foobar"));
     }
 }

branches/try2/src/libextra/bitv.rs

@@ -10,6 +10,8 @@
 
 use core::prelude::*;
 
+use core::vec::from_elem;
+
 struct SmallBitv {
     /// only the lowest nbits of this value are used. the rest is undefined.
     bits: uint
@@ -255,7 +257,7 @@ pub impl Bitv {
             let nelems = nbits/uint::bits +
                          if nbits % uint::bits == 0 {0} else {1};
             let elem = if init {!0} else {0};
-            let s = vec::from_elem(nelems, elem);
+            let s = from_elem(nelems, elem);
             Big(~BigBitv::new(s))
         };
         Bitv {rep: rep, nbits: nbits}
@@ -500,7 +502,7 @@ impl Clone for Bitv {
             Bitv{nbits: self.nbits, rep: Small(~SmallBitv{bits: b.bits})}
           }
           Big(ref b) => {
-            let mut st = vec::from_elem(self.nbits / uint::bits + 1, 0);
+            let mut st = from_elem(self.nbits / uint::bits + 1, 0);
             let len = st.len();
             for uint::range(0, len) |i| { st[i] = b.storage[i]; };
             Bitv{nbits: self.nbits, rep: Big(~BigBitv{storage: st})}
@@ -870,14 +872,17 @@ mod tests {
 
     #[test]
     fn test_0_elements() {
-        let act = Bitv::new(0u, false);
-        let exp = vec::from_elem::<uint>(0u, 0u);
+        let mut act;
+        let exp;
+        act = Bitv::new(0u, false);
+        exp = vec::from_elem::<uint>(0u, 0u);
         assert!(act.eq_vec(exp));
     }
 
     #[test]
     fn test_1_element() {
-        let mut act = Bitv::new(1u, false);
+        let mut act;
+        act = Bitv::new(1u, false);
         assert!(act.eq_vec(~[0u]));
         act = Bitv::new(1u, true);
         assert!(act.eq_vec(~[1u]));
@@ -1483,7 +1488,7 @@ mod tests {
     #[bench]
     fn bench_bitv_big_union(b: &mut BenchHarness) {
         let mut b1 = Bitv::new(bench_bits, false);
-        let b2 = Bitv::new(bench_bits, false);
+        let mut b2 = Bitv::new(bench_bits, false);
         do b.iter {
             b1.union(&b2);
         }