Auto merge of #21730 - Manishearth:rollup, r=alexcrichton

Should clear our backlog of rollups from the queue

Author: bors

AUTHORS.txt

@@ -516,7 +516,7 @@ Olivier Saut <[email protected]>
 Olle Jonsson <[email protected]>
 Or Brostovski <[email protected]>
 Oren Hazi <[email protected]>
-Orphée Lafond-Lummis <o@orftz.com>
+Orpheus Lummis <o@orpheuslummis.com>
 P1start <[email protected]>
 Pablo Brasero <[email protected]>
 Palmer Cox <[email protected]>

CONTRIBUTING.md

@@ -50,11 +50,11 @@ example, if it's 2014, and you change a Rust file that was created in
 # Coordination and communication
 
 Get feedback from other developers on
-[discuss.rust-lang.org][discuss], and
+[internals.rust-lang.org][internals], and
 [#rust-internals][pound-rust-internals].
 
 [pound-rust-internals]: http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-internals
-[discuss]: http://discuss.rust-lang.org
+[internals]: http://internals.rust-lang.org
 
 For more details, please refer to
 [Note-development-policy](https://github.com/rust-lang/rust/wiki/Note-development-policy).

README.md

@@ -30,9 +30,9 @@ documentation.
 
     To build from the [tarball] do:
 
-        $ curl -O https://static.rust-lang.org/dist/rust-nightly.tar.gz
-        $ tar -xzf rust-nightly.tar.gz
-        $ cd rust-nightly
+        $ curl -O https://static.rust-lang.org/dist/rustc-nightly-src.tar.gz
+        $ tar -xzf rustc-nightly-src.tar.gz
+        $ cd rustc-nightly
 
     Or to build from the [repo] do:
 
@@ -80,7 +80,7 @@ $ pacman -S base-devel
         $ make && make install
 
 [repo]: https://github.com/rust-lang/rust
-[tarball]: https://static.rust-lang.org/dist/rust-nightly.tar.gz
+[tarball]: https://static.rust-lang.org/dist/rustc-nightly-src.tar.gz
 [trpl]: http://doc.rust-lang.org/book/index.html
 
 ## Notes
@@ -112,11 +112,11 @@ The Rust community congregates in a few places:
 
 * [StackOverflow] - Get help here.
 * [/r/rust] - General discussion.
-* [discuss.rust-lang.org] - For development of the Rust language itself.
+* [internals.rust-lang.org] - For development of the Rust language itself.
 
 [StackOverflow]: http://stackoverflow.com/questions/tagged/rust
 [/r/rust]: http://reddit.com/r/rust
-[discuss.rust-lang.org]: http://discuss.rust-lang.org/
+[internals.rust-lang.org]: http://internals.rust-lang.org/
 
 ## License
 

src/doc/index.md

@@ -41,7 +41,7 @@ problem might reveal someone who has asked it before!
 There is an active [subreddit](http://reddit.com/r/rust) with lots of
 discussion about Rust.
 
-There is also a [developer forum](http://discuss.rust-lang.org/), where the
+There is also a [developer forum](http://internals.rust-lang.org/), where the
 development of Rust itself is discussed.
 
 # Specification

src/etc/local_stage0.sh

@@ -21,19 +21,16 @@ case $OS in
     ("Linux"|"FreeBSD"|"DragonFly")
     BIN_SUF=
     LIB_SUF=.so
-    break
     ;;
     ("Darwin")
     BIN_SUF=
     LIB_SUF=.dylib
-    break
     ;;
     (*)
     BIN_SUF=.exe
     LIB_SUF=.dll
     LIB_DIR=bin
     LIB_PREFIX=
-    break
     ;;
 esac
 

src/liballoc/heap.rs

@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#[cfg(not(test))]
 use core::ptr::PtrExt;
 
 // FIXME: #13996: mark the `allocate` and `reallocate` return value as `noalias`

src/libcore/cell.rs

@@ -594,12 +594,6 @@ impl<'b, T> DerefMut for RefMut<'b, T> {
 /// The `UnsafeCell<T>` type is the only legal way to obtain aliasable data that is considered
 /// mutable. In general, transmuting an `&T` type into an `&mut T` is considered undefined behavior.
 ///
-/// Although it is possible to put an `UnsafeCell<T>` into static item, it is not permitted to take
-/// the address of the static item if the item is not declared as mutable. This rule exists because
-/// immutable static items are stored in read-only memory, and thus any attempt to mutate their
-/// interior can cause segfaults. Immutable static items containing `UnsafeCell<T>` instances are
-/// still useful as read-only initializers, however, so we do not forbid them altogether.
-///
 /// Types like `Cell<T>` and `RefCell<T>` use this type to wrap their internal data.
 ///
 /// `UnsafeCell<T>` doesn't opt-out from any marker traits, instead, types with an `UnsafeCell<T>`

src/libfmt_macros/lib.rs

@@ -447,7 +447,7 @@ mod tests {
     use super::*;
 
     fn same(fmt: &'static str, p: &[Piece<'static>]) {
-        let mut parser = Parser::new(fmt);
+        let parser = Parser::new(fmt);
         assert!(p == parser.collect::<Vec<Piece<'static>>>());
     }
 

src/liblibc/lib.rs

@@ -273,6 +273,7 @@ pub use funcs::bsd43::{shutdown};
 #[cfg(windows)] pub use funcs::extra::kernel32::{GetOverlappedResult, ConnectNamedPipe};
 #[cfg(windows)] pub use funcs::extra::kernel32::{DisconnectNamedPipe, OpenProcess};
 #[cfg(windows)] pub use funcs::extra::kernel32::{MoveFileExW, VirtualProtect};
+#[cfg(windows)] pub use funcs::extra::kernel32::{RemoveDirectoryW};
 #[cfg(windows)] pub use funcs::extra::msvcrt::{get_osfhandle, open_osfhandle};
 #[cfg(windows)] pub use funcs::extra::winsock::{ioctlsocket};
 

src/librustc/metadata/csearch.rs

@@ -10,10 +10,6 @@
 
 // Searching for information from the cstore
 
-#![allow(non_camel_case_types)]
-
-pub use self::found_ast::*;
-
 use metadata::common::*;
 use metadata::cstore;
 use metadata::decoder;
@@ -101,18 +97,18 @@ pub fn get_item_path(tcx: &ty::ctxt, def: ast::DefId) -> Vec<ast_map::PathElem>
     r
 }
 
-pub enum found_ast<'ast> {
-    found(&'ast ast::InlinedItem),
-    found_parent(ast::DefId, &'ast ast::InlinedItem),
-    not_found,
+pub enum FoundAst<'ast> {
+    Found(&'ast ast::InlinedItem),
+    FoundParent(ast::DefId, &'ast ast::InlinedItem),
+    NotFound,
 }
 
 // Finds the AST for this item in the crate metadata, if any.  If the item was
 // not marked for inlining, then the AST will not be present and hence none
 // will be returned.
 pub fn maybe_get_item_ast<'tcx>(tcx: &ty::ctxt<'tcx>, def: ast::DefId,
                                 decode_inlined_item: decoder::DecodeInlinedItem)
-                                -> found_ast<'tcx> {
+                                -> FoundAst<'tcx> {
     let cstore = &tcx.sess.cstore;
     let cdata = cstore.get_crate_data(def.krate);
     decoder::maybe_get_item_ast(&*cdata, tcx, def.node, decode_inlined_item)

src/librustc/metadata/decoder.rs

@@ -693,23 +693,23 @@ pub type DecodeInlinedItem<'a> =
 
 pub fn maybe_get_item_ast<'tcx>(cdata: Cmd, tcx: &ty::ctxt<'tcx>, id: ast::NodeId,
                                 mut decode_inlined_item: DecodeInlinedItem)
-                                -> csearch::found_ast<'tcx> {
+                                -> csearch::FoundAst<'tcx> {
     debug!("Looking up item: {}", id);
     let item_doc = lookup_item(id, cdata.data());
     let path = item_path(item_doc).init().to_vec();
     match decode_inlined_item(cdata, tcx, path, item_doc) {
-        Ok(ii) => csearch::found(ii),
+        Ok(ii) => csearch::FoundAst::Found(ii),
         Err(path) => {
             match item_parent_item(item_doc) {
                 Some(did) => {
                     let did = translate_def_id(cdata, did);
                     let parent_item = lookup_item(did.node, cdata.data());
                     match decode_inlined_item(cdata, tcx, path, parent_item) {
-                        Ok(ii) => csearch::found_parent(did, ii),
-                        Err(_) => csearch::not_found
+                        Ok(ii) => csearch::FoundAst::FoundParent(did, ii),
+                        Err(_) => csearch::FoundAst::NotFound
                     }
                 }
-                None => csearch::not_found
+                None => csearch::FoundAst::NotFound
             }
         }
     }

src/librustc/metadata/encoder.rs

@@ -1577,7 +1577,7 @@ fn encode_info_for_items(ecx: &EncodeContext,
                         &krate.module,
                         &[],
                         ast::CRATE_NODE_ID,
-                        ast_map::Values([].iter()).chain(None),
+                        [].iter().cloned().chain(None),
                         syntax::parse::token::special_idents::invalid,
                         ast::Public);
 
@@ -1949,7 +1949,7 @@ fn encode_misc_info(ecx: &EncodeContext,
     }
 
     // Encode reexports for the root module.
-    encode_reexports(ecx, rbml_w, 0, ast_map::Values([].iter()).chain(None));
+    encode_reexports(ecx, rbml_w, 0, [].iter().cloned().chain(None));
 
     rbml_w.end_tag();
     rbml_w.end_tag();

src/librustc/middle/astencode.rs

@@ -130,7 +130,7 @@ pub fn decode_inlined_item<'tcx>(cdata: &cstore::crate_metadata,
         debug!("> Decoding inlined fn: {:?}::?",
         {
             // Do an Option dance to use the path after it is moved below.
-            let s = ast_map::path_to_string(ast_map::Values(path.iter()));
+            let s = ast_map::path_to_string(path.iter().cloned());
             path_as_str = Some(s);
             path_as_str.as_ref().map(|x| &x[])
         });

src/librustc/middle/const_eval.rs

@@ -133,7 +133,7 @@ fn lookup_variant_by_id<'a>(tcx: &'a ty::ctxt,
         }
         let expr_id = match csearch::maybe_get_item_ast(tcx, enum_def,
             box |a, b, c, d| astencode::decode_inlined_item(a, b, c, d)) {
-            csearch::found(&ast::IIItem(ref item)) => match item.node {
+            csearch::FoundAst::Found(&ast::IIItem(ref item)) => match item.node {
                 ast::ItemEnum(ast::EnumDef { ref variants }, _) => {
                     // NOTE this doesn't do the right thing, it compares inlined
                     // NodeId's to the original variant_def's NodeId, but they
@@ -173,7 +173,7 @@ pub fn lookup_const_by_id<'a>(tcx: &'a ty::ctxt, def_id: ast::DefId)
         }
         let expr_id = match csearch::maybe_get_item_ast(tcx, def_id,
             box |a, b, c, d| astencode::decode_inlined_item(a, b, c, d)) {
-            csearch::found(&ast::IIItem(ref item)) => match item.node {
+            csearch::FoundAst::Found(&ast::IIItem(ref item)) => match item.node {
                 ast::ItemConst(_, ref const_expr) => Some(const_expr.id),
                 _ => None
             },

src/librustc/middle/ty.rs

@@ -5264,7 +5264,7 @@ pub fn with_path<T, F>(cx: &ctxt, id: ast::DefId, f: F) -> T where
     if id.krate == ast::LOCAL_CRATE {
         cx.map.with_path(id.node, f)
     } else {
-        f(ast_map::Values(csearch::get_item_path(cx, id).iter()).chain(None))
+        f(csearch::get_item_path(cx, id).iter().cloned().chain(None))
     }
 }
 

src/librustc_back/rpath.rs

@@ -151,7 +151,6 @@ fn minimize_rpaths(rpaths: &[String]) -> Vec<String> {
 mod test {
     use super::{RPathConfig};
     use super::{minimize_rpaths, rpaths_to_flags, get_rpath_relative_to_output};
-    use syntax::abi;
 
     #[test]
     fn test_rpaths_to_flags() {

src/librustc_trans/back/link.rs

@@ -37,7 +37,6 @@ use flate;
 use serialize::hex::ToHex;
 use syntax::ast;
 use syntax::ast_map::{PathElem, PathElems, PathName};
-use syntax::ast_map;
 use syntax::attr::AttrMetaMethods;
 use syntax::codemap::Span;
 use syntax::parse::token;
@@ -339,7 +338,7 @@ pub fn mangle_internal_name_by_type_and_seq<'a, 'tcx>(ccx: &CrateContext<'a, 'tc
     let path = [PathName(token::intern(&s[])),
                 gensym_name(name)];
     let hash = get_symbol_hash(ccx, t);
-    mangle(ast_map::Values(path.iter()), Some(&hash[]))
+    mangle(path.iter().cloned(), Some(&hash[]))
 }
 
 pub fn mangle_internal_name_by_path_and_seq(path: PathElems, flav: &str) -> String {

src/librustc_trans/back/write.rs

@@ -1012,6 +1012,9 @@ unsafe fn configure_llvm(sess: &Session) {
         if sess.time_llvm_passes() { add("-time-passes"); }
         if sess.print_llvm_passes() { add("-debug-pass=Structure"); }
 
+        // FIXME #21627 disable faulty FastISel on AArch64 (even for -O0)
+        if sess.target.target.arch.as_slice() == "aarch64" { add("-fast-isel=0"); }
+
         for arg in sess.opts.cg.llvm_args.iter() {
             add(&(*arg)[]);
         }

src/librustc_trans/trans/inline.rs

@@ -43,11 +43,11 @@ fn instantiate_inline(ccx: &CrateContext, fn_id: ast::DefId)
             box |a,b,c,d| astencode::decode_inlined_item(a, b, c, d));
 
     let inline_def = match csearch_result {
-        csearch::not_found => {
+        csearch::FoundAst::NotFound => {
             ccx.external().borrow_mut().insert(fn_id, None);
             return None;
         }
-        csearch::found(&ast::IIItem(ref item)) => {
+        csearch::FoundAst::Found(&ast::IIItem(ref item)) => {
             ccx.external().borrow_mut().insert(fn_id, Some(item.id));
             ccx.external_srcs().borrow_mut().insert(item.id, fn_id);
 
@@ -90,12 +90,12 @@ fn instantiate_inline(ccx: &CrateContext, fn_id: ast::DefId)
 
             local_def(item.id)
         }
-        csearch::found(&ast::IIForeign(ref item)) => {
+        csearch::FoundAst::Found(&ast::IIForeign(ref item)) => {
             ccx.external().borrow_mut().insert(fn_id, Some(item.id));
             ccx.external_srcs().borrow_mut().insert(item.id, fn_id);
             local_def(item.id)
         }
-        csearch::found_parent(parent_id, &ast::IIItem(ref item)) => {
+        csearch::FoundAst::FoundParent(parent_id, &ast::IIItem(ref item)) => {
             ccx.external().borrow_mut().insert(parent_id, Some(item.id));
             ccx.external_srcs().borrow_mut().insert(item.id, parent_id);
 
@@ -124,11 +124,11 @@ fn instantiate_inline(ccx: &CrateContext, fn_id: ast::DefId)
           trans_item(ccx, &**item);
           local_def(my_id)
         }
-        csearch::found_parent(_, _) => {
-            ccx.sess().bug("maybe_get_item_ast returned a found_parent \
+        csearch::FoundAst::FoundParent(_, _) => {
+            ccx.sess().bug("maybe_get_item_ast returned a FoundParent \
              with a non-item parent");
         }
-        csearch::found(&ast::IITraitItem(_, ref trait_item)) => {
+        csearch::FoundAst::Found(&ast::IITraitItem(_, ref trait_item)) => {
             match *trait_item {
                 ast::RequiredMethod(_) => ccx.sess().bug("found RequiredMethod IITraitItem"),
                 ast::ProvidedMethod(ref mth) => {
@@ -147,7 +147,7 @@ fn instantiate_inline(ccx: &CrateContext, fn_id: ast::DefId)
                 }
             }
         }
-        csearch::found(&ast::IIImplItem(impl_did, ref impl_item)) => {
+        csearch::FoundAst::Found(&ast::IIImplItem(impl_did, ref impl_item)) => {
             match *impl_item {
                 ast::MethodImplItem(ref mth) => {
                     ccx.external().borrow_mut().insert(fn_id, Some(mth.id));