Add core::reflect, start migrating core::repr to use it. Tidy up various Repr types.

Author: graydon

src/libcore/at_vec.rs

@@ -30,7 +30,7 @@ pure fn capacity<T>(&&v: @[const T]) -> uint {
     unsafe {
         let repr: **unsafe::VecRepr =
             ::unsafe::reinterpret_cast(&addr_of(v));
-        (**repr).alloc / sys::size_of::<T>()
+        (**repr).unboxed.alloc / sys::size_of::<T>()
     }
 }
 
@@ -155,14 +155,14 @@ mod unsafe {
     #[inline(always)]
     unsafe fn set_len<T>(&&v: @[const T], new_len: uint) {
         let repr: **VecRepr = ::unsafe::reinterpret_cast(&addr_of(v));
-        (**repr).fill = new_len * sys::size_of::<T>();
+        (**repr).unboxed.fill = new_len * sys::size_of::<T>();
     }
 
     #[inline(always)]
     unsafe fn push<T>(&v: @[const T], +initval: T) {
         let repr: **VecRepr = ::unsafe::reinterpret_cast(&addr_of(v));
-        let fill = (**repr).fill;
-        if (**repr).alloc > fill {
+        let fill = (**repr).unboxed.fill;
+        if (**repr).unboxed.alloc > fill {
             push_fast(v, move initval);
         }
         else {
@@ -173,9 +173,9 @@ mod unsafe {
     #[inline(always)] // really pretty please
     unsafe fn push_fast<T>(&v: @[const T], +initval: T) {
         let repr: **VecRepr = ::unsafe::reinterpret_cast(&addr_of(v));
-        let fill = (**repr).fill;
-        (**repr).fill += sys::size_of::<T>();
-        let p = ptr::addr_of((**repr).data);
+        let fill = (**repr).unboxed.fill;
+        (**repr).unboxed.fill += sys::size_of::<T>();
+        let p = ptr::addr_of((**repr).unboxed.data);
         let p = ptr::offset(p, fill) as *mut T;
         rusti::move_val_init(*p, move initval);
     }

src/libcore/box.rs

@@ -5,8 +5,25 @@
 #[forbid(deprecated_pattern)];
 
 use cmp::{Eq, Ord};
+use intrinsic::TyDesc;
 
-export ptr_eq;
+export ptr_eq, raw;
+
+mod raw {
+
+    struct BoxHeaderRepr {
+        ref_count: uint,
+        type_desc: *TyDesc,
+        prev: *BoxRepr,
+        next: *BoxRepr,
+    }
+
+    struct BoxRepr {
+        header: BoxHeaderRepr,
+        data: u8
+    }
+
+}
 
 pure fn ptr_eq<T>(a: @T, b: @T) -> bool {
     //! Determine if two shared boxes point to the same object

src/libcore/cleanup.rs

@@ -80,28 +80,28 @@ pub unsafe fn annihilate() {
     let mut box: *mut BoxRepr = transmute(copy box);
     while box != mut_null() {
         debug!("making box immortal: %x", box as uint);
-        (*box).ref_count = 0x77777777;
-        box = transmute(copy (*box).next);
+        (*box).header.ref_count = 0x77777777;
+        box = transmute(copy (*box).header.next);
     }
 
     // Pass 2: Drop all boxes.
     let box = (*task).boxed_region.live_allocs;
     let mut box: *mut BoxRepr = transmute(copy box);
     while box != mut_null() {
         debug!("calling drop glue for box: %x", box as uint);
-        let tydesc: *TypeDesc = transmute(copy (*box).type_desc);
+        let tydesc: *TypeDesc = transmute(copy (*box).header.type_desc);
         let drop_glue: DropGlue = transmute(((*tydesc).drop_glue, 0));
         drop_glue(to_unsafe_ptr(&tydesc), transmute(&(*box).data));
 
-        box = transmute(copy (*box).next);
+        box = transmute(copy (*box).header.next);
     }
 
     // Pass 3: Free all boxes.
     loop {
         let box = (*task).boxed_region.live_allocs;
         if box == null() { break; }
         let mut box: *mut BoxRepr = transmute(copy box);
-        assert (*box).prev == null();
+        assert (*box).header.prev == null();
 
         debug!("freeing box: %x", box as uint);
         rt_free(transmute(box));

src/libcore/core.rc

@@ -63,6 +63,7 @@ export unit;
 export uniq;
 export repr;
 export cleanup;
+export reflect;
 
 // NDM seems to be necessary for resolve to work
 export option_iter;
@@ -230,6 +231,7 @@ mod mutable;
 mod flate;
 mod repr;
 mod cleanup;
+mod reflect;
 
 // Modules supporting compiler-generated code
 // Exported but not part of the public interface