---

yaml
---
r: 102350
b: refs/heads/master
c: f1955e0
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 4cdc6ce3374f934b6c8cab986d3b0c83119fed6f
+refs/heads/master: f1955e028cd3ea5097845f183f8cd099014ac6d8
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6e7f170fedd3c526a643c0b2d13863acd982be02
 refs/heads/try: a97642026c18a624ff6ea01075dd9550f8ed07ff

trunk/src/libgreen/simple.rs

@@ -11,6 +11,7 @@
 //! A small module implementing a simple "runtime" used for bootstrapping a rust
 //! scheduler pool and then interacting with it.
 
+use std::any::Any;
 use std::cast;
 use std::rt::Runtime;
 use std::rt::local::Local;

trunk/src/libgreen/task.rs

@@ -18,6 +18,7 @@
 //! contains the rust task itself in order to juggle around ownership of the
 //! values.
 
+use std::any::Any;
 use std::cast;
 use std::rt::env;
 use std::rt::Runtime;

trunk/src/libnative/task.rs

@@ -14,6 +14,7 @@
 //! by rust tasks. This implements the necessary API traits laid out by std::rt
 //! in order to spawn new tasks and deschedule the current task.
 
+use std::any::Any;
 use std::cast;
 use std::rt::env;
 use std::rt::local::Local;

trunk/src/librustc/lib.rs

@@ -27,6 +27,7 @@ This API is completely unstable and subject to change.
       html_favicon_url = "http://www.rust-lang.org/favicon.ico",
       html_root_url = "http://static.rust-lang.org/doc/master")];
 
+#[allow(deprecated)];
 #[feature(macro_rules, globs, struct_variant, managed_boxes)];
 #[feature(quote)];
 
@@ -46,6 +47,7 @@ use middle::lint;
 
 use d = driver::driver;
 
+use std::any::AnyRefExt;
 use std::cmp;
 use std::io;
 use std::os;

trunk/src/libserialize/json.rs

@@ -2229,6 +2229,7 @@ mod tests {
         B(~str)
     }
     fn check_err<T: Decodable<Decoder>>(to_parse: &'static str, expected_error: &str) {
+        use std::any::AnyRefExt;
         use std::task;
         let res = task::try(proc() {
             // either fails in `decode` (which is what we want), or

trunk/src/libstd/any.rs

@@ -20,9 +20,10 @@
 //! value. `~Any` adds the `move` method, which will unwrap a `~T` from the object.  See the
 //! extension traits (`*Ext`) for the full details.
 
-use cast::transmute;
+use cast::{transmute, transmute_copy};
 use fmt;
 use option::{Option, Some, None};
+use raw::TraitObject;
 use result::{Result, Ok, Err};
 use intrinsics::TypeId;
 use intrinsics;
@@ -39,34 +40,18 @@ pub enum Void { }
 pub trait Any {
     /// Get the `TypeId` of `self`
     fn get_type_id(&self) -> TypeId;
-
-    /// Get a void pointer to `self`
-    fn as_void_ptr(&self) -> *Void;
-
-    /// Get a mutable void pointer to `self`
-    fn as_mut_void_ptr(&mut self) -> *mut Void;
 }
 
 impl<T: 'static> Any for T {
     /// Get the `TypeId` of `self`
     fn get_type_id(&self) -> TypeId {
         TypeId::of::<T>()
     }
-
-    /// Get a void pointer to `self`
-    fn as_void_ptr(&self) -> *Void {
-        self as *T as *Void
-    }
-
-    /// Get a mutable void pointer to `self`
-    fn as_mut_void_ptr(&mut self) -> *mut Void {
-        self as *mut T as *mut Void
-    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Extension methods for Any trait objects.
-// Implemented as three extension traits so that generics work.
+// Implemented as three extension traits so that the methods can be generic.
 ///////////////////////////////////////////////////////////////////////////////
 
 /// Extension methods for a referenced `Any` trait object
@@ -95,7 +80,13 @@ impl<'a> AnyRefExt<'a> for &'a Any {
     #[inline]
     fn as_ref<T: 'static>(self) -> Option<&'a T> {
         if self.is::<T>() {
-            Some(unsafe { transmute(self.as_void_ptr()) })
+            unsafe {
+                // Get the raw representation of the trait object
+                let to: TraitObject = transmute_copy(&self);
+
+                // Extract the data pointer
+                Some(transmute(to.data))
+            }
         } else {
             None
         }
@@ -113,7 +104,13 @@ impl<'a> AnyMutRefExt<'a> for &'a mut Any {
     #[inline]
     fn as_mut<T: 'static>(self) -> Option<&'a mut T> {
         if self.is::<T>() {
-            Some(unsafe { transmute(self.as_mut_void_ptr()) })
+            unsafe {
+                // Get the raw representation of the trait object
+                let to: TraitObject = transmute_copy(&self);
+
+                // Extract the data pointer
+                Some(transmute(to.data))
+            }
         } else {
             None
         }
@@ -132,13 +129,14 @@ impl AnyOwnExt for ~Any {
     fn move<T: 'static>(self) -> Result<~T, ~Any> {
         if self.is::<T>() {
             unsafe {
-                // Extract the pointer to the boxed value, temporary alias with self
-                let ptr: ~T = transmute(self.as_void_ptr());
+                // Get the raw representation of the trait object
+                let to: TraitObject = transmute_copy(&self);
 
                 // Prevent destructor on self being run
                 intrinsics::forget(self);
 
-                Ok(ptr)
+                // Extract the data pointer
+                Ok(transmute(to.data))
             }
         } else {
             Err(self)
@@ -172,100 +170,6 @@ mod tests {
 
     static TEST: &'static str = "Test";
 
-    #[test]
-    fn any_as_void_ptr() {
-        let (a, b, c) = (~5u as ~Any, ~TEST as ~Any, ~Test as ~Any);
-        let a_r: &Any = a;
-        let b_r: &Any = b;
-        let c_r: &Any = c;
-
-        assert_eq!(a.as_void_ptr(), a_r.as_void_ptr());
-        assert_eq!(b.as_void_ptr(), b_r.as_void_ptr());
-        assert_eq!(c.as_void_ptr(), c_r.as_void_ptr());
-
-        let (a, b, c) = (&5u as &Any, &TEST as &Any, &Test as &Any);
-        let a_r: &Any = a;
-        let b_r: &Any = b;
-        let c_r: &Any = c;
-
-        assert_eq!(a.as_void_ptr(), a_r.as_void_ptr());
-        assert_eq!(b.as_void_ptr(), b_r.as_void_ptr());
-        assert_eq!(c.as_void_ptr(), c_r.as_void_ptr());
-
-        let mut x = Test;
-        let mut y: &'static str = "Test";
-        let (a, b, c) = (&mut 5u as &mut Any,
-                         &mut y as &mut Any,
-                         &mut x as &mut Any);
-        let a_r: &Any = a;
-        let b_r: &Any = b;
-        let c_r: &Any = c;
-
-        assert_eq!(a.as_void_ptr(), a_r.as_void_ptr());
-        assert_eq!(b.as_void_ptr(), b_r.as_void_ptr());
-        assert_eq!(c.as_void_ptr(), c_r.as_void_ptr());
-
-        let (a, b, c) = (5u, "hello", Test);
-        let (a_r, b_r, c_r) = (&a as &Any, &b as &Any, &c as &Any);
-
-        assert_eq!(a.as_void_ptr(), a_r.as_void_ptr());
-        assert_eq!(b.as_void_ptr(), b_r.as_void_ptr());
-        assert_eq!(c.as_void_ptr(), c_r.as_void_ptr());
-    }
-
-    #[test]
-    fn any_as_mut_void_ptr() {
-        let y: &'static str = "Test";
-        let mut a = ~5u as ~Any;
-        let mut b = ~y as ~Any;
-        let mut c = ~Test as ~Any;
-
-        let a_ptr = a.as_mut_void_ptr();
-        let b_ptr = b.as_mut_void_ptr();
-        let c_ptr = c.as_mut_void_ptr();
-
-        let a_r: &mut Any = a;
-        let b_r: &mut Any = b;
-        let c_r: &mut Any = c;
-
-        assert_eq!(a_ptr, a_r.as_mut_void_ptr());
-        assert_eq!(b_ptr, b_r.as_mut_void_ptr());
-        assert_eq!(c_ptr, c_r.as_mut_void_ptr());
-
-        let mut x = Test;
-        let mut y: &'static str = "Test";
-        let a = &mut 5u as &mut Any;
-        let b = &mut y as &mut Any;
-        let c = &mut x as &mut Any;
-
-        let a_ptr = a.as_mut_void_ptr();
-        let b_ptr = b.as_mut_void_ptr();
-        let c_ptr = c.as_mut_void_ptr();
-
-        let a_r: &mut Any = a;
-        let b_r: &mut Any = b;
-        let c_r: &mut Any = c;
-
-        assert_eq!(a_ptr, a_r.as_mut_void_ptr());
-        assert_eq!(b_ptr, b_r.as_mut_void_ptr());
-        assert_eq!(c_ptr, c_r.as_mut_void_ptr());
-
-        let y: &'static str = "Test";
-        let mut a = 5u;
-        let mut b = y;
-        let mut c = Test;
-
-        let a_ptr = a.as_mut_void_ptr();
-        let b_ptr = b.as_mut_void_ptr();
-        let c_ptr = c.as_mut_void_ptr();
-
-        let (a_r, b_r, c_r) = (&mut a as &mut Any, &mut b as &mut Any, &mut c as &mut Any);
-
-        assert_eq!(a_ptr, a_r.as_mut_void_ptr());
-        assert_eq!(b_ptr, b_r.as_mut_void_ptr());
-        assert_eq!(c_ptr, c_r.as_mut_void_ptr());
-    }
-
     #[test]
     fn any_referenced() {
         let (a, b, c) = (&5u as &Any, &TEST as &Any, &Test as &Any);
@@ -395,3 +299,21 @@ mod tests {
         assert_eq!(format!("{}", b), ~"&Any");
     }
 }
+
+#[cfg(test)]
+mod bench {
+    extern crate test;
+
+    use any::{Any, AnyRefExt};
+    use option::Some;
+    use self::test::BenchHarness;
+
+    #[bench]
+    fn bench_as_ref(bh: &mut BenchHarness) {
+        bh.iter(|| {
+            let mut x = 0; let mut y = &mut x as &mut Any;
+            test::black_box(&mut y);
+            test::black_box(y.as_ref::<int>() == Some(&0));
+        });
+    }
+}

trunk/src/libstd/prelude.rs

@@ -35,7 +35,6 @@ pub use mem::drop;
 
 // Reexported types and traits
 
-pub use any::{Any, AnyOwnExt, AnyRefExt, AnyMutRefExt};
 pub use ascii::{Ascii, AsciiCast, OwnedAsciiCast, AsciiStr, IntoBytes};
 pub use c_str::ToCStr;
 pub use char::Char;

trunk/src/libstd/raw.rs

@@ -10,6 +10,13 @@
 
 #[allow(missing_doc)];
 
+//! Contains struct definitions for the layout of compiler built-in types.
+//!
+//! They can be used as targets of transmutes in unsafe code for manipulating
+//! the raw representations directly.
+//!
+//! Their definitition should always match the ABI defined in `rustc::back::abi`.
+
 use cast;
 
 /// The representation of a Rust managed box
@@ -49,13 +56,22 @@ pub struct Procedure {
     env: *(),
 }
 
+/// The representation of a Rust trait object.
+///
+/// This struct does not have a `Repr` implementation
+/// because there is no way to refer to all trait objects generically.
+pub struct TraitObject {
+    vtable: *(),
+    data: *(),
+}
+
 /// This trait is meant to map equivalences between raw structs and their
 /// corresponding rust values.
 pub trait Repr<T> {
     /// This function "unwraps" a rust value (without consuming it) into its raw
     /// struct representation. This can be used to read/write different values
     /// for the struct. This is a safe method because by default it does not
-    /// give write-access to the struct returned.
+    /// enable write-access to the fields of the return value in safe code.
     #[inline]
     fn repr(&self) -> T { unsafe { cast::transmute_copy(self) } }
 }

trunk/src/libstd/vec.rs

@@ -2311,11 +2311,13 @@ impl<'a,T> MutableVector<'a, T> for &'a mut [T] {
             if mem::size_of::<T>() == 0 {
                 MutItems{ptr: p,
                          end: (p as uint + self.len()) as *mut T,
-                         marker: marker::ContravariantLifetime::<'a>}
+                         marker: marker::ContravariantLifetime::<'a>,
+                         marker2: marker::NoPod}
             } else {
                 MutItems{ptr: p,
                          end: p.offset(self.len() as int),
-                         marker: marker::ContravariantLifetime::<'a>}
+                         marker: marker::ContravariantLifetime::<'a>,
+                         marker2: marker::NoPod}
             }
         }
     }
@@ -2682,15 +2684,23 @@ impl<A> Default for ~[A] {
     fn default() -> ~[A] { ~[] }
 }
 
+/// Immutable slice iterator
+pub struct Items<'a, T> {
+    priv ptr: *T,
+    priv end: *T,
+    priv marker: marker::ContravariantLifetime<'a>
+}
+
+/// Mutable slice iterator
+pub struct MutItems<'a, T> {
+    priv ptr: *mut T,
+    priv end: *mut T,
+    priv marker: marker::ContravariantLifetime<'a>,
+    priv marker2: marker::NoPod
+}
+
 macro_rules! iterator {
     (struct $name:ident -> $ptr:ty, $elem:ty) => {
-        /// An iterator for iterating over a vector.
-        pub struct $name<'a, T> {
-            priv ptr: $ptr,
-            priv end: $ptr,
-            priv marker: marker::ContravariantLifetime<'a>,
-        }
-
         impl<'a, T> Iterator<$elem> for $name<'a, T> {
             #[inline]
             fn next(&mut self) -> Option<$elem> {

trunk/src/libstd/vec_ng.rs

@@ -369,6 +369,7 @@ impl<T> Vec<T> {
     }
 
     #[inline]
+    #[deprecated="Use `xs.iter().map(closure)` instead."]
     pub fn map<U>(&self, f: |t: &T| -> U) -> Vec<U> {
         self.iter().map(f).collect()
     }