---

yaml
---
r: 107007
b: refs/heads/try
c: 988664a
h: refs/heads/master
i:
  107005: 4db75fd
  107003: 4cf2529
  106999: fcd2a69
  106991: bcf6a39
  106975: c798691
  106943: 739d260
  106879: b020a74
  106751: 8ca7142
  106495: 546b03f
v: v3

Author: alexcrichton

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: b8ef9fd9c9f642ce7b8aed82782a1ed745d08d64
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: b8601a3d8b91ad3b653d143307611f2f5c75617e
-refs/heads/try: cff012dc90172a345bcea2465ac0d65f703527f8
+refs/heads/try: 988664ac8a9ae3f53341afd5a60d5e11d3f0ba7e
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/.travis.yml

@@ -41,7 +41,7 @@ script: |
   fi &&
   make tidy &&
   make -j4 rustc-stage1 &&
-  make check-stage1-std check-stage1-rpass check-stage1-cfail check-stage1-rfail check-stage1-doc
+  make check-stage1-std check-stage1-rpass check-stage1-cfail check-stage1-rfail
 
 env:
   global:

branches/try/mk/dist.mk

@@ -65,6 +65,8 @@ $(PKG_EXE): rust.iss modpath.iss LICENSE.txt rust-logo.ico \
 dist-prepare-win: PREPARE_HOST=$(CFG_BUILD)
 dist-prepare-win: PREPARE_TARGETS=$(CFG_BUILD)
 dist-prepare-win: PREPARE_DEST_DIR=tmp/dist/win
+# On windows we're using stage3, unlike Unix...
+dist-prepare-win: PREPARE_STAGE=3
 dist-prepare-win: PREPARE_DIR_CMD=$(DEFAULT_PREPARE_DIR_CMD)
 dist-prepare-win: PREPARE_BIN_CMD=$(DEFAULT_PREPARE_BIN_CMD)
 dist-prepare-win: PREPARE_LIB_CMD=$(DEFAULT_PREPARE_LIB_CMD)
@@ -133,6 +135,7 @@ ifeq ($(CFG_OSTYPE), apple-darwin)
 dist-prepare-osx: PREPARE_HOST=$(CFG_BUILD)
 dist-prepare-osx: PREPARE_TARGETS=$(CFG_BUILD)
 dist-prepare-osx: PREPARE_DEST_DIR=tmp/dist/pkgroot
+dist-prepare-osx: PREPARE_STAGE=2
 dist-prepare-osx: PREPARE_DIR_CMD=$(DEFAULT_PREPARE_DIR_CMD)
 dist-prepare-osx: PREPARE_BIN_CMD=$(DEFAULT_PREPARE_BIN_CMD)
 dist-prepare-osx: PREPARE_LIB_CMD=$(DEFAULT_PREPARE_LIB_CMD)
@@ -162,6 +165,7 @@ dist-tar-bins: $(foreach host,$(CFG_HOST),dist/$(PKG_DIR)-$(host).tar.gz)
 define DEF_INSTALLER
 dist-install-dir-$(1): PREPARE_HOST=$(1)
 dist-install-dir-$(1): PREPARE_TARGETS=$(1)
+dist-install-dir-$(1): PREPARE_STAGE=2
 dist-install-dir-$(1): PREPARE_DEST_DIR=tmp/dist/$$(PKG_DIR)-$(1)
 dist-install-dir-$(1): PREPARE_DIR_CMD=$(DEFAULT_PREPARE_DIR_CMD)
 dist-install-dir-$(1): PREPARE_BIN_CMD=$(DEFAULT_PREPARE_BIN_CMD)

branches/try/mk/install.mk

@@ -13,10 +13,11 @@
 # mirror of the installation directory structure.
 
 # The stage we install from
-ISTAGE = $(PREPARE_STAGE)
+ISTAGE = 2
 
 install: PREPARE_HOST=$(CFG_BUILD)
 install: PREPARE_TARGETS=$(CFG_TARGET)
+install: PREPARE_STAGE=$(ISTAGE)
 install: PREPARE_DIR_CMD=$(DEFAULT_PREPARE_DIR_CMD)
 install: PREPARE_BIN_CMD=$(DEFAULT_PREPARE_BIN_CMD)
 install: PREPARE_LIB_CMD=$(DEFAULT_PREPARE_LIB_CMD)

branches/try/mk/prepare.mk

@@ -20,14 +20,7 @@
 #   PREPARE_TARGETS - the target triples, space separated
 #   PREPARE_DEST_DIR - the directory to put the image
 
-
-# On windows we install from stage3, but on unix only stage2
-ifdef CFG_WINDOWSY_$(CFG_BUILD)
-PREPARE_STAGE=3
-else
-PREPARE_STAGE=2
-endif
-
+prepare: PREPARE_STAGE=2
 prepare: PREPARE_DIR_CMD=$(DEFAULT_PREPARE_DIR_CMD)
 prepare: PREPARE_BIN_CMD=$(DEFAULT_PREPARE_BIN_CMD)
 prepare: PREPARE_LIB_CMD=$(DEFAULT_PREPARE_LIB_CMD)
@@ -50,6 +43,15 @@ DEFAULT_PREPARE_BIN_CMD = install -m755
 DEFAULT_PREPARE_LIB_CMD = install -m644
 DEFAULT_PREPARE_MAN_CMD = install -m644
 
+# On windows we install from stage3, but on unix only stage2
+# Because of the way these rules are organized, preparing from any
+# stage requires all these stages to be built
+ifdef CFG_WINDOWSY_$(CFG_BUILD)
+PREPARE_STAGES=3
+else
+PREPARE_STAGES=2
+endif
+
 # Create a directory
 # $(1) is the directory
 define PREPARE_DIR
@@ -100,8 +102,9 @@ prepare-host: prepare-host-tools
 
 prepare-host-tools: \
         $(foreach tool, $(PREPARE_TOOLS),\
-          $(foreach host,$(CFG_HOST),\
-            prepare-host-tool-$(tool)-$(PREPARE_STAGE)-$(host)))
+          $(foreach stage,$(PREPARE_STAGES),\
+            $(foreach host,$(CFG_HOST),\
+              prepare-host-tool-$(tool)-$(stage)-$(host))))
 
 prepare-host-dirs: prepare-maybe-clean
 	$(call PREPARE_DIR,$(PREPARE_DEST_BIN_DIR))
@@ -125,8 +128,9 @@ prepare-host-tool-$(1)-$(2)-$(3): prepare-maybe-clean \
 endef
 
 $(foreach tool,$(PREPARE_TOOLS),\
-  $(foreach host,$(CFG_HOST),\
-      $(eval $(call DEF_PREPARE_HOST_TOOL,$(tool),$(PREPARE_STAGE),$(host)))))
+  $(foreach stage,$(PREPARE_STAGES),\
+    $(foreach host,$(CFG_HOST),\
+        $(eval $(call DEF_PREPARE_HOST_TOOL,$(tool),$(stage),$(host))))))
 
 # For host libraries only install dylibs, not rlibs since the host libs are only
 # used to support rustc and rustc uses dynamic linking
@@ -147,13 +151,15 @@ prepare-host-lib-$(1)-$(2)-$(3): prepare-maybe-clean \
 endef
 
 $(foreach lib,$(CRATES),\
-  $(foreach host,$(CFG_HOST),\
-    $(eval $(call DEF_PREPARE_HOST_LIB,$(lib),$(PREPARE_STAGE),$(host)))))
+  $(foreach stage,$(PREPARE_STAGES),\
+    $(foreach host,$(CFG_HOST),\
+      $(eval $(call DEF_PREPARE_HOST_LIB,$(lib),$(stage),$(host))))))
 
 prepare-targets:\
         $(foreach host,$(CFG_HOST),\
            $(foreach target,$(CFG_TARGET),\
-             prepare-target-$(target)-host-$(host)-$(PREPARE_STAGE)))
+             $(foreach stage,$(PREPARE_STAGES),\
+               prepare-target-$(target)-host-$(host)-$(stage))))
 
 # $(1) is stage
 # $(2) is target
@@ -188,7 +194,8 @@ endef
 
 $(foreach host,$(CFG_HOST),\
   $(foreach target,$(CFG_TARGET), \
-    $(eval $(call DEF_PREPARE_TARGET_N,$(PREPARE_STAGE),$(target),$(host)))))
+    $(foreach stage,$(PREPARE_STAGES),\
+      $(eval $(call DEF_PREPARE_TARGET_N,$(stage),$(target),$(host))))))
 
 prepare-maybe-clean:
 	$(if $(findstring true,$(PREPARE_CLEAN)),\

branches/try/src/compiletest/compiletest.rs

@@ -12,7 +12,6 @@
 #[feature(phase)];
 
 #[allow(non_camel_case_types)];
-#[allow(deprecated_owned_vector)]; // NOTE: remove after stage0
 #[deny(warnings)];
 
 extern crate test;
@@ -43,15 +42,15 @@ pub mod errors;
 
 pub fn main() {
     let args = os::args();
-    let config = parse_config(args.move_iter().collect());
+    let config = parse_config(args);
     log_config(&config);
     run_tests(&config);
 }
 
-pub fn parse_config(args: Vec<~str> ) -> config {
+pub fn parse_config(args: ~[~str]) -> config {
 
-    let groups : Vec<getopts::OptGroup> =
-        vec!(reqopt("", "compile-lib-path", "path to host shared libraries", "PATH"),
+    let groups : ~[getopts::OptGroup] =
+        ~[reqopt("", "compile-lib-path", "path to host shared libraries", "PATH"),
           reqopt("", "run-lib-path", "path to target shared libraries", "PATH"),
           reqopt("", "rustc-path", "path to rustc to use for compiling", "PATH"),
           optopt("", "clang-path", "path to  executable for codegen tests", "PATH"),
@@ -79,27 +78,28 @@ pub fn parse_config(args: Vec<~str> ) -> config {
           optopt("", "adb-path", "path to the android debugger", "PATH"),
           optopt("", "adb-test-dir", "path to tests for the android debugger", "PATH"),
           optopt("", "test-shard", "run shard A, of B shards, worth of the testsuite", "A.B"),
-          optflag("h", "help", "show this message"));
+          optflag("h", "help", "show this message"),
+         ];
 
     assert!(!args.is_empty());
-    let argv0 = (*args.get(0)).clone();
+    let argv0 = args[0].clone();
     let args_ = args.tail();
-    if *args.get(1) == ~"-h" || *args.get(1) == ~"--help" {
+    if args[1] == ~"-h" || args[1] == ~"--help" {
         let message = format!("Usage: {} [OPTIONS] [TESTNAME...]", argv0);
-        println!("{}", getopts::usage(message, groups.as_slice()));
+        println!("{}", getopts::usage(message, groups));
         println!("");
         fail!()
     }
 
     let matches =
-        &match getopts::getopts(args_, groups.as_slice()) {
+        &match getopts::getopts(args_, groups) {
           Ok(m) => m,
           Err(f) => fail!("{}", f.to_err_msg())
         };
 
     if matches.opt_present("h") || matches.opt_present("help") {
         let message = format!("Usage: {} [OPTIONS]  [TESTNAME...]", argv0);
-        println!("{}", getopts::usage(message, groups.as_slice()));
+        println!("{}", getopts::usage(message, groups));
         println!("");
         fail!()
     }
@@ -122,7 +122,7 @@ pub fn parse_config(args: Vec<~str> ) -> config {
         run_ignored: matches.opt_present("ignored"),
         filter:
             if !matches.free.is_empty() {
-                 Some((*matches.free.get(0)).clone())
+                 Some(matches.free[0].clone())
             } else {
                 None
             },
@@ -238,7 +238,7 @@ pub fn run_tests(config: &config) {
     // parallel (especially when we have lots and lots of child processes).
     // For context, see #8904
     io::test::raise_fd_limit();
-    let res = test::run_tests_console(&opts, tests.move_iter().collect());
+    let res = test::run_tests_console(&opts, tests);
     match res {
         Ok(true) => {}
         Ok(false) => fail!("Some tests failed"),
@@ -262,10 +262,10 @@ pub fn test_opts(config: &config) -> test::TestOpts {
     }
 }
 
-pub fn make_tests(config: &config) -> Vec<test::TestDescAndFn> {
+pub fn make_tests(config: &config) -> ~[test::TestDescAndFn] {
     debug!("making tests from {}",
            config.src_base.display());
-    let mut tests = Vec::new();
+    let mut tests = ~[];
     let dirs = fs::readdir(&config.src_base).unwrap();
     for file in dirs.iter() {
         let file = file.clone();
@@ -287,10 +287,10 @@ pub fn is_test(config: &config, testfile: &Path) -> bool {
     // Pretty-printer does not work with .rc files yet
     let valid_extensions =
         match config.mode {
-          mode_pretty => vec!(~".rs"),
-          _ => vec!(~".rc", ~".rs")
+          mode_pretty => ~[~".rs"],
+          _ => ~[~".rc", ~".rs"]
         };
-    let invalid_prefixes = vec!(~".", ~"#", ~"~");
+    let invalid_prefixes = ~[~".", ~"#", ~"~"];
     let name = testfile.filename_str().unwrap();
 
     let mut valid = false;

branches/try/src/compiletest/errors.rs

@@ -13,9 +13,9 @@ use std::io::{BufferedReader, File};
 pub struct ExpectedError { line: uint, kind: ~str, msg: ~str }
 
 // Load any test directives embedded in the file
-pub fn load_errors(testfile: &Path) -> Vec<ExpectedError> {
+pub fn load_errors(testfile: &Path) -> ~[ExpectedError] {
 
-    let mut error_patterns = Vec::new();
+    let mut error_patterns = ~[];
     let mut rdr = BufferedReader::new(File::open(testfile).unwrap());
     let mut line_num = 1u;
     for ln in rdr.lines() {
@@ -25,12 +25,12 @@ pub fn load_errors(testfile: &Path) -> Vec<ExpectedError> {
     return error_patterns;
 }
 
-fn parse_expected(line_num: uint, line: ~str) -> Vec<ExpectedError> {
+fn parse_expected(line_num: uint, line: ~str) -> ~[ExpectedError] {
     let line = line.trim();
     let error_tag = ~"//~";
     let mut idx;
     match line.find_str(error_tag) {
-      None => return Vec::new(),
+      None => return ~[],
       Some(nn) => { idx = (nn as uint) + error_tag.len(); }
     }
 
@@ -57,6 +57,6 @@ fn parse_expected(line_num: uint, line: ~str) -> Vec<ExpectedError> {
 
     debug!("line={} kind={} msg={}", line_num - adjust_line, kind, msg);
 
-    return vec!(ExpectedError{line: line_num - adjust_line, kind: kind,
-                           msg: msg});
+    return ~[ExpectedError{line: line_num - adjust_line, kind: kind,
+                           msg: msg}];
 }

branches/try/src/compiletest/header.rs

@@ -14,20 +14,20 @@ use util;
 
 pub struct TestProps {
     // Lines that should be expected, in order, on standard out
-    error_patterns: Vec<~str> ,
+    error_patterns: ~[~str],
     // Extra flags to pass to the compiler
     compile_flags: Option<~str>,
     // If present, the name of a file that this test should match when
     // pretty-printed
     pp_exact: Option<Path>,
     // Modules from aux directory that should be compiled
-    aux_builds: Vec<~str> ,
+    aux_builds: ~[~str],
     // Environment settings to use during execution
-    exec_env: Vec<(~str,~str)> ,
+    exec_env: ~[(~str,~str)],
     // Commands to be given to the debugger, when testing debug info
-    debugger_cmds: Vec<~str> ,
+    debugger_cmds: ~[~str],
     // Lines to check if they appear in the expected debugger output
-    check_lines: Vec<~str> ,
+    check_lines: ~[~str],
     // Flag to force a crate to be built with the host architecture
     force_host: bool,
     // Check stdout for error-pattern output as well as stderr
@@ -38,13 +38,13 @@ pub struct TestProps {
 
 // Load any test directives embedded in the file
 pub fn load_props(testfile: &Path) -> TestProps {
-    let mut error_patterns = Vec::new();
-    let mut aux_builds = Vec::new();
-    let mut exec_env = Vec::new();
+    let mut error_patterns = ~[];
+    let mut aux_builds = ~[];
+    let mut exec_env = ~[];
     let mut compile_flags = None;
     let mut pp_exact = None;
-    let mut debugger_cmds = Vec::new();
-    let mut check_lines = Vec::new();
+    let mut debugger_cmds = ~[];
+    let mut check_lines = ~[];
     let mut force_host = false;
     let mut check_stdout = false;
     let mut no_prefer_dynamic = false;
@@ -183,7 +183,7 @@ fn parse_no_prefer_dynamic(line: &str) -> bool {
 fn parse_exec_env(line: &str) -> Option<(~str, ~str)> {
     parse_name_value_directive(line, ~"exec-env").map(|nv| {
         // nv is either FOO or FOO=BAR
-        let mut strs: Vec<~str> = nv.splitn('=', 1).map(|s| s.to_owned()).collect();
+        let mut strs: ~[~str] = nv.splitn('=', 1).map(|s| s.to_owned()).collect();
 
         match strs.len() {
           1u => (strs.pop().unwrap(), ~""),

branches/try/src/compiletest/procsrv.rs

@@ -11,10 +11,9 @@
 use std::os;
 use std::str;
 use std::io::process::{ProcessExit, Process, ProcessConfig, ProcessOutput};
-use std::vec;
 
 #[cfg(target_os = "win32")]
-fn target_env(lib_path: &str, prog: &str) -> Vec<(~str,~str)> {
+fn target_env(lib_path: &str, prog: &str) -> ~[(~str,~str)] {
 
     let mut env = os::env();
 
@@ -36,11 +35,11 @@ fn target_env(lib_path: &str, prog: &str) -> Vec<(~str,~str)> {
 #[cfg(target_os = "linux")]
 #[cfg(target_os = "macos")]
 #[cfg(target_os = "freebsd")]
-fn target_env(lib_path: &str, prog: &str) -> Vec<(~str,~str)> {
+fn target_env(lib_path: &str, prog: &str) -> ~[(~str,~str)] {
     // Make sure we include the aux directory in the path
     let aux_path = prog + ".libaux";
 
-    let mut env: Vec<(~str,~str)> = os::env().move_iter().collect();
+    let mut env = os::env();
     let var = if cfg!(target_os = "macos") {
         "DYLD_LIBRARY_PATH"
     } else {
@@ -63,11 +62,10 @@ pub struct Result {status: ProcessExit, out: ~str, err: ~str}
 pub fn run(lib_path: &str,
            prog: &str,
            args: &[~str],
-           env: Vec<(~str, ~str)> ,
+           env: ~[(~str, ~str)],
            input: Option<~str>) -> Option<Result> {
 
-    let env = vec::append(env.clone(),
-                             target_env(lib_path, prog).as_slice());
+    let env = env + target_env(lib_path, prog);
     let mut opt_process = Process::configure(ProcessConfig {
         program: prog,
         args: args,
@@ -95,11 +93,10 @@ pub fn run(lib_path: &str,
 pub fn run_background(lib_path: &str,
            prog: &str,
            args: &[~str],
-           env: Vec<(~str, ~str)> ,
+           env: ~[(~str, ~str)],
            input: Option<~str>) -> Option<Process> {
 
-    let env = vec::append(env.clone(),
-                             target_env(lib_path, prog).as_slice());
+    let env = env + target_env(lib_path, prog);
     let opt_process = Process::configure(ProcessConfig {
         program: prog,
         args: args,