---

yaml
---
r: 277225
b: refs/heads/try
c: 2ef88c9
h: refs/heads/master
i:
  277223: dd61a6a

Author: Sander Maijers

[refs]

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

branches/try/CONTRIBUTING.md

@@ -307,7 +307,7 @@ are:
 [gsearchdocs]: https://www.google.com/search?q=site:doc.rust-lang.org+your+query+here
 [rif]: http://internals.rust-lang.org
 [rr]: https://doc.rust-lang.org/book/README.html
-[tlgba]: http://tomlee.co/2014/04/a-more-detailed-tour-of-the-rust-compiler/
+[tlgba]: http://tomlee.co/2014/04/03/a-more-detailed-tour-of-the-rust-compiler/
 [ro]: http://www.rustaceans.org/
 [rctd]: ./COMPILER_TESTS.md
 [cheatsheet]: http://buildbot.rust-lang.org/homu/

branches/try/RELEASES.md

@@ -140,9 +140,9 @@ Cargo
 Performance
 -----------
 
-* [During type unification, the complexity of comparing variables for
-  equivalance was reduced from `O(n!)` to `O(n)`][1.9tu]. This leads
-  to major compile-time improvements in some scenarios.
+* [The complexity of comparing variables for equivalence during type 
+  unification is reduced from O(n!) to O(n)[1.9tu]. This leads
+  to major compilation time improvement in some scenarios.
 * [`ToString` is specialized for `str`, giving it the same performance
   as `to_owned`][1.9ts].
 * [Spawning processes with `Command::output` no longer creates extra

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/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/casting-between-types.md

@@ -165,15 +165,10 @@ Rust lets us:
 ```rust
 use std::mem;
 
-fn main() {
-    unsafe {
-        let a = [0u8, 1u8, 0u8, 0u8];
-        let b = mem::transmute::<[u8; 4], u32>(a);
-        println!("{}", b); // 256
-        // or, more concisely:
-        let c: u32 = mem::transmute(a);
-        println!("{}", c); // 256
-    }
+unsafe {
+    let a = [0u8, 0u8, 0u8, 0u8];
+
+    let b = mem::transmute::<[u8; 4], u32>(a);
 }
 ```
 

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/doc/book/mutability.md

@@ -24,16 +24,18 @@ changed from one `i32` to another.
 
 [vb]: variable-bindings.html
 
-You can also create a [reference][ref] to it, using `&x`, but if you want to use the reference to change it, you will need a mutable reference:
+If you want to change what the binding points to, you’ll need a [mutable reference][mr]:
 
 ```rust
 let mut x = 5;
 let y = &mut x;
 ```
 
-[ref]: references-and-borrowing.html
+[mr]: references-and-borrowing.html
 
-`y` is an immutable binding to a mutable reference, which means that you can’t bind 'y' to something else (`y = &mut z`), but `y` can be used to bind `x` to something else (`*y = 5`). A subtle distinction.
+`y` is an immutable binding to a mutable reference, which means that you can’t
+bind `y` to something else (`y = &mut z`), but you can mutate the thing that’s
+bound to `y` (`*y = 5`). A subtle distinction.
 
 Of course, if you need both:
 

branches/try/src/doc/book/primitive-types.md

@@ -97,10 +97,9 @@ and `i64` is a signed, 64-bit integer.
 
 ## Variable-size types
 
-Rust also provides types whose particular size depends on the underlying machine
-architecture. Their range is sufficient to express the size of any collection, so
-these types have ‘size’ as the category. They come in signed and unsigned varieties
-which account for two types: `isize` and `usize`.
+Rust also provides types whose size depends on the size of a pointer of the
+underlying machine. These types have ‘size’ as the category, and come in signed
+and unsigned varieties. This makes for two types: `isize` and `usize`.
 
 ## Floating-point types
 

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
         }
     }