---

yaml
---
r: 151805
b: refs/heads/try2
c: bf8648d
h: refs/heads/master
i:
  151803: 8c429c3
v: v3

Author: bors

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

branches/try2/mk/crates.mk

@@ -51,14 +51,15 @@
 
 TARGET_CRATES := libc std green rustuv native flate arena glob term semver \
                  uuid serialize sync getopts collections num test time rand \
-		 workcache url log regex graphviz core rlibc
+		 workcache url log regex graphviz core rlibc alloc
 HOST_CRATES := syntax rustc rustdoc fourcc hexfloat regex_macros fmt_macros
 CRATES := $(TARGET_CRATES) $(HOST_CRATES)
 TOOLS := compiletest rustdoc rustc
 
 DEPS_core :=
 DEPS_rlibc :=
-DEPS_std := core libc native:rustrt native:compiler-rt native:backtrace native:jemalloc
+DEPS_alloc := core libc native:jemalloc
+DEPS_std := core libc alloc native:rustrt native:backtrace
 DEPS_graphviz := std
 DEPS_green := std rand native:context_switch
 DEPS_rustuv := std native:uv native:uv_support
@@ -76,14 +77,14 @@ DEPS_serialize := std collections log
 DEPS_term := std collections log
 DEPS_semver := std
 DEPS_uuid := std serialize rand
-DEPS_sync := std
+DEPS_sync := std alloc
 DEPS_getopts := std
 DEPS_collections := std rand
 DEPS_fourcc := syntax std
 DEPS_hexfloat := syntax std
 DEPS_num := std rand
 DEPS_test := std collections getopts serialize term time regex
-DEPS_time := std serialize
+DEPS_time := std serialize sync
 DEPS_rand := std
 DEPS_url := std collections
 DEPS_workcache := std serialize collections log
@@ -101,6 +102,7 @@ TOOL_SOURCE_rustc := $(S)src/driver/driver.rs
 
 ONLY_RLIB_core := 1
 ONLY_RLIB_rlibc := 1
+ONLY_RLIB_alloc := 1
 
 ################################################################################
 # You should not need to edit below this line

branches/try2/src/compiletest/common.rs

@@ -56,10 +56,10 @@ impl fmt::Show for Mode {
 #[deriving(Clone)]
 pub struct Config {
     // The library paths required for running the compiler
-    pub compile_lib_path: ~str,
+    pub compile_lib_path: StrBuf,
 
     // The library paths required for running compiled programs
-    pub run_lib_path: ~str,
+    pub run_lib_path: StrBuf,
 
     // The rustc executable
     pub rustc_path: Path,
@@ -80,7 +80,7 @@ pub struct Config {
     pub aux_base: Path,
 
     // The name of the stage being built (stage1, etc)
-    pub stage_id: ~str,
+    pub stage_id: StrBuf,
 
     // The test mode, compile-fail, run-fail, run-pass
     pub mode: Mode,
@@ -110,37 +110,37 @@ pub struct Config {
 
     // A command line to prefix program execution with,
     // for running under valgrind
-    pub runtool: Option<~str>,
+    pub runtool: Option<StrBuf>,
 
     // Flags to pass to the compiler when building for the host
-    pub host_rustcflags: Option<~str>,
+    pub host_rustcflags: Option<StrBuf>,
 
     // Flags to pass to the compiler when building for the target
-    pub target_rustcflags: Option<~str>,
+    pub target_rustcflags: Option<StrBuf>,
 
     // Run tests using the JIT
     pub jit: bool,
 
     // Target system to be tested
-    pub target: ~str,
+    pub target: StrBuf,
 
     // Host triple for the compiler being invoked
-    pub host: ~str,
+    pub host: StrBuf,
 
     // Path to the android tools
     pub android_cross_path: Path,
 
     // Extra parameter to run adb on arm-linux-androideabi
-    pub adb_path: ~str,
+    pub adb_path: StrBuf,
 
     // Extra parameter to run test sute on arm-linux-androideabi
-    pub adb_test_dir: ~str,
+    pub adb_test_dir: StrBuf,
 
     // status whether android device available or not
     pub adb_device_status: bool,
 
     // the path containing LLDB's Python module
-    pub lldb_python_dir: Option<~str>,
+    pub lldb_python_dir: Option<StrBuf>,
 
     // Explain what's going on
     pub verbose: bool

branches/try2/src/compiletest/compiletest.rs

@@ -48,12 +48,14 @@ fn start(argc: int, argv: **u8) -> int {
 
 pub fn main() {
     let args = os::args();
-    let config = parse_config(args.move_iter().collect());
+    let config = parse_config(args.move_iter()
+                                  .map(|x| x.to_strbuf())
+                                  .collect());
     log_config(&config);
     run_tests(&config);
 }
 
-pub fn parse_config(args: Vec<~str> ) -> Config {
+pub fn parse_config(args: Vec<StrBuf> ) -> Config {
 
     let groups : Vec<getopts::OptGroup> =
         vec!(reqopt("", "compile-lib-path", "path to host shared libraries", "PATH"),
@@ -91,15 +93,15 @@ pub fn parse_config(args: Vec<~str> ) -> Config {
     assert!(!args.is_empty());
     let argv0 = (*args.get(0)).clone();
     let args_ = args.tail();
-    if *args.get(1) == "-h".to_owned() || *args.get(1) == "--help".to_owned() {
+    if args.get(1).as_slice() == "-h" || args.get(1).as_slice() == "--help" {
         let message = format!("Usage: {} [OPTIONS] [TESTNAME...]", argv0);
         println!("{}", getopts::usage(message, groups.as_slice()));
         println!("");
         fail!()
     }
 
     let matches =
-        &match getopts::getopts(args_, groups.as_slice()) {
+        &match getopts::getopts(args_.as_slice(), groups.as_slice()) {
           Ok(m) => m,
           Err(f) => fail!("{}", f.to_err_msg())
         };
@@ -129,39 +131,53 @@ pub fn parse_config(args: Vec<~str> ) -> Config {
     };
 
     Config {
-        compile_lib_path: matches.opt_str("compile-lib-path").unwrap(),
-        run_lib_path: matches.opt_str("run-lib-path").unwrap(),
+        compile_lib_path: matches.opt_str("compile-lib-path")
+                                 .unwrap()
+                                 .to_strbuf(),
+        run_lib_path: matches.opt_str("run-lib-path").unwrap().to_strbuf(),
         rustc_path: opt_path(matches, "rustc-path"),
         clang_path: matches.opt_str("clang-path").map(|s| Path::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: FromStr::from_str(matches.opt_str("mode").unwrap()).expect("invalid mode"),
+        stage_id: matches.opt_str("stage-id").unwrap().to_strbuf(),
+        mode: FromStr::from_str(matches.opt_str("mode")
+                                       .unwrap()
+                                       .as_slice()).expect("invalid mode"),
         run_ignored: matches.opt_present("ignored"),
         filter: filter,
         logfile: matches.opt_str("logfile").map(|s| Path::new(s)),
         save_metrics: matches.opt_str("save-metrics").map(|s| Path::new(s)),
         ratchet_metrics:
             matches.opt_str("ratchet-metrics").map(|s| Path::new(s)),
         ratchet_noise_percent:
-            matches.opt_str("ratchet-noise-percent").and_then(|s| from_str::<f64>(s)),
-        runtool: matches.opt_str("runtool"),
-        host_rustcflags: matches.opt_str("host-rustcflags"),
-        target_rustcflags: matches.opt_str("target-rustcflags"),
+            matches.opt_str("ratchet-noise-percent")
+                   .and_then(|s| from_str::<f64>(s.as_slice())),
+        runtool: matches.opt_str("runtool").map(|x| x.to_strbuf()),
+        host_rustcflags: matches.opt_str("host-rustcflags")
+                                .map(|x| x.to_strbuf()),
+        target_rustcflags: matches.opt_str("target-rustcflags")
+                                  .map(|x| x.to_strbuf()),
         jit: matches.opt_present("jit"),
-        target: opt_str2(matches.opt_str("target")).to_str(),
-        host: opt_str2(matches.opt_str("host")).to_str(),
+        target: opt_str2(matches.opt_str("target").map(|x| x.to_strbuf())),
+        host: opt_str2(matches.opt_str("host").map(|x| x.to_strbuf())),
         android_cross_path: opt_path(matches, "android-cross-path"),
-        adb_path: opt_str2(matches.opt_str("adb-path")).to_str(),
-        adb_test_dir:
-            opt_str2(matches.opt_str("adb-test-dir")).to_str(),
+        adb_path: opt_str2(matches.opt_str("adb-path")
+                                  .map(|x| x.to_strbuf())),
+        adb_test_dir: opt_str2(matches.opt_str("adb-test-dir")
+                                      .map(|x| x.to_strbuf())),
         adb_device_status:
-            "arm-linux-androideabi" == opt_str2(matches.opt_str("target")) &&
-            "(none)" != opt_str2(matches.opt_str("adb-test-dir")) &&
-            !opt_str2(matches.opt_str("adb-test-dir")).is_empty(),
-        lldb_python_dir: matches.opt_str("lldb-python-dir"),
+            "arm-linux-androideabi" ==
+                opt_str2(matches.opt_str("target")
+                                .map(|x| x.to_strbuf())).as_slice() &&
+            "(none)" !=
+                opt_str2(matches.opt_str("adb-test-dir")
+                                .map(|x| x.to_strbuf())).as_slice() &&
+            !opt_str2(matches.opt_str("adb-test-dir")
+                             .map(|x| x.to_strbuf())).is_empty(),
+        lldb_python_dir: matches.opt_str("lldb-python-dir")
+                                .map(|x| x.to_strbuf()),
         test_shard: test::opt_shard(matches.opt_str("test-shard")
                                            .map(|x| x.to_strbuf())),
         verbose: matches.opt_present("verbose")
@@ -170,50 +186,59 @@ pub fn parse_config(args: Vec<~str> ) -> 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!("stage_id: {}", config.stage_id));
-    logv(c, format!("mode: {}", config.mode));
-    logv(c, format!("run_ignored: {}", config.run_ignored));
-    logv(c, format!("filter: {}", opt_str(&config.filter.as_ref().map(|re| re.to_str()))));
-    logv(c, format!("runtool: {}", opt_str(&config.runtool)));
-    logv(c, format!("host-rustcflags: {}", opt_str(&config.host_rustcflags)));
-    logv(c, format!("target-rustcflags: {}", opt_str(&config.target_rustcflags)));
-    logv(c, format!("jit: {}", config.jit));
-    logv(c, format!("target: {}", config.target));
-    logv(c, format!("host: {}", config.host));
-    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_device_status: {}", config.adb_device_status));
+    logv(c, format_strbuf!("configuration:"));
+    logv(c, format_strbuf!("compile_lib_path: {}", config.compile_lib_path));
+    logv(c, format_strbuf!("run_lib_path: {}", config.run_lib_path));
+    logv(c, format_strbuf!("rustc_path: {}", config.rustc_path.display()));
+    logv(c, format_strbuf!("src_base: {}", config.src_base.display()));
+    logv(c, format_strbuf!("build_base: {}", config.build_base.display()));
+    logv(c, format_strbuf!("stage_id: {}", config.stage_id));
+    logv(c, format_strbuf!("mode: {}", config.mode));
+    logv(c, format_strbuf!("run_ignored: {}", config.run_ignored));
+    logv(c, format_strbuf!("filter: {}",
+                           opt_str(&config.filter
+                                          .as_ref()
+                                          .map(|re| {
+                                              re.to_str().into_strbuf()
+                                          }))));
+    logv(c, format_strbuf!("runtool: {}", opt_str(&config.runtool)));
+    logv(c, format_strbuf!("host-rustcflags: {}",
+                           opt_str(&config.host_rustcflags)));
+    logv(c, format_strbuf!("target-rustcflags: {}",
+                           opt_str(&config.target_rustcflags)));
+    logv(c, format_strbuf!("jit: {}", config.jit));
+    logv(c, format_strbuf!("target: {}", config.target));
+    logv(c, format_strbuf!("host: {}", config.host));
+    logv(c, format_strbuf!("android-cross-path: {}",
+                           config.android_cross_path.display()));
+    logv(c, format_strbuf!("adb_path: {}", config.adb_path));
+    logv(c, format_strbuf!("adb_test_dir: {}", config.adb_test_dir));
+    logv(c, format_strbuf!("adb_device_status: {}",
+                           config.adb_device_status));
     match config.test_shard {
-        None => logv(c, "test_shard: (all)".to_owned()),
-        Some((a,b)) => logv(c, format!("test_shard: {}.{}", a, b))
+        None => logv(c, "test_shard: (all)".to_strbuf()),
+        Some((a,b)) => logv(c, format_strbuf!("test_shard: {}.{}", a, b))
     }
-    logv(c, format!("verbose: {}", config.verbose));
-    logv(c, format!("\n"));
+    logv(c, format_strbuf!("verbose: {}", config.verbose));
+    logv(c, format_strbuf!("\n"));
 }
 
-pub fn opt_str<'a>(maybestr: &'a Option<~str>) -> &'a str {
+pub fn opt_str<'a>(maybestr: &'a Option<StrBuf>) -> &'a str {
     match *maybestr {
         None => "(none)",
-        Some(ref s) => {
-            let s: &'a str = *s;
-            s
-        }
+        Some(ref s) => s.as_slice(),
     }
 }
 
-pub fn opt_str2(maybestr: Option<~str>) -> ~str {
-    match maybestr { None => "(none)".to_owned(), Some(s) => { s } }
+pub fn opt_str2(maybestr: Option<StrBuf>) -> StrBuf {
+    match maybestr {
+        None => "(none)".to_strbuf(),
+        Some(s) => s,
+    }
 }
 
 pub fn run_tests(config: &Config) {
-    if config.target == "arm-linux-androideabi".to_owned() {
+    if config.target.as_slice() == "arm-linux-androideabi" {
         match config.mode {
             DebugInfoGdb => {
                 println!("arm-linux-androideabi debug-info \
@@ -321,11 +346,11 @@ pub fn make_test(config: &Config, testfile: &Path, f: || -> test::TestFn)
 pub fn make_test_name(config: &Config, testfile: &Path) -> test::TestName {
 
     // Try to elide redundant long paths
-    fn shorten(path: &Path) -> ~str {
+    fn shorten(path: &Path) -> StrBuf {
         let filename = path.filename_str();
         let p = path.dir_path();
         let dir = p.filename_str();
-        format!("{}/{}", dir.unwrap_or(""), filename.unwrap_or(""))
+        format_strbuf!("{}/{}", dir.unwrap_or(""), filename.unwrap_or(""))
     }
 
     test::DynTestName(format_strbuf!("[{}] {}",
@@ -336,14 +361,16 @@ 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();
     // FIXME (#9639): This needs to handle non-utf8 paths
-    let testfile = testfile.as_str().unwrap().to_owned();
-    test::DynTestFn(proc() { runtest::run(config, testfile) })
+    let testfile = testfile.as_str().unwrap().to_strbuf();
+    test::DynTestFn(proc() {
+        runtest::run(config, testfile)
+    })
 }
 
 pub fn make_metrics_test_closure(config: &Config, testfile: &Path) -> test::TestFn {
     let config = (*config).clone();
     // FIXME (#9639): This needs to handle non-utf8 paths
-    let testfile = testfile.as_str().unwrap().to_owned();
+    let testfile = testfile.as_str().unwrap().to_strbuf();
     test::DynMetricFn(proc(mm) {
         runtest::run_metrics(config, testfile, mm)
     })