---

yaml
---
r: 212849
b: refs/heads/master
c: 4500019
h: refs/heads/master
i:
  212847: 78858a4
v: v3

Author: steveklabnik

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: a27982623c12e759c0d8d8e53c5290b76351bdd3
+refs/heads/master: 45000197831c34a317de5c0f6fd81ebb9354fb65
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ba0e1cd8147d452c356aacb29fb87568ca26f111
 refs/heads/try: 1864973ae17213c5a58c4dd3f9af6d1b6c7d2e05

trunk/RELEASES.md

@@ -1,21 +1,3 @@
-Version 1.1.0 (July 2015)
-========================
-
-* NNNN changes, numerous bugfixes
-
-Libraries
----------
-
-* The [`std::fs` module has been expanded][fs-expand] to expand the set of
-  functionality exposed:
-  * `DirEntry` now supports optimizations like `file_type` and `metadata` which
-    don't incur a syscall on some platforms.
-  * A `symlink_metadata` function has been added.
-  * The `fs::Metadata` structure now lowers to its OS counterpart, providing
-    access to all underlying information.
-
-[fs-expand]: https://github.com/rust-lang/rust/pull/25844
-
 Version 1.0.0 (May 2015)
 ========================
 

trunk/src/doc/reference.md

@@ -1111,7 +1111,7 @@ extern fn new_i32() -> i32 { 0 }
 extern "stdcall" fn new_i32_stdcall() -> i32 { 0 }
 ```
 
-Unlike normal functions, extern fns have type `extern "ABI" fn()`. This is the
+Unlike normal functions, extern fns have an `extern "ABI" fn()`. This is the
 same type as the functions declared in an extern block.
 
 ```

trunk/src/doc/trpl/iterators.md

@@ -285,8 +285,7 @@ has no side effect on the original iterator. Let's try it out with our infinite
 iterator from before:
 
 ```rust
-# #![feature(step_by)]
-for i in (1..).step_by(5).take(5) {
+for i in (1..).take(5) {
     println!("{}", i);
 }
 ```
@@ -295,10 +294,10 @@ This will print
 
 ```text
 1
-6
-11
-16
-21
+2
+3
+4
+5
 ```
 
 `filter()` is an adapter that takes a closure as an argument. This closure

trunk/src/doc/trpl/patterns.md

@@ -221,27 +221,12 @@ struct Point {
 let origin = Point { x: 0, y: 0 };
 
 match origin {
-    Point { x, y } => println!("({},{})", x, y),
+    Point { x: x, y: y } => println!("({},{})", x, y),
 }
 ```
 
 [struct]: structs.html
 
-We can use `:` to give a value a different name.
-
-```rust
-struct Point {
-    x: i32,
-    y: i32,
-}
-
-let origin = Point { x: 0, y: 0 };
-
-match origin {
-    Point { x: x1, y: y1 } => println!("({},{})", x1, y1),
-}
-```
-
 If we only care about some of the values, we don’t have to give them all names:
 
 ```rust
@@ -253,7 +238,7 @@ struct Point {
 let origin = Point { x: 0, y: 0 };
 
 match origin {
-    Point { x, .. } => println!("x is {}", x),
+    Point { x: x, .. } => println!("x is {}", x),
 }
 ```
 
@@ -270,7 +255,7 @@ struct Point {
 let origin = Point { x: 0, y: 0 };
 
 match origin {
-    Point { y, .. } => println!("y is {}", y),
+    Point { y: y, .. } => println!("y is {}", y),
 }
 ```
 

trunk/src/doc/trpl/traits.md

@@ -1,8 +1,5 @@
 % Traits
 
-A trait is a language feature that tells the Rust compiler about
-functionality a type must provide.
-
 Do you remember the `impl` keyword, used to call a function with [method
 syntax][methodsyntax]?
 

trunk/src/liballoc/arc.rs

@@ -330,6 +330,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>`.
     ///

trunk/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>`.

trunk/src/librustc/metadata/decoder.rs

@@ -719,7 +719,7 @@ pub fn get_enum_variants<'tcx>(intr: Rc<IdentInterner>, cdata: Cmd, id: ast::Nod
                                 item, tcx, cdata);
         let name = item_name(&*intr, item);
         let (ctor_ty, arg_tys, arg_names) = match ctor_ty.sty {
-            ty::TyBareFn(_, ref f) =>
+            ty::ty_bare_fn(_, ref f) =>
                 (Some(ctor_ty), f.sig.0.inputs.clone(), None),
             _ => { // Nullary or struct enum variant.
                 let mut arg_names = Vec::new();

trunk/src/librustc/metadata/tydecode.rs

@@ -28,7 +28,7 @@ use syntax::abi;
 use syntax::ast;
 use syntax::parse::token;
 
-// Compact string representation for Ty values. API TyStr &
+// Compact string representation for Ty values. API ty_str &
 // parse_from_str. Extra parameters are for converting to/from def_ids in the
 // data buffer. Whatever format you choose should not contain pipe characters.
 

trunk/src/librustc/metadata/tyencode.rs

@@ -41,7 +41,7 @@ pub struct ctxt<'a, 'tcx: 'a> {
     pub abbrevs: &'a abbrev_map<'tcx>
 }
 
-// Compact string representation for Ty values. API TyStr & parse_from_str.
+// Compact string representation for Ty values. API ty_str & parse_from_str.
 // Extra parameters are for converting to/from def_ids in the string rep.
 // Whatever format you choose should not contain pipe characters.
 pub struct ty_abbrev {
@@ -60,9 +60,9 @@ pub fn enc_ty<'a, 'tcx>(w: &mut Encoder, cx: &ctxt<'a, 'tcx>, t: Ty<'tcx>) {
     let pos = w.mark_stable_position();
 
     match t.sty {
-        ty::TyBool => mywrite!(w, "b"),
-        ty::TyChar => mywrite!(w, "c"),
-        ty::TyInt(t) => {
+        ty::ty_bool => mywrite!(w, "b"),
+        ty::ty_char => mywrite!(w, "c"),
+        ty::ty_int(t) => {
             match t {
                 ast::TyIs => mywrite!(w, "is"),
                 ast::TyI8 => mywrite!(w, "MB"),
@@ -71,7 +71,7 @@ pub fn enc_ty<'a, 'tcx>(w: &mut Encoder, cx: &ctxt<'a, 'tcx>, t: Ty<'tcx>) {
                 ast::TyI64 => mywrite!(w, "MD")
             }
         }
-        ty::TyUint(t) => {
+        ty::ty_uint(t) => {
             match t {
                 ast::TyUs => mywrite!(w, "us"),
                 ast::TyU8 => mywrite!(w, "Mb"),
@@ -80,80 +80,79 @@ pub fn enc_ty<'a, 'tcx>(w: &mut Encoder, cx: &ctxt<'a, 'tcx>, t: Ty<'tcx>) {
                 ast::TyU64 => mywrite!(w, "Md")
             }
         }
-        ty::TyFloat(t) => {
+        ty::ty_float(t) => {
             match t {
                 ast::TyF32 => mywrite!(w, "Mf"),
                 ast::TyF64 => mywrite!(w, "MF"),
             }
         }
-        ty::TyEnum(def, substs) => {
+        ty::ty_enum(def, substs) => {
             mywrite!(w, "t[{}|", (cx.ds)(def));
             enc_substs(w, cx, substs);
             mywrite!(w, "]");
         }
-        ty::TyTrait(box ty::TraitTy { ref principal,
+        ty::ty_trait(box ty::TyTrait { ref principal,
                                        ref bounds }) => {
             mywrite!(w, "x[");
             enc_trait_ref(w, cx, principal.0);
             enc_existential_bounds(w, cx, bounds);
             mywrite!(w, "]");
         }
-        ty::TyTuple(ref ts) => {
+        ty::ty_tup(ref ts) => {
             mywrite!(w, "T[");
             for t in ts { enc_ty(w, cx, *t); }
             mywrite!(w, "]");
         }
-        ty::TyBox(typ) => { mywrite!(w, "~"); enc_ty(w, cx, typ); }
-        ty::TyRawPtr(mt) => { mywrite!(w, "*"); enc_mt(w, cx, mt); }
-        ty::TyRef(r, mt) => {
+        ty::ty_uniq(typ) => { mywrite!(w, "~"); enc_ty(w, cx, typ); }
+        ty::ty_ptr(mt) => { mywrite!(w, "*"); enc_mt(w, cx, mt); }
+        ty::ty_rptr(r, mt) => {
             mywrite!(w, "&");
             enc_region(w, cx, *r);
             enc_mt(w, cx, mt);
         }
-        ty::TyArray(t, sz) => {
+        ty::ty_vec(t, sz) => {
             mywrite!(w, "V");
             enc_ty(w, cx, t);
-            mywrite!(w, "/{}|", sz);
-        }
-        ty::TySlice(t) => {
-            mywrite!(w, "V");
-            enc_ty(w, cx, t);
-            mywrite!(w, "/|");
+            mywrite!(w, "/");
+            match sz {
+                Some(n) => mywrite!(w, "{}|", n),
+                None => mywrite!(w, "|"),
+            }
         }
-        ty::TyStr => {
+        ty::ty_str => {
             mywrite!(w, "v");
         }
-        ty::TyBareFn(Some(def_id), f) => {
+        ty::ty_bare_fn(Some(def_id), f) => {
             mywrite!(w, "F");
             mywrite!(w, "{}|", (cx.ds)(def_id));
             enc_bare_fn_ty(w, cx, f);
         }
-        ty::TyBareFn(None, f) => {
+        ty::ty_bare_fn(None, f) => {
             mywrite!(w, "G");
             enc_bare_fn_ty(w, cx, f);
         }
-        ty::TyInfer(_) => {
+        ty::ty_infer(_) => {
             cx.diag.handler().bug("cannot encode inference variable types");
         }
-        ty::TyParam(ParamTy {space, idx, name}) => {
+        ty::ty_param(ParamTy {space, idx, name}) => {
             mywrite!(w, "p[{}|{}|{}]", idx, space.to_uint(), token::get_name(name))
         }
-        ty::TyStruct(def, substs) => {
+        ty::ty_struct(def, substs) => {
             mywrite!(w, "a[{}|", (cx.ds)(def));
             enc_substs(w, cx, substs);
             mywrite!(w, "]");
         }
-        ty::TyClosure(def, substs) => {
+        ty::ty_closure(def, substs) => {
             mywrite!(w, "k[{}|", (cx.ds)(def));
             enc_substs(w, cx, substs);
             mywrite!(w, "]");
         }
-        ty::TyProjection(ref data) => {
+        ty::ty_projection(ref data) => {
             mywrite!(w, "P[");
             enc_trait_ref(w, cx, data.trait_ref);
             mywrite!(w, "{}]", token::get_name(data.item_name));
         }
-        ty::TyError => {
+        ty::ty_err => {
             mywrite!(w, "e");
         }
     }

trunk/src/librustc/middle/cast.rs

@@ -61,16 +61,16 @@ impl<'tcx> CastTy<'tcx> {
     pub fn from_ty(tcx: &ty::ctxt<'tcx>, t: Ty<'tcx>)
                    -> Option<CastTy<'tcx>> {
         match t.sty {
-            ty::TyBool => Some(CastTy::Int(IntTy::Bool)),
-            ty::TyChar => Some(CastTy::Int(IntTy::Char)),
-            ty::TyInt(_) => Some(CastTy::Int(IntTy::I)),
-            ty::TyUint(u) => Some(CastTy::Int(IntTy::U(u))),
-            ty::TyFloat(_) => Some(CastTy::Float),
-            ty::TyEnum(..) if ty::type_is_c_like_enum(
+            ty::ty_bool => Some(CastTy::Int(IntTy::Bool)),
+            ty::ty_char => Some(CastTy::Int(IntTy::Char)),
+            ty::ty_int(_) => Some(CastTy::Int(IntTy::I)),
+            ty::ty_uint(u) => Some(CastTy::Int(IntTy::U(u))),
+            ty::ty_float(_) => Some(CastTy::Float),
+            ty::ty_enum(..) if ty::type_is_c_like_enum(
                 tcx, t) => Some(CastTy::Int(IntTy::CEnum)),
-            ty::TyRawPtr(ref mt) => Some(CastTy::Ptr(mt)),
-            ty::TyRef(_, ref mt) => Some(CastTy::RPtr(mt)),
-            ty::TyBareFn(..) => Some(CastTy::FnPtr),
+            ty::ty_ptr(ref mt) => Some(CastTy::Ptr(mt)),
+            ty::ty_rptr(_, ref mt) => Some(CastTy::RPtr(mt)),
+            ty::ty_bare_fn(..) => Some(CastTy::FnPtr),
             _ => None,
         }
     }