---

yaml
---
r: 141258
b: refs/heads/try2
c: 363e672
h: refs/heads/master
v: v3

Author: sanxiyn

[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: d98cc9995fb5c87230f57eeffb8061df25d85190
+refs/heads/try2: 363e67273622285a65caa74bb63ecfa04df59055
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/compiletest/procsrv.rs

@@ -10,6 +10,8 @@
 
 use core::prelude::*;
 
+use core::libc::c_int;
+use core::run::spawn_process;
 use core::run;
 
 #[cfg(target_os = "win32")]
@@ -36,35 +38,86 @@ fn target_env(lib_path: &str, prog: &str) -> ~[(~str,~str)] {
 #[cfg(target_os = "macos")]
 #[cfg(target_os = "freebsd")]
 fn target_env(_lib_path: &str, _prog: &str) -> ~[(~str,~str)] {
-    os::env()
+    ~[]
 }
 
 pub struct Result {status: int, out: ~str, err: ~str}
 
+// FIXME (#2659): This code is duplicated in core::run::program_output
 pub fn run(lib_path: &str,
            prog: &str,
            args: &[~str],
            env: ~[(~str, ~str)],
            input: Option<~str>) -> Result {
+    let pipe_in = os::pipe();
+    let pipe_out = os::pipe();
+    let pipe_err = os::pipe();
+    let pid = spawn_process(prog, args,
+                            &Some(env + target_env(lib_path, prog)),
+                            &None, pipe_in.in, pipe_out.out, pipe_err.out);
+
+    os::close(pipe_in.in);
+    os::close(pipe_out.out);
+    os::close(pipe_err.out);
+    if pid == -1i32 {
+        os::close(pipe_in.out);
+        os::close(pipe_out.in);
+        os::close(pipe_err.in);
+        fail!();
+    }
 
-    let env = env + target_env(lib_path, prog);
-    let mut proc = run::Process::new(prog, args, run::ProcessOptions {
-        env: Some(env.slice(0, env.len())),
-        dir: None,
-        in_fd: None,
-        out_fd: None,
-        err_fd: None
-    });
 
-    for input.each |input| {
-        proc.input().write_str(*input);
+    writeclose(pipe_in.out, input);
+    let p = comm::PortSet::new();
+    let ch = p.chan();
+    do task::spawn_sched(task::SingleThreaded) || {
+        let errput = readclose(pipe_err.in);
+        ch.send((2, errput));
     }
-    let output = proc.finish_with_output();
+    let ch = p.chan();
+    do task::spawn_sched(task::SingleThreaded) || {
+        let output = readclose(pipe_out.in);
+        ch.send((1, output));
+    }
+    let status = run::waitpid(pid);
+    let mut errs = ~"";
+    let mut outs = ~"";
+    let mut count = 2;
+    while count > 0 {
+        match p.recv() {
+          (1, s) => {
+            outs = s;
+          }
+          (2, s) => {
+            errs = s;
+          }
+          _ => { fail!() }
+        };
+        count -= 1;
+    };
+    return Result {status: status, out: outs, err: errs};
+}
 
-    Result {
-        status: output.status,
-        out: str::from_bytes(output.output),
-        err: str::from_bytes(output.error)
+fn writeclose(fd: c_int, s: Option<~str>) {
+    if s.is_some() {
+        let writer = io::fd_writer(fd, false);
+        writer.write_str(s.get());
     }
+
+    os::close(fd);
 }
 
+fn readclose(fd: c_int) -> ~str {
+    unsafe {
+        // Copied from run::program_output
+        let file = os::fdopen(fd);
+        let reader = io::FILE_reader(file, false);
+        let mut buf = ~"";
+        while !reader.eof() {
+            let bytes = reader.read_bytes(4096u);
+            str::push_str(&mut buf, str::from_bytes(bytes));
+        }
+        os::fclose(file);
+        return buf;
+    }
+}

branches/try2/src/etc/ctags.rust

@@ -4,7 +4,9 @@
 --regex-rust=/[ \t]*type[ \t]+([a-zA-Z0-9_]+)/\1/T,types/
 --regex-rust=/[ \t]*enum[ \t]+([a-zA-Z0-9_]+)/\1/T,types/
 --regex-rust=/[ \t]*struct[ \t]+([a-zA-Z0-9_]+)/\1/m,types/
+--regex-rust=/[ \t]*class[ \t]+([a-zA-Z0-9_]+)/\1/m,types/
 --regex-rust=/[ \t]*mod[ \t]+([a-zA-Z0-9_]+)/\1/m,modules/
---regex-rust=/[ \t]*static[ \t]+([a-zA-Z0-9_]+)/\1/m,consts/
+--regex-rust=/[ \t]*const[ \t]+([a-zA-Z0-9_]+)/\1/m,consts/
 --regex-rust=/[ \t]*trait[ \t]+([a-zA-Z0-9_]+)/\1/m,traits/
 --regex-rust=/[ \t]*impl[ \t]+([a-zA-Z0-9_]+)/\1/m,impls/
+--regex-rust=/[ \t]*impl[ \t]+of[ \t]([a-zA-Z0-9_]+)/\1/m,impls/

branches/try2/src/libextra/std.rc

@@ -123,7 +123,7 @@ pub mod serialize;
 // A curious inner-module that's not exported that contains the binding
 // 'extra' so that macro-expanded references to std::serialize and such
 // can be resolved within libextra.
-#[doc(hidden)]
+#[doc(hidden)] // FIXME #3538
 pub mod std {
     pub use serialize;
     pub use test;
@@ -134,7 +134,7 @@ pub mod std {
     pub use core::cmp;
     pub use core::sys;
 }
-#[doc(hidden)]
+#[doc(hidden)] // FIXME #3538
 pub mod extra {
     pub use serialize;
     pub use test;

branches/try2/src/libextra/workcache.rs

@@ -415,7 +415,7 @@ fn test() {
         prep.declare_input("file", pth.to_str(), digest_file(&pth));
         do prep.exec |_exe| {
             let out = Path("foo.o");
-            run::process_status("gcc", [~"foo.c", ~"-o", out.to_str()]);
+            run::run_program("gcc", [~"foo.c", ~"-o", out.to_str()]);
             out.to_str()
         }
     };

branches/try2/src/libfuzzer/fuzzer.rc

@@ -412,20 +412,20 @@ pub fn check_whole_compiler(code: &str,
 pub fn removeIfExists(filename: &Path) {
     // So sketchy!
     assert!(!contains(filename.to_str(), " "));
-    run::process_status("bash", [~"-c", ~"rm " + filename.to_str()]);
+    run::program_output("bash", [~"-c", ~"rm " + filename.to_str()]);
 }
 
 pub fn removeDirIfExists(filename: &Path) {
     // So sketchy!
     assert!(!contains(filename.to_str(), " "));
-    run::process_status("bash", [~"-c", ~"rm -r " + filename.to_str()]);
+    run::program_output("bash", [~"-c", ~"rm -r " + filename.to_str()]);
 }
 
 pub fn check_running(exe_filename: &Path) -> happiness {
-    let p = run::process_output(
+    let p = run::program_output(
         "/Users/jruderman/scripts/timed_run_rust_program.py",
         [exe_filename.to_str()]);
-    let comb = str::from_bytes(p.output) + ~"\n" + str::from_bytes(p.error);
+    let comb = p.out + ~"\n" + p.err;
     if str::len(comb) > 1u {
         error!("comb comb comb: %?", comb);
     }
@@ -461,35 +461,33 @@ pub fn check_running(exe_filename: &Path) -> happiness {
 }
 
 pub fn check_compiling(filename: &Path) -> happiness {
-    let p = run::process_output(
-        "/Users/jruderman/code/rust/build/x86_64-apple-darwin/stage1/bin/rustc",
+    let p = run::program_output(
+        "/Users/jruderman/code/rust/build/x86_64-apple-darwin/\
+         stage1/bin/rustc",
         [filename.to_str()]);
 
-    let out = str::from_bytes(p.output);
-    let err = str::from_bytes(p.error);
-
     //error!("Status: %d", p.status);
     if p.status == 0 {
         passed
-    } else if !err.is_empty() {
-        if err.contains("error:") {
+    } else if p.err != ~"" {
+        if contains(p.err, "error:") {
             cleanly_rejected(~"rejected with span_error")
         } else {
-            error!("Stderr: %?", err);
+            error!("Stderr: %?", p.err);
             failed(~"Unfamiliar error message")
         }
-    } else if out.contains("Assertion") && out.contains("failed") {
-        error!("Stdout: %?", out);
+    } else if contains(p.out, "Assertion") && contains(p.out, "failed") {
+        error!("Stdout: %?", p.out);
         failed(~"Looks like an llvm assertion failure")
-    } else if out.contains("internal compiler error unimplemented") {
+    } else if contains(p.out, "internal compiler error unimplemented") {
         known_bug(~"Something unimplemented")
-    } else if out.contains("internal compiler error") {
-        error!("Stdout: %?", out);
+    } else if contains(p.out, "internal compiler error") {
+        error!("Stdout: %?", p.out);
         failed(~"internal compiler error")
 
     } else {
         error!("%?", p.status);
-        error!("!Stdout: %?", out);
+        error!("!Stdout: %?", p.out);
         failed(~"What happened?")
     }
 }
@@ -610,7 +608,9 @@ pub fn check_roundtrip_convergence(code: @~str, maxIters: uint) {
         error!("Did not converge after %u iterations!", i);
         write_file(&Path("round-trip-a.rs"), *oldv);
         write_file(&Path("round-trip-b.rs"), *newv);
-        run::process_status("diff", [~"-w", ~"-u", ~"round-trip-a.rs", ~"round-trip-b.rs"]);
+        run::run_program("diff",
+                         [~"-w", ~"-u", ~"round-trip-a.rs",
+                          ~"round-trip-b.rs"]);
         fail!("Mismatch");
     }
 }

branches/try2/src/librust/rust.rc

@@ -163,7 +163,7 @@ fn cmd_test(args: &[~str]) -> ValidUsage {
             let test_exec = Path(filename).filestem().unwrap() + "test~";
             invoke("rustc", &[~"--test", filename.to_owned(),
                               ~"-o", test_exec.to_owned()], rustc::main);
-            let exit_code = run::process_status(~"./" + test_exec, []);
+            let exit_code = run::run_program(~"./" + test_exec, []);
             Valid(exit_code)
         }
         _ => Invalid
@@ -176,7 +176,7 @@ fn cmd_run(args: &[~str]) -> ValidUsage {
             let exec = Path(filename).filestem().unwrap() + "~";
             invoke("rustc", &[filename.to_owned(), ~"-o", exec.to_owned()],
                    rustc::main);
-            let exit_code = run::process_status(~"./"+exec, prog_args);
+            let exit_code = run::run_program(~"./"+exec, prog_args);
             Valid(exit_code)
         }
         _ => Invalid

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

@@ -403,14 +403,14 @@ pub mod write {
         cc_args.push(object.to_str());
         cc_args.push(assembly.to_str());
 
-        let prog = run::process_output(cc_prog, cc_args);
+        let prog = run::program_output(cc_prog, cc_args);
 
         if prog.status != 0 {
             sess.err(fmt!("building with `%s` failed with code %d",
                         cc_prog, prog.status));
             sess.note(fmt!("%s arguments: %s",
                         cc_prog, str::connect(cc_args, " ")));
-            sess.note(str::from_bytes(prog.error + prog.output));
+            sess.note(prog.err + prog.out);
             sess.abort_if_errors();
         }
     }
@@ -817,19 +817,19 @@ pub fn link_binary(sess: Session,
     let cc_args = link_args(sess, obj_filename, out_filename, lm);
     debug!("%s link args: %s", cc_prog, str::connect(cc_args, " "));
     // We run 'cc' here
-    let prog = run::process_output(cc_prog, cc_args);
+    let prog = run::program_output(cc_prog, cc_args);
     if 0 != prog.status {
         sess.err(fmt!("linking with `%s` failed with code %d",
                       cc_prog, prog.status));
         sess.note(fmt!("%s arguments: %s",
                        cc_prog, str::connect(cc_args, " ")));
-        sess.note(str::from_bytes(prog.error + prog.output));
+        sess.note(prog.err + prog.out);
         sess.abort_if_errors();
     }
 
     // Clean up on Darwin
     if sess.targ_cfg.os == session::os_macos {
-        run::process_status("dsymutil", [output.to_str()]);
+        run::run_program("dsymutil", [output.to_str()]);
     }
 
     // Remove the temporary object file if we aren't saving temps

branches/try2/src/librustc/driver/driver.rs

@@ -811,7 +811,7 @@ pub fn optgroups() -> ~[getopts::groups::OptGroup] {
                           for detail)", "FEATURE"),
   optopt("", "android-cross-path",
          "The path to the Android NDK", "PATH"),
-  optflagopt("W", "warn",
+  optmulti("W", "warn",
                         "Set lint warnings", "OPT"),
   optmulti("A", "allow",
                         "Set lint allowed", "OPT"),

branches/try2/src/librustc/metadata/encoder.rs

@@ -1470,10 +1470,19 @@ pub fn encode_metadata(parms: EncodeParams, crate: &crate) -> ~[u8] {
     // remaining % 4 bytes.
     wr.write(&[0u8, 0u8, 0u8, 0u8]);
 
+    // FIXME #3396: weird bug here, for reasons unclear this emits random
+    // looking bytes (mostly 0x1) if we use the version byte-array constant
+    // above; so we use a string constant inline instead.
+    //
+    // Should be:
+    //
+    //   vec::to_owned(metadata_encoding_version) +
+
     let writer_bytes: &mut ~[u8] = wr.bytes;
 
-    vec::to_owned(metadata_encoding_version) +
-        flate::deflate_bytes(*writer_bytes)
+    (do str::as_bytes(&~"rust\x00\x00\x00\x01") |bytes| {
+        vec::slice(*bytes, 0, 8).to_vec()
+    }) + flate::deflate_bytes(*writer_bytes)
 }
 
 // Get the encoded string for a type

branches/try2/src/librustc/middle/lint.rs

@@ -892,14 +892,9 @@ fn lint_session(cx: @mut Context) -> visit::vt<()> {
 }
 
 fn lint_unnecessary_allocations(cx: @mut Context) -> visit::vt<()> {
-    // If the expression `e` has an allocated type, but `t` dictates that it's
-    // something like a slice (doesn't need allocation), emit a warning with the
-    // specified span.
-    //
-    // Currently, this only applies to string and vector literals with sigils in
-    // front. Those can have the sigil removed to get a borrowed pointer
-    // automatically.
-    fn check(cx: @mut Context, e: @ast::expr, t: ty::t) {
+    // Warn if string and vector literals with sigils are immediately borrowed.
+    // Those can have the sigil removed.
+    fn check(cx: @mut Context, e: @ast::expr) {
         match e.node {
             ast::expr_vstore(e2, ast::expr_vstore_uniq) |
             ast::expr_vstore(e2, ast::expr_vstore_box) => {
@@ -914,9 +909,9 @@ fn lint_unnecessary_allocations(cx: @mut Context) -> visit::vt<()> {
             _ => return
         }
 
-        match ty::get(t).sty {
-            ty::ty_estr(ty::vstore_slice(*)) |
-            ty::ty_evec(_, ty::vstore_slice(*)) => {
+        match cx.tcx.adjustments.find_copy(&e.id) {
+            Some(@ty::AutoDerefRef(ty::AutoDerefRef {
+                autoref: Some(ty::AutoBorrowVec(*)), _ })) => {
                 cx.span_lint(unnecessary_allocation,
                              e.span, "unnecessary allocation, the sigil can be \
                                       removed");
@@ -927,23 +922,7 @@ fn lint_unnecessary_allocations(cx: @mut Context) -> visit::vt<()> {
     }
 
     let visit_expr: @fn(@ast::expr) = |e| {
-        match e.node {
-            ast::expr_call(c, ref args, _) => {
-                let t = ty::node_id_to_type(cx.tcx, c.id);
-                let s = ty::ty_fn_sig(t);
-                for vec::each2(*args, s.inputs) |e, t| {
-                    check(cx, *e, *t);
-                }
-            }
-            ast::expr_method_call(_, _, _, ref args, _) => {
-                let t = ty::node_id_to_type(cx.tcx, e.callee_id);
-                let s = ty::ty_fn_sig(t);
-                for vec::each2(*args, s.inputs) |e, t| {
-                    check(cx, *e, *t);
-                }
-            }
-            _ => {}
-        }
+        check(cx, e);
     };
 
     visit::mk_simple_visitor(@visit::SimpleVisitor {