---

yaml
---
r: 210375
b: refs/heads/try
c: 8227db8
h: refs/heads/master
i:
  210373: cc0fa6a
  210371: 5643a9f
  210367: b5f6e50
v: v3

Author: tshepang

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 3e561f05c00cd180ec02db4ccab2840a4aba93d2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ba0e1cd8147d452c356aacb29fb87568ca26f111
-refs/heads/try: 42212bb44a3abb76b145238866ad1dc1f9589b8f
+refs/heads/try: 8227db86eb8c9497ba81da35c012f23ece7a1ac0
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try/mk/crates.mk

@@ -58,7 +58,7 @@ RUSTC_CRATES := rustc rustc_typeck rustc_borrowck rustc_resolve rustc_driver \
                 rustc_data_structures
 HOST_CRATES := syntax $(RUSTC_CRATES) rustdoc fmt_macros
 CRATES := $(TARGET_CRATES) $(HOST_CRATES)
-TOOLS := compiletest rustdoc rustc rustbook error-index-generator
+TOOLS := compiletest rustdoc rustc rustbook
 
 DEPS_core :=
 DEPS_libc := core
@@ -107,12 +107,10 @@ TOOL_DEPS_compiletest := test getopts
 TOOL_DEPS_rustdoc := rustdoc
 TOOL_DEPS_rustc := rustc_driver
 TOOL_DEPS_rustbook := std rustdoc
-TOOL_DEPS_error-index-generator := rustdoc syntax serialize
 TOOL_SOURCE_compiletest := $(S)src/compiletest/compiletest.rs
 TOOL_SOURCE_rustdoc := $(S)src/driver/driver.rs
 TOOL_SOURCE_rustc := $(S)src/driver/driver.rs
 TOOL_SOURCE_rustbook := $(S)src/rustbook/main.rs
-TOOL_SOURCE_error-index-generator := $(S)src/error-index-generator/main.rs
 
 ONLY_RLIB_core := 1
 ONLY_RLIB_libc := 1

branches/try/mk/docs.mk

@@ -71,13 +71,9 @@ RUSTBOOK_EXE = $(HBIN2_H_$(CFG_BUILD))/rustbook$(X_$(CFG_BUILD))
 # ./configure
 RUSTBOOK = $(RPATH_VAR2_T_$(CFG_BUILD)_H_$(CFG_BUILD)) $(RUSTBOOK_EXE)
 
-# The error-index-generator executable...
-ERR_IDX_GEN_EXE = $(HBIN2_H_$(CFG_BUILD))/error-index-generator$(X_$(CFG_BUILD))
-ERR_IDX_GEN = $(RPATH_VAR2_T_$(CFG_BUILD)_H_$(CFG_BUILD)) $(ERR_IDX_GEN_EXE)
-
 D := $(S)src/doc
 
-DOC_TARGETS := trpl style error-index
+DOC_TARGETS := trpl style
 COMPILER_DOC_TARGETS :=
 DOC_L10N_TARGETS :=
 
@@ -292,9 +288,3 @@ doc/style/index.html: $(RUSTBOOK_EXE) $(wildcard $(S)/src/doc/style/*.md) | doc/
 	@$(call E, rustbook: $@)
 	$(Q)rm -rf doc/style
 	$(Q)$(RUSTBOOK) build $(S)src/doc/style doc/style
-
-error-index: doc/error-index.html
-
-doc/error-index.html: $(ERR_IDX_GEN_EXE) | doc/
-	$(Q)$(call E, error-index-generator: $@)
-	$(Q)$(ERR_IDX_GEN)

branches/try/mk/prepare.mk

@@ -70,7 +70,7 @@ define PREPARE_MAN
 	$(Q)$(PREPARE_MAN_CMD) $(PREPARE_SOURCE_MAN_DIR)/$(1) $(PREPARE_DEST_MAN_DIR)/$(1)
 endef
 
-PREPARE_TOOLS = $(filter-out compiletest rustbook error-index-generator, $(TOOLS))
+PREPARE_TOOLS = $(filter-out compiletest rustbook, $(TOOLS))
 
 
 # $(1) is tool

branches/try/src/doc/reference.md

@@ -1867,12 +1867,13 @@ macro scope.
   lower to the target's SIMD instructions, if any; the `simd` feature gate
   is necessary to use this attribute.
 - `static_assert` - on statics whose type is `bool`, terminates compilation
-  with an error if it is not initialized to `true`. To use this, the `static_assert`
-  feature gate must be enabled.
+  with an error if it is not initialized to `true`.
+- `unsafe_destructor` - allow implementations of the "drop" language item
+  where the type it is implemented for does not implement the "send" language
+  item; the `unsafe_destructor` feature gate is needed to use this attribute
 - `unsafe_no_drop_flag` - on structs, remove the flag that prevents
   destructors from being run twice. Destructors might be run multiple times on
-  the same object with this attribute. To use this, the `unsafe_no_drop_flag` feature
-  gate must be enabled.
+  the same object with this attribute.
 - `doc` - Doc comments such as `/// foo` are equivalent to `#[doc = "foo"]`.
 - `rustc_on_unimplemented` - Write a custom note to be shown along with the error
    when the trait is found to be unimplemented on a type.

branches/try/src/error-index-generator/main.rs

@@ -8,14 +8,14 @@ lexer grammar RustLexer;
 
 
 tokens {
-    EQ, LT, LE, EQEQ, NE, GE, GT, ANDAND, OROR, NOT, TILDE, PLUS,
+    EQ, LT, LE, EQEQ, NE, GE, GT, ANDAND, OROR, NOT, TILDE, PLUT,
     MINUS, STAR, SLASH, PERCENT, CARET, AND, OR, SHL, SHR, BINOP,
     BINOPEQ, AT, DOT, DOTDOT, DOTDOTDOT, COMMA, SEMI, COLON,
     MOD_SEP, RARROW, FAT_ARROW, LPAREN, RPAREN, LBRACKET, RBRACKET,
-    LBRACE, RBRACE, POUND, DOLLAR, UNDERSCORE, LIT_CHAR, LIT_BYTE,
+    LBRACE, RBRACE, POUND, DOLLAR, UNDERSCORE, LIT_CHAR,
     LIT_INTEGER, LIT_FLOAT, LIT_STR, LIT_STR_RAW, LIT_BINARY,
-    LIT_BINARY_RAW, QUESTION, IDENT, LIFETIME, WHITESPACE, DOC_COMMENT,
-    COMMENT, SHEBANG, UTF8_BOM
+    LIT_BINARY_RAW, IDENT, LIFETIME, WHITESPACE, DOC_COMMENT,
+    COMMENT, SHEBANG
 }
 
 import xidstart , xidcontinue;

branches/try/src/grammar/RustLexer.g4

@@ -111,7 +111,7 @@ fn parse_token_list(file: &str) -> HashMap<String, token::Token> {
             "LIT_BINARY_RAW"    => token::Literal(token::BinaryRaw(Name(0), 0), None),
             "QUESTION"          => token::Question,
             "SHEBANG"           => token::Shebang(Name(0)),
-            _                   => panic!("Bad token str `{}`", val),
+            _                   => continue,
         };
 
         res.insert(num.to_string(), tok);

branches/try/src/grammar/verify.rs

@@ -37,7 +37,7 @@
 //! }
 //! ```
 //!
-//! This will print `Cons(1, Cons(2, Nil))`.
+//! This will print `Cons(1, Box(Cons(2, Box(Nil))))`.
 //!
 //! Recursive structures must be boxed, because if the definition of `Cons` looked like this:
 //!

branches/try/src/liballoc/boxed.rs

@@ -89,7 +89,6 @@ use core::hash;
 use core::iter::RandomAccessIterator;
 use core::iter::{Chain, Enumerate, Repeat, Skip, Take, repeat, Cloned};
 use core::iter::{self, FromIterator};
-use core::mem::swap;
 use core::ops::Index;
 use core::slice;
 use core::{u8, u32, usize};
@@ -603,106 +602,6 @@ impl BitVec {
         Iter { bit_vec: self, next_idx: 0, end_idx: self.nbits }
     }
 
-    /// Moves all bits from `other` into `Self`, leaving `other` empty.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # #![feature(collections, bit_vec_append_split_off)]
-    /// use std::collections::BitVec;
-    ///
-    /// let mut a = BitVec::from_bytes(&[0b10000000]);
-    /// let mut b = BitVec::from_bytes(&[0b01100001]);
-    ///
-    /// a.append(&mut b);
-    ///
-    /// assert_eq!(a.len(), 16);
-    /// assert_eq!(b.len(), 0);
-    /// assert!(a.eq_vec(&[true, false, false, false, false, false, false, false,
-    ///                    false, true, true, false, false, false, false, true]));
-    /// ```
-    #[unstable(feature = "bit_vec_append_split_off",
-               reason = "recently added as part of collections reform 2")]
-    pub fn append(&mut self, other: &mut Self) {
-        let b = self.len() % u32::BITS;
-
-        self.nbits += other.len();
-        other.nbits = 0;
-
-        if b == 0 {
-            self.storage.append(&mut other.storage);
-        } else {
-            self.storage.reserve(other.storage.len());
-
-            for block in other.storage.drain(..) {
-                *(self.storage.last_mut().unwrap()) |= block << b;
-                self.storage.push(block >> (u32::BITS - b));
-            }
-        }
-    }
-
-    /// Splits the `BitVec` into two at the given bit,
-    /// retaining the first half in-place and returning the second one.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # #![feature(collections, bit_vec_append_split_off)]
-    /// use std::collections::BitVec;
-    /// let mut a = BitVec::new();
-    /// a.push(true);
-    /// a.push(false);
-    /// a.push(false);
-    /// a.push(true);
-    ///
-    /// let b = a.split_off(2);
-    ///
-    /// assert_eq!(a.len(), 2);
-    /// assert_eq!(b.len(), 2);
-    /// assert!(a.eq_vec(&[true, false]));
-    /// assert!(b.eq_vec(&[false, true]));
-    /// ```
-    #[unstable(feature = "bit_vec_append_split_off",
-               reason = "recently added as part of collections reform 2")]
-    pub fn split_off(&mut self, at: usize) -> Self {
-        assert!(at <= self.len(), "`at` out of bounds");
-
-        let mut other = BitVec::new();
-
-        if at == 0 {
-            swap(self, &mut other);
-            return other;
-        } else if at == self.len() {
-            return other;
-        }
-
-        let w = at / u32::BITS;
-        let b = at % u32::BITS;
-        other.nbits = self.nbits - at;
-        self.nbits = at;
-        if b == 0 {
-            // Split at block boundary
-            other.storage = self.storage.split_off(w);
-        } else {
-            other.storage.reserve(self.storage.len() - w);
-
-            {
-                let mut iter = self.storage[w..].iter();
-                let mut last = *iter.next().unwrap();
-                for &cur in iter {
-                    other.storage.push((last >> b) | (cur << (u32::BITS - b)));
-                    last = cur;
-                }
-                other.storage.push(last >> b);
-            }
-
-            self.storage.truncate(w+1);
-            self.fix_last_block();
-        }
-
-        other
-    }
-
     /// Returns `true` if all bits are 0.
     ///
     /// # Examples

branches/try/src/libcollections/bit.rs

@@ -996,13 +996,9 @@ impl<T> [T] {
 ////////////////////////////////////////////////////////////////////////////////
 // Extension traits for slices over specific kinds of data
 ////////////////////////////////////////////////////////////////////////////////
-#[unstable(feature = "collections", reason = "recently changed")]
+#[unstable(feature = "collections", reason = "U should be an associated type")]
 /// An extension trait for concatenating slices
-pub trait SliceConcatExt<T: ?Sized> {
-    #[unstable(feature = "collections", reason = "recently changed")]
-    /// The resulting type after concatenation
-    type Output;
-
+pub trait SliceConcatExt<T: ?Sized, U> {
     /// Flattens a slice of `T` into a single value `U`.
     ///
     /// # Examples
@@ -1011,7 +1007,7 @@ pub trait SliceConcatExt<T: ?Sized> {
     /// assert_eq!(["hello", "world"].concat(), "helloworld");
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    fn concat(&self) -> Self::Output;
+    fn concat(&self) -> U;
 
     /// Flattens a slice of `T` into a single value `U`, placing a given separator between each.
     ///
@@ -1021,12 +1017,10 @@ pub trait SliceConcatExt<T: ?Sized> {
     /// assert_eq!(["hello", "world"].connect(" "), "hello world");
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    fn connect(&self, sep: &T) -> Self::Output;
+    fn connect(&self, sep: &T) -> U;
 }
 
-impl<T: Clone, V: AsRef<[T]>> SliceConcatExt<T> for [V] {
-    type Output = Vec<T>;
-
+impl<T: Clone, V: AsRef<[T]>> SliceConcatExt<T, Vec<T>> for [V] {
     fn concat(&self) -> Vec<T> {
         let size = self.iter().fold(0, |acc, v| acc + v.as_ref().len());
         let mut result = Vec::with_capacity(size);