---

yaml
---
r: 277182
b: refs/heads/try
c: 9da67da
h: refs/heads/master

Author: pravic

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 6dbb0e86aec11050480beb76eade6fb805010ba7
 refs/heads/snap-stage3: 235d77457d80b549dad3ac36d94f235208a1eafb
-refs/heads/try: d8d71747fea8ade214cd2da9703d1823b6b314a8
+refs/heads/try: 9da67dae52e18a078d071acbcad592a5f02a8392
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try/src/bootstrap/bootstrap.py

@@ -10,7 +10,6 @@
 
 import argparse
 import contextlib
-import hashlib
 import os
 import shutil
 import subprocess
@@ -19,29 +18,13 @@
 
 def get(url, path, verbose=False):
     print("downloading " + url)
-    sha_url = url + ".sha256"
-    sha_path = path + ".sha256"
-    for _url, _path in ((url, path), (sha_url, sha_path)):
-        # see http://serverfault.com/questions/301128/how-to-download
-        if sys.platform == 'win32':
-            run(["PowerShell.exe", "/nologo", "-Command",
-                 "(New-Object System.Net.WebClient)"
-                 ".DownloadFile('{}', '{}')".format(_url, _path)],
-                verbose=verbose)
-        else:
-            run(["curl", "-o", _path, _url], verbose=verbose)
-    print("verifying " + path)
-    with open(path, "rb") as f:
-        found = hashlib.sha256(f.read()).hexdigest()
-    with open(sha_path, "r") as f:
-        expected, _ = f.readline().split()
-    if found != expected:
-        err = ("invalid checksum:\n"
-               "    found:    {}\n"
-               "    expected: {}".format(found, expected))
-        if verbose:
-            raise RuntimeError(err)
-        sys.exit(err)
+    # see http://serverfault.com/questions/301128/how-to-download
+    if sys.platform == 'win32':
+        run(["PowerShell.exe", "/nologo", "-Command",
+             "(New-Object System.Net.WebClient).DownloadFile('" + url +
+                "', '" + path + "')"], verbose=verbose)
+    else:
+        run(["curl", "-o", path, url], verbose=verbose)
 
 def unpack(tarball, dst, verbose=False, match=None):
     print("extracting " + tarball)
@@ -74,10 +57,9 @@ def run(args, verbose=False):
     ret = subprocess.Popen(args)
     code = ret.wait()
     if code != 0:
-        err = "failed to run: " + ' '.join(args)
-        if verbose:
-            raise RuntimeError(err)
-        sys.exit(err)
+        if not verbose:
+            print("failed to run: " + ' '.join(args))
+        raise RuntimeError("failed to run command")
 
 class RustBuild:
     def download_rust_nightly(self):
@@ -228,10 +210,7 @@ def build_triple(self):
             if sys.platform == 'win32':
                 return 'x86_64-pc-windows-msvc'
             else:
-                err = "uname not found"
-                if self.verbose:
-                    raise Exception(err)
-                sys.exit(err)
+                raise
 
         # Darwin's `uname -s` lies and always returns i386. We have to use
         # sysctl instead.
@@ -274,10 +253,7 @@ def build_triple(self):
                 cputype = 'x86_64'
             ostype = 'pc-windows-gnu'
         else:
-            err = "unknown OS type: " + ostype
-            if self.verbose:
-                raise ValueError(err)
-            sys.exit(err)
+            raise ValueError("unknown OS type: " + ostype)
 
         if cputype in {'i386', 'i486', 'i686', 'i786', 'x86'}:
             cputype = 'i686'
@@ -293,10 +269,7 @@ def build_triple(self):
         elif cputype in {'amd64', 'x86_64', 'x86-64', 'x64'}:
             cputype = 'x86_64'
         else:
-            err = "unknown cpu type: " + cputype
-            if self.verbose:
-                raise ValueError(err)
-            sys.exit(err)
+            raise ValueError("unknown cpu type: " + cputype)
 
         return cputype + '-' + ostype
 

branches/try/src/bootstrap/build/check.rs

@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::fs;
-
 use build::{Build, Compiler};
 
 pub fn linkcheck(build: &Build, stage: u32, host: &str) {
@@ -31,16 +29,9 @@ pub fn cargotest(build: &Build, stage: u32, host: &str) {
     let sep = if cfg!(windows) { ";" } else {":" };
     let ref newpath = format!("{}{}{}", path.display(), sep, old_path);
 
-    // Note that this is a short, cryptic, and not scoped directory name. This
-    // is currently to minimize the length of path on Windows where we otherwise
-    // quickly run into path name limit constraints.
-    let out_dir = build.out.join("ct");
-    t!(fs::create_dir_all(&out_dir));
-
     build.run(build.tool_cmd(compiler, "cargotest")
-                   .env("PATH", newpath)
-                   .arg(&build.cargo)
-                   .arg(&out_dir));
+              .env("PATH", newpath)
+              .arg(&build.cargo));
 }
 
 pub fn tidy(build: &Build, stage: u32, host: &str) {

branches/try/src/bootstrap/build/step.rs

@@ -318,8 +318,7 @@ impl<'a> Step<'a> {
                 vec![self.tool_linkchecker(stage), self.doc(stage)]
             }
             Source::CheckCargoTest { stage } => {
-                vec![self.tool_cargotest(stage),
-                     self.librustc(self.compiler(stage))]
+                vec![self.tool_cargotest(stage)]
             }
             Source::CheckTidy { stage } => {
                 vec![self.tool_tidy(stage)]
@@ -334,7 +333,7 @@ impl<'a> Step<'a> {
                 vec![self.librustc(self.compiler(stage))]
             }
             Source::ToolCargoTest { stage } => {
-                vec![self.libstd(self.compiler(stage))]
+                vec![self.librustc(self.compiler(stage))]
             }
 
             Source::DistDocs { stage } => vec![self.doc(stage)],

branches/try/src/compiletest/runtest.rs

@@ -1911,7 +1911,6 @@ fn run_rustdoc_test(config: &Config, props: &TestProps, testpaths: &TestPaths) {
 }
 
 fn run_codegen_units_test(config: &Config, props: &TestProps, testpaths: &TestPaths) {
-
     assert!(props.revisions.is_empty(), "revisions not relevant here");
 
     let proc_res = compile_test(config, props, testpaths);
@@ -1922,148 +1921,36 @@ fn run_codegen_units_test(config: &Config, props: &TestProps, testpaths: &TestPa
 
     check_no_compiler_crash(None, &proc_res);
 
-    const PREFIX: &'static str = "TRANS_ITEM ";
-    const CGU_MARKER: &'static str = "@@";
+    let prefix = "TRANS_ITEM ";
 
-    let actual: Vec<TransItem> = proc_res
+    let actual: HashSet<String> = proc_res
         .stdout
         .lines()
-        .filter(|line| line.starts_with(PREFIX))
-        .map(str_to_trans_item)
+        .filter(|line| line.starts_with(prefix))
+        .map(|s| (&s[prefix.len()..]).to_string())
         .collect();
 
-    let expected: Vec<TransItem> = errors::load_errors(&testpaths.file, None)
+    let expected: HashSet<String> = errors::load_errors(&testpaths.file, None)
         .iter()
-        .map(|e| str_to_trans_item(&e.msg[..]))
+        .map(|e| e.msg.trim().to_string())
         .collect();
 
-    let mut missing = Vec::new();
-    let mut wrong_cgus = Vec::new();
-
-    for expected_item in &expected {
-        let actual_item_with_same_name = actual.iter()
-                                               .find(|ti| ti.name == expected_item.name);
-
-        if let Some(actual_item) = actual_item_with_same_name {
-            if !expected_item.codegen_units.is_empty() {
-                // Also check for codegen units
-                if expected_item.codegen_units != actual_item.codegen_units {
-                    wrong_cgus.push((expected_item.clone(), actual_item.clone()));
-                }
-            }
-        } else {
-            missing.push(expected_item.string.clone());
-        }
-    }
-
-    let unexpected: Vec<_> =
-        actual.iter()
-              .filter(|acgu| !expected.iter().any(|ecgu| acgu.name == ecgu.name))
-              .map(|acgu| acgu.string.clone())
-              .collect();
-
-    if !missing.is_empty() {
+    if actual != expected {
+        let mut missing: Vec<_> = expected.difference(&actual).collect();
         missing.sort();
 
-        println!("\nThese items should have been contained but were not:\n");
-
-        for item in &missing {
-            println!("{}", item);
-        }
+        let mut too_much: Vec<_> = actual.difference(&expected).collect();
+        too_much.sort();
 
-        println!("\n");
-    }
-
-    if !unexpected.is_empty() {
-        let sorted = {
-            let mut sorted = unexpected.clone();
-            sorted.sort();
-            sorted
-        };
-
-        println!("\nThese items were contained but should not have been:\n");
-
-        for item in sorted {
-            println!("{}", item);
-        }
-
-        println!("\n");
-    }
-
-    if !wrong_cgus.is_empty() {
-        wrong_cgus.sort_by_key(|pair| pair.0.name.clone());
-        println!("\nThe following items were assigned to wrong codegen units:\n");
-
-        for &(ref expected_item, ref actual_item) in &wrong_cgus {
-            println!("{}", expected_item.name);
-            println!("  expected: {}", codegen_units_to_str(&expected_item.codegen_units));
-            println!("  actual:   {}", codegen_units_to_str(&actual_item.codegen_units));
-            println!("");
-        }
-    }
-
-    if !(missing.is_empty() && unexpected.is_empty() && wrong_cgus.is_empty())
-    {
+        println!("Expected and actual sets of codegen-items differ.\n\
+                  These items should have been contained but were not:\n\n\
+                  {}\n\n\
+                  These items were contained but should not have been:\n\n\
+                  {}\n\n",
+            missing.iter().fold("".to_string(), |s1, s2| s1 + "\n" + s2),
+            too_much.iter().fold("".to_string(), |s1, s2| s1 + "\n" + s2));
         panic!();
     }
-
-    #[derive(Clone, Eq, PartialEq)]
-    struct TransItem {
-        name: String,
-        codegen_units: HashSet<String>,
-        string: String,
-    }
-
-    // [TRANS_ITEM] name [@@ (cgu)+]
-    fn str_to_trans_item(s: &str) -> TransItem {
-        let s = if s.starts_with(PREFIX) {
-            (&s[PREFIX.len()..]).trim()
-        } else {
-            s.trim()
-        };
-
-        let full_string = format!("{}{}", PREFIX, s.trim().to_owned());
-
-        let parts: Vec<&str> = s.split(CGU_MARKER)
-                                .map(str::trim)
-                                .filter(|s| !s.is_empty())
-                                .collect();
-
-        let name = parts[0].trim();
-
-        let cgus = if parts.len() > 1 {
-            let cgus_str = parts[1];
-
-            cgus_str.split(" ")
-                    .map(str::trim)
-                    .filter(|s| !s.is_empty())
-                    .map(str::to_owned)
-                    .collect()
-        }
-        else {
-            HashSet::new()
-        };
-
-        TransItem {
-            name: name.to_owned(),
-            codegen_units: cgus,
-            string: full_string,
-        }
-    }
-
-    fn codegen_units_to_str(cgus: &HashSet<String>) -> String
-    {
-        let mut cgus: Vec<_> = cgus.iter().collect();
-        cgus.sort();
-
-        let mut string = String::new();
-        for cgu in cgus {
-            string.push_str(&cgu[..]);
-            string.push_str(" ");
-        }
-
-        string
-    }
 }
 
 fn run_incremental_test(config: &Config, props: &TestProps, testpaths: &TestPaths) {

branches/try/src/doc/book/closures.md

@@ -492,12 +492,12 @@ fn factory() -> Box<Fn(i32) -> i32> {
 
     Box::new(move |x| x + num)
 }
-fn main() {
+# fn main() {
 let f = factory();
 
 let answer = f(1);
 assert_eq!(6, answer);
-}
+# }
 ```
 
 By making the inner closure a `move Fn`, we create a new stack frame for our

branches/try/src/doc/book/getting-started.md

@@ -575,12 +575,8 @@ look something like this:
 name = "hello_world"
 version = "0.1.0"
 authors = ["Your Name <you@example.com>"]
-
-[dependencies]
 ```
 
-Do not worry about the `[dependencies]` line, we will come back to it later.
-
 Cargo has populated *Cargo.toml* with reasonable defaults based on the arguments
 you gave it and your `git` global configuration. You may notice that Cargo has
 also initialized the `hello_world` directory as a `git` repository.

branches/try/src/liballoc_system/lib.rs

@@ -96,10 +96,8 @@ mod imp {
             libc::realloc(ptr as *mut libc::c_void, size as libc::size_t) as *mut u8
         } else {
             let new_ptr = allocate(size, align);
-            if !new_ptr.is_null() {
-                ptr::copy(ptr, new_ptr, cmp::min(size, old_size));
-                deallocate(ptr, old_size, align);
-            }
+            ptr::copy(ptr, new_ptr, cmp::min(size, old_size));
+            deallocate(ptr, old_size, align);
             new_ptr
         }
     }