---

yaml
---
r: 233515
b: refs/heads/beta
c: 6f6ea46
h: refs/heads/master
i:
  233513: 8849add
  233511: 353603b
v: v3

Author: jdferreira

[refs]

@@ -23,7 +23,7 @@ refs/tags/0.9: 36870b185fc5f5486636d4515f0e22677493f225
 refs/tags/0.10: ac33f2b15782272ae348dbd7b14b8257b2148b5a
 refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
-refs/heads/beta: 6c11e4a48ec3ac385f32da1879384bc6921bdf75
+refs/heads/beta: 6f6ea4687e9d596d7136dc591dee312e51fa0ad7
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: 370fe2786109360f7c35b8ba552b83b773dd71d6
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f

branches/beta/src/doc/trpl/trait-objects.md

@@ -300,41 +300,3 @@ let y = TraitObject {
 // y.method();
 (y.vtable.method)(y.data);
 ```
-
-## Object Safety
-
-Not every trait can be used to make a trait object. For example, vectors implement
-`Clone`, but if we try to make a trait object:
-
-```ignore
-let v = vec![1, 2, 3];
-let o = &v as &Clone;
-```
-
-We get an error:
-
-```text
-error: cannot convert to a trait object because trait `core::clone::Clone` is not object-safe [E0038]
-let o = &v as &Clone;
-        ^~
-note: the trait cannot require that `Self : Sized`
-let o = &v as &Clone;
-        ^~
-```
-
-The error says that `Clone` is not ‘object-safe’. Only traits that are
-object-safe can be made into trait objects. A trait is object-safe if both of
-these are true:
-
-* the trait does not require that `Self: Sized`
-* all of its methods are object-safe
-
-So what makes a method object-safe? Each method must require that `Self: Sized`
-or all of the following:
-
-* must not have any type parameters
-* must not use `Self`
-
-Whew! As we can see, almost all of these rules talk about `Self`. A good intuition
-is “except in special circumstances, if your trait’s method uses `Self`, it is not
-object-safe.”

branches/beta/src/libcollections/binary_heap.rs

@@ -112,7 +112,7 @@
 //!     //                  7
 //!     //          +-----------------+
 //!     //          |                 |
-//!     //          v   1        2    |
+//!     //          v   1        2    |  2
 //!     //          0 -----> 1 -----> 3 ---> 4
 //!     //          |        ^        ^      ^
 //!     //          |        | 1      |      |

branches/beta/src/libcollections/btree/node.rs

@@ -387,29 +387,8 @@ impl<K, V> Node<K, V> {
 
     #[inline]
     pub fn as_slices_internal_mut<'b>(&'b mut self) -> MutNodeSlice<'b, K, V> {
-        let len = self.len();
-        let is_leaf = self.is_leaf();
-        let keys = unsafe { slice::from_raw_parts_mut(*self.keys, len) };
-        let vals = unsafe { slice::from_raw_parts_mut(*self.vals, len) };
-        let edges: &mut [_] = if is_leaf {
-            &mut []
-        } else {
-            unsafe {
-                let data = match self.edges {
-                    None => heap::EMPTY as *mut Node<K,V>,
-                    Some(ref mut p) => **p as *mut Node<K,V>,
-                };
-                slice::from_raw_parts_mut(data, len + 1)
-            }
-        };
-        MutNodeSlice {
-            keys: keys,
-            vals: vals,
-            edges: edges,
-            head_is_edge: true,
-            tail_is_edge: true,
-            has_edges: !is_leaf,
-        }
+        // FIXME(#27620): Bad: This relies on structure layout!
+        unsafe { mem::transmute(self.as_slices_internal()) }
     }
 
     #[inline]

branches/beta/src/libstd/io/mod.rs

@@ -1060,6 +1060,9 @@ pub trait Seek {
     /// A seek beyond the end of a stream is allowed, but implementation
     /// defined.
     ///
+    /// The behavior when seeking past the end of the stream is implementation
+    /// defined.
+    ///
     /// If the seek operation completed successfully,
     /// this method returns the new position from the start of the stream.
     /// That position can be used later with `SeekFrom::Start`.