---

yaml
---
r: 134619
b: refs/heads/try
c: f85e4f7
h: refs/heads/master
i:
  134617: 4447302
  134615: 2514fa1
v: v3

Author: Keegan McAllister

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 58413c09cd52ea4005d6ea7733ba1fb3a8f36589
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 437179ed8bf7f7672f84b19265df1ce569e70490
-refs/heads/try: aef6c4b1382dcf2f943bd5872656625f935c0b7c
+refs/heads/try: f85e4f75b9b60e2ce4b2ade8f04e2537e48f7095
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/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
@@ -453,8 +453,6 @@ valopt datadir "${CFG_PREFIX}/share" "install data"
 valopt infodir "${CFG_PREFIX}/share/info" "install additional info"
 valopt mandir "${CFG_PREFIX}/share/man" "install man pages in PATH"
 
-valopt release-channel "source" "the name of the release channel to build"
-
 # On windows we just store the libraries in the bin directory because
 # there's no rpath. This is where the build system itself puts libraries;
 # --libdir is used to configure the installation directory.
@@ -477,22 +475,11 @@ fi
 step_msg "validating $CFG_SELF args"
 validate_opt
 
-# Validate the release channel
-case "$CFG_RELEASE_CHANNEL" in
-    (source | nightly | beta | stable)
-	;;
-    (*)
-        err "release channel must be 'source', 'nightly', 'beta' or 'stable'"
-        ;;
-esac
-
-# Continue supporting the old --enable-nightly flag to transition the bots
+# Temporarily support the old windows triples while the bots make the transition
 # XXX Remove me
-if [ $CFG_ENABLE_NIGHTLY -eq 1 ]
-then
-    CFG_RELEASE_CHANNEL=nightly
-    putvar CFG_RELEASE_CHANNEL
-fi
+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'`
 
 step_msg "looking for build programs"
 
@@ -649,7 +636,7 @@ then
             # check that gcc, cc and g++ all point to the same compiler.
             # note that for xcode 5, g++ points to clang, not clang++
             if !((chk_cc gcc clang  && chk_cc g++ clang) ||
-                (chk_cc gcc gcc  &&( chk_cc g++ g++ || chk g++ gcc))); then
+                (chk_cc gcc gcc  &&( chk_cc g++ g++ || chk g++ gcc))) then
                 err "the gcc and g++ in your path point to different compilers.
     Check which versions are in your path with gcc --version and g++ --version.
     To resolve this problem, either fix your PATH  or run configure with --enable-clang"

branches/try/man/rustc.1

@@ -1,4 +1,4 @@
-.TH RUSTC "1" "March 2014" "rustc 0.12.0" "User Commands"
+.TH RUSTC "1" "March 2014" "rustc 0.12.0-pre" "User Commands"
 .SH NAME
 rustc \- The Rust compiler
 .SH SYNOPSIS

branches/try/man/rustdoc.1

@@ -1,4 +1,4 @@
-.TH RUSTDOC "1" "March 2014" "rustdoc 0.12.0" "User Commands"
+.TH RUSTDOC "1" "March 2014" "rustdoc 0.12.0-pre" "User Commands"
 .SH NAME
 rustdoc \- generate documentation from Rust source code
 .SH SYNOPSIS

branches/try/mk/main.mk

@@ -14,32 +14,22 @@
 
 # The version number
 CFG_RELEASE_NUM=0.12.0
+CFG_RELEASE_LABEL=-pre
 
 CFG_FILENAME_EXTRA=4e7c5e5c
 
-ifeq ($(CFG_RELEASE_CHANNEL),stable)
-# This is the normal semver version string, e.g. "0.12.0", "0.12.0-nightly"
-CFG_RELEASE=$(CFG_RELEASE_NUM)
-# This is the string used in dist artifact file names, e.g. "0.12.0", "nightly"
-CFG_PACKAGE_VERS=$(CFG_RELEASE_NUM)
-endif
-ifeq ($(CFG_RELEASE_CHANNEL),beta)
-CFG_RELEASE=$(CFG_RELEASE_NUM)-beta
-# When building beta/nightly distributables just reuse the same "beta"
-# name so when we upload we'll always override the previous
-# nighly. This doesn't actually impact the version reported by rustc -
-# it's just for file naming.
-CFG_PACKAGE_VERS=beta
-endif
-ifeq ($(CFG_RELEASE_CHANNEL),nightly)
-CFG_RELEASE=$(CFG_RELEASE_NUM)-nightly
+ifndef CFG_ENABLE_NIGHTLY
+# This is the normal version string
+CFG_RELEASE=$(CFG_RELEASE_NUM)$(CFG_RELEASE_LABEL)
+CFG_PACKAGE_VERS=$(CFG_RELEASE)
+else
+# Modify the version label for nightly builds
+CFG_RELEASE=$(CFG_RELEASE_NUM)$(CFG_RELEASE_LABEL)-nightly
+# When building nightly distributables just reuse the same "rust-nightly" name
+# so when we upload we'll always override the previous nighly. This doesn't actually
+# impact the version reported by rustc - it's just for file naming.
 CFG_PACKAGE_VERS=nightly
 endif
-ifeq ($(CFG_RELEASE_CHANNEL),source)
-CFG_RELEASE=$(CFG_RELEASE_NUM)-pre
-CFG_PACKAGE_VERS=$(CFG_RELEASE_NUM)-pre
-endif
-
 # The name of the package to use for creating tarballs, installers etc.
 CFG_PACKAGE_NAME=rust-$(CFG_PACKAGE_VERS)
 

branches/try/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

branches/try/src/compiletest/header.rs

@@ -42,6 +42,8 @@ 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
@@ -59,6 +61,7 @@ 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),
@@ -116,6 +119,11 @@ pub fn load_props(testfile: &Path) -> TestProps {
             None => ()
         };
 
+        match parse_forbid_output(ln) {
+            Some(of) => forbid_output.push(of),
+            None => (),
+        }
+
         true
     });
 
@@ -132,7 +140,8 @@ 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
+        pretty_compare_only: pretty_compare_only,
+        forbid_output: forbid_output,
     }
 }
 
@@ -210,6 +219,10 @@ 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")
 }

branches/try/src/compiletest/runtest.rs

@@ -71,6 +71,14 @@ 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);
 
@@ -81,16 +89,22 @@ 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, &proc_res);
+        check_error_patterns(props, testfile, output_to_check.as_slice(), &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) {
@@ -112,8 +126,9 @@ 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, &proc_res);
+    check_error_patterns(props, testfile, output_to_check.as_slice(), &proc_res);
 }
 
 fn check_correct_failure_status(proc_res: &ProcRes) {
@@ -834,24 +849,15 @@ 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);
@@ -890,6 +896,16 @@ 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) {

branches/try/src/doc/guide-tasks.md

@@ -235,7 +235,7 @@ fn partial_sum(start: uint) -> f64 {
 }
 
 fn main() {
-    let mut futures = Vec::from_fn(200, |ind| Future::spawn( proc() { partial_sum(ind) }));
+    let mut futures = Vec::from_fn(1000, |ind| Future::spawn( proc() { partial_sum(ind) }));
 
     let mut final_res = 0f64;
     for ft in futures.iter_mut()  {

branches/try/src/doc/guide.md

@@ -29,11 +29,8 @@ $ curl -s https://static.rust-lang.org/rustup.sh | sudo sh
 (If you're concerned about `curl | sudo sh`, please keep reading. Disclaimer
 below.)
 
-If you're on Windows, please download either the [32-bit
-installer](https://static.rust-lang.org/dist/rust-nightly-i686-w64-mingw32.exe)
-or the [64-bit
-installer](https://static.rust-lang.org/dist/rust-nightly-x86_64-w64-mingw32.exe)
-and run it.
+If you're on Windows, please [download this .exe and run
+it](https://static.rust-lang.org/dist/rust-nightly-install.exe).
 
 If you decide you don't want Rust anymore, we'll be a bit sad, but that's okay.
 Not every programming language is great for everyone. Just pass an argument to
@@ -188,8 +185,8 @@ Next up is this line:
 This line does all of the work in our little program. There are a number of
 details that are important here. The first is that it's indented with four
 spaces, not tabs. Please configure your editor of choice to insert four spaces
-with the tab key. We provide some [sample configurations for various
-editors](https://github.com/rust-lang/rust/tree/master/src/etc).
+with the tab key. We provide some sample configurations for various editors
+[here](https://github.com/rust-lang/rust/tree/master/src/etc).
 
 The second point is the `println!()` part. This is calling a Rust **macro**,
 which is how metaprogramming is done in Rust. If it were a function instead, it
@@ -395,10 +392,14 @@ By the way, in these examples, `i` indicates that the number is an integer.
 
 Rust is a statically typed language, which means that we specify our types up
 front. So why does our first example compile? Well, Rust has this thing called
-"type inference." If it can figure out what the type of something is, Rust
+"[Hindley-Milner type
+inference](http://en.wikipedia.org/wiki/Hindley%E2%80%93Milner_type_system)",
+named after some really smart type theorists. If you clicked that link, don't
+be scared: what this means for you is that Rust will attempt to infer the types
+in your program, and it's pretty good at it. If it can infer the type, Rust
 doesn't require you to actually type it out.
 
-We can add the type if we want to, though. Types come after a colon (`:`):
+We can add the type if we want to. Types come after a colon (`:`):
 
 ```{rust}
 let x: int = 5;
@@ -1280,15 +1281,15 @@ two main looping constructs: `for` and `while`.
 
 The `for` loop is used to loop a particular number of times. Rust's `for` loops
 work a bit differently than in other systems languages, however. Rust's `for`
-loop doesn't look like this "C style" `for` loop:
+loop doesn't look like this C `for` loop:
 
-```{c}
+```{ignore,c}
 for (x = 0; x < 10; x++) {
     printf( "%d\n", x );
 }
 ```
 
-Instead, it looks like this:
+It looks like this:
 
 ```{rust}
 for x in range(0i, 10i) {
@@ -1311,9 +1312,10 @@ valid for the loop body. Once the body is over, the next value is fetched from
 the iterator, and we loop another time. When there are no more values, the
 `for` loop is over.
 
-In our example, `range` is a function that takes a start and an end position,
-and gives an iterator over those values. The upper bound is exclusive, though,
-so our loop will print `0` through `9`, not `10`.
+In our example, the `range` function is a function, provided by Rust, that
+takes a start and an end position, and gives an iterator over those values. The
+upper bound is exclusive, though, so our loop will print `0` through `9`, not
+`10`.
 
 Rust does not have the "C style" `for` loop on purpose. Manually controlling
 each element of the loop is complicated and error prone, even for experienced C
@@ -1575,6 +1577,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!");
 

branches/try/src/doc/index.md

@@ -86,10 +86,10 @@ There are questions that are asked quite often, and so we've made FAQs for them:
 
 # The standard library
 
-We have [API documentation for the entire standard
-library](std/index.html). There's a list of crates on the left with more
-specific sections, or you can use the search bar at the top to search for
-something if you know its name.
+You can find function-level documentation for the entire standard library
+[here](std/index.html). There's a list of crates on the left with more specific
+sections, or you can use the search bar at the top to search for something if
+you know its name.
 
 # External documentation
 

branches/try/src/doc/rust.md

@@ -2557,8 +2557,6 @@ The currently implemented features of the reference compiler are:
 
 * `tuple_indexing` - Allows use of tuple indexing (expressions like `expr.0`)
 
-* `associated_types` - Allows type aliases in traits. Experimental.
-
 If a feature is promoted to a language feature, then all existing programs will
 start to receive compilation warnings about #[feature] directives which enabled
 the new feature (because the directive is no longer necessary). However, if

branches/try/src/etc/kate/rust.xml

@@ -7,7 +7,7 @@
 	<!ENTITY rustIdent "[a-zA-Z_][a-zA-Z_0-9]*">
 	<!ENTITY rustIntSuf "([iu](8|16|32|64)?)?">
 ]>
-<language name="Rust" version="0.12.0" kateversion="2.4" section="Sources" extensions="*.rs" mimetype="text/x-rust" priority="15">
+<language name="Rust" version="0.12.0-pre" kateversion="2.4" section="Sources" extensions="*.rs" mimetype="text/x-rust" priority="15">
 <highlighting>
 	<list name="fn">
 		<item> fn </item>