---

yaml
---
r: 170971
b: refs/heads/try
c: 2404232
h: refs/heads/master
i:
  170969: 7a96e4f
  170967: 25eac3d
v: v3

Author: reem

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 73a25f55ad748b4d3516417c711b99ce446591af
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 5b3cd3900ceda838f5798c30ab96ceb41f962534
-refs/heads/try: 0393a1602fd224adc36b62e7158f3b1ebb257afb
+refs/heads/try: 240423236906a2df976edd6065bbc595711b83c0
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try/src/compiletest/common.rs

@@ -43,9 +43,9 @@ impl FromStr for Mode {
     }
 }
 
-impl fmt::String for Mode {
+impl fmt::Show for Mode {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(match *self {
+        let msg = match *self {
             CompileFail => "compile-fail",
             RunFail => "run-fail",
             RunPass => "run-pass",
@@ -54,13 +54,8 @@ impl fmt::String for Mode {
             DebugInfoGdb => "debuginfo-gdb",
             DebugInfoLldb => "debuginfo-lldb",
             Codegen => "codegen",
-        }, f)
-    }
-}
-
-impl fmt::Show for Mode {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
+        };
+        msg.fmt(f)
     }
 }
 

branches/try/src/compiletest/compiletest.rs

@@ -16,8 +16,14 @@
 extern crate test;
 extern crate getopts;
 
+#[cfg(stage0)]
+#[phase(plugin, link)]
+extern crate log;
+
+#[cfg(not(stage0))]
 #[macro_use]
 extern crate log;
+
 extern crate regex;
 
 use std::os;
@@ -102,7 +108,7 @@ pub fn parse_config(args: Vec<String> ) -> Config {
     let matches =
         &match getopts::getopts(args_.as_slice(), groups.as_slice()) {
           Ok(m) => m,
-          Err(f) => panic!("{:?}", f)
+          Err(f) => panic!("{}", f)
         };
 
     if matches.opt_present("h") || matches.opt_present("help") {
@@ -121,7 +127,7 @@ pub fn parse_config(args: Vec<String> ) -> Config {
         match regex::Regex::new(s) {
             Ok(re) => Some(re),
             Err(e) => {
-                println!("failed to parse filter /{}/: {:?}", s, e);
+                println!("failed to parse filter /{}/: {}", s, e);
                 panic!()
             }
         }
@@ -180,11 +186,11 @@ pub fn parse_config(args: Vec<String> ) -> Config {
 pub fn log_config(config: &Config) {
     let c = config;
     logv(c, format!("configuration:"));
-    logv(c, format!("compile_lib_path: {:?}", config.compile_lib_path));
-    logv(c, format!("run_lib_path: {:?}", config.run_lib_path));
-    logv(c, format!("rustc_path: {:?}", config.rustc_path.display()));
-    logv(c, format!("src_base: {:?}", config.src_base.display()));
-    logv(c, format!("build_base: {:?}", config.build_base.display()));
+    logv(c, format!("compile_lib_path: {}", config.compile_lib_path));
+    logv(c, format!("run_lib_path: {}", config.run_lib_path));
+    logv(c, format!("rustc_path: {}", config.rustc_path.display()));
+    logv(c, format!("src_base: {}", config.src_base.display()));
+    logv(c, format!("build_base: {}", config.build_base.display()));
     logv(c, format!("stage_id: {}", config.stage_id));
     logv(c, format!("mode: {}", config.mode));
     logv(c, format!("run_ignored: {}", config.run_ignored));
@@ -200,10 +206,10 @@ pub fn log_config(config: &Config) {
     logv(c, format!("jit: {}", config.jit));
     logv(c, format!("target: {}", config.target));
     logv(c, format!("host: {}", config.host));
-    logv(c, format!("android-cross-path: {:?}",
+    logv(c, format!("android-cross-path: {}",
                     config.android_cross_path.display()));
-    logv(c, format!("adb_path: {:?}", config.adb_path));
-    logv(c, format!("adb_test_dir: {:?}", config.adb_test_dir));
+    logv(c, format!("adb_path: {}", config.adb_path));
+    logv(c, format!("adb_test_dir: {}", config.adb_test_dir));
     logv(c, format!("adb_device_status: {}",
                     config.adb_device_status));
     match config.test_shard {
@@ -265,7 +271,7 @@ pub fn run_tests(config: &Config) {
         Ok(true) => {}
         Ok(false) => panic!("Some tests failed"),
         Err(e) => {
-            println!("I/O failure during tests: {:?}", e);
+            println!("I/O failure during tests: {}", e);
         }
     }
 }
@@ -293,13 +299,13 @@ pub fn test_opts(config: &Config) -> test::TestOpts {
 }
 
 pub fn make_tests(config: &Config) -> Vec<test::TestDescAndFn> {
-    debug!("making tests from {:?}",
+    debug!("making tests from {}",
            config.src_base.display());
     let mut tests = Vec::new();
     let dirs = fs::readdir(&config.src_base).unwrap();
     for file in dirs.iter() {
         let file = file.clone();
-        debug!("inspecting file {:?}", file.display());
+        debug!("inspecting file {}", file.display());
         if is_test(config, &file) {
             let t = make_test(config, &file, || {
                 match config.mode {

branches/try/src/compiletest/errors.rs

@@ -84,7 +84,7 @@ fn parse_expected(last_nonfollow_error: Option<uint>,
             (which, line)
         };
 
-        debug!("line={} which={:?} kind={:?} msg={:?}", line_num, which, kind, msg);
+        debug!("line={} which={} kind={} msg={}", line_num, which, kind, msg);
         Some((which, ExpectedError { line: line,
                                      kind: kind,
                                      msg: msg, }))

branches/try/src/compiletest/runtest.rs

@@ -61,7 +61,7 @@ pub fn run_metrics(config: Config, testfile: String, mm: &mut MetricMap) {
         print!("\n\n");
     }
     let testfile = Path::new(testfile);
-    debug!("running {:?}", testfile.display());
+    debug!("running {}", testfile.display());
     let props = header::load_props(&testfile);
     debug!("loaded props");
     match config.mode {
@@ -141,7 +141,7 @@ fn check_correct_failure_status(proc_res: &ProcRes) {
     static RUST_ERR: int = 101;
     if !proc_res.status.matches_exit_status(RUST_ERR) {
         fatal_proc_rec(
-            format!("failure produced the wrong error: {:?}",
+            format!("failure produced the wrong error: {}",
                     proc_res.status).as_slice(),
             proc_res);
     }
@@ -410,7 +410,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
                          ],
                          vec!(("".to_string(), "".to_string())),
                          Some("".to_string()))
-                .expect(format!("failed to exec `{:?}`", config.adb_path).as_slice());
+                .expect(format!("failed to exec `{}`", config.adb_path).as_slice());
 
             procsrv::run("",
                          config.adb_path.as_slice(),
@@ -422,7 +422,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
                          ],
                          vec!(("".to_string(), "".to_string())),
                          Some("".to_string()))
-                .expect(format!("failed to exec `{:?}`", config.adb_path).as_slice());
+                .expect(format!("failed to exec `{}`", config.adb_path).as_slice());
 
             let adb_arg = format!("export LD_LIBRARY_PATH={}; \
                                    gdbserver :5039 {}/{}",
@@ -443,11 +443,11 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
                                                       vec!(("".to_string(),
                                                             "".to_string())),
                                                       Some("".to_string()))
-                .expect(format!("failed to exec `{:?}`", config.adb_path).as_slice());
+                .expect(format!("failed to exec `{}`", config.adb_path).as_slice());
             loop {
                 //waiting 1 second for gdbserver start
                 timer::sleep(Duration::milliseconds(1000));
-                let result = Thread::scoped(move || {
+                let result = Thread::spawn(move || {
                     tcp::TcpStream::connect("127.0.0.1:5039").unwrap();
                 }).join();
                 if result.is_err() {
@@ -481,7 +481,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
                              debugger_opts.as_slice(),
                              vec!(("".to_string(), "".to_string())),
                              None)
-                .expect(format!("failed to exec `{:?}`", gdb_path).as_slice());
+                .expect(format!("failed to exec `{}`", gdb_path).as_slice());
             let cmdline = {
                 let cmdline = make_cmdline("",
                                            "arm-linux-androideabi-gdb",
@@ -539,17 +539,18 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
             script_str.push_str("set print pretty off\n");
 
             // Add the pretty printer directory to GDB's source-file search path
-            script_str.push_str(&format!("directory {}\n", rust_pp_module_abs_path)[]);
+            script_str.push_str(format!("directory {}\n", rust_pp_module_abs_path)[]);
 
             // Load the target executable
-            script_str.push_str(&format!("file {}\n",
-                                         exe_file.as_str().unwrap().replace("\\", "\\\\"))[]);
+            script_str.push_str(format!("file {}\n",
+                                        exe_file.as_str().unwrap().replace("\\", "\\\\"))
+                                    .as_slice());
 
             // Add line breakpoints
             for line in breakpoint_lines.iter() {
-                script_str.push_str(&format!("break '{:?}':{}\n",
-                                             testfile.filename_display(),
-                                             *line)[]);
+                script_str.push_str(format!("break '{}':{}\n",
+                                            testfile.filename_display(),
+                                            *line)[]);
             }
 
             script_str.push_str(cmds.as_slice());
@@ -675,7 +676,7 @@ fn run_debuginfo_lldb_test(config: &Config, props: &TestProps, testfile: &Path)
                                                .unwrap()
                                                .to_string();
 
-    script_str.push_str(&format!("command script import {}\n", &rust_pp_module_abs_path[])[]);
+    script_str.push_str(format!("command script import {}\n", rust_pp_module_abs_path[])[]);
     script_str.push_str("type summary add --no-value ");
     script_str.push_str("--python-function lldb_rust_formatters.print_val ");
     script_str.push_str("-x \".*\" --category Rust\n");
@@ -888,7 +889,7 @@ fn check_error_patterns(props: &TestProps,
                         output_to_check: &str,
                         proc_res: &ProcRes) {
     if props.error_patterns.is_empty() {
-        fatal(format!("no error pattern specified in {:?}",
+        fatal(format!("no error pattern specified in {}",
                       testfile.display()).as_slice());
     }
     let mut next_err_idx = 0u;
@@ -909,7 +910,7 @@ fn check_error_patterns(props: &TestProps,
     if done { return; }
 
     let missing_patterns =
-        props.error_patterns.index(&(next_err_idx..));
+        props.error_patterns[next_err_idx..];
     if missing_patterns.len() == 1u {
         fatal_proc_rec(format!("error pattern '{}' not found!",
                               missing_patterns[0]).as_slice(),
@@ -954,7 +955,7 @@ fn check_expected_errors(expected_errors: Vec<errors::ExpectedError> ,
     }
 
     let prefixes = expected_errors.iter().map(|ee| {
-        format!("{:?}:{}:", testfile.display(), ee.line)
+        format!("{}:{}:", testfile.display(), ee.line)
     }).collect::<Vec<String> >();
 
     #[cfg(windows)]
@@ -1190,7 +1191,7 @@ fn compose_and_run_compiler(
                                      None);
         if !auxres.status.success() {
             fatal_proc_rec(
-                format!("auxiliary build of {:?} failed to compile: ",
+                format!("auxiliary build of {} failed to compile: ",
                         abs_ab.display()).as_slice(),
                 &auxres);
         }
@@ -1600,7 +1601,7 @@ fn _arm_push_aux_shared_library(config: &Config, testfile: &Path) {
                 .expect(format!("failed to exec `{}`", config.adb_path).as_slice());
 
             if config.verbose {
-                println!("push ({}) {:?} {} {}",
+                println!("push ({}) {} {} {}",
                     config.target, file.display(),
                     copy_result.out, copy_result.err);
             }

branches/try/src/doc/guide-unsafe.md

@@ -703,10 +703,10 @@ Other features provided by lang items include:
   `deref`, and `add` respectively.
 - stack unwinding and general failure; the `eh_personality`, `fail`
   and `fail_bounds_checks` lang items.
-- the traits in `std::markers` used to indicate types of
+- the traits in `std::kinds` used to indicate types that satisfy
   various kinds; lang items `send`, `sync` and `copy`.
 - the marker types and variance indicators found in
-  `std::markers`; lang items `covariant_type`,
+  `std::kinds::markers`; lang items `covariant_type`,
   `contravariant_lifetime`, `no_sync_bound`, etc.
 
 Lang items are loaded lazily by the compiler; e.g. if one never uses

branches/try/src/doc/intro.md

@@ -395,7 +395,7 @@ fn main() {
     for _ in range(0u, 10u) {
         Thread::spawn(move || {
             println!("Hello, world!");
-        });
+        }).detach();
     }
 }
 ```
@@ -405,7 +405,8 @@ This program creates ten threads, who all print `Hello, world!`. The
 double bars `||`. (The `move` keyword indicates that the closure takes
 ownership of any data it uses; we'll have more on the significance of
 this shortly.) This closure is executed in a new thread created by
-`spawn`.
+`spawn`. The `detach` method means that the child thread is allowed to
+outlive its parent.
 
 One common form of problem in concurrent programs is a 'data race.'
 This occurs when two different threads attempt to access the same
@@ -428,7 +429,7 @@ fn main() {
     for i in range(0u, 3u) {
         Thread::spawn(move || {
             for j in range(0, 3) { numbers[j] += 1 }
-        });
+        }).detach();
     }
 }
 ```
@@ -487,7 +488,7 @@ fn main() {
             (*array)[i] += 1;
 
             println!("numbers[{}] is {}", i, (*array)[i]);
-        });
+        }).detach();
     }
 }
 ```

branches/try/src/doc/reference.md

@@ -690,9 +690,10 @@ balanced, but they are otherwise not special.
 
 In the matcher, `$` _name_ `:` _designator_ matches the nonterminal in the Rust
 syntax named by _designator_. Valid designators are `item`, `block`, `stmt`,
-`pat`, `expr`, `ty` (type), `ident`, `path`, `tt` (either side of the `=>`
-in macro rules). In the transcriber, the designator is already known, and so
-only the name of a matched nonterminal comes after the dollar sign.
+`pat`, `expr`, `ty` (type), `ident`, `path`, `matchers` (lhs of the `=>` in
+macro rules), `tt` (rhs of the `=>` in macro rules). In the transcriber, the
+designator is already known, and so only the name of a matched nonterminal
+comes after the dollar sign.
 
 In both the matcher and transcriber, the Kleene star-like operator indicates
 repetition. The Kleene star operator consists of `$` and parens, optionally

branches/try/src/etc/gdb_rust_pretty_printing.py

@@ -51,7 +51,7 @@ def rust_pretty_printer_lookup_function(val):
     enum_member_count = len(enum_members)
 
     if enum_member_count == 0:
-      return RustStructPrinter(val, False)
+      return RustStructPrinter(val, false)
 
     if enum_member_count == 1:
       first_variant_name = enum_members[0].name
@@ -60,27 +60,21 @@ def rust_pretty_printer_lookup_function(val):
         return rust_pretty_printer_lookup_function(val[enum_members[0]])
       else:
         assert first_variant_name.startswith("RUST$ENCODED$ENUM$")
-        # This is a space-optimized enum.
-        # This means this enum has only two states, and Rust uses one of the
-        # fields somewhere in the struct to determine which of the two states
-        # it's in. The location of the field is encoded in the name as something
-        # like RUST$ENCODED$ENUM$(num$)*name_of_zero_state
+        # This is a space-optimized enum
         last_separator_index = first_variant_name.rfind("$")
-        start_index = len("RUST$ENCODED$ENUM$")
-        disr_field_indices = first_variant_name[start_index :
-                                              last_separator_index].split("$")
-        disr_field_indices = [int(index) for index in disr_field_indices]
+        second_last_separator_index = first_variant_name.rfind("$", 0, last_separator_index)
+        disr_field_index = first_variant_name[second_last_separator_index + 1 :
+                                              last_separator_index]
+        disr_field_index = int(disr_field_index)
 
         sole_variant_val = val[enum_members[0]]
-        discriminant = sole_variant_val
-        for disr_field_index in disr_field_indices:
-          disr_field = get_field_at_index(discriminant, disr_field_index)
-          discriminant = discriminant[disr_field]
+        disr_field = get_field_at_index(sole_variant_val, disr_field_index)
+        discriminant = sole_variant_val[disr_field]
 
         # If the discriminant field is a fat pointer we have to consider the
         # first word as the true discriminant
         if discriminant.type.code == gdb.TYPE_CODE_STRUCT:
-          discriminant = discriminant[get_field_at_index(discriminant, 0)]
+            discriminant = discriminant[get_field_at_index(discriminant, 0)]
 
         if discriminant == 0:
           null_variant_name = first_variant_name[last_separator_index + 1:]
@@ -240,5 +234,4 @@ def get_field_at_index(val, index):
   for field in val.type.fields():
     if i == index:
       return field
-    i += 1
   return None