Removed libcore/mutable.rs, Mut<T> is now dead.

2 files changed, 0 insertions, 96 deletions

diff --git a/src/libcore/core.rc b/src/libcore/core.rc
index 292dd1d92cf..f7c64e3f374 100644
--- a/src/libcore/core.rc
+++ b/src/libcore/core.rc
@@ -212,7 +212,6 @@ pub mod rand;
 pub mod run;
 pub mod sys;
 pub mod cast;
-pub mod mutable;
 pub mod flate;
 pub mod repr;
 pub mod cleanup;
diff --git a/src/libcore/mutable.rs b/src/libcore/mutable.rs
deleted file mode 100644
index 39d184b951a..00000000000
--- a/src/libcore/mutable.rs
+++ /dev/null
@@ -1,95 +0,0 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-/*!
-
-Module for wrapping freezable data structures in managed boxes.
-Normally freezable data structures require an unaliased reference,
-such as `T` or `~T`, so that the compiler can track when they are
-being mutated.  The `managed<T>` type converts these static checks into
-dynamic checks: your program will fail if you attempt to perform
-mutation when the data structure should be immutable.
-
-*/
-
-use util::with;
-use cast::{transmute_mut,transmute_immut};
-
-enum Mode { ReadOnly, Mutable, Immutable }
-
-struct Data<T> {
-    priv value: T,
-    priv mode: Mode
-}
-
-pub type Mut<T> = Data<T>;
-
-pub fn Mut<T>(t: T) -> Mut<T> {
-    Data {value: t, mode: ReadOnly}
-}
-
-pub fn unwrap<T>(m: Mut<T>) -> T {
-    // Borrowck should prevent us from calling unwrap while the value
-    // is in use, as that would be a move from a borrowed value.
-    assert!((m.mode as uint) == (ReadOnly as uint));
-    let Data {value: value, mode: _} = m;
-    value
-}
-
-pub impl<T> Data<T> {
-    fn borrow_mut<R>(&self, op: &fn(t: &mut T) -> R) -> R {
-        match self.mode {
-            Immutable => fail!(~"currently immutable"),
-            ReadOnly | Mutable => {}
-        }
-
-        do with( unsafe { transmute_mut(&self.mode) }, Mutable) {
-            op(  unsafe { transmute_mut(&self.value) })
-        }
-    }
-
-    fn borrow_imm<R>(&self, op: &fn(t: &T) -> R) -> R {
-        match self.mode {
-          Mutable => fail!(~"currently mutable"),
-          ReadOnly | Immutable => {}
-        }
-
-        do with( unsafe { transmute_mut(&self.mode) }, Immutable) {
-            op( &self.value )
-        }
-    }
-
-    #[inline(always)]
-    fn unwrap(self) -> T { unwrap(self) }
-}
-
-#[test]
-#[ignore(cfg(windows))]
-#[should_fail]
-pub fn test_mut_in_imm() {
-    let m = @Mut(1);
-    do m.borrow_imm |_p| {
-        do m.borrow_mut |_q| {
-            // should not be permitted
-        }
-    }
-}
-
-#[test]
-#[ignore(cfg(windows))]
-#[should_fail]
-pub fn test_imm_in_mut() {
-    let m = @Mut(1);
-    do m.borrow_mut |_p| {
-        do m.borrow_imm |_q| {
-            // should not be permitted
-        }
-    }
-}