---

yaml
---
r: 194203
b: refs/heads/beta
c: 5fa4b4c
h: refs/heads/master
i:
  194201: ee103ff
  194199: a14fe9b
v: v3

Author: pnkfelix

[refs]

@@ -31,7 +31,7 @@ refs/heads/automation-fail: 1bf06495443584539b958873e04cc2f864ab10e4
 refs/heads/issue-18208-method-dispatch-3-quick-reject: 2009f85b9f99dedcec4404418eda9ddba90258a2
 refs/heads/batch: b7fd822592a4fb577552d93010c4a4e14f314346
 refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
-refs/heads/beta: 91b633aa038008fdbee658a10182afdd794d2aa6
+refs/heads/beta: 5fa4b4c4af14e391d7f16b4968aa25cca7c617c6
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: de8a23bbc3a7b9cbd7574b5b91a34af59bf030e6

branches/beta/src/doc/reference.md

@@ -1265,7 +1265,7 @@ be undesired.
 * Sending signals
 * Accessing/modifying the file system
 * Unsigned integer overflow (well-defined as wrapping)
-* Signed integer overflow (well-defined as two’s complement representation
+* Signed integer overflow (well-defined as two's complement representation
   wrapping)
 
 #### Diverging functions
@@ -2961,10 +2961,10 @@ meaning of the operators on standard types is given here.
   : Exclusive or.
     Calls the `bitxor` method of the `std::ops::BitXor` trait.
 * `<<`
-  : Left shift.
+  : Logical left shift.
     Calls the `shl` method of the `std::ops::Shl` trait.
 * `>>`
-  : Right shift.
+  : Logical right shift.
     Calls the `shr` method of the `std::ops::Shr` trait.
 
 #### Lazy boolean operators

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

@@ -22,7 +22,6 @@
     * [More Strings](more-strings.md)
     * [Patterns](patterns.md)
     * [Method Syntax](method-syntax.md)
-    * [Associated Types](associated-types.md)
     * [Closures](closures.md)
     * [Iterators](iterators.md)
     * [Generics](generics.md)

branches/beta/src/doc/trpl/associated-types.md

@@ -513,8 +513,8 @@ Otherwise, it is an error to elide an output lifetime.
 
 ### Examples
 
-Here are some examples of functions with elided lifetimes.  We've paired each
-example of an elided lifetime with its expanded form.
+Here are some examples of functions with elided lifetimes, and the version of
+what the elided lifetimes are expand to:
 
 ```{rust,ignore}
 fn print(s: &str); // elided

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

@@ -165,16 +165,6 @@ void posix88_consts() {
   put_const(S_IWUSR, int);
   put_const(S_IRUSR, int);
 
-  put_const(S_IRWXG, int);
-  put_const(S_IXGRP, int);
-  put_const(S_IWGRP, int);
-  put_const(S_IRGRP, int);
-
-  put_const(S_IRWXO, int);
-  put_const(S_IXOTH, int);
-  put_const(S_IWOTH, int);
-  put_const(S_IROTH, int);
-
 #ifdef F_OK
   put_const(F_OK, int);
 #endif

branches/beta/src/etc/libc.c

@@ -321,7 +321,7 @@ impl<T: Send + Sync + Clone> Arc<T> {
 
 #[unsafe_destructor]
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Sync + Send> Drop for Arc<T> {
+impl<T> Drop for Arc<T> {
     /// Drops the `Arc<T>`.
     ///
     /// This will decrement the strong reference count. If the strong reference
@@ -388,7 +388,7 @@ impl<T: Sync + Send> Drop for Arc<T> {
 
 #[unstable(feature = "alloc",
            reason = "Weak pointers may not belong in this module.")]
-impl<T: Sync + Send> Weak<T> {
+impl<T> Weak<T> {
     /// Upgrades a weak reference to a strong reference.
     ///
     /// Upgrades the `Weak<T>` reference to an `Arc<T>`, if possible.
@@ -454,7 +454,7 @@ impl<T: Sync + Send> Clone for Weak<T> {
 
 #[unsafe_destructor]
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Sync + Send> Drop for Weak<T> {
+impl<T> Drop for Weak<T> {
     /// Drops the `Weak<T>`.
     ///
     /// This will decrement the weak reference count.

branches/beta/src/liballoc/arc.rs

@@ -429,8 +429,7 @@ impl<T> TypedArenaChunk<T> {
         // Destroy the next chunk.
         let next = self.next;
         let size = calculate_size::<T>(self.capacity);
-        let self_ptr: *mut TypedArenaChunk<T> = self;
-        deallocate(self_ptr as *mut u8, size,
+        deallocate(self as *mut TypedArenaChunk<T> as *mut u8, size,
                    mem::min_align_of::<TypedArenaChunk<T>>());
         if !next.is_null() {
             let capacity = (*next).capacity;

branches/beta/src/libarena/lib.rs

@@ -24,8 +24,6 @@
        html_playground_url = "http://play.rust-lang.org/")]
 #![doc(test(no_crate_inject))]
 
-#![allow(trivial_casts)]
-#![allow(trivial_numeric_casts)]
 #![feature(alloc)]
 #![feature(box_syntax)]
 #![feature(box_patterns)]

branches/beta/src/libcollections/lib.rs

@@ -1199,8 +1199,8 @@ impl<T: PartialEq> Vec<T> {
 
             // Avoid bounds checks by using unsafe pointers.
             let p = self.as_mut_ptr();
-            let mut r: usize = 1;
-            let mut w: usize = 1;
+            let mut r = 1;
+            let mut w = 1;
 
             while r < ln {
                 let p_r = p.offset(r as isize);

branches/beta/src/libcollections/vec.rs

@@ -43,21 +43,15 @@ struct Counter<'a, 'b> {
 }
 
 impl<'a, 'b, 'c> FnMut<(&'c i32,)> for Counter<'a, 'b> {
+    type Output = bool;
+
     extern "rust-call" fn call_mut(&mut self, (&x,): (&'c i32,)) -> bool {
         assert_eq!(x, self.expected[*self.i]);
         *self.i += 1;
         true
     }
 }
 
-impl<'a, 'b, 'c> FnOnce<(&'c i32,)> for Counter<'a, 'b> {
-    type Output = bool;
-
-    extern "rust-call" fn call_once(mut self, args: (&'c i32,)) -> bool {
-        self.call_mut(args)
-    }
-}
-
 fn check<F>(a: &[i32], b: &[i32], expected: &[i32], f: F) where
     // FIXME Replace Counter with `Box<FnMut(_) -> _>`
     F: FnOnce(&BTreeSet<i32>, &BTreeSet<i32>, Counter) -> bool,

branches/beta/src/libcollectionstest/btree/set.rs

@@ -82,11 +82,11 @@ use marker::Sized;
 // Any trait
 ///////////////////////////////////////////////////////////////////////////////
 
-/// A type to emulate dynamic typing. See the [module-level documentation][mod] for more details.
+/// The `Any` trait is implemented by all `'static` types, and can be used for
+/// dynamic typing
 ///
-/// Every type with no non-`'static` references implements `Any`.
-///
-/// [mod]: ../index.html
+/// Every type with no non-`'static` references implements `Any`, so `Any` can
+/// be used as a trait object to emulate the effects dynamic typing.
 #[stable(feature = "rust1", since = "1.0.0")]
 pub trait Any: 'static {
     /// Get the `TypeId` of `self`

branches/beta/src/libcore/any.rs

@@ -713,11 +713,7 @@ impl<T> UnsafeCell<T> {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn get(&self) -> *mut T {
-        // FIXME(#23542) Replace with type ascription.
-        #![allow(trivial_casts)]
-        &self.value as *const T as *mut T
-    }
+    pub fn get(&self) -> *mut T { &self.value as *const T as *mut T }
 
     /// Unwraps the value
     ///