---

yaml
---
r: 92296
b: refs/heads/auto
c: d7c9493
h: refs/heads/master
v: v3

Author: MicahChalmer

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: ca54ad8592087dfe7d2b422f35d75f3932c1991b
+refs/heads/auto: d7c949368c0df7a17a87e0597e4948c533ecac43
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/compiletest/procsrv.rs

@@ -46,57 +46,47 @@ pub fn run(lib_path: &str,
            prog: &str,
            args: &[~str],
            env: ~[(~str, ~str)],
-           input: Option<~str>) -> Option<Result> {
+           input: Option<~str>) -> Result {
 
     let env = env + target_env(lib_path, prog);
-    let mut opt_process = run::Process::new(prog, args, run::ProcessOptions {
+    let mut process = run::Process::new(prog, args, run::ProcessOptions {
         env: Some(env),
         dir: None,
         in_fd: None,
         out_fd: None,
         err_fd: None
     });
 
-    match opt_process {
-        Some(ref mut process) => {
-            for input in input.iter() {
-                process.input().write(input.as_bytes());
-            }
-            let run::ProcessOutput { status, output, error } = process.finish_with_output();
+    for input in input.iter() {
+        process.input().write(input.as_bytes());
+    }
+    let run::ProcessOutput { status, output, error } = process.finish_with_output();
 
-            Some(Result {
-                status: status,
-                out: str::from_utf8_owned(output),
-                err: str::from_utf8_owned(error)
-            })
-        },
-        None => None
+    Result {
+        status: status,
+        out: str::from_utf8_owned(output),
+        err: str::from_utf8_owned(error)
     }
 }
 
 pub fn run_background(lib_path: &str,
            prog: &str,
            args: &[~str],
            env: ~[(~str, ~str)],
-           input: Option<~str>) -> Option<run::Process> {
+           input: Option<~str>) -> run::Process {
 
     let env = env + target_env(lib_path, prog);
-    let opt_process = run::Process::new(prog, args, run::ProcessOptions {
+    let mut process = run::Process::new(prog, args, run::ProcessOptions {
         env: Some(env),
         dir: None,
         in_fd: None,
         out_fd: None,
         err_fd: None
     });
 
-    match opt_process {
-        Some(mut process) => {
-            for input in input.iter() {
-                process.input().write(input.as_bytes());
-            }
-
-            Some(process)
-        },
-        None => None
+    for input in input.iter() {
+        process.input().write(input.as_bytes());
     }
+
+    return process;
 }

branches/auto/src/compiletest/runtest.rs

@@ -289,23 +289,20 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
                 dump_output_file(config, testfile, script_str, "debugger.script");
 
 
-                procsrv::run("", config.adb_path,
+                procsrv::run("", config.adb_path.clone(),
                     [~"push", exe_file.as_str().unwrap().to_owned(), config.adb_test_dir.clone()],
-                    ~[(~"",~"")], Some(~""))
-                    .expect(format!("failed to exec `{}`", config.adb_path));
+                    ~[(~"",~"")], Some(~""));
 
                 procsrv::run("", config.adb_path,
                     [~"forward", ~"tcp:5039", ~"tcp:5039"],
-                    ~[(~"",~"")], Some(~""))
-                    .expect(format!("failed to exec `{}`", config.adb_path));
+                    ~[(~"",~"")], Some(~""));
 
                 let adb_arg = format!("export LD_LIBRARY_PATH={}; gdbserver :5039 {}/{}",
                          config.adb_test_dir.clone(), config.adb_test_dir.clone(),
                          str::from_utf8(exe_file.filename().unwrap()));
 
-                let mut process = procsrv::run_background("", config.adb_path,
-                        [~"shell",adb_arg.clone()],~[(~"",~"")], Some(~""))
-                        .expect(format!("failed to exec `{}`", config.adb_path));
+                let mut process = procsrv::run_background("", config.adb_path.clone(),
+                        [~"shell",adb_arg.clone()],~[(~"",~"")], Some(~""));
                 loop {
                     //waiting 1 second for gdbserver start
                     timer::sleep(1000);
@@ -337,12 +334,10 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
                 let debugger_opts = ~[~"-quiet", ~"-batch", ~"-nx",
                     "-command=" + debugger_script.as_str().unwrap().to_owned()];
 
-                let gdb_path = tool_path.append("/bin/arm-linux-androideabi-gdb");
                 let procsrv::Result{ out, err, status }=
                     procsrv::run("",
-                            gdb_path,
-                            debugger_opts, ~[(~"",~"")], None)
-                    .expect(format!("failed to exec `{}`", gdb_path));
+                            tool_path.append("/bin/arm-linux-androideabi-gdb"),
+                            debugger_opts, ~[(~"",~"")], None);
                 let cmdline = {
                     let cmdline = make_cmdline("", "arm-linux-androideabi-gdb", debugger_opts);
                     logv(config, format!("executing {}", cmdline));
@@ -805,8 +800,7 @@ fn program_output(config: &config, testfile: &Path, lib_path: &str, prog: ~str,
             cmdline
         };
     let procsrv::Result{ out, err, status } =
-            procsrv::run(lib_path, prog, args, env, input)
-            .expect(format!("failed to exec `{}`", prog));
+            procsrv::run(lib_path, prog, args, env, input);
     dump_output(config, testfile, out, err);
     return ProcRes {status: status,
          stdout: out,
@@ -914,8 +908,7 @@ fn _arm_exec_compiled_test(config: &config, props: &TestProps,
     // copy to target
     let copy_result = procsrv::run("", config.adb_path,
         [~"push", args.prog.clone(), config.adb_test_dir.clone()],
-        ~[(~"",~"")], Some(~""))
-        .expect(format!("failed to exec `{}`", config.adb_path));
+        ~[(~"",~"")], Some(~""));
 
     if config.verbose {
         println!("push ({}) {} {} {}",
@@ -939,8 +932,7 @@ fn _arm_exec_compiled_test(config: &config, props: &TestProps,
     for tv in args.args.iter() {
         runargs.push(tv.to_owned());
     }
-    procsrv::run("", config.adb_path, runargs, ~[(~"",~"")], Some(~""))
-        .expect(format!("failed to exec `{}`", config.adb_path));
+    procsrv::run("", config.adb_path, runargs, ~[(~"",~"")], Some(~""));
 
     // get exitcode of result
     runargs = ~[];
@@ -950,8 +942,7 @@ fn _arm_exec_compiled_test(config: &config, props: &TestProps,
 
     let procsrv::Result{ out: exitcode_out, err: _, status: _ } =
         procsrv::run("", config.adb_path, runargs, ~[(~"",~"")],
-                     Some(~""))
-        .expect(format!("failed to exec `{}`", config.adb_path));
+                     Some(~""));
 
     let mut exitcode : int = 0;
     for c in exitcode_out.chars() {
@@ -969,8 +960,7 @@ fn _arm_exec_compiled_test(config: &config, props: &TestProps,
     runargs.push(format!("{}/{}.stdout", config.adb_test_dir, prog_short));
 
     let procsrv::Result{ out: stdout_out, err: _, status: _ } =
-        procsrv::run("", config.adb_path, runargs, ~[(~"",~"")], Some(~""))
-        .expect(format!("failed to exec `{}`", config.adb_path));
+        procsrv::run("", config.adb_path, runargs, ~[(~"",~"")], Some(~""));
 
     // get stderr of result
     runargs = ~[];
@@ -979,8 +969,7 @@ fn _arm_exec_compiled_test(config: &config, props: &TestProps,
     runargs.push(format!("{}/{}.stderr", config.adb_test_dir, prog_short));
 
     let procsrv::Result{ out: stderr_out, err: _, status: _ } =
-        procsrv::run("", config.adb_path, runargs, ~[(~"",~"")], Some(~""))
-        .expect(format!("failed to exec `{}`", config.adb_path));
+        procsrv::run("", config.adb_path, runargs, ~[(~"",~"")], Some(~""));
 
     dump_output(config, testfile, stdout_out, stderr_out);
 
@@ -1015,8 +1004,7 @@ fn _arm_push_aux_shared_library(config: &config, testfile: &Path) {
             // FIXME (#9639): This needs to handle non-utf8 paths
             let copy_result = procsrv::run("", config.adb_path,
                 [~"push", file.as_str().unwrap().to_owned(), config.adb_test_dir.clone()],
-                ~[(~"",~"")], Some(~""))
-                .expect(format!("failed to exec `{}`", config.adb_path));
+                ~[(~"",~"")], Some(~""));
 
             if config.verbose {
                 println!("push ({}) {} {} {}",

branches/auto/src/etc/emacs/rust-mode.el

@@ -134,7 +134,7 @@
     "if" "impl" "in"
     "let" "loop"
     "match" "mod" "mut"
-    "priv" "pub"
+    "priv" "proc" "pub"
     "ref" "return"
     "self" "static" "struct" "super"
     "true" "trait" "type"

branches/auto/src/libextra/test.rs

@@ -1110,15 +1110,6 @@ impl BenchHarness {
         } else {
             n = 1_000_000 / self.ns_per_iter().max(&1);
         }
-        // if the first run took more than 1ms we don't want to just
-        // be left doing 0 iterations on every loop. The unfortunate
-        // side effect of not being able to do as many runs is
-        // automatically handled by the statistical analysis below
-        // (i.e. larger error bars).
-        if n == 0 { n = 1; }
-
-        debug!("Initial run took {} ns, iter count that takes 1ms estimated as {}",
-               self.ns_per_iter(), n);
 
         let mut total_run = 0;
         let samples : &mut [f64] = [0.0_f64, ..50];
@@ -1150,7 +1141,7 @@ impl BenchHarness {
             let now = precise_time_ns();
             let loop_run = now - loop_start;
 
-            // If we've run for 100ms and seem to have converged to a
+            // If we've run for 100ms an seem to have converged to a
             // stable median.
             if loop_run > 100_000_000 &&
                 summ.median_abs_dev_pct < 1.0 &&

branches/auto/src/librustc/back/archive.rs

@@ -40,25 +40,15 @@ fn run_ar(sess: Session, args: &str, cwd: Option<&Path>,
         Some(p) => { debug!("inside {}", p.display()); }
         None => {}
     }
-    let mut opt_prog = Process::new(ar, args.as_slice(), opts);
-    match opt_prog {
-        Some(ref mut prog) => {
-            let o = prog.finish_with_output();
-            if !o.status.success() {
-                sess.err(format!("{} {} failed with: {}", ar, args.connect(" "),
-                                 o.status));
-                sess.note(format!("stdout ---\n{}", str::from_utf8(o.output)));
-                sess.note(format!("stderr ---\n{}", str::from_utf8(o.error)));
-                sess.abort_if_errors();
-            }
-            o
-        },
-        None => {
-            sess.err(format!("could not exec `{}`", ar));
-            sess.abort_if_errors();
-            fail!("rustc::back::archive::run_ar() should not reach this point");
-        }
+    let o = Process::new(ar, args.as_slice(), opts).finish_with_output();
+    if !o.status.success() {
+        sess.err(format!("{} {} failed with: {}", ar, args.connect(" "),
+                         o.status));
+        sess.note(format!("stdout ---\n{}", str::from_utf8(o.output)));
+        sess.note(format!("stderr ---\n{}", str::from_utf8(o.error)));
+        sess.abort_if_errors();
     }
+    o
 }
 
 impl Archive {

branches/auto/src/librustc/back/link.rs

@@ -310,19 +310,13 @@ pub mod write {
             assembly.as_str().unwrap().to_owned()];
 
         debug!("{} '{}'", cc, args.connect("' '"));
-        match run::process_output(cc, args) {
-            Some(prog) => {
-                if !prog.status.success() {
-                    sess.err(format!("linking with `{}` failed: {}", cc, prog.status));
-                    sess.note(format!("{} arguments: '{}'", cc, args.connect("' '")));
-                    sess.note(str::from_utf8_owned(prog.error + prog.output));
-                    sess.abort_if_errors();
-                }
-            },
-            None => {
-                sess.err(format!("could not exec `{}`", cc));
-                sess.abort_if_errors();
-            }
+        let prog = run::process_output(cc, args);
+
+        if !prog.status.success() {
+            sess.err(format!("linking with `{}` failed: {}", cc, prog.status));
+            sess.note(format!("{} arguments: '{}'", cc, args.connect("' '")));
+            sess.note(str::from_utf8_owned(prog.error + prog.output));
+            sess.abort_if_errors();
         }
     }
 
@@ -955,22 +949,14 @@ fn link_natively(sess: Session, dylib: bool, obj_filename: &Path,
 
     // Invoke the system linker
     debug!("{} {}", cc_prog, cc_args.connect(" "));
-    let opt_prog = time(sess.time_passes(), "running linker", (), |()|
-                        run::process_output(cc_prog, cc_args));
-
-    match opt_prog {
-        Some(prog) => {
-            if !prog.status.success() {
-                sess.err(format!("linking with `{}` failed: {}", cc_prog, prog.status));
-                sess.note(format!("{} arguments: '{}'", cc_prog, cc_args.connect("' '")));
-                sess.note(str::from_utf8_owned(prog.error + prog.output));
-                sess.abort_if_errors();
-            }
-        },
-        None => {
-            sess.err(format!("could not exec `{}`", cc_prog));
-            sess.abort_if_errors();
-        }
+    let prog = time(sess.time_passes(), "running linker", (), |()|
+                    run::process_output(cc_prog, cc_args));
+
+    if !prog.status.success() {
+        sess.err(format!("linking with `{}` failed: {}", cc_prog, prog.status));
+        sess.note(format!("{} arguments: '{}'", cc_prog, cc_args.connect("' '")));
+        sess.note(str::from_utf8_owned(prog.error + prog.output));
+        sess.abort_if_errors();
     }
 
 

branches/auto/src/librustpkg/api.rs

@@ -142,14 +142,14 @@ pub fn install_pkg(cx: &BuildContext,
 /// Builds an arbitrary library whose short name is `output`,
 /// by invoking `tool` with arguments `args` plus "-o %s", where %s
 /// is the platform-specific library name for `output`.
-/// Returns that platform-specific name, or None if `tool` could not be started.
+/// Returns that platform-specific name.
 pub fn build_library_in_workspace(exec: &mut workcache::Exec,
                                   context: &mut Context,
                                   package_name: &str,
                                   tool: &str,
                                   flags: &[~str],
                                   paths: &[~str],
-                                  output: &str) -> Option<~str> {
+                                  output: &str) -> ~str {
     use command_failed = conditions::command_failed::cond;
 
     let workspace = my_workspace(context, package_name);
@@ -169,20 +169,16 @@ pub fn build_library_in_workspace(exec: &mut workcache::Exec,
 
     let all_args = flags + absolute_paths + cc_args +
          ~[~"-o", out_name.as_str().unwrap().to_owned()];
-    match run::process_status(tool, all_args) {
-        Some(exit_process) => {
-            if exit_process.success() {
-                let out_name_str = out_name.as_str().unwrap().to_owned();
-                exec.discover_output("binary",
-                                     out_name_str,
-                                     digest_only_date(&out_name));
-                context.add_library_path(out_name.dir_path());
-                Some(out_name_str)
-            } else {
-                Some(command_failed.raise((tool.to_owned(), all_args, exit_process)))
-            }
-        },
-        None => None
+    let exit_process = run::process_status(tool, all_args);
+    if exit_process.success() {
+        let out_name_str = out_name.as_str().unwrap().to_owned();
+        exec.discover_output("binary",
+                             out_name_str,
+                             digest_only_date(&out_name));
+        context.add_library_path(out_name.dir_path());
+        out_name_str
+    } else {
+        command_failed.raise((tool.to_owned(), all_args, exit_process))
     }
 }