auto merge of #14069 : alexcrichton/rust/cast-module, r=brson

This commit revisits the `cast` module in libcore and libstd, and scrutinizes
all functions inside of it. The result was to remove the `cast` module entirely,
folding all functionality into the `mem` module. Specifically, this is the fate
of each function in the `cast` module.

* transmute - This function was moved to `mem`, but it is now marked as
              #[unstable]. This is due to planned changes to the `transmute`
              function and how it can be invoked (see the #[unstable] comment).
              For more information, see RFC 5 and #12898

* transmute_copy - This function was moved to `mem`, with clarification that is
                   is not an error to invoke it with T/U that are different
                   sizes, but rather that it is strongly discouraged. This
                   function is now #[stable]

* forget - This function was moved to `mem` and marked #[stable]

* bump_box_refcount - This function was removed due to the deprecation of
                      managed boxes as well as its questionable utility.

* transmute_mut - This function was previously deprecated, and removed as part
                  of this commit.

* transmute_mut_unsafe - This function doesn't serve much of a purpose when it
                         can be achieved with an `as` in safe code, so it was
                         removed.

* transmute_lifetime - This function was removed because it is likely a strong
                       indication that code is incorrect in the first place.

* transmute_mut_lifetime - This function was removed for the same reasons as
                           `transmute_lifetime`

* copy_lifetime - This function was moved to `mem`, but it is marked
                  `#[unstable]` now due to the likelihood of being removed in
                  the future if it is found to not be very useful.

* copy_mut_lifetime - This function was also moved to `mem`, but had the same
                      treatment as `copy_lifetime`.

* copy_lifetime_vec - This function was removed because it is not used today,
                      and its existence is not necessary with DST
                      (copy_lifetime will suffice).

In summary, the cast module was stripped down to these functions, and then the
functions were moved to the `mem` module.

    transmute - #[unstable]
    transmute_copy - #[stable]
    forget - #[stable]
    copy_lifetime - #[unstable]
    copy_mut_lifetime - #[unstable]

5 files changed, 14 insertions, 14 deletions

diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index 0f3b96c2132..84525718bd9 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -29,9 +29,9 @@ use visit;
 use visit::Visitor;
 use util::small_vector::SmallVector;
 
-use std::cast;
-use std::unstable::dynamic_lib::DynamicLibrary;
+use std::mem;
 use std::os;
+use std::unstable::dynamic_lib::DynamicLibrary;
 
 pub fn expand_expr(e: @ast::Expr, fld: &mut MacroExpander) -> @ast::Expr {
     match e.node {
@@ -544,7 +544,7 @@ fn load_extern_macros(krate: &ast::ViewItem, fld: &mut MacroExpander) {
         // Intentionally leak the dynamic library. We can't ever unload it
         // since the library can do things that will outlive the expansion
         // phase (e.g. make an @-box cycle or launch a task).
-        cast::forget(lib);
+        mem::forget(lib);
     }
 }
 
diff --git a/src/libsyntax/owned_slice.rs b/src/libsyntax/owned_slice.rs
index 57529228b51..f93c3576943 100644
--- a/src/libsyntax/owned_slice.rs
+++ b/src/libsyntax/owned_slice.rs
@@ -10,7 +10,7 @@
 
 use std::default::Default;
 use std::hash::Hash;
-use std::{cast, mem, raw, ptr, slice};
+use std::{mem, raw, ptr, slice};
 use serialize::{Encodable, Decodable, Encoder, Decoder};
 
 /// A non-growable owned slice. This would preferably become `~[T]`
@@ -48,7 +48,7 @@ impl<T> OwnedSlice<T> {
         } else {
             let p = v.as_mut_ptr();
             // we own the allocation now
-            unsafe {cast::forget(v)}
+            unsafe {mem::forget(v)}
 
             OwnedSlice { data: p, len: len }
         }
@@ -60,7 +60,7 @@ impl<T> OwnedSlice<T> {
         unsafe {
             let ret = Vec::from_raw_parts(self.len, self.len, self.data);
             // the vector owns the allocation now
-            cast::forget(self);
+            mem::forget(self);
             ret
         }
     }
@@ -74,7 +74,7 @@ impl<T> OwnedSlice<T> {
             self.data as *T
         };
 
-        let slice: &[T] = unsafe {cast::transmute(raw::Slice {
+        let slice: &[T] = unsafe {mem::transmute(raw::Slice {
             data: ptr,
             len: self.len
         })};
diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs
index 8fb2fe61b83..3888ed6b8d1 100644
--- a/src/libsyntax/parse/token.rs
+++ b/src/libsyntax/parse/token.rs
@@ -17,9 +17,9 @@ use util::interner::{RcStr, StrInterner};
 use util::interner;
 
 use serialize::{Decodable, Decoder, Encodable, Encoder};
-use std::cast;
 use std::fmt;
 use std::path::BytesContainer;
+use std::mem;
 use std::rc::Rc;
 use std::strbuf::StrBuf;
 
@@ -585,7 +585,7 @@ impl BytesContainer for InternedString {
         // DST.
         unsafe {
             let this = self.get();
-            cast::transmute(this.container_as_bytes())
+            mem::transmute(this.container_as_bytes())
         }
     }
 }
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index 8486a8aeb35..71c2f6337e0 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -26,9 +26,9 @@ use print::pp::{break_offset, word, space, zerobreak, hardbreak};
 use print::pp::{Breaks, Consistent, Inconsistent, eof};
 use print::pp;
 
-use std::cast;
 use std::io::{IoResult, MemWriter};
 use std::io;
+use std::mem;
 use std::rc::Rc;
 use std::str;
 use std::strbuf::StrBuf;
@@ -140,9 +140,9 @@ pub fn to_str(f: |&mut State| -> IoResult<()>) -> StrBuf {
         // FIXME(pcwalton): A nasty function to extract the string from an `io::Writer`
         // that we "know" to be a `MemWriter` that works around the lack of checked
         // downcasts.
-        let (_, wr): (uint, Box<MemWriter>) = cast::transmute_copy(&s.s.out);
+        let (_, wr): (uint, Box<MemWriter>) = mem::transmute_copy(&s.s.out);
         let result = str::from_utf8_owned(wr.get_ref().to_owned()).unwrap();
-        cast::forget(wr);
+        mem::forget(wr);
         result.to_strbuf()
     }
 }
diff --git a/src/libsyntax/util/interner.rs b/src/libsyntax/util/interner.rs
index 7f856845722..c3c9596bfc4 100644
--- a/src/libsyntax/util/interner.rs
+++ b/src/libsyntax/util/interner.rs
@@ -15,11 +15,11 @@
 use ast::Name;
 
 use collections::HashMap;
-use std::cast;
 use std::cell::RefCell;
 use std::cmp::Equiv;
 use std::fmt;
 use std::hash::Hash;
+use std::mem;
 use std::rc::Rc;
 
 pub struct Interner<T> {
@@ -198,7 +198,7 @@ impl StrInterner {
         let vect = self.vect.borrow();
         let s: &str = vect.get(idx as uint).as_slice();
         unsafe {
-            cast::transmute(s)
+            mem::transmute(s)
         }
     }