libcore: De-export cleanup, cmath, future, gc, hash, iter-trait, mutable, and private

Author: pcwalton

src/libcore/cleanup.rs

@@ -10,8 +10,6 @@ use repr::BoxRepr;
 use sys::TypeDesc;
 use cast::transmute;
 
-export annihilate;
-
 /**
  * Runtime structures
  *

src/libcore/cmath.rs

@@ -3,10 +3,6 @@
 #[forbid(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
-// uncomment once #1433 is fixed
-// FIXME (#1433): export c_float_math_consts;
-// FIXME (#1433): export c_double_math_consts;
-
 use libc::c_int;
 use libc::c_float;
 use libc::c_double;
@@ -193,66 +189,62 @@ pub mod c_double_targ_consts {
 
 FIXME use these once they can be parsed (see Issue #1433)
 
-mod c_float_math_consts {
-    #[legacy_exports];
-    const pi: c_float = 0x1.921fb6p+1_f32;
-    const div_1_pi: c_float = 0x1.45f306p-2_f32;
-    const div_2_pi: c_float = 0x1.45f306p-1_f32;
-    const div_pi_2: c_float = 0x1.921fb6p+0_f32;
-    const div_pi_4: c_float = 0x1.921fb6p-1_f32;
-    const div_2_sqrtpi: c_float = 0x1.20dd76p+0_f32;
-    const e: c_float = 0x1.5bf0a8p+1_f32;
-    const log2_e: c_float = 0x1.715476p+0_f32;
-    const log10_e: c_float = 0x1.bcb7b2p-2_f32;
-    const ln_2: c_float = 0x1.62e43p-1_f32;
-    const ln_10: c_float = 0x1.26bb1cp+1_f32;
-    const sqrt2: c_float = 0x1.6a09e6p+0_f32;
-    const div_1_sqrt2: c_float = 0x1.6a09e6p-1_f32;
+pub mod c_float_math_consts {
+    pub const pi: c_float = 0x1.921fb6p+1_f32;
+    pub const div_1_pi: c_float = 0x1.45f306p-2_f32;
+    pub const div_2_pi: c_float = 0x1.45f306p-1_f32;
+    pub const div_pi_2: c_float = 0x1.921fb6p+0_f32;
+    pub const div_pi_4: c_float = 0x1.921fb6p-1_f32;
+    pub const div_2_sqrtpi: c_float = 0x1.20dd76p+0_f32;
+    pub const e: c_float = 0x1.5bf0a8p+1_f32;
+    pub const log2_e: c_float = 0x1.715476p+0_f32;
+    pub const log10_e: c_float = 0x1.bcb7b2p-2_f32;
+    pub const ln_2: c_float = 0x1.62e43p-1_f32;
+    pub const ln_10: c_float = 0x1.26bb1cp+1_f32;
+    pub const sqrt2: c_float = 0x1.6a09e6p+0_f32;
+    pub const div_1_sqrt2: c_float = 0x1.6a09e6p-1_f32;
 }
 
-mod c_double_math_consts {
-    #[legacy_exports];
-    const pi: c_double = 0x1.921fb54442d18p+1_f64;
-    const div_1_pi: c_double = 0x1.45f306dc9c883p-2_f64;
-    const div_2_pi: c_double = 0x1.45f306dc9c883p-1_f64;
-    const div_pi_2: c_double = 0x1.921fb54442d18p+0_f64;
-    const div_pi_4: c_double = 0x1.921fb54442d18p-1_f64;
-    const div_2_sqrtpi: c_double = 0x1.20dd750429b6dp+0_f64;
-    const e: c_double = 0x1.5bf0a8b145769p+1_f64;
-    const log2_e: c_double = 0x1.71547652b82fep+0_f64;
-    const log10_e: c_double = 0x1.bcb7b1526e50ep-2_f64;
-    const ln_2: c_double = 0x1.62e42fefa39efp-1_f64;
-    const ln_10: c_double = 0x1.26bb1bbb55516p+1_f64;
-    const sqrt2: c_double = 0x1.6a09e667f3bcdp+0_f64;
-    const div_1_sqrt2: c_double = 0x1.6a09e667f3bcdp-1_f64;
+pub mod c_double_math_consts {
+    pub const pi: c_double = 0x1.921fb54442d18p+1_f64;
+    pub const div_1_pi: c_double = 0x1.45f306dc9c883p-2_f64;
+    pub const div_2_pi: c_double = 0x1.45f306dc9c883p-1_f64;
+    pub const div_pi_2: c_double = 0x1.921fb54442d18p+0_f64;
+    pub const div_pi_4: c_double = 0x1.921fb54442d18p-1_f64;
+    pub const div_2_sqrtpi: c_double = 0x1.20dd750429b6dp+0_f64;
+    pub const e: c_double = 0x1.5bf0a8b145769p+1_f64;
+    pub const log2_e: c_double = 0x1.71547652b82fep+0_f64;
+    pub const log10_e: c_double = 0x1.bcb7b1526e50ep-2_f64;
+    pub const ln_2: c_double = 0x1.62e42fefa39efp-1_f64;
+    pub const ln_10: c_double = 0x1.26bb1bbb55516p+1_f64;
+    pub const sqrt2: c_double = 0x1.6a09e667f3bcdp+0_f64;
+    pub const div_1_sqrt2: c_double = 0x1.6a09e667f3bcdp-1_f64;
 }
 
-mod c_float_targ_consts {
-    #[legacy_exports];
-    const radix: uint = 2u;
-    const mantissa_digits: uint = 24u;
-    const digits: uint = 6u;
-    const min_exp: int = -125;
-    const max_exp: int = 128;
-    const min_10_exp: int = -37;
-    const max_10_exp: int = 38;
-    const min_value: c_float = 0x1p-126_f32;
-    const max_value: c_float = 0x1.fffffep+127_f32;
-    const epsilon: c_float = 0x1p-23_f32;
+pub mod c_float_targ_consts {
+    pub const radix: uint = 2u;
+    pub const mantissa_digits: uint = 24u;
+    pub const digits: uint = 6u;
+    pub const min_exp: int = -125;
+    pub const max_exp: int = 128;
+    pub const min_10_exp: int = -37;
+    pub const max_10_exp: int = 38;
+    pub const min_value: c_float = 0x1p-126_f32;
+    pub const max_value: c_float = 0x1.fffffep+127_f32;
+    pub const epsilon: c_float = 0x1p-23_f32;
 }
 
-mod c_double_targ_consts {
-    #[legacy_exports];
-    const radix: uint = 2u;
-    const mantissa_digits: uint = 53u;
-    const digits: uint = 15u;
-    const min_exp: int = -1021;
-    const max_exp: int = 1024;
-    const min_10_exp: int = -307;
-    const max_10_exp: int = 308;
-    const min_value: c_double = 0x1p-1022_f64;
-    const max_value: c_double = 0x1.fffffffffffffp+1023_f64;
-    const epsilon: c_double = 0x1p-52_f64;
+pub mod c_double_targ_consts {
+    pub const radix: uint = 2u;
+    pub const mantissa_digits: uint = 53u;
+    pub const digits: uint = 15u;
+    pub const min_exp: int = -1021;
+    pub const max_exp: int = 1024;
+    pub const min_10_exp: int = -307;
+    pub const max_10_exp: int = 308;
+    pub const min_value: c_double = 0x1p-1022_f64;
+    pub const max_value: c_double = 0x1.fffffffffffffp+1023_f64;
+    pub const epsilon: c_double = 0x1p-52_f64;
 }
 
 */

src/libcore/future.rs

@@ -19,20 +19,8 @@ use either::Either;
 use pipes::recv;
 use cast::copy_lifetime;
 
-export Future;
-export extensions;
-export from_value;
-export from_port;
-export from_fn;
-export get;
-export with;
-export spawn;
-
-// for task.rs
-export future_pipe;
-
 #[doc = "The future type"]
-struct Future<A> {
+pub struct Future<A> {
     /*priv*/ mut state: FutureState<A>,
 
     // FIXME(#2829) -- futures should not be copyable, because they close
@@ -67,7 +55,7 @@ impl<A> Future<A> {
     }
 }
 
-fn from_value<A>(+val: A) -> Future<A> {
+pub fn from_value<A>(+val: A) -> Future<A> {
     /*!
      * Create a future from a value
      *
@@ -78,7 +66,8 @@ fn from_value<A>(+val: A) -> Future<A> {
     Future {state: Forced(~(move val))}
 }
 
-fn from_port<A:Send>(+port: future_pipe::client::waiting<A>) -> Future<A> {
+pub fn from_port<A:Send>(+port: future_pipe::client::waiting<A>) ->
+        Future<A> {
     /*!
      * Create a future from a port
      *
@@ -97,7 +86,7 @@ fn from_port<A:Send>(+port: future_pipe::client::waiting<A>) -> Future<A> {
     }
 }
 
-fn from_fn<A>(+f: ~fn() -> A) -> Future<A> {
+pub fn from_fn<A>(+f: ~fn() -> A) -> Future<A> {
     /*!
      * Create a future from a function.
      *
@@ -109,7 +98,7 @@ fn from_fn<A>(+f: ~fn() -> A) -> Future<A> {
     Future {state: Pending(move f)}
 }
 
-fn spawn<A:Send>(+blk: fn~() -> A) -> Future<A> {
+pub fn spawn<A:Send>(+blk: fn~() -> A) -> Future<A> {
     /*!
      * Create a future from a unique closure.
      *
@@ -122,7 +111,7 @@ fn spawn<A:Send>(+blk: fn~() -> A) -> Future<A> {
     }))
 }
 
-fn get_ref<A>(future: &r/Future<A>) -> &r/A {
+pub fn get_ref<A>(future: &r/Future<A>) -> &r/A {
     /*!
      * Executes the future's closure and then returns a borrowed
      * pointer to the result.  The borrowed pointer lasts as long as
@@ -160,13 +149,13 @@ fn get_ref<A>(future: &r/Future<A>) -> &r/A {
     }
 }
 
-fn get<A:Copy>(future: &Future<A>) -> A {
+pub fn get<A:Copy>(future: &Future<A>) -> A {
     //! Get the value of the future
 
     *get_ref(future)
 }
 
-fn with<A,B>(future: &Future<A>, blk: fn((&A)) -> B) -> B {
+pub fn with<A,B>(future: &Future<A>, blk: fn((&A)) -> B) -> B {
     //! Work with the value without copying it
 
     blk(get_ref(future))
@@ -179,74 +168,73 @@ proto! future_pipe (
 )
 
 #[allow(non_implicitly_copyable_typarams)]
-mod test {
-    #[legacy_exports];
+pub mod test {
     #[test]
-    fn test_from_value() {
+    pub fn test_from_value() {
         let f = from_value(~"snail");
         assert get(&f) == ~"snail";
     }
 
     #[test]
-    fn test_from_port() {
+    pub fn test_from_port() {
         let (po, ch) = future_pipe::init();
         future_pipe::server::completed(ch, ~"whale");
         let f = from_port(po);
         assert get(&f) == ~"whale";
     }
 
     #[test]
-    fn test_from_fn() {
+    pub fn test_from_fn() {
         let f = from_fn(|| ~"brail");
         assert get(&f) == ~"brail";
     }
 
     #[test]
-    fn test_interface_get() {
+    pub fn test_interface_get() {
         let f = from_value(~"fail");
         assert f.get() == ~"fail";
     }
 
     #[test]
-    fn test_with() {
+    pub fn test_with() {
         let f = from_value(~"nail");
         assert with(&f, |v| copy *v) == ~"nail";
     }
 
     #[test]
-    fn test_get_ref_method() {
+    pub fn test_get_ref_method() {
         let f = from_value(22);
         assert *f.get_ref() == 22;
     }
 
     #[test]
-    fn test_get_ref_fn() {
+    pub fn test_get_ref_fn() {
         let f = from_value(22);
         assert *get_ref(&f) == 22;
     }
 
     #[test]
-    fn test_interface_with() {
+    pub fn test_interface_with() {
         let f = from_value(~"kale");
         assert f.with(|v| copy *v) == ~"kale";
     }
 
     #[test]
-    fn test_spawn() {
+    pub fn test_spawn() {
         let f = spawn(|| ~"bale");
         assert get(&f) == ~"bale";
     }
 
     #[test]
     #[should_fail]
     #[ignore(cfg(target_os = "win32"))]
-    fn test_futurefail() {
+    pub fn test_futurefail() {
         let f = spawn(|| fail);
         let _x: ~str = get(&f);
     }
 
     #[test]
-    fn test_sendable_future() {
+    pub fn test_sendable_future() {
         let expected = ~"schlorf";
         let f = do spawn |copy expected| { copy expected };
         do task::spawn {

src/libcore/gc.rs

@@ -34,10 +34,6 @@ use libc::size_t;
 use libc::uintptr_t;
 use send_map::linear::LinearMap;
 
-export Word;
-export gc;
-export cleanup_stack_for_failure;
-
 // Mirrors rust_stack.h stk_seg
 struct StackSegment {
     prev: *StackSegment,
@@ -268,7 +264,7 @@ unsafe fn walk_gc_roots(mem: Memory, sentinel: **Word, visitor: Visitor) {
     }
 }
 
-fn gc() {
+pub fn gc() {
     unsafe {
         // Abort when GC is disabled.
         if get_safe_point_count() == 0 {
@@ -301,7 +297,7 @@ fn expect_sentinel() -> bool { false }
 // This should only be called from fail, as it will drop the roots
 // which are *live* on the stack, rather than dropping those that are
 // dead.
-fn cleanup_stack_for_failure() {
+pub fn cleanup_stack_for_failure() {
     unsafe {
         // Abort when GC is disabled.
         if get_safe_point_count() == 0 {