---

yaml
---
r: 215023
b: refs/heads/beta
c: 75fb009
h: refs/heads/master
i:
  215021: 786a463
  215019: ad420cb
  215015: 2957b05
  215007: 0621c2d
v: v3

Author: bors

[refs]

@@ -23,7 +23,7 @@ refs/tags/0.9: 36870b185fc5f5486636d4515f0e22677493f225
 refs/tags/0.10: ac33f2b15782272ae348dbd7b14b8257b2148b5a
 refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
-refs/heads/beta: 39e6855966c97da26e0978bcbf24db418420e018
+refs/heads/beta: 75fb009c7699983ccceed11bd7f56a588ccf5a96
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: 8c0aa6d64ebab528f7eb182812007155d6044972
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f

branches/beta/configure

@@ -1307,6 +1307,12 @@ CFG_LLVM_SRC_DIR=${CFG_SRC_DIR}src/llvm/
 for t in $CFG_HOST
 do
     do_reconfigure=1
+    is_msvc=0
+    case "$t" in
+        (*-msvc)
+        is_msvc=1
+        ;;
+    esac
 
     if [ -z $CFG_LLVM_ROOT ]
     then
@@ -1326,7 +1332,13 @@ do
             LLVM_ASSERTION_OPTS="--disable-assertions"
         else
             LLVM_ASSERTION_OPTS="--enable-assertions"
-            LLVM_INST_DIR=${LLVM_INST_DIR}+Asserts
+
+            # Apparently even if we request assertions be enabled for MSVC,
+            # LLVM's CMake build system ignore this and outputs in `Release`
+            # anyway.
+            if [ ${is_msvc} -eq 0 ]; then
+                LLVM_INST_DIR=${LLVM_INST_DIR}+Asserts
+            fi
         fi
     else
         msg "not reconfiguring LLVM, external LLVM root"
@@ -1356,14 +1368,7 @@ do
         done
     fi
 
-    use_cmake=0
-    case "$t" in
-        (*-msvc)
-        use_cmake=1
-        ;;
-    esac
-
-    if [ ${do_reconfigure} -ne 0 ] && [ ${use_cmake} -ne 0 ]
+    if [ ${do_reconfigure} -ne 0 ] && [ ${is_msvc} -ne 0 ]
     then
         msg "configuring LLVM for $t with cmake"
 
@@ -1388,7 +1393,7 @@ do
         need_ok "LLVM cmake configure failed"
     fi
 
-    if [ ${do_reconfigure} -ne 0 ] && [ ${use_cmake} -eq 0 ]
+    if [ ${do_reconfigure} -ne 0 ] && [ ${is_msvc} -eq 0 ]
     then
         # LLVM's configure doesn't recognize the new Windows triples yet
         gnu_t=$(to_gnu_triple $t)

branches/beta/src/doc/index.md

@@ -25,7 +25,7 @@ series of small examples.
 If you need help with something, or just want to talk about Rust with others,
 there are a few places you can do that:
 
-The Rust IRC channels on [irc.mozilla.org](http://irc.mozilla.org/) are the
+The Rust IRC channels on [irc.mozilla.org](irc://irc.mozilla.org/) are the
 fastest way to get help.
 [`#rust`](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust) is
 the general discussion channel, and you'll find people willing to help you with
@@ -40,15 +40,15 @@ There's also
 [`#rust-internals`](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-internals), which is for discussion of the development of Rust itself.
 
 You can also get help on [Stack
-Overflow](http://stackoverflow.com/questions/tagged/rust). Searching for your
+Overflow](https://stackoverflow.com/questions/tagged/rust). Searching for your
 problem might reveal someone who has asked it before!
 
-There is an active [subreddit](http://reddit.com/r/rust) with lots of
+There is an active [subreddit](https://reddit.com/r/rust) with lots of
 discussion and news about Rust.
 
-There is also a [user forum](http://users.rust-lang.org), for all
-user-oriented discussion, and a [developer
-forum](http://internals.rust-lang.org/), where the development of Rust
+There is also a [user forum](https://users.rust-lang.org), for all
+user-oriented discussion, and a [developer 
+forum](https://internals.rust-lang.org/), where the development of Rust
 itself is discussed.
 
 # Specification
@@ -61,7 +61,7 @@ the language in as much detail as possible is in [the reference](reference.html)
 Rust is still a young language, so there isn't a ton of tooling yet, but the
 tools we have are really nice.
 
-[Cargo](http://crates.io) is Rust's package manager, and its website contains
+[Cargo](https://crates.io) is Rust's package manager, and its website contains
 lots of good documentation.
 
 [`rustdoc`](book/documentation.html) is used to generate documentation for Rust code.

branches/beta/src/doc/trpl/for-loops.md

@@ -41,3 +41,45 @@ 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
 developers.
+
+# Enumerate
+
+When you need to keep track of how many times you already looped, you can use the `.enumerate()` function.
+
+## On ranges:
+
+```rust
+for (i,j) in (5..10).enumerate() {
+    println!("i = {} and j = {}", i, j);
+}
+```
+
+Outputs:
+
+```text
+i = 0 and j = 5
+i = 1 and j = 6
+i = 2 and j = 7
+i = 3 and j = 8
+i = 4 and j = 9
+```
+
+Don't forget to add the parentheses around the range.
+
+## On iterators:
+
+```rust
+# let lines = "hello\nworld".lines();
+for (linenumber, line) in lines.enumerate() {
+    println!("{}: {}", linenumber, line);
+}
+```
+
+Outputs:
+
+```text
+0: Content of line one
+1: Content of line two
+2: Content of line tree
+3: Content of line four
+```

branches/beta/src/doc/trpl/macros.md

@@ -224,7 +224,7 @@ more" match. Both forms optionally include a separator, which can be any token
 except `+` or `*`.
 
 This system is based on
-"[Macro-by-Example](http://www.cs.indiana.edu/ftp/techreports/TR206.pdf)"
+"[Macro-by-Example](https://www.cs.indiana.edu/ftp/techreports/TR206.pdf)"
 (PDF link).
 
 # Hygiene
@@ -319,7 +319,7 @@ syntax context where it was introduced. It’s as though the variable `state`
 inside `main` is painted a different "color" from the variable `state` inside
 the macro, and therefore they don’t conflict.
 
-[hygienic macro system]: http://en.wikipedia.org/wiki/Hygienic_macro
+[hygienic macro system]: https://en.wikipedia.org/wiki/Hygienic_macro
 
 This also restricts the ability of macros to introduce new bindings at the
 invocation site. Code such as the following will not work:
@@ -622,7 +622,7 @@ invocation gives you another opportunity to pattern-match the macro’s
 arguments.
 
 As an extreme example, it is possible, though hardly advisable, to implement
-the [Bitwise Cyclic Tag](http://esolangs.org/wiki/Bitwise_Cyclic_Tag) automaton
+the [Bitwise Cyclic Tag](https://esolangs.org/wiki/Bitwise_Cyclic_Tag) automaton
 within Rust’s macro system.
 
 ```rust

branches/beta/src/doc/trpl/references-and-borrowing.md

@@ -155,7 +155,7 @@ First, any borrow must last for a smaller scope than the owner. Second, you may
 have one or the other of these two kinds of borrows, but not both at the same
 time:
 
-* 0 to N references (`&T`) to a resource.
+* one or more references (`&T`) to a resource.
 * exactly one mutable reference (`&mut T`)
 
 

branches/beta/src/liballoc/arc.rs

@@ -332,6 +332,15 @@ impl<T: ?Sized> Deref for Arc<T> {
     }
 }
 
+#[stable(feature = "rc_arc_as_ref", since = "1.2.0")]
+impl<T: ?Sized> AsRef<T> for Arc<T> {
+
+    #[inline]
+    fn as_ref(&self) -> &T {
+        &self.inner().data
+    }
+}
+
 impl<T: Clone> Arc<T> {
     /// Make a mutable reference from the given `Arc<T>`.
     ///

branches/beta/src/liballoc/rc.rs

@@ -156,6 +156,7 @@ use std::boxed;
 use core::cell::Cell;
 use core::clone::Clone;
 use core::cmp::{PartialEq, PartialOrd, Eq, Ord, Ordering};
+use core::convert::AsRef;
 use core::default::Default;
 use core::fmt;
 use core::hash::{Hasher, Hash};
@@ -379,6 +380,15 @@ impl<T: ?Sized> Deref for Rc<T> {
     }
 }
 
+#[stable(feature = "rc_arc_as_ref", since = "1.2.0")]
+impl<T: ?Sized> AsRef<T> for Rc<T> {
+
+    #[inline(always)]
+    fn as_ref(&self) -> &T {
+        &self.inner().value
+    }
+}
+
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: ?Sized> Drop for Rc<T> {
     /// Drops the `Rc<T>`.

branches/beta/src/libcollections/linked_list.rs

@@ -609,7 +609,13 @@ impl<T> LinkedList<T> {
             length: len - at
         };
 
+        // Swap split_node.next with list_head (which is None), nulling out split_node.next,
+        // as it is the new tail.
         mem::swap(&mut split_node.resolve().unwrap().next, &mut splitted_list.list_head);
+        // Null out list_head.prev. Note this `unwrap` won't fail because if at == len
+        // we already branched out at the top of the fn to return the empty list.
+        splitted_list.list_head.as_mut().unwrap().prev = Rawlink::none();
+        // Fix the tail ptr
         self.list_tail = split_node;
         self.length = at;
 
@@ -1075,6 +1081,26 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_26021() {
+        use std::iter::ExactSizeIterator;
+        // There was a bug in split_off that failed to null out the RHS's head's prev ptr.
+        // This caused the RHS's dtor to walk up into the LHS at drop and delete all of
+        // its nodes.
+        //
+        // https://github.com/rust-lang/rust/issues/26021
+        let mut v1 = LinkedList::new();
+        v1.push_front(1u8);
+        v1.push_front(1u8);
+        v1.push_front(1u8);
+        v1.push_front(1u8);
+        let _ = v1.split_off(3); // Dropping this now should not cause laundry consumption
+        assert_eq!(v1.len(), 3);
+
+        assert_eq!(v1.iter().len(), 3);
+        assert_eq!(v1.iter().collect::<Vec<_>>().len(), 3);
+    }
+
     #[cfg(test)]
     fn fuzz_test(sz: i32) {
         let mut m: LinkedList<_> = LinkedList::new();

branches/beta/src/libcore/cell.rs

@@ -38,7 +38,7 @@
 //!
 //! * Introducing inherited mutability roots to shared types.
 //! * Implementation details of logically-immutable methods.
-//! * Mutating implementations of `clone`.
+//! * Mutating implementations of `Clone`.
 //!
 //! ## Introducing inherited mutability roots to shared types
 //!
@@ -109,7 +109,7 @@
 //! }
 //! ```
 //!
-//! ## Mutating implementations of `clone`
+//! ## Mutating implementations of `Clone`
 //!
 //! This is simply a special - but common - case of the previous: hiding mutability for operations
 //! that appear to be immutable. The `clone` method is expected to not change the source value, and

branches/beta/src/liblibc/lib.rs

@@ -6308,8 +6308,8 @@ pub mod funcs {
                                 lpOverlapped: LPOVERLAPPED) -> BOOL;
                 pub fn WriteFile(hFile: HANDLE,
                                  lpBuffer: LPVOID,
-                                 nNumberOfBytesToRead: DWORD,
-                                 lpNumberOfBytesRead: LPDWORD,
+                                 nNumberOfBytesToWrite: DWORD,
+                                 lpNumberOfBytesWritten: LPDWORD,
                                  lpOverlapped: LPOVERLAPPED) -> BOOL;
                 pub fn SetFilePointerEx(hFile: HANDLE,
                                         liDistanceToMove: LARGE_INTEGER,

branches/beta/src/librustc/metadata/csearch.rs

@@ -13,7 +13,6 @@
 use metadata::common::*;
 use metadata::cstore;
 use metadata::decoder;
-use middle::def;
 use middle::lang_items;
 use middle::ty;
 
@@ -114,12 +113,6 @@ pub fn maybe_get_item_ast<'tcx>(tcx: &ty::ctxt<'tcx>, def: ast::DefId,
     decoder::maybe_get_item_ast(&*cdata, tcx, def.node, decode_inlined_item)
 }
 
-pub fn get_enum_variant_defs(cstore: &cstore::CStore, enum_id: ast::DefId)
-                             -> Vec<(def::Def, ast::Name, ast::Visibility)> {
-    let cdata = cstore.get_crate_data(enum_id.krate);
-    decoder::get_enum_variant_defs(&*cstore.intr, &*cdata, enum_id.node)
-}
-
 pub fn get_enum_variants<'tcx>(tcx: &ty::ctxt<'tcx>, def: ast::DefId)
                                -> Vec<Rc<ty::VariantInfo<'tcx>>> {
     let cstore = &tcx.sess.cstore;

branches/beta/src/librustc/metadata/decoder.rs

@@ -268,30 +268,6 @@ fn item_trait_ref<'tcx>(doc: rbml::Doc, tcx: &ty::ctxt<'tcx>, cdata: Cmd)
     doc_trait_ref(tp, tcx, cdata)
 }
 
-struct EnumVariantIds<'a> {
-    iter: reader::TaggedDocsIterator<'a>,
-    cdata: Cmd<'a>,
-}
-
-impl<'a> Iterator for EnumVariantIds<'a> {
-    type Item = ast::DefId;
-
-    fn next(&mut self) -> Option<ast::DefId> {
-        self.iter.next().map(|p| translated_def_id(self.cdata, p))
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.iter.size_hint()
-    }
-}
-
-fn enum_variant_ids<'a>(item: rbml::Doc<'a>, cdata: Cmd<'a>) -> EnumVariantIds<'a> {
-    EnumVariantIds {
-        iter: reader::tagged_docs(item, tag_items_data_item_variant),
-        cdata: cdata,
-    }
-}
-
 fn item_path(item_doc: rbml::Doc) -> Vec<ast_map::PathElem> {
     let path_doc = reader::get_doc(item_doc, tag_path);
     reader::docs(path_doc).filter_map(|(tag, elt_doc)| {
@@ -730,31 +706,14 @@ pub fn maybe_get_item_ast<'tcx>(cdata: Cmd, tcx: &ty::ctxt<'tcx>, id: ast::NodeI
     }
 }
 
-pub fn get_enum_variant_defs(intr: &IdentInterner,
-                             cdata: Cmd,
-                             id: ast::NodeId)
-                             -> Vec<(def::Def, ast::Name, ast::Visibility)> {
-    let data = cdata.data();
-    let items = reader::get_doc(rbml::Doc::new(data), tag_items);
-    let item = find_item(id, items);
-    enum_variant_ids(item, cdata).map(|did| {
-        let item = find_item(did.node, items);
-        let name = item_name(intr, item);
-        let visibility = item_visibility(item);
-        match item_to_def_like(cdata, item, did) {
-            DlDef(def @ def::DefVariant(..)) => (def, name, visibility),
-            _ => unreachable!()
-        }
-    }).collect()
-}
-
 pub fn get_enum_variants<'tcx>(intr: Rc<IdentInterner>, cdata: Cmd, id: ast::NodeId,
                                tcx: &ty::ctxt<'tcx>) -> Vec<Rc<ty::VariantInfo<'tcx>>> {
     let data = cdata.data();
     let items = reader::get_doc(rbml::Doc::new(data), tag_items);
     let item = find_item(id, items);
     let mut disr_val = 0;
-    enum_variant_ids(item, cdata).map(|did| {
+    reader::tagged_docs(item, tag_items_data_item_variant).map(|p| {
+        let did = translated_def_id(cdata, p);
         let item = find_item(did.node, items);
         let ctor_ty = item_type(ast::DefId { krate: cdata.cnum, node: id},
                                 item, tcx, cdata);

branches/beta/src/librustc/middle/subst.rs

@@ -448,20 +448,6 @@ impl<T> VecPerParamSpace<T> {
                                        self.self_limit)
     }
 
-    pub fn map_move<U, F>(self, mut pred: F) -> VecPerParamSpace<U> where
-        F: FnMut(T) -> U,
-    {
-        let SeparateVecsPerParamSpace {
-            types: t,
-            selfs: s,
-            fns: f
-        } = self.split();
-
-        VecPerParamSpace::new(t.into_iter().map(|p| pred(p)).collect(),
-                              s.into_iter().map(|p| pred(p)).collect(),
-                              f.into_iter().map(|p| pred(p)).collect())
-    }
-
     pub fn split(self) -> SeparateVecsPerParamSpace<T> {
         let VecPerParamSpace { type_limit, self_limit, content } = self;