---

yaml
---
r: 102349
b: refs/heads/master
c: 4cdc6ce
h: refs/heads/master
i:
  102347: 0764910
v: v3

Author: alexcrichton

[refs]

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

trunk/src/libgreen/simple.rs

@@ -11,7 +11,6 @@
 //! 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,7 +18,6 @@
 //! 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,7 +14,6 @@
 //! 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,7 +27,6 @@ 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)];
 
@@ -47,7 +46,6 @@ use middle::lint;
 
 use d = driver::driver;
 
-use std::any::AnyRefExt;
 use std::cmp;
 use std::io;
 use std::os;

trunk/src/librustc/metadata/cstore.rs

@@ -154,15 +154,10 @@ impl CStore {
             .collect()
     }
 
-    pub fn add_used_library(&self, lib: ~str, kind: NativeLibaryKind)
-                            -> bool {
+    pub fn add_used_library(&self, lib: ~str, kind: NativeLibaryKind) {
         assert!(!lib.is_empty());
         let mut used_libraries = self.used_libraries.borrow_mut();
-        if used_libraries.get().iter().any(|&(ref x, _)| x == &lib) {
-            return false;
-        }
         used_libraries.get().push((lib, kind));
-        true
     }
 
     pub fn get_used_libraries<'a>(&'a self)

trunk/src/libserialize/json.rs

@@ -2229,7 +2229,6 @@ 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,10 +20,9 @@
 //! 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, transmute_copy};
+use cast::transmute;
 use fmt;
 use option::{Option, Some, None};
-use raw::TraitObject;
 use result::{Result, Ok, Err};
 use intrinsics::TypeId;
 use intrinsics;
@@ -40,18 +39,34 @@ 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 the methods can be generic.
+// Implemented as three extension traits so that generics work.
 ///////////////////////////////////////////////////////////////////////////////
 
 /// Extension methods for a referenced `Any` trait object
@@ -80,13 +95,7 @@ impl<'a> AnyRefExt<'a> for &'a Any {
     #[inline]
     fn as_ref<T: 'static>(self) -> Option<&'a T> {
         if self.is::<T>() {
-            unsafe {
-                // Get the raw representation of the trait object
-                let to: TraitObject = transmute_copy(&self);
-
-                // Extract the data pointer
-                Some(transmute(to.data))
-            }
+            Some(unsafe { transmute(self.as_void_ptr()) })
         } else {
             None
         }
@@ -104,13 +113,7 @@ impl<'a> AnyMutRefExt<'a> for &'a mut Any {
     #[inline]
     fn as_mut<T: 'static>(self) -> Option<&'a mut T> {
         if self.is::<T>() {
-            unsafe {
-                // Get the raw representation of the trait object
-                let to: TraitObject = transmute_copy(&self);
-
-                // Extract the data pointer
-                Some(transmute(to.data))
-            }
+            Some(unsafe { transmute(self.as_mut_void_ptr()) })
         } else {
             None
         }
@@ -129,14 +132,13 @@ impl AnyOwnExt for ~Any {
     fn move<T: 'static>(self) -> Result<~T, ~Any> {
         if self.is::<T>() {
             unsafe {
-                // Get the raw representation of the trait object
-                let to: TraitObject = transmute_copy(&self);
+                // Extract the pointer to the boxed value, temporary alias with self
+                let ptr: ~T = transmute(self.as_void_ptr());
 
                 // Prevent destructor on self being run
                 intrinsics::forget(self);
 
-                // Extract the data pointer
-                Ok(transmute(to.data))
+                Ok(ptr)
             }
         } else {
             Err(self)
@@ -170,6 +172,100 @@ 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);
@@ -299,21 +395,3 @@ 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,6 +35,7 @@ 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,13 +10,6 @@
 
 #[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
@@ -56,22 +49,13 @@ 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
-    /// enable write-access to the fields of the return value in safe code.
+    /// give write-access to the struct returned.
     #[inline]
     fn repr(&self) -> T { unsafe { cast::transmute_copy(self) } }
 }

trunk/src/libstd/vec.rs

@@ -2311,13 +2311,11 @@ 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>,
-                         marker2: marker::NoPod}
+                         marker: marker::ContravariantLifetime::<'a>}
             } else {
                 MutItems{ptr: p,
                          end: p.offset(self.len() as int),
-                         marker: marker::ContravariantLifetime::<'a>,
-                         marker2: marker::NoPod}
+                         marker: marker::ContravariantLifetime::<'a>}
             }
         }
     }
@@ -2684,23 +2682,15 @@ 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,7 +369,6 @@ 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()
     }