---

yaml
---
r: 277150
b: refs/heads/try
c: 99c0547
h: refs/heads/master

Author: alexcrichton

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 6dbb0e86aec11050480beb76eade6fb805010ba7
 refs/heads/snap-stage3: 235d77457d80b549dad3ac36d94f235208a1eafb
-refs/heads/try: eba80558d7223900549786207fad4791e1f01d88
+refs/heads/try: 99c05478542c6624d537f587ce34f84d09fd0627
 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/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,8 +96,10 @@ 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);
-            ptr::copy(ptr, new_ptr, cmp::min(size, old_size));
-            deallocate(ptr, old_size, align);
+            if !new_ptr.is_null() {
+                ptr::copy(ptr, new_ptr, cmp::min(size, old_size));
+                deallocate(ptr, old_size, align);
+            }
             new_ptr
         }
     }

branches/try/src/librustc/diagnostics.rs

@@ -292,7 +292,7 @@ E0072: r##"
 When defining a recursive struct or enum, any use of the type being defined
 from inside the definition must occur behind a pointer (like `Box` or `&`).
 This is because structs and enums must have a well-defined size, and without
-the pointer, the size of the type would need to be unbounded.
+the pointer the size of the type would need to be unbounded.
 
 Consider the following erroneous definition of a type for a list of bytes:
 

branches/try/src/librustc/middle/lang_items.rs

@@ -189,19 +189,13 @@ impl<'a, 'tcx> LanguageItemCollector<'a, 'tcx> {
         match self.items.items[item_index] {
             Some(original_def_id) if original_def_id != item_def_id => {
                 let cstore = &self.session.cstore;
-                let name = LanguageItems::item_name(item_index);
-                let mut err = match self.ast_map.span_if_local(item_def_id) {
-                    Some(span) => struct_span_err!(
-                        self.session,
-                        span,
-                        E0152,
-                        "duplicate lang item found: `{}`.",
-                        name),
-                    None => self.session.struct_err(&format!(
-                            "duplicate lang item in crate `{}`: `{}`.",
-                            cstore.crate_name(item_def_id.krate),
-                            name)),
-                };
+                let span = self.ast_map.span_if_local(item_def_id)
+                                       .expect("we should have found local duplicate earlier");
+                let mut err = struct_span_err!(self.session,
+                                               span,
+                                               E0152,
+                                               "duplicate lang item found: `{}`.",
+                                               LanguageItems::item_name(item_index));
                 if let Some(span) = self.ast_map.span_if_local(original_def_id) {
                     span_note!(&mut err, span,
                                "first defined here.");

branches/try/src/librustc_trans/callee.rs

@@ -582,19 +582,15 @@ fn get_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
         debug!("get_fn: not casting pointer!");
 
         attributes::from_fn_attrs(ccx, attrs, llfn);
-        if local_item.is_some() {
+        if let Some(id) = local_item {
             // FIXME(eddyb) Doubt all extern fn should allow unwinding.
             attributes::unwind(llfn, true);
+            ccx.item_symbols().borrow_mut().insert(id, sym);
         }
 
         llfn
     };
 
-    // Always insert into item_symbols, in case this item is exported.
-    if let Some(id) = local_item {
-        ccx.item_symbols().borrow_mut().insert(id, sym);
-    }
-
     ccx.instances().borrow_mut().insert(instance, llfn);
 
     immediate_rvalue(llfn, fn_ptr_ty)

branches/try/src/librustdoc/html/render.rs

@@ -2489,7 +2489,7 @@ fn render_impl(w: &mut fmt::Formatter, cx: &Context, i: &Impl, link: AssocItemLi
     }
 
     fn doctraititem(w: &mut fmt::Formatter, cx: &Context, item: &clean::Item,
-                    link: AssocItemLink, render_static: bool, is_default_item: bool,
+                    link: AssocItemLink, render_static: bool,
                     outer_version: Option<&str>) -> fmt::Result {
         let shortty = shortty(item);
         let name = item.name.as_ref().unwrap();
@@ -2540,16 +2540,17 @@ fn render_impl(w: &mut fmt::Formatter, cx: &Context, i: &Impl, link: AssocItemLi
             _ => panic!("can't make docs for trait item with name {:?}", item.name)
         }
 
-        if !is_default_item && (!is_static || render_static) {
-            document(w, cx, item)
-        } else {
-            Ok(())
+        match link {
+            AssocItemLink::Anchor if !is_static || render_static => {
+                document(w, cx, item)
+            },
+            _ => Ok(()),
         }
     }
 
     write!(w, "<div class='impl-items'>")?;
     for trait_item in &i.impl_.items {
-        doctraititem(w, cx, trait_item, link, render_header, false, outer_version)?;
+        doctraititem(w, cx, trait_item, link, render_header, outer_version)?;
     }
 
     fn render_default_items(w: &mut fmt::Formatter,
@@ -2566,7 +2567,7 @@ fn render_impl(w: &mut fmt::Formatter, cx: &Context, i: &Impl, link: AssocItemLi
             let did = i.trait_.as_ref().unwrap().def_id().unwrap();
             let assoc_link = AssocItemLink::GotoSource(did, &i.provided_trait_methods);
 
-            doctraititem(w, cx, trait_item, assoc_link, render_static, true,
+            doctraititem(w, cx, trait_item, assoc_link, render_static,
                          outer_version)?;
         }
         Ok(())

branches/try/src/libsyntax/ext/expand.rs

@@ -504,13 +504,6 @@ pub fn expand_item_mac(it: P<ast::Item>,
 
 /// Expand a stmt
 fn expand_stmt(stmt: Stmt, fld: &mut MacroExpander) -> SmallVector<Stmt> {
-    // perform all pending renames
-    let stmt = {
-        let pending_renames = &mut fld.cx.syntax_env.info().pending_renames;
-        let mut rename_fld = IdentRenamer{renames:pending_renames};
-        rename_fld.fold_stmt(stmt).expect_one("rename_fold didn't return one value")
-    };
-
     let (mac, style, attrs) = match stmt.node {
         StmtKind::Mac(mac, style, attrs) => (mac, style, attrs),
         _ => return expand_non_macro_stmt(stmt, fld)
@@ -724,8 +717,14 @@ pub fn expand_block(blk: P<Block>, fld: &mut MacroExpander) -> P<Block> {
 pub fn expand_block_elts(b: P<Block>, fld: &mut MacroExpander) -> P<Block> {
     b.map(|Block {id, stmts, expr, rules, span}| {
         let new_stmts = stmts.into_iter().flat_map(|x| {
-            // perform pending renames and expand macros in the statement
-            fld.fold_stmt(x).into_iter()
+            // perform all pending renames
+            let renamed_stmt = {
+                let pending_renames = &mut fld.cx.syntax_env.info().pending_renames;
+                let mut rename_fld = IdentRenamer{renames:pending_renames};
+                rename_fld.fold_stmt(x).expect_one("rename_fold didn't return one value")
+            };
+            // expand macros in the statement
+            fld.fold_stmt(renamed_stmt).into_iter()
         }).collect();
         let new_expr = expr.map(|x| {
             let expr = {

branches/try/src/libsyntax/ext/tt/macro_rules.rs

@@ -1014,7 +1014,6 @@ fn is_in_follow(_: &ExtCtxt, tok: &Token, frag: &str) -> Result<bool, String> {
                 match *tok {
                     OpenDelim(token::DelimToken::Brace) | OpenDelim(token::DelimToken::Bracket) |
                     Comma | FatArrow | Colon | Eq | Gt | Semi | BinOp(token::Or) => Ok(true),
-                    MatchNt(_, ref frag, _, _) if frag.name.as_str() == "block" => Ok(true),
                     Ident(i, _) if (i.name.as_str() == "as" ||
                                     i.name.as_str() == "where") => Ok(true),
                     _ => Ok(false)

branches/try/src/libsyntax/feature_gate.rs

@@ -45,8 +45,8 @@ use std::cmp;
 // The version numbers here correspond to the version in which the current status
 // was set. This is most important for knowing when a particular feature became
 // stable (active).
-// NB: The tidy tool parses this information directly out of the source so take
-// care when modifying it.
+// NB: The featureck.py script parses this information directly out of the source
+// so take care when modifying it.
 const KNOWN_FEATURES: &'static [(&'static str, &'static str, Option<u32>, Status)] = &[
     ("globs", "1.0.0", None, Accepted),
     ("macro_rules", "1.0.0", None, Accepted),

branches/try/src/libsyntax/parse/parser.rs

@@ -1532,8 +1532,9 @@ impl<'a> Parser<'a> {
         } else {
             let span = self.last_span;
             self.span_err(span,
-                          "expected mut or const in raw pointer type (use \
-                           `*mut T` or `*const T` as appropriate)");
+                          "bare raw pointers are no longer allowed, you should \
+                           likely use `*mut T`, but otherwise `*T` is now \
+                           known as `*const T`");
             Mutability::Immutable
         };
         let t = self.parse_ty()?;

branches/try/src/test/auxiliary/foreign_lib.rs

@@ -9,7 +9,6 @@
 // except according to those terms.
 
 #![crate_name="foreign_lib"]
-
 #![feature(libc)]
 
 pub mod rustrt {
@@ -20,29 +19,3 @@ pub mod rustrt {
         pub fn rust_get_test_int() -> libc::intptr_t;
     }
 }
-
-pub mod rustrt2 {
-    extern crate libc;
-
-    extern {
-        pub fn rust_get_test_int() -> libc::intptr_t;
-    }
-}
-
-pub mod rustrt3 {
-    // Different type, but same ABI (on all supported platforms).
-    // Ensures that we don't ICE or trigger LLVM asserts when
-    // importing the same symbol under different types.
-    // See https://github.com/rust-lang/rust/issues/32740.
-    extern {
-        pub fn rust_get_test_int() -> *const u8;
-    }
-}
-
-pub fn local_uses() {
-    unsafe {
-        let x = rustrt::rust_get_test_int();
-        assert_eq!(x, rustrt2::rust_get_test_int());
-        assert_eq!(x as *const _, rustrt3::rust_get_test_int());
-    }
-}