1 files changed, 20 insertions, 33 deletions

diff --git a/src/libcore/sys.rs b/src/libcore/sys.rs
index 37403213ab2..12329616fbf 100644
--- a/src/libcore/sys.rs
+++ b/src/libcore/sys.rs
@@ -7,21 +7,10 @@
 use cmp::{Eq, Ord};
 use libc::c_void;
 
-export FreeGlue;
-export TypeDesc;
-export Closure;
-export get_type_desc;
-export size_of;
-export min_align_of;
-export pref_align_of;
-export refcount;
-export log_str;
-export shape_eq, shape_lt, shape_le;
-
-type FreeGlue = fn(*TypeDesc, *c_void);
+pub type FreeGlue = fn(*TypeDesc, *c_void);
 
 // Corresponds to runtime type_desc type
-enum TypeDesc = {
+pub enum TypeDesc = {
     size: uint,
     align: uint,
     take_glue: uint,
@@ -31,14 +20,13 @@ enum TypeDesc = {
 };
 
 /// The representation of a Rust closure
-struct Closure {
+pub struct Closure {
     code: *(),
     env: *(),
 }
 
 #[abi = "rust-intrinsic"]
 extern mod rusti {
-    #[legacy_exports];
     fn get_tydesc<T>() -> *();
     fn size_of<T>() -> uint;
     fn pref_align_of<T>() -> uint;
@@ -47,15 +35,15 @@ extern mod rusti {
 
 /// Compares contents of two pointers using the default method.
 /// Equivalent to `*x1 == *x2`.  Useful for hashtables.
-pure fn shape_eq<T:Eq>(x1: &T, x2: &T) -> bool {
+pub pure fn shape_eq<T:Eq>(x1: &T, x2: &T) -> bool {
     *x1 == *x2
 }
 
-pure fn shape_lt<T:Ord>(x1: &T, x2: &T) -> bool {
+pub pure fn shape_lt<T:Ord>(x1: &T, x2: &T) -> bool {
     *x1 < *x2
 }
 
-pure fn shape_le<T:Ord>(x1: &T, x2: &T) -> bool {
+pub pure fn shape_le<T:Ord>(x1: &T, x2: &T) -> bool {
     *x1 <= *x2
 }
 
@@ -66,13 +54,13 @@ pure fn shape_le<T:Ord>(x1: &T, x2: &T) -> bool {
  * performing dark magick.
  */
 #[inline(always)]
-pure fn get_type_desc<T>() -> *TypeDesc {
+pub pure fn get_type_desc<T>() -> *TypeDesc {
     unsafe { rusti::get_tydesc::<T>() as *TypeDesc }
 }
 
 /// Returns the size of a type
 #[inline(always)]
-pure fn size_of<T>() -> uint {
+pub pure fn size_of<T>() -> uint {
     unsafe { rusti::size_of::<T>() }
 }
 
@@ -83,26 +71,26 @@ pure fn size_of<T>() -> uint {
  * than the preferred alignment.
  */
 #[inline(always)]
-pure fn min_align_of<T>() -> uint {
+pub pure fn min_align_of<T>() -> uint {
     unsafe { rusti::min_align_of::<T>() }
 }
 
 /// Returns the preferred alignment of a type
 #[inline(always)]
-pure fn pref_align_of<T>() -> uint {
+pub pure fn pref_align_of<T>() -> uint {
     unsafe { rusti::pref_align_of::<T>() }
 }
 
 /// Returns the refcount of a shared box (as just before calling this)
 #[inline(always)]
-pure fn refcount<T>(+t: @T) -> uint {
+pub pure fn refcount<T>(t: @T) -> uint {
     unsafe {
         let ref_ptr: *uint = cast::reinterpret_cast(&t);
         *ref_ptr - 1
     }
 }
 
-pure fn log_str<T>(t: &T) -> ~str {
+pub pure fn log_str<T>(t: &T) -> ~str {
     unsafe {
         do io::with_str_writer |wr| {
             repr::write_repr(wr, t)
@@ -111,11 +99,10 @@ pure fn log_str<T>(t: &T) -> ~str {
 }
 
 #[cfg(test)]
-mod tests {
-    #[legacy_exports];
+pub mod tests {
 
     #[test]
-    fn size_of_basic() {
+    pub fn size_of_basic() {
         assert size_of::<u8>() == 1u;
         assert size_of::<u16>() == 2u;
         assert size_of::<u32>() == 4u;
@@ -125,20 +112,20 @@ mod tests {
     #[test]
     #[cfg(target_arch = "x86")]
     #[cfg(target_arch = "arm")]
-    fn size_of_32() {
+    pub fn size_of_32() {
         assert size_of::<uint>() == 4u;
         assert size_of::<*uint>() == 4u;
     }
 
     #[test]
     #[cfg(target_arch = "x86_64")]
-    fn size_of_64() {
+    pub fn size_of_64() {
         assert size_of::<uint>() == 8u;
         assert size_of::<*uint>() == 8u;
     }
 
     #[test]
-    fn align_of_basic() {
+    pub fn align_of_basic() {
         assert pref_align_of::<u8>() == 1u;
         assert pref_align_of::<u16>() == 2u;
         assert pref_align_of::<u32>() == 4u;
@@ -147,20 +134,20 @@ mod tests {
     #[test]
     #[cfg(target_arch = "x86")]
     #[cfg(target_arch = "arm")]
-    fn align_of_32() {
+    pub fn align_of_32() {
         assert pref_align_of::<uint>() == 4u;
         assert pref_align_of::<*uint>() == 4u;
     }
 
     #[test]
     #[cfg(target_arch = "x86_64")]
-    fn align_of_64() {
+    pub fn align_of_64() {
         assert pref_align_of::<uint>() == 8u;
         assert pref_align_of::<*uint>() == 8u;
     }
 
     #[test]
-    fn synthesize_closure() unsafe {
+    pub fn synthesize_closure() unsafe {
         let x = 10;
         let f: fn(int) -> int = |y| x + y;