---

yaml
---
r: 212868
b: refs/heads/master
c: 5f3233f
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 49d8573dd2bc06b172142c58d2c0f1356b497f44
+refs/heads/master: 5f3233f0924ccff5e94cddd7fa9355f4e9ad78f3
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ba0e1cd8147d452c356aacb29fb87568ca26f111
 refs/heads/try: 1864973ae17213c5a58c4dd3f9af6d1b6c7d2e05

trunk/RELEASES.md

@@ -1,3 +1,21 @@
+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/mk/prepare.mk

@@ -29,30 +29,34 @@ DEFAULT_PREPARE_MAN_CMD = install -m644
 
 # Create a directory
 # $(1) is the directory
+#
+# XXX: These defines are called to generate make steps.
+# Adding blank lines means two steps from different defines will not end up on
+# the same line.
 define PREPARE_DIR
-	@$(Q)$(call E, prepare: $(1))
+
+	@$(call E, prepare: $(1))
 	$(Q)$(PREPARE_DIR_CMD) $(1)
+
 endef
 
 # Copy an executable
 # $(1) is the filename/libname-glob
 #
-# Gee, what's up with that $(nop)? See comment below.
+# See above for an explanation on the surrounding blank lines
 define PREPARE_BIN
-	$(nop)
+
 	@$(call E, prepare: $(PREPARE_DEST_BIN_DIR)/$(1))
 	$(Q)$(PREPARE_BIN_CMD) $(PREPARE_SOURCE_BIN_DIR)/$(1) $(PREPARE_DEST_BIN_DIR)/$(1)
+
 endef
 
 # Copy a dylib or rlib
 # $(1) is the filename/libname-glob
 #
-# XXX: Don't remove the $(nop) command below!
-# Yeah, that's right, it's voodoo. Something in the way this macro is being expanded
-# causes it to parse incorrectly. Throwing in that empty command seems to fix the
-# problem. I'm sorry, just don't remove the $(nop), alright?
+# See above for an explanation on the surrounding blank lines
 define PREPARE_LIB
-	$(nop)
+
 	@$(call E, prepare: $(PREPARE_WORKING_DEST_LIB_DIR)/$(1))
 	$(Q)LIB_NAME="$(notdir $(lastword $(wildcard $(PREPARE_WORKING_SOURCE_LIB_DIR)/$(1))))"; \
 	MATCHES="$(filter-out %$(notdir $(lastword $(wildcard $(PREPARE_WORKING_SOURCE_LIB_DIR)/$(1)))), \
@@ -64,13 +68,18 @@ define PREPARE_LIB
 	  echo $$MATCHES ; \
 	fi
 	$(Q)$(PREPARE_LIB_CMD) `ls -drt1 $(PREPARE_WORKING_SOURCE_LIB_DIR)/$(1)` $(PREPARE_WORKING_DEST_LIB_DIR)/
+
 endef
 
 # Copy a man page
 # $(1) - source dir
+#
+# See above for an explanation on the surrounding blank lines
 define PREPARE_MAN
+
 	@$(call E, prepare: $(PREPARE_DEST_MAN_DIR)/$(1))
 	$(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))

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 an `extern "ABI" fn()`. This is the
+Unlike normal functions, extern fns have type `extern "ABI" fn()`. This is the
 same type as the functions declared in an extern block.
 
 ```

trunk/src/doc/trpl/associated-types.md

@@ -43,7 +43,7 @@ trait Graph {
 Now, our clients can be abstract over a given `Graph`:
 
 ```rust,ignore
-fn distance<G: Graph>(graph: &G, start: &G::N, end: &G::N) -> usize { ... }
+fn distance<G: Graph>(graph: &G, start: &G::N, end: &G::N) -> u32 { ... }
 ```
 
 No need to deal with the `E`dge type here!

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/lifetimes.md

@@ -305,7 +305,7 @@ fn substr<'a>(s: &'a str, until: u32) -> &'a str; // expanded
 fn get_str() -> &str; // ILLEGAL, no inputs
 
 fn frob(s: &str, t: &str) -> &str; // ILLEGAL, two inputs
-fn frob<'a, 'b>(s: &'a str, t: &'b str) -> &str; // Expanded: Output lifetime is unclear
+fn frob<'a, 'b>(s: &'a str, t: &'b str) -> &str; // Expanded: Output lifetime is ambiguous
 
 fn get_mut(&mut self) -> &mut T; // elided
 fn get_mut<'a>(&'a mut self) -> &'a mut T; // expanded

trunk/src/doc/trpl/patterns.md

@@ -221,12 +221,27 @@ struct Point {
 let origin = Point { x: 0, y: 0 };
 
 match origin {
-    Point { x: x, y: y } => println!("({},{})", x, y),
+    Point { x, 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
@@ -238,7 +253,7 @@ struct Point {
 let origin = Point { x: 0, y: 0 };
 
 match origin {
-    Point { x: x, .. } => println!("x is {}", x),
+    Point { x, .. } => println!("x is {}", x),
 }
 ```
 
@@ -255,7 +270,7 @@ struct Point {
 let origin = Point { x: 0, y: 0 };
 
 match origin {
-    Point { y: y, .. } => println!("y is {}", y),
+    Point { y, .. } => println!("y is {}", y),
 }
 ```
 

trunk/src/doc/trpl/traits.md

@@ -1,5 +1,8 @@
 % 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,15 +330,6 @@ 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,7 +156,6 @@ 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};
@@ -380,15 +379,6 @@ 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::ty_bare_fn(_, ref f) =>
+            ty::TyBareFn(_, 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 ty_str &
+// Compact string representation for Ty values. API TyStr &
 // 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 ty_str & parse_from_str.
+// Compact string representation for Ty values. API TyStr & 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::ty_bool => mywrite!(w, "b"),
-        ty::ty_char => mywrite!(w, "c"),
-        ty::ty_int(t) => {
+        ty::TyBool => mywrite!(w, "b"),
+        ty::TyChar => mywrite!(w, "c"),
+        ty::TyInt(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::ty_uint(t) => {
+        ty::TyUint(t) => {
             match t {
                 ast::TyUs => mywrite!(w, "us"),
                 ast::TyU8 => mywrite!(w, "Mb"),
@@ -80,79 +80,80 @@ pub fn enc_ty<'a, 'tcx>(w: &mut Encoder, cx: &ctxt<'a, 'tcx>, t: Ty<'tcx>) {
                 ast::TyU64 => mywrite!(w, "Md")
             }
         }
-        ty::ty_float(t) => {
+        ty::TyFloat(t) => {
             match t {
                 ast::TyF32 => mywrite!(w, "Mf"),
                 ast::TyF64 => mywrite!(w, "MF"),
             }
         }
-        ty::ty_enum(def, substs) => {
+        ty::TyEnum(def, substs) => {
             mywrite!(w, "t[{}|", (cx.ds)(def));
             enc_substs(w, cx, substs);
             mywrite!(w, "]");
         }
-        ty::ty_trait(box ty::TyTrait { ref principal,
+        ty::TyTrait(box ty::TraitTy { ref principal,
                                        ref bounds }) => {
             mywrite!(w, "x[");
             enc_trait_ref(w, cx, principal.0);
             enc_existential_bounds(w, cx, bounds);
             mywrite!(w, "]");
         }
-        ty::ty_tup(ref ts) => {
+        ty::TyTuple(ref ts) => {
             mywrite!(w, "T[");
             for t in ts { enc_ty(w, cx, *t); }
             mywrite!(w, "]");
         }
-        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) => {
+        ty::TyBox(typ) => { mywrite!(w, "~"); enc_ty(w, cx, typ); }
+        ty::TyRawPtr(mt) => { mywrite!(w, "*"); enc_mt(w, cx, mt); }
+        ty::TyRef(r, mt) => {
             mywrite!(w, "&");
             enc_region(w, cx, *r);
             enc_mt(w, cx, mt);
         }
-        ty::ty_vec(t, sz) => {
+        ty::TyArray(t, sz) => {
             mywrite!(w, "V");
             enc_ty(w, cx, t);
-            mywrite!(w, "/");
-            match sz {
-                Some(n) => mywrite!(w, "{}|", n),
-                None => mywrite!(w, "|"),
-            }
+            mywrite!(w, "/{}|", sz);
+        }
+        ty::TySlice(t) => {
+            mywrite!(w, "V");
+            enc_ty(w, cx, t);
+            mywrite!(w, "/|");
         }
-        ty::ty_str => {
+        ty::TyStr => {
             mywrite!(w, "v");
         }
-        ty::ty_bare_fn(Some(def_id), f) => {
+        ty::TyBareFn(Some(def_id), f) => {
             mywrite!(w, "F");
             mywrite!(w, "{}|", (cx.ds)(def_id));
             enc_bare_fn_ty(w, cx, f);
         }
-        ty::ty_bare_fn(None, f) => {
+        ty::TyBareFn(None, f) => {
             mywrite!(w, "G");
             enc_bare_fn_ty(w, cx, f);
         }
-        ty::ty_infer(_) => {
+        ty::TyInfer(_) => {
             cx.diag.handler().bug("cannot encode inference variable types");
         }
-        ty::ty_param(ParamTy {space, idx, name}) => {
+        ty::TyParam(ParamTy {space, idx, name}) => {
             mywrite!(w, "p[{}|{}|{}]", idx, space.to_uint(), token::get_name(name))
         }
-        ty::ty_struct(def, substs) => {
+        ty::TyStruct(def, substs) => {
             mywrite!(w, "a[{}|", (cx.ds)(def));
             enc_substs(w, cx, substs);
             mywrite!(w, "]");
         }
-        ty::ty_closure(def, substs) => {
+        ty::TyClosure(def, substs) => {
             mywrite!(w, "k[{}|", (cx.ds)(def));
             enc_substs(w, cx, substs);
             mywrite!(w, "]");
         }
-        ty::ty_projection(ref data) => {
+        ty::TyProjection(ref data) => {
             mywrite!(w, "P[");
             enc_trait_ref(w, cx, data.trait_ref);
             mywrite!(w, "{}]", token::get_name(data.item_name));
         }
-        ty::ty_err => {
+        ty::TyError => {
             mywrite!(w, "e");
         }
     }