---

yaml
---
r: 134124
b: refs/heads/master
c: c942df9
h: refs/heads/master
v: v3

Author: ohazi

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 321785927c0514ada9989aae7849940ca86f0600
+refs/heads/master: c942df9fa590d53a87a1c47aba5938c7f7d100b6
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 437179ed8bf7f7672f84b19265df1ce569e70490
 refs/heads/try: 777654cfccbfa39bc7f671d8e9629018ed8ca12d

trunk/CONTRIBUTING.md

@@ -4,12 +4,6 @@ If you're just reporting a bug, please see:
 
 http://doc.rust-lang.org/complement-bugreport.html
 
-## Submitting an issue
-
-Please submit issues here for bug reports or implementation details. For feature
-requests, language changes, or major changes to the libraries, please submit an
-issue against the [RFCs repository](https://github.com/rust-lang/rfcs).
-
 ## Pull request procedure
 
 Pull requests should be targeted at Rust's `master` branch.

trunk/configure

@@ -306,7 +306,7 @@ case $CFG_OSTYPE in
         # instead, msys defines $MSYSTEM which is MINGW32 on i686 and
         # MINGW64 on x86_64.
         CFG_CPUTYPE=i686
-        CFG_OSTYPE=w64-mingw32
+        CFG_OSTYPE=pc-mingw32
         if [ "$MSYSTEM" = MINGW64 ]
         then
             CFG_CPUTYPE=x86_64
@@ -477,6 +477,12 @@ fi
 step_msg "validating $CFG_SELF args"
 validate_opt
 
+# Temporarily support the old windows triples while the bots make the transition
+# XXX Remove me
+CFG_BUILD=`echo "${CFG_BUILD}" | sed 's/-pc-mingw32/-w64-mingw32/g'`
+CFG_HOST=`echo "${CFG_HOST}" | sed 's/-pc-mingw32/-w64-mingw32/g'`
+CFG_TARGET=`echo "${CFG_TARGET}" | sed 's/-pc-mingw32/-w64-mingw32/g'`
+
 # Validate the release channel
 case "$CFG_RELEASE_CHANNEL" in
     (source | nightly | beta | stable)

trunk/mk/tests.mk

@@ -194,6 +194,9 @@ check-ref: cleantestlibs cleantmptestlogs check-stage2-rpass \
 check-docs: cleantestlibs cleantmptestlogs check-stage2-docs
 	$(Q)$(CFG_PYTHON) $(S)src/etc/check-summary.py tmp/*.log
 
+# NOTE: Remove after reprogramming windows bots
+check-fast: check-lite
+
 # Some less critical tests that are not prone to breakage.
 # Not run as part of the normal test suite, but tested by bors on checkin.
 check-secondary: check-lexer check-pretty

trunk/src/compiletest/header.rs

@@ -42,8 +42,6 @@ pub struct TestProps {
     pub pretty_mode: String,
     // Only compare pretty output and don't try compiling
     pub pretty_compare_only: bool,
-    // Patterns which must not appear in the output of a cfail test.
-    pub forbid_output: Vec<String>,
 }
 
 // Load any test directives embedded in the file
@@ -61,7 +59,6 @@ pub fn load_props(testfile: &Path) -> TestProps {
     let mut no_pretty_expanded = false;
     let mut pretty_mode = None;
     let mut pretty_compare_only = false;
-    let mut forbid_output = Vec::new();
     iter_header(testfile, |ln| {
         match parse_error_pattern(ln) {
           Some(ep) => error_patterns.push(ep),
@@ -119,11 +116,6 @@ pub fn load_props(testfile: &Path) -> TestProps {
             None => ()
         };
 
-        match parse_forbid_output(ln) {
-            Some(of) => forbid_output.push(of),
-            None => (),
-        }
-
         true
     });
 
@@ -140,8 +132,7 @@ pub fn load_props(testfile: &Path) -> TestProps {
         no_prefer_dynamic: no_prefer_dynamic,
         no_pretty_expanded: no_pretty_expanded,
         pretty_mode: pretty_mode.unwrap_or("normal".to_string()),
-        pretty_compare_only: pretty_compare_only,
-        forbid_output: forbid_output,
+        pretty_compare_only: pretty_compare_only
     }
 }
 
@@ -219,10 +210,6 @@ fn parse_error_pattern(line: &str) -> Option<String> {
     parse_name_value_directive(line, "error-pattern")
 }
 
-fn parse_forbid_output(line: &str) -> Option<String> {
-    parse_name_value_directive(line, "forbid-output")
-}
-
 fn parse_aux_build(line: &str) -> Option<String> {
     parse_name_value_directive(line, "aux-build")
 }

trunk/src/compiletest/runtest.rs

@@ -71,14 +71,6 @@ pub fn run_metrics(config: Config, testfile: String, mm: &mut MetricMap) {
     }
 }
 
-fn get_output(props: &TestProps, proc_res: &ProcRes) -> String {
-    if props.check_stdout {
-        format!("{}{}", proc_res.stdout, proc_res.stderr)
-    } else {
-        proc_res.stderr.clone()
-    }
-}
-
 fn run_cfail_test(config: &Config, props: &TestProps, testfile: &Path) {
     let proc_res = compile_test(config, props, testfile);
 
@@ -89,22 +81,16 @@ fn run_cfail_test(config: &Config, props: &TestProps, testfile: &Path) {
 
     check_correct_failure_status(&proc_res);
 
-    if proc_res.status.success() {
-        fatal("process did not return an error status");
-    }
-
-    let output_to_check = get_output(props, &proc_res);
     let expected_errors = errors::load_errors(&config.cfail_regex, testfile);
     if !expected_errors.is_empty() {
         if !props.error_patterns.is_empty() {
             fatal("both error pattern and expected errors specified");
         }
         check_expected_errors(expected_errors, testfile, &proc_res);
     } else {
-        check_error_patterns(props, testfile, output_to_check.as_slice(), &proc_res);
+        check_error_patterns(props, testfile, &proc_res);
     }
     check_no_compiler_crash(&proc_res);
-    check_forbid_output(props, output_to_check.as_slice(), &proc_res);
 }
 
 fn run_rfail_test(config: &Config, props: &TestProps, testfile: &Path) {
@@ -126,9 +112,8 @@ fn run_rfail_test(config: &Config, props: &TestProps, testfile: &Path) {
         fatal_proc_rec("run-fail test isn't valgrind-clean!", &proc_res);
     }
 
-    let output_to_check = get_output(props, &proc_res);
     check_correct_failure_status(&proc_res);
-    check_error_patterns(props, testfile, output_to_check.as_slice(), &proc_res);
+    check_error_patterns(props, testfile, &proc_res);
 }
 
 fn check_correct_failure_status(proc_res: &ProcRes) {
@@ -273,8 +258,8 @@ fn run_pretty_test(config: &Config, props: &TestProps, testfile: &Path) {
                             format!("--target={}", config.target),
                             "-L".to_string(),
                             aux_dir.as_str().unwrap().to_string());
-        args.extend(split_maybe_args(&config.target_rustcflags).into_iter());
-        args.extend(split_maybe_args(&props.compile_flags).into_iter());
+        args.push_all_move(split_maybe_args(&config.target_rustcflags));
+        args.push_all_move(split_maybe_args(&props.compile_flags));
         return ProcArgs {
             prog: config.rustc_path.as_str().unwrap().to_string(),
             args: args,
@@ -321,8 +306,8 @@ actual:\n\
                             config.build_base.as_str().unwrap().to_string(),
                             "-L".to_string(),
                             aux_dir.as_str().unwrap().to_string());
-        args.extend(split_maybe_args(&config.target_rustcflags).into_iter());
-        args.extend(split_maybe_args(&props.compile_flags).into_iter());
+        args.push_all_move(split_maybe_args(&config.target_rustcflags));
+        args.push_all_move(split_maybe_args(&props.compile_flags));
         // FIXME (#9639): This needs to handle non-utf8 paths
         return ProcArgs {
             prog: config.rustc_path.as_str().unwrap().to_string(),
@@ -849,15 +834,24 @@ fn check_debugger_output(debugger_run_result: &ProcRes, check_lines: &[String])
 
 fn check_error_patterns(props: &TestProps,
                         testfile: &Path,
-                        output_to_check: &str,
                         proc_res: &ProcRes) {
     if props.error_patterns.is_empty() {
         fatal(format!("no error pattern specified in {}",
                       testfile.display()).as_slice());
     }
+
+    if proc_res.status.success() {
+        fatal("process did not return an error status");
+    }
+
     let mut next_err_idx = 0u;
     let mut next_err_pat = &props.error_patterns[next_err_idx];
     let mut done = false;
+    let output_to_check = if props.check_stdout {
+        format!("{}{}", proc_res.stdout, proc_res.stderr)
+    } else {
+        proc_res.stderr.clone()
+    };
     for line in output_to_check.as_slice().lines() {
         if line.contains(next_err_pat.as_slice()) {
             debug!("found error pattern {}", next_err_pat);
@@ -896,16 +890,6 @@ fn check_no_compiler_crash(proc_res: &ProcRes) {
     }
 }
 
-fn check_forbid_output(props: &TestProps,
-                       output_to_check: &str,
-                       proc_res: &ProcRes) {
-    for pat in props.forbid_output.iter() {
-        if output_to_check.contains(pat.as_slice()) {
-            fatal_proc_rec("forbidden pattern found in compiler output", proc_res);
-        }
-    }
-}
-
 fn check_expected_errors(expected_errors: Vec<errors::ExpectedError> ,
                          testfile: &Path,
                          proc_res: &ProcRes) {
@@ -1095,12 +1079,11 @@ fn compile_test_(config: &Config, props: &TestProps,
                  testfile: &Path, extra_args: &[String]) -> ProcRes {
     let aux_dir = aux_output_dir_name(config, testfile);
     // FIXME (#9639): This needs to handle non-utf8 paths
-    let mut link_args = vec!("-L".to_string(),
-                             aux_dir.as_str().unwrap().to_string());
-    link_args.extend(extra_args.iter().map(|s| s.clone()));
+    let link_args = vec!("-L".to_string(),
+                         aux_dir.as_str().unwrap().to_string());
     let args = make_compile_args(config,
                                  props,
-                                 link_args,
+                                 link_args.append(extra_args),
                                  |a, b| ThisFile(make_exe_name(a, b)), testfile);
     compose_and_run_compiler(config, props, testfile, args, None)
 }
@@ -1147,16 +1130,16 @@ fn compose_and_run_compiler(
     for rel_ab in props.aux_builds.iter() {
         let abs_ab = config.aux_base.join(rel_ab.as_slice());
         let aux_props = header::load_props(&abs_ab);
-        let mut crate_type = if aux_props.no_prefer_dynamic {
+        let crate_type = if aux_props.no_prefer_dynamic {
             Vec::new()
         } else {
             vec!("--crate-type=dylib".to_string())
         };
-        crate_type.extend(extra_link_args.clone().into_iter());
         let aux_args =
             make_compile_args(config,
                               &aux_props,
-                              crate_type,
+                              crate_type.append(
+                                  extra_link_args.as_slice()),
                               |a,b| {
                                   let f = make_lib_name(a, b, testfile);
                                   ThisDirectory(f.dir_path())
@@ -1247,11 +1230,11 @@ fn make_compile_args(config: &Config,
     };
     args.push(path.as_str().unwrap().to_string());
     if props.force_host {
-        args.extend(split_maybe_args(&config.host_rustcflags).into_iter());
+        args.push_all_move(split_maybe_args(&config.host_rustcflags));
     } else {
-        args.extend(split_maybe_args(&config.target_rustcflags).into_iter());
+        args.push_all_move(split_maybe_args(&config.target_rustcflags));
     }
-    args.extend(split_maybe_args(&props.compile_flags).into_iter());
+    args.push_all_move(split_maybe_args(&props.compile_flags));
     return ProcArgs {
         prog: config.rustc_path.as_str().unwrap().to_string(),
         args: args,
@@ -1268,9 +1251,10 @@ fn make_lib_name(config: &Config, auxfile: &Path, testfile: &Path) -> Path {
 fn make_exe_name(config: &Config, testfile: &Path) -> Path {
     let mut f = output_base_name(config, testfile);
     if !os::consts::EXE_SUFFIX.is_empty() {
-        let mut fname = f.filename().unwrap().to_vec();
-        fname.extend(os::consts::EXE_SUFFIX.bytes());
-        f.set_filename(fname);
+        match f.filename().map(|s| Vec::from_slice(s).append(os::consts::EXE_SUFFIX.as_bytes())) {
+            Some(v) => f.set_filename(v),
+            None => ()
+        }
     }
     f
 }
@@ -1286,7 +1270,7 @@ fn make_run_args(config: &Config, props: &TestProps, testfile: &Path) ->
     args.push(exe_file.as_str().unwrap().to_string());
 
     // Add the arguments in the run_flags directive
-    args.extend(split_maybe_args(&props.run_flags).into_iter());
+    args.push_all_move(split_maybe_args(&props.run_flags));
 
     let prog = args.remove(0).unwrap();
     return ProcArgs {
@@ -1381,10 +1365,12 @@ fn make_out_name(config: &Config, testfile: &Path, extension: &str) -> Path {
 }
 
 fn aux_output_dir_name(config: &Config, testfile: &Path) -> Path {
-    let f = output_base_name(config, testfile);
-    let mut fname = f.filename().unwrap().to_vec();
-    fname.extend("libaux".bytes());
-    f.with_filename(fname)
+    let mut f = output_base_name(config, testfile);
+    match f.filename().map(|s| Vec::from_slice(s).append(b".libaux")) {
+        Some(v) => f.set_filename(v),
+        None => ()
+    }
+    f
 }
 
 fn output_testname(testfile: &Path) -> Path {
@@ -1596,25 +1582,22 @@ fn append_suffix_to_stem(p: &Path, suffix: &str) -> Path {
     if suffix.len() == 0 {
         (*p).clone()
     } else {
-        let mut stem = p.filestem().unwrap().to_vec();
-        stem.extend("-".bytes());
-        stem.extend(suffix.bytes());
-        p.with_filename(stem)
+        let stem = p.filestem().unwrap();
+        p.with_filename(Vec::from_slice(stem).append(b"-").append(suffix.as_bytes()))
     }
 }
 
 fn compile_test_and_save_bitcode(config: &Config, props: &TestProps,
                                  testfile: &Path) -> ProcRes {
     let aux_dir = aux_output_dir_name(config, testfile);
     // FIXME (#9639): This needs to handle non-utf8 paths
-    let mut link_args = vec!("-L".to_string(),
-                             aux_dir.as_str().unwrap().to_string());
+    let link_args = vec!("-L".to_string(),
+                         aux_dir.as_str().unwrap().to_string());
     let llvm_args = vec!("--emit=bc,obj".to_string(),
                          "--crate-type=lib".to_string());
-    link_args.extend(llvm_args.into_iter());
     let args = make_compile_args(config,
                                  props,
-                                 link_args,
+                                 link_args.append(llvm_args.as_slice()),
                                  |a, b| ThisDirectory(output_base_name(a, b).dir_path()),
                                  testfile);
     compose_and_run_compiler(config, props, testfile, args, None)

trunk/src/doc/guide.md

@@ -1575,6 +1575,8 @@ we haven't seen before. Here's a simple program that reads some input,
 and then prints it back out:
 
 ```{rust,ignore}
+use std::io;
+
 fn main() {
     println!("Type something!");
 
@@ -2151,14 +2153,10 @@ In this case, we say `x` is a `uint` explicitly, so Rust is able to properly
 tell `random()` what to generate. In a similar fashion, both of these work:
 
 ```{rust,ignore}
-let input_num = from_str::<Option<uint>>("5");
+let input_num = from_str::<uint>("5");
 let input_num: Option<uint> = from_str("5");
 ```
 
-In this case, I happen to prefer the latter, and in the `random()` case, I prefer
-the former. I think the nested `<>`s make the first option especially ugly and
-a bit harder to read.
-
 Anyway, with us now converting our input to a number, our code looks like this:
 
 ```{rust,ignore}

trunk/src/doc/intro.md

@@ -300,7 +300,8 @@ Here's some code:
 use std::sync::Arc;
 
 fn main() {
-    let numbers = Arc::new(vec![1i, 2i, 3i]);
+    let numbers = vec![1i, 2i, 3i];
+    let numbers = Arc::new(numbers);
 
     for num in range(0u, 3) {
         let (tx, rx)  = channel();
@@ -345,7 +346,8 @@ and modify it to mutate the shared state:
 use std::sync::{Arc, Mutex};
 
 fn main() {
-    let numbers_lock = Arc::new(Mutex::new(vec![1i, 2i, 3i]));
+    let numbers = vec![1i, 2i, 3i];
+    let numbers_lock = Arc::new(Mutex::new(numbers));
 
     for num in range(0u, 3) {
         let (tx, rx)  = channel();

trunk/src/doc/rust.md

@@ -3833,9 +3833,8 @@ fn map<A: Clone, B: Clone>(f: |A| -> B, xs: &[A]) -> Vec<B> {
        return vec![];
     }
     let first: B = f(xs[0].clone());
-    let mut rest: Vec<B> = map(f, xs.slice(1, xs.len()));
-    rest.insert(0, first);
-    return rest;
+    let rest: Vec<B> = map(f, xs.slice(1, xs.len()));
+    return vec![first].append(rest.as_slice());
 }
 ~~~~