---

yaml
---
r: 216495
b: refs/heads/stable
c: 554da45
h: refs/heads/master
i:
  216493: 4ab8d3d
  216491: 7cfca1d
  216487: 82c4f06
  216479: f64bec8
v: v3

Author: frewsxcv

[refs]

@@ -29,5 +29,5 @@ refs/heads/tmp: 378a370ff2057afeb1eae86eb6e78c476866a4a6
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: a5286998df566e736b32f6795bfc3803bdaf453d
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: ac7a75ec976f05eb940b800e072e60c1a52b78a1
+refs/heads/stable: 554da45762ff11def1d7ef85c68d4ed86550aa40
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375

branches/stable/src/doc/reference.md

@@ -1557,7 +1557,8 @@ warnings are generated, or otherwise "you used a private item of another module
 and weren't allowed to."
 
 By default, everything in Rust is *private*, with one exception. Enum variants
-in a `pub` enum are also public by default. When an item is declared as `pub`,
+in a `pub` enum are also public by default. You are allowed to alter this
+default visibility with the `priv` keyword. When an item is declared as `pub`,
 it can be thought of as being accessible to the outside world. For example:
 
 ```
@@ -2425,18 +2426,11 @@ Tuples are written by enclosing zero or more comma-separated expressions in
 parentheses. They are used to create [tuple-typed](#tuple-types) values.
 
 ```{.tuple}
+(0,);
 (0.0, 4.5);
 ("a", 4usize, true);
 ```
 
-You can disambiguate a single-element tuple from a value in parentheses with a
-comma:
-
-```
-(0,); // single-element tuple
-(0); // zero in parentheses
-```
-
 ### Unit expressions
 
 The expression `()` denotes the _unit value_, the only value of the type with

branches/stable/src/doc/trpl/attributes.md

@@ -67,4 +67,4 @@ Rust attributes are used for a number of different things. There is a full list
 of attributes [in the reference][reference]. Currently, you are not allowed to
 create your own attributes, the Rust compiler defines them.
 
-[reference]: ../reference.html#attributes
+[reference]: reference.html#attributes

branches/stable/src/doc/trpl/const-and-static.md

@@ -19,16 +19,18 @@ this reason.
 # `static`
 
 Rust provides a ‘global variable’ sort of facility in static items. They’re
-similar to constants, but static items aren’t inlined upon use. This means that
-there is only one instance for each value, and it’s at a fixed location in
-memory.
+similar to [constants][const], but static items aren’t inlined upon use. This
+means that there is only one instance for each value, and it’s at a fixed
+location in memory.
 
 Here’s an example:
 
 ```rust
 static N: i32 = 5;
 ```
 
+[const]: const.html
+
 Unlike [`let`][let] bindings, you must annotate the type of a `static`.
 
 [let]: variable-bindings.html

branches/stable/src/doc/trpl/iterators.md

@@ -235,15 +235,26 @@ Ranges are one of two basic iterators that you'll see. The other is `iter()`.
 in turn:
 
 ```rust
-let nums = vec![1, 2, 3];
+let nums = [1, 2, 3];
 
 for num in nums.iter() {
    println!("{}", num);
 }
 ```
 
 These two basic iterators should serve you well. There are some more
-advanced iterators, including ones that are infinite.
+advanced iterators, including ones that are infinite. Like using range syntax
+and `step_by`:
+
+```rust
+# #![feature(step_by)]
+(1..).step_by(5);
+```
+
+This iterator counts up from one, adding five each time. It will give
+you a new integer every time, forever (well, technically, until it reaches the
+maximum number representable by an `i32`). But since iterators are lazy,
+that's okay! You probably don't want to use `collect()` on it, though...
 
 That's enough about iterators. Iterator adapters are the last concept
 we need to talk about with regards to iterators. Let's get to it!

branches/stable/src/doc/trpl/nightly-rust.md

@@ -93,7 +93,8 @@ If not, there are a number of places where you can get help. The easiest is
 [the #rust IRC channel on irc.mozilla.org][irc], which you can access through
 [Mibbit][mibbit]. Click that link, and you'll be chatting with other Rustaceans
 (a silly nickname we call ourselves), and we can help you out. Other great
-resources include [the user’s forum][users], and [Stack Overflow][stack overflow].
+resources include [the user’s forum][users], and [Stack Overflow][stack
+overflow].
 
 [irc]: irc://irc.mozilla.org/#rust
 [mibbit]: http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust

branches/stable/src/doc/trpl/primitive-types.md

@@ -248,14 +248,6 @@ or “breaks up” the tuple, and assigns the bits to three bindings.
 
 This pattern is very powerful, and we’ll see it repeated more later.
 
-You can disambiguate a single-element tuple from a value in parentheses with a
-comma:
-
-```
-(0,); // single-element tuple
-(0); // zero in parentheses
-```
-
 ## Tuple Indexing
 
 You can also access fields of a tuple with indexing syntax:

branches/stable/src/doc/trpl/raw-pointers.md

@@ -80,7 +80,7 @@ Raw pointers are useful for FFI: Rust’s `*const T` and `*mut T` are similar to
 C’s `const T*` and `T*`, respectfully. For more about this use, consult the
 [FFI chapter][ffi].
 
-[ffi]: ffi.html
+[ffi]: ffi.md
 
 # References and raw pointers
 

branches/stable/src/doc/trpl/unsafe.md

@@ -101,7 +101,7 @@ Rust has a feature called ‘`static mut`’ which allows for mutable global sta
 Doing so can cause a data race, and as such is inherently not safe. For more
 details, see the [static][static] section of the book.
 
-[static]: const-and-static.html#static
+[static]: static.html
 
 ## Dereference a raw pointer
 

branches/stable/src/doc/trpl/unsized-types.md

@@ -38,11 +38,9 @@ impl Foo for &str {
 ```
 
 Meaning, this implementation would only work for [references][ref], and not
-other types of pointers. With the `impl for str`, all pointers, including (at
-some point, there are some bugs to fix first) user-defined custom smart
-pointers, can use this `impl`.
-
-[ref]: references-and-borrowing.html
+other types of pointers. With this `impl`, all pointers, including (at some
+point, there are some bugs to fix first) user-defined custom smart pointers,
+can use this `impl`.
 
 # ?Sized
 

branches/stable/src/liballoc/boxed.rs

@@ -240,7 +240,6 @@ impl<T: ?Sized + Hash> Hash for Box<T> {
 impl Box<Any> {
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    /// Attempt to downcast the box to a concrete type.
     pub fn downcast<T: Any>(self) -> Result<Box<T>, Box<Any>> {
         if self.is::<T>() {
             unsafe {
@@ -258,15 +257,11 @@ impl Box<Any> {
     }
 }
 
-impl Box<Any + Send> {
+impl Box<Any+Send> {
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    /// Attempt to downcast the box to a concrete type.
-    pub fn downcast<T: Any>(self) -> Result<Box<T>, Box<Any + Send>> {
-        <Box<Any>>::downcast(self).map_err(|s| unsafe {
-            // reapply the Send marker
-            mem::transmute::<Box<Any>, Box<Any + Send>>(s)
-        })
+    pub fn downcast<T: Any>(self) -> Result<Box<T>, Box<Any>> {
+        <Box<Any>>::downcast(self)
     }
 }
 

branches/stable/src/libcollections/fmt.rs

@@ -398,7 +398,7 @@
 //! longer than this width, then it is truncated down to this many characters and only those are
 //! emitted.
 //!
-//! For integral types, this is ignored.
+//! For integral types, this has no meaning currently.
 //!
 //! For floating-point types, this indicates how many digits after the decimal point should be
 //! printed.

branches/stable/src/libcore/any.rs

@@ -97,7 +97,9 @@ pub trait Any: Reflect + 'static {
     fn get_type_id(&self) -> TypeId;
 }
 
-impl<T: Reflect + 'static> Any for T {
+impl<T> Any for T
+    where T: Reflect + 'static
+{
     fn get_type_id(&self) -> TypeId { TypeId::of::<T>() }
 }
 
@@ -220,7 +222,7 @@ impl TypeId {
     /// Returns the `TypeId` of the type this generic function has been
     /// instantiated with
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn of<T: ?Sized + Reflect + 'static>() -> TypeId {
+    pub fn of<T: ?Sized + Any>() -> TypeId {
         TypeId {
             t: unsafe { intrinsics::type_id::<T>() },
         }

branches/stable/src/libcore/marker.rs

@@ -416,8 +416,6 @@ mod impls {
 #[rustc_reflect_like]
 #[unstable(feature = "core", reason = "requires RFC and more experience")]
 #[allow(deprecated)]
-#[rustc_on_unimplemented = "`{Self}` does not implement `Any`; \
-                            ensure all type parameters are bounded by `Any`"]
 pub trait Reflect {}
 
 impl Reflect for .. { }

branches/stable/src/libcore/num/mod.rs

@@ -113,14 +113,12 @@ macro_rules! int_impl {
      $mul_with_overflow:path) => {
         /// Returns the smallest value that can be represented by this integer type.
         #[stable(feature = "rust1", since = "1.0.0")]
-        #[inline]
         pub fn min_value() -> $T {
             (-1 as $T) << ($BITS - 1)
         }
 
         /// Returns the largest value that can be represented by this integer type.
         #[stable(feature = "rust1", since = "1.0.0")]
-        #[inline]
         pub fn max_value() -> $T {
             let min = $T::min_value(); !min
         }

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

@@ -283,7 +283,7 @@ pub fn get_impl_polarity<'tcx>(tcx: &ty::ctxt<'tcx>,
 // if there is one.
 pub fn get_impl_trait<'tcx>(tcx: &ty::ctxt<'tcx>,
                             def: ast::DefId)
-                            -> Option<ty::TraitRef<'tcx>> {
+                            -> Option<Rc<ty::TraitRef<'tcx>>> {
     let cstore = &tcx.sess.cstore;
     let cdata = cstore.get_crate_data(def.krate);
     decoder::get_impl_trait(&*cdata, def.node, tcx)

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

@@ -30,9 +30,7 @@ use middle::subst;
 use middle::ty::{ImplContainer, TraitContainer};
 use middle::ty::{self, Ty};
 use middle::astencode::vtable_decoder_helpers;
-use util::nodemap::FnvHashMap;
 
-use std::cell::{Cell, RefCell};
 use std::collections::HashMap;
 use std::hash::{self, Hash, SipHasher};
 use std::io::prelude::*;
@@ -249,13 +247,13 @@ pub fn item_type<'tcx>(_item_id: ast::DefId, item: rbml::Doc,
 }
 
 fn doc_trait_ref<'tcx>(doc: rbml::Doc, tcx: &ty::ctxt<'tcx>, cdata: Cmd)
-                       -> ty::TraitRef<'tcx> {
+                       -> Rc<ty::TraitRef<'tcx>> {
     parse_trait_ref_data(doc.data, cdata.cnum, doc.start, tcx,
                          |_, did| translate_def_id(cdata, did))
 }
 
 fn item_trait_ref<'tcx>(doc: rbml::Doc, tcx: &ty::ctxt<'tcx>, cdata: Cmd)
-                        -> ty::TraitRef<'tcx> {
+                        -> Rc<ty::TraitRef<'tcx>> {
     let tp = reader::get_doc(doc, tag_item_trait_ref);
     doc_trait_ref(tp, tcx, cdata)
 }
@@ -422,9 +420,6 @@ pub fn get_trait_def<'tcx>(cdata: Cmd,
         generics: generics,
         trait_ref: item_trait_ref(item_doc, tcx, cdata),
         associated_type_names: associated_type_names,
-        nonblanket_impls: RefCell::new(FnvHashMap()),
-        blanket_impls: RefCell::new(vec![]),
-        flags: Cell::new(ty::TraitFlags::NO_TRAIT_FLAGS)
     }
 }
 
@@ -495,7 +490,7 @@ pub fn get_impl_polarity<'tcx>(cdata: Cmd,
 pub fn get_impl_trait<'tcx>(cdata: Cmd,
                             id: ast::NodeId,
                             tcx: &ty::ctxt<'tcx>)
-                            -> Option<ty::TraitRef<'tcx>>
+                            -> Option<Rc<ty::TraitRef<'tcx>>>
 {
     let item_doc = lookup_item(id, cdata.data());
     let fam = item_family(item_doc);

branches/stable/src/librustc/metadata/encoder.rs

@@ -103,7 +103,7 @@ struct entry<T> {
 
 fn encode_trait_ref<'a, 'tcx>(rbml_w: &mut Encoder,
                               ecx: &EncodeContext<'a, 'tcx>,
-                              trait_ref: ty::TraitRef<'tcx>,
+                              trait_ref: &ty::TraitRef<'tcx>,
                               tag: usize) {
     let ty_str_ctxt = &tyencode::ctxt {
         diag: ecx.diag,
@@ -191,7 +191,7 @@ pub fn write_trait_ref<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>,
         tcx: ecx.tcx,
         abbrevs: &ecx.type_abbrevs
     };
-    tyencode::enc_trait_ref(rbml_w, ty_str_ctxt, *trait_ref);
+    tyencode::enc_trait_ref(rbml_w, ty_str_ctxt, trait_ref);
 }
 
 pub fn write_region(ecx: &EncodeContext,
@@ -974,14 +974,16 @@ fn encode_inherent_implementations(ecx: &EncodeContext,
 fn encode_extension_implementations(ecx: &EncodeContext,
                                     rbml_w: &mut Encoder,
                                     trait_def_id: DefId) {
-    assert!(ast_util::is_local(trait_def_id));
-    let def = ty::lookup_trait_def(ecx.tcx, trait_def_id);
-
-    def.for_each_impl(ecx.tcx, |impl_def_id| {
-        rbml_w.start_tag(tag_items_data_item_extension_impl);
-        encode_def_id(rbml_w, impl_def_id);
-        rbml_w.end_tag();
-    });
+    match ecx.tcx.trait_impls.borrow().get(&trait_def_id) {
+        None => {}
+        Some(implementations) => {
+            for &impl_def_id in &*implementations.borrow() {
+                rbml_w.start_tag(tag_items_data_item_extension_impl);
+                encode_def_id(rbml_w, impl_def_id);
+                rbml_w.end_tag();
+            }
+        }
+    }
 }
 
 fn encode_stability(rbml_w: &mut Encoder, stab_opt: Option<attr::Stability>) {
@@ -1199,7 +1201,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
           encode_unsafety(rbml_w, unsafety);
 
           let trait_ref = ty::impl_id_to_trait_ref(tcx, item.id);
-          encode_trait_ref(rbml_w, ecx, trait_ref, tag_item_trait_ref);
+          encode_trait_ref(rbml_w, ecx, &*trait_ref, tag_item_trait_ref);
           rbml_w.end_tag();
       }
       ast::ItemImpl(unsafety, polarity, _, ref opt_trait, ref ty, ref ast_items) => {
@@ -1244,7 +1246,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
         }
         if opt_trait.is_some() {
             let trait_ref = ty::impl_id_to_trait_ref(tcx, item.id);
-            encode_trait_ref(rbml_w, ecx, trait_ref, tag_item_trait_ref);
+            encode_trait_ref(rbml_w, ecx, &*trait_ref, tag_item_trait_ref);
         }
         encode_path(rbml_w, path.clone());
         encode_stability(rbml_w, stab);
@@ -1312,7 +1314,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
                         tag_item_generics);
         encode_predicates(rbml_w, ecx, &ty::lookup_super_predicates(tcx, def_id),
                           tag_item_super_predicates);
-        encode_trait_ref(rbml_w, ecx, trait_def.trait_ref, tag_item_trait_ref);
+        encode_trait_ref(rbml_w, ecx, &*trait_def.trait_ref, tag_item_trait_ref);
         encode_name(rbml_w, item.ident.name);
         encode_attributes(rbml_w, &item.attrs);
         encode_visibility(rbml_w, vis);

branches/stable/src/librustc/metadata/tydecode.rs

@@ -23,6 +23,7 @@ use middle::subst;
 use middle::subst::VecPerParamSpace;
 use middle::ty::{self, AsPredicate, Ty};
 
+use std::rc::Rc;
 use std::str;
 use syntax::abi;
 use syntax::ast;
@@ -181,7 +182,7 @@ pub fn parse_bare_fn_ty_data<'tcx, F>(data: &[u8], crate_num: ast::CrateNum, pos
 
 pub fn parse_trait_ref_data<'tcx, F>(data: &[u8], crate_num: ast::CrateNum, pos: usize,
                                      tcx: &ty::ctxt<'tcx>, conv: F)
-                                     -> ty::TraitRef<'tcx> where
+                                     -> Rc<ty::TraitRef<'tcx>> where
     F: FnMut(DefIdSource, ast::DefId) -> ast::DefId,
 {
     debug!("parse_trait_ref_data {}", data_log_string(data, pos));
@@ -433,19 +434,19 @@ fn parse_str(st: &mut PState, term: char) -> String {
 }
 
 fn parse_trait_ref<'a, 'tcx, F>(st: &mut PState<'a, 'tcx>, mut conv: F)
-                                -> ty::TraitRef<'tcx> where
+                                -> Rc<ty::TraitRef<'tcx>> where
     F: FnMut(DefIdSource, ast::DefId) -> ast::DefId,
 {
     parse_trait_ref_(st, &mut conv)
 }
 
 fn parse_trait_ref_<'a, 'tcx, F>(st: &mut PState<'a, 'tcx>, conv: &mut F)
-                              -> ty::TraitRef<'tcx> where
+                              -> Rc<ty::TraitRef<'tcx>> where
     F: FnMut(DefIdSource, ast::DefId) -> ast::DefId,
 {
     let def = parse_def_(st, NominalType, conv);
     let substs = st.tcx.mk_substs(parse_substs_(st, conv));
-    ty::TraitRef {def_id: def, substs: substs}
+    Rc::new(ty::TraitRef {def_id: def, substs: substs})
 }
 
 fn parse_ty<'a, 'tcx, F>(st: &mut PState<'a, 'tcx>, mut conv: F) -> Ty<'tcx> where