---

yaml
---
r: 189151
b: refs/heads/snap-stage3
c: 61a2766
h: refs/heads/master
i:
  189149: 0e64b88
  189147: 39e2e1e
  189143: 96b11e5
  189135: 87a493f
  189119: c687f7c
v: v3

Author: steveklabnik

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 4d716decb5d9944bc0d79cdc51b03e3af69bc59c
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 32631b4138fbaeca0f6496dd83aa327c76d5a900
+refs/heads/snap-stage3: 61a2766136536f9993ae095075ec766cfc729f8b
 refs/heads/try: 649d35e4d830b27806705dc5352c86ab6d6fd1a1
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

branches/snap-stage3/mk/docs.mk

@@ -273,13 +273,11 @@ compiler-docs: $(COMPILER_DOC_TARGETS)
 trpl: doc/book/index.html
 
 doc/book/index.html: $(RUSTBOOK_EXE) $(wildcard $(S)/src/doc/trpl/*.md) | doc/
-	@$(call E, rustbook: $@)
 	$(Q)rm -rf doc/book
 	$(Q)$(RUSTBOOK) build $(S)src/doc/trpl doc/book
 
 style: doc/style/index.html
 
 doc/style/index.html: $(RUSTBOOK_EXE) $(wildcard $(S)/src/doc/style/*.md) | doc/
-	@$(call E, rustbook: $@)
 	$(Q)rm -rf doc/style
 	$(Q)$(RUSTBOOK) build $(S)src/doc/style doc/style

branches/snap-stage3/mk/tests.mk

@@ -590,7 +590,7 @@ TEST_SREQ$(1)_T_$(2)_H_$(3) = \
 
 # The tests select when to use debug configuration on their own;
 # remove directive, if present, from CFG_RUSTC_FLAGS (issue #7898).
-CTEST_RUSTC_FLAGS := $$(subst -C debug-assertions,,$$(CFG_RUSTC_FLAGS))
+CTEST_RUSTC_FLAGS := $$(subst --cfg ndebug,,$$(CFG_RUSTC_FLAGS))
 
 # The tests cannot be optimized while the rest of the compiler is optimized, so
 # filter out the optimization (if any) from rustc and then figure out if we need

branches/snap-stage3/src/compiletest/common.rs

@@ -11,7 +11,6 @@ pub use self::Mode::*;
 
 use std::fmt;
 use std::str::FromStr;
-use std::path::PathBuf;
 
 #[derive(Clone, Copy, PartialEq, Debug)]
 pub enum Mode {
@@ -69,13 +68,13 @@ pub struct Config {
     pub run_lib_path: String,
 
     // The rustc executable
-    pub rustc_path: PathBuf,
+    pub rustc_path: Path,
 
     // The clang executable
-    pub clang_path: Option<PathBuf>,
+    pub clang_path: Option<Path>,
 
     // The llvm binaries path
-    pub llvm_bin_path: Option<PathBuf>,
+    pub llvm_bin_path: Option<Path>,
 
     // The valgrind path
     pub valgrind_path: Option<String>,
@@ -85,13 +84,13 @@ pub struct Config {
     pub force_valgrind: bool,
 
     // The directory containing the tests to run
-    pub src_base: PathBuf,
+    pub src_base: Path,
 
     // The directory where programs should be built
-    pub build_base: PathBuf,
+    pub build_base: Path,
 
     // Directory for auxiliary libraries
-    pub aux_base: PathBuf,
+    pub aux_base: Path,
 
     // The name of the stage being built (stage1, etc)
     pub stage_id: String,
@@ -106,7 +105,7 @@ pub struct Config {
     pub filter: Option<String>,
 
     // Write out a parseable log of tests that were run
-    pub logfile: Option<PathBuf>,
+    pub logfile: Option<Path>,
 
     // A command line to prefix program execution with,
     // for running under valgrind
@@ -134,7 +133,7 @@ pub struct Config {
     pub lldb_version: Option<String>,
 
     // Path to the android tools
-    pub android_cross_path: PathBuf,
+    pub android_cross_path: Path,
 
     // Extra parameter to run adb on arm-linux-androideabi
     pub adb_path: String,

branches/snap-stage3/src/compiletest/compiletest.rs

@@ -21,11 +21,6 @@
 #![feature(test)]
 #![feature(unicode)]
 #![feature(core)]
-#![feature(path)]
-#![feature(os)]
-#![feature(io)]
-#![feature(fs)]
-#![feature(net)]
 
 #![deny(warnings)]
 
@@ -36,9 +31,8 @@ extern crate getopts;
 extern crate log;
 
 use std::env;
-use std::fs;
 use std::old_io;
-use std::path::{Path, PathBuf};
+use std::old_io::fs;
 use std::thunk::Thunk;
 use getopts::{optopt, optflag, reqopt};
 use common::Config;
@@ -120,9 +114,9 @@ pub fn parse_config(args: Vec<String> ) -> Config {
         panic!()
     }
 
-    fn opt_path(m: &getopts::Matches, nm: &str) -> PathBuf {
+    fn opt_path(m: &getopts::Matches, nm: &str) -> Path {
         match m.opt_str(nm) {
-            Some(s) => PathBuf::new(&s),
+            Some(s) => Path::new(s),
             None => panic!("no option (=path) found for {}", nm),
         }
     }
@@ -137,18 +131,18 @@ pub fn parse_config(args: Vec<String> ) -> Config {
         compile_lib_path: matches.opt_str("compile-lib-path").unwrap(),
         run_lib_path: matches.opt_str("run-lib-path").unwrap(),
         rustc_path: opt_path(matches, "rustc-path"),
-        clang_path: matches.opt_str("clang-path").map(|s| PathBuf::new(&s)),
+        clang_path: matches.opt_str("clang-path").map(|s| Path::new(s)),
         valgrind_path: matches.opt_str("valgrind-path"),
         force_valgrind: matches.opt_present("force-valgrind"),
-        llvm_bin_path: matches.opt_str("llvm-bin-path").map(|s| PathBuf::new(&s)),
+        llvm_bin_path: matches.opt_str("llvm-bin-path").map(|s| Path::new(s)),
         src_base: opt_path(matches, "src-base"),
         build_base: opt_path(matches, "build-base"),
         aux_base: opt_path(matches, "aux-base"),
         stage_id: matches.opt_str("stage-id").unwrap(),
         mode: matches.opt_str("mode").unwrap().parse().ok().expect("invalid mode"),
         run_ignored: matches.opt_present("ignored"),
         filter: filter,
-        logfile: matches.opt_str("logfile").map(|s| PathBuf::new(&s)),
+        logfile: matches.opt_str("logfile").map(|s| Path::new(s)),
         runtool: matches.opt_str("runtool"),
         host_rustcflags: matches.opt_str("host-rustcflags"),
         target_rustcflags: matches.opt_str("target-rustcflags"),
@@ -282,9 +276,9 @@ pub fn make_tests(config: &Config) -> Vec<test::TestDescAndFn> {
     debug!("making tests from {:?}",
            config.src_base.display());
     let mut tests = Vec::new();
-    let dirs = fs::read_dir(&config.src_base).unwrap();
-    for file in dirs {
-        let file = file.unwrap().path();
+    let dirs = fs::readdir(&config.src_base).unwrap();
+    for file in &dirs {
+        let file = file.clone();
         debug!("inspecting file {:?}", file.display());
         if is_test(config, &file) {
             let t = make_test(config, &file, || {
@@ -307,7 +301,7 @@ pub fn is_test(config: &Config, testfile: &Path) -> bool {
           _ => vec!(".rc".to_string(), ".rs".to_string())
         };
     let invalid_prefixes = vec!(".".to_string(), "#".to_string(), "~".to_string());
-    let name = testfile.file_name().unwrap().to_str().unwrap();
+    let name = testfile.filename_str().unwrap();
 
     let mut valid = false;
 
@@ -343,9 +337,9 @@ pub fn make_test_name(config: &Config, testfile: &Path) -> test::TestName {
 
     // Try to elide redundant long paths
     fn shorten(path: &Path) -> String {
-        let filename = path.file_name().unwrap().to_str();
-        let p = path.parent().unwrap();
-        let dir = p.file_name().unwrap().to_str();
+        let filename = path.filename_str();
+        let p = path.dir_path();
+        let dir = p.filename_str();
         format!("{}/{}", dir.unwrap_or(""), filename.unwrap_or(""))
     }
 
@@ -354,17 +348,19 @@ pub fn make_test_name(config: &Config, testfile: &Path) -> test::TestName {
 
 pub fn make_test_closure(config: &Config, testfile: &Path) -> test::TestFn {
     let config = (*config).clone();
-    let testfile = testfile.to_path_buf();
+    // FIXME (#9639): This needs to handle non-utf8 paths
+    let testfile = testfile.as_str().unwrap().to_string();
     test::DynTestFn(Thunk::new(move || {
-        runtest::run(config, &testfile)
+        runtest::run(config, testfile)
     }))
 }
 
 pub fn make_metrics_test_closure(config: &Config, testfile: &Path) -> test::TestFn {
     let config = (*config).clone();
-    let testfile = testfile.to_path_buf();
+    // FIXME (#9639): This needs to handle non-utf8 paths
+    let testfile = testfile.as_str().unwrap().to_string();
     test::DynMetricFn(box move |mm: &mut test::MetricMap| {
-        runtest::run_metrics(config, &testfile, mm)
+        runtest::run_metrics(config, testfile, mm)
     })
 }
 

branches/snap-stage3/src/compiletest/errors.rs

@@ -9,10 +9,7 @@
 // except according to those terms.
 use self::WhichLine::*;
 
-use std::fs::File;
-use std::io::BufReader;
-use std::io::prelude::*;
-use std::path::Path;
+use std::old_io::{BufferedReader, File};
 
 pub struct ExpectedError {
     pub line: uint,
@@ -32,7 +29,7 @@ enum WhichLine { ThisLine, FollowPrevious(uint), AdjustBackward(uint) }
 ///          //~| ERROR message two for that same line.
 // Load any test directives embedded in the file
 pub fn load_errors(testfile: &Path) -> Vec<ExpectedError> {
-    let rdr = BufReader::new(File::open(testfile).unwrap());
+    let mut rdr = BufferedReader::new(File::open(testfile).unwrap());
 
     // `last_nonfollow_error` tracks the most recently seen
     // line with an error template that did not use the

branches/snap-stage3/src/compiletest/header.rs

@@ -9,10 +9,6 @@
 // except according to those terms.
 
 use std::env;
-use std::fs::File;
-use std::io::BufReader;
-use std::io::prelude::*;
-use std::path::{Path, PathBuf};
 
 use common::Config;
 use common;
@@ -27,7 +23,7 @@ pub struct TestProps {
     pub run_flags: Option<String>,
     // If present, the name of a file that this test should match when
     // pretty-printed
-    pub pp_exact: Option<PathBuf>,
+    pub pp_exact: Option<Path>,
     // Modules from aux directory that should be compiled
     pub aux_builds: Vec<String> ,
     // Environment settings to use during execution
@@ -66,7 +62,7 @@ pub fn load_props(testfile: &Path) -> TestProps {
     let mut pretty_mode = None;
     let mut pretty_compare_only = false;
     let mut forbid_output = Vec::new();
-    iter_header(testfile, &mut |ln| {
+    iter_header(testfile, |ln| {
         match parse_error_pattern(ln) {
           Some(ep) => error_patterns.push(ep),
           None => ()
@@ -223,7 +219,7 @@ pub fn is_test_ignored(config: &Config, testfile: &Path) -> bool {
         }
     }
 
-    let val = iter_header(testfile, &mut |ln| {
+    let val = iter_header(testfile, |ln| {
         !parse_name_directive(ln, "ignore-test") &&
         !parse_name_directive(ln, &ignore_target(config)) &&
         !parse_name_directive(ln, &ignore_stage(config)) &&
@@ -236,8 +232,12 @@ pub fn is_test_ignored(config: &Config, testfile: &Path) -> bool {
     !val
 }
 
-fn iter_header(testfile: &Path, it: &mut FnMut(&str) -> bool) -> bool {
-    let rdr = BufReader::new(File::open(testfile).unwrap());
+fn iter_header<F>(testfile: &Path, mut it: F) -> bool where
+    F: FnMut(&str) -> bool,
+{
+    use std::old_io::{BufferedReader, File};
+
+    let mut rdr = BufferedReader::new(File::open(testfile).unwrap());
     for ln in rdr.lines() {
         // Assume that any directives will be found before the first
         // module or function. This doesn't seem to be an optimization
@@ -322,12 +322,12 @@ fn parse_exec_env(line: &str) -> Option<(String, String)> {
     })
 }
 
-fn parse_pp_exact(line: &str, testfile: &Path) -> Option<PathBuf> {
+fn parse_pp_exact(line: &str, testfile: &Path) -> Option<Path> {
     match parse_name_value_directive(line, "pp-exact") {
-      Some(s) => Some(PathBuf::new(&s)),
+      Some(s) => Some(Path::new(s)),
       None => {
         if parse_name_directive(line, "pp-exact") {
-            testfile.file_name().map(|s| PathBuf::new(s))
+            testfile.filename().map(|s| Path::new(s))
         } else {
             None
         }

branches/snap-stage3/src/compiletest/procsrv.rs

@@ -8,8 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::process::{ExitStatus, Command, Child, Output, Stdio};
-use std::io::prelude::*;
+use std::old_io::process::{ProcessExit, Command, Process, ProcessOutput};
 use std::dynamic_lib::DynamicLibrary;
 
 fn add_target_env(cmd: &mut Command, lib_path: &str, aux_path: Option<&str>) {
@@ -26,10 +25,10 @@ fn add_target_env(cmd: &mut Command, lib_path: &str, aux_path: Option<&str>) {
     let var = DynamicLibrary::envvar();
     let newpath = DynamicLibrary::create_path(&path);
     let newpath = String::from_utf8(newpath).unwrap();
-    cmd.env(var, &newpath);
+    cmd.env(var.to_string(), newpath);
 }
 
-pub struct Result {pub status: ExitStatus, pub out: String, pub err: String}
+pub struct Result {pub status: ProcessExit, pub out: String, pub err: String}
 
 pub fn run(lib_path: &str,
            prog: &str,
@@ -39,27 +38,24 @@ pub fn run(lib_path: &str,
            input: Option<String>) -> Option<Result> {
 
     let mut cmd = Command::new(prog);
-    cmd.args(args)
-       .stdin(Stdio::piped())
-       .stdout(Stdio::piped())
-       .stderr(Stdio::piped());
+    cmd.args(args);
     add_target_env(&mut cmd, lib_path, aux_path);
     for (key, val) in env {
-        cmd.env(&key, &val);
+        cmd.env(key, val);
     }
 
     match cmd.spawn() {
         Ok(mut process) => {
             if let Some(input) = input {
                 process.stdin.as_mut().unwrap().write_all(input.as_bytes()).unwrap();
             }
-            let Output { status, stdout, stderr } =
+            let ProcessOutput { status, output, error } =
                 process.wait_with_output().unwrap();
 
             Some(Result {
                 status: status,
-                out: String::from_utf8(stdout).unwrap(),
-                err: String::from_utf8(stderr).unwrap()
+                out: String::from_utf8(output).unwrap(),
+                err: String::from_utf8(error).unwrap()
             })
         },
         Err(..) => None
@@ -71,16 +67,13 @@ pub fn run_background(lib_path: &str,
            aux_path: Option<&str>,
            args: &[String],
            env: Vec<(String, String)> ,
-           input: Option<String>) -> Option<Child> {
+           input: Option<String>) -> Option<Process> {
 
     let mut cmd = Command::new(prog);
-    cmd.args(args)
-       .stdin(Stdio::piped())
-       .stdout(Stdio::piped())
-       .stderr(Stdio::piped());
+    cmd.args(args);
     add_target_env(&mut cmd, lib_path, aux_path);
     for (key, val) in env {
-        cmd.env(&key, &val);
+        cmd.env(key, val);
     }
 
     match cmd.spawn() {