auto merge of #10929 : pcwalton/rust/deboxing, r=pcwalton

...eyword.

r? @brson

Author: bors

src/librustc/middle/trans/base.rs

@@ -303,7 +303,7 @@ pub fn opaque_box_body(bcx: @mut Block,
     let _icx = push_ctxt("opaque_box_body");
     let ccx = bcx.ccx();
     let ty = type_of(ccx, body_t);
-    let ty = Type::box(ccx, &ty);
+    let ty = Type::smart_ptr(ccx, &ty);
     let boxptr = PointerCast(bcx, boxptr, ty.ptr_to());
     GEPi(bcx, boxptr, [0u, abi::box_field_body])
 }
@@ -385,20 +385,24 @@ pub fn malloc_raw(bcx: @mut Block, t: ty::t, heap: heap) -> Result {
 
 pub struct MallocResult {
     bcx: @mut Block,
-    box: ValueRef,
+    smart_ptr: ValueRef,
     body: ValueRef
 }
 
-// malloc_general_dyn: usefully wraps malloc_raw_dyn; allocates a box,
-// and pulls out the body
+// malloc_general_dyn: usefully wraps malloc_raw_dyn; allocates a smart
+// pointer, and pulls out the body
 pub fn malloc_general_dyn(bcx: @mut Block, t: ty::t, heap: heap, size: ValueRef)
     -> MallocResult {
     assert!(heap != heap_exchange);
     let _icx = push_ctxt("malloc_general");
     let Result {bcx: bcx, val: llbox} = malloc_raw_dyn(bcx, t, heap, size);
     let body = GEPi(bcx, llbox, [0u, abi::box_field_body]);
 
-    MallocResult { bcx: bcx, box: llbox, body: body }
+    MallocResult {
+        bcx: bcx,
+        smart_ptr: llbox,
+        body: body,
+    }
 }
 
 pub fn malloc_general(bcx: @mut Block, t: ty::t, heap: heap) -> MallocResult {

src/librustc/middle/trans/debuginfo.rs

@@ -1683,7 +1683,7 @@ fn boxed_type_metadata(cx: &mut CrateContext,
         None                    => ~"BoxedType"
     };
 
-    let box_llvm_type = Type::box(cx, &content_llvm_type);
+    let box_llvm_type = Type::smart_ptr(cx, &content_llvm_type);
     let member_llvm_types = box_llvm_type.field_types();
     assert!(box_layout_is_correct(cx, member_llvm_types, content_llvm_type));
 

src/librustc/middle/trans/expr.rs

@@ -1396,8 +1396,11 @@ fn trans_unary_datum(bcx: @mut Block,
             revoke_clean(bcx, val);
             return immediate_rvalue_bcx(bcx, val, box_ty);
         } else {
-            let base::MallocResult { bcx, box: bx, body } =
-                base::malloc_general(bcx, contents_ty, heap);
+            let base::MallocResult {
+                bcx,
+                smart_ptr: bx,
+                body
+            } = base::malloc_general(bcx, contents_ty, heap);
             add_clean_free(bcx, bx, heap);
             let bcx = trans_into(bcx, contents, SaveIn(body));
             revoke_clean(bcx, bx);

src/librustc/middle/trans/tvec.rs

@@ -98,7 +98,7 @@ pub fn alloc_raw(bcx: @mut Block, unit_ty: ty::t,
         Store(bcx, alloc, GEPi(bcx, val, [0u, abi::vec_elt_alloc]));
         return rslt(bcx, val);
     } else {
-        let base::MallocResult {bcx, box: bx, body} =
+        let base::MallocResult {bcx, smart_ptr: bx, body} =
             base::malloc_general_dyn(bcx, vecbodyty, heap, vecsize);
         Store(bcx, fill, GEPi(bcx, body, [0u, abi::vec_elt_fill]));
         Store(bcx, alloc, GEPi(bcx, body, [0u, abi::vec_elt_alloc]));

src/librustc/middle/trans/type_.rs

@@ -258,7 +258,7 @@ impl Type {
         Type::struct_(Type::box_header_fields(ctx), false)
     }
 
-    pub fn box(ctx: &CrateContext, ty: &Type) -> Type {
+    pub fn smart_ptr(ctx: &CrateContext, ty: &Type) -> Type {
         Type::struct_(Type::box_header_fields(ctx) + &[*ty], false)
     }
 
@@ -267,11 +267,11 @@ impl Type {
     }
 
     pub fn opaque_box(ctx: &CrateContext) -> Type {
-        Type::box(ctx, &Type::opaque())
+        Type::smart_ptr(ctx, &Type::opaque())
     }
 
     pub fn unique(ctx: &CrateContext, ty: &Type) -> Type {
-        Type::box(ctx, ty)
+        Type::smart_ptr(ctx, ty)
     }
 
     pub fn opaque_cbox_ptr(cx: &CrateContext) -> Type {

src/librustc/middle/trans/type_of.rs

@@ -221,16 +221,18 @@ pub fn type_of(cx: &mut CrateContext, t: ty::t) -> Type {
         adt::incomplete_type_of(cx, repr, name)
       }
       ty::ty_estr(ty::vstore_box) => {
-        Type::box(cx, &Type::vec(cx.sess.targ_cfg.arch, &Type::i8())).ptr_to()
+        Type::smart_ptr(cx,
+                        &Type::vec(cx.sess.targ_cfg.arch,
+                                   &Type::i8())).ptr_to()
       }
       ty::ty_evec(ref mt, ty::vstore_box) => {
           let e_ty = type_of(cx, mt.ty);
           let v_ty = Type::vec(cx.sess.targ_cfg.arch, &e_ty);
-          Type::box(cx, &v_ty).ptr_to()
+          Type::smart_ptr(cx, &v_ty).ptr_to()
       }
       ty::ty_box(ref mt) => {
           let ty = type_of(cx, mt.ty);
-          Type::box(cx, &ty).ptr_to()
+          Type::smart_ptr(cx, &ty).ptr_to()
       }
       ty::ty_opaque_box => Type::opaque_box(cx).ptr_to(),
       ty::ty_uniq(ref mt) => {

src/libstd/at_vec.rs

@@ -25,8 +25,8 @@ use vec::{ImmutableVector, OwnedVector};
 #[inline]
 pub fn capacity<T>(v: @[T]) -> uint {
     unsafe {
-        let box = v.repr();
-        (*box).data.alloc / mem::size_of::<T>()
+        let managed_box = v.repr();
+        (*managed_box).data.alloc / mem::size_of::<T>()
     }
 }
 

src/libstd/cast.rs

@@ -120,11 +120,11 @@ mod tests {
     }
 
     #[test]
-    fn test_bump_box_refcount() {
+    fn test_bump_managed_refcount() {
         unsafe {
-            let box = @~"box box box";       // refcount 1
-            bump_box_refcount(box);         // refcount 2
-            let ptr: *int = transmute(box); // refcount 2
+            let managed = @~"box box box";      // refcount 1
+            bump_box_refcount(managed);     // refcount 2
+            let ptr: *int = transmute(managed); // refcount 2
             let _box1: @~str = ::cast::transmute_copy(&ptr);
             let _box2: @~str = ::cast::transmute_copy(&ptr);
             assert!(*_box1 == ~"box box box");

src/libstd/cell.rs

@@ -157,19 +157,19 @@ impl<T: Eq> Eq for RefCell<T> {
 }
 
 /// Wraps a borrowed reference to a value in a `RefCell` box.
-pub struct Ref<'box, T> {
-    priv parent: &'box RefCell<T>
+pub struct Ref<'b, T> {
+    priv parent: &'b RefCell<T>
 }
 
 #[unsafe_destructor]
-impl<'box, T> Drop for Ref<'box, T> {
+impl<'b, T> Drop for Ref<'b, T> {
     fn drop(&mut self) {
         assert!(self.parent.borrow != WRITING && self.parent.borrow != UNUSED);
         unsafe { self.parent.as_mut().borrow -= 1; }
     }
 }
 
-impl<'box, T> Ref<'box, T> {
+impl<'b, T> Ref<'b, T> {
     /// Retrieve an immutable reference to the stored value.
     #[inline]
     pub fn get<'a>(&'a self) -> &'a T {
@@ -178,19 +178,19 @@ impl<'box, T> Ref<'box, T> {
 }
 
 /// Wraps a mutable borrowed reference to a value in a `RefCell` box.
-pub struct RefMut<'box, T> {
-    priv parent: &'box mut RefCell<T>
+pub struct RefMut<'b, T> {
+    priv parent: &'b mut RefCell<T>
 }
 
 #[unsafe_destructor]
-impl<'box, T> Drop for RefMut<'box, T> {
+impl<'b, T> Drop for RefMut<'b, T> {
     fn drop(&mut self) {
         assert!(self.parent.borrow == WRITING);
         self.parent.borrow = UNUSED;
     }
 }
 
-impl<'box, T> RefMut<'box, T> {
+impl<'b, T> RefMut<'b, T> {
     /// Retrieve a mutable reference to the stored value.
     #[inline]
     pub fn get<'a>(&'a mut self) -> &'a mut T {

src/libstd/cleanup.rs

@@ -30,26 +30,26 @@ struct AnnihilateStats {
 }
 
 unsafe fn each_live_alloc(read_next_before: bool,
-                          f: |box: *mut raw::Box<()>, uniq: bool| -> bool)
+                          f: |alloc: *mut raw::Box<()>, uniq: bool| -> bool)
                           -> bool {
     //! Walks the internal list of allocations
 
     use managed;
     use rt::local_heap;
 
-    let mut box = local_heap::live_allocs();
-    while box != ptr::mut_null() {
-        let next_before = (*box).next;
-        let uniq = (*box).ref_count == managed::RC_MANAGED_UNIQUE;
+    let mut alloc = local_heap::live_allocs();
+    while alloc != ptr::mut_null() {
+        let next_before = (*alloc).next;
+        let uniq = (*alloc).ref_count == managed::RC_MANAGED_UNIQUE;
 
-        if !f(box as *mut raw::Box<()>, uniq) {
+        if !f(alloc as *mut raw::Box<()>, uniq) {
             return false;
         }
 
         if read_next_before {
-            box = next_before;
+            alloc = next_before;
         } else {
-            box = (*box).next;
+            alloc = (*alloc).next;
         }
     }
     return true;
@@ -82,12 +82,12 @@ pub unsafe fn annihilate() {
     //
     // In this pass, nothing gets freed, so it does not matter whether
     // we read the next field before or after the callback.
-    each_live_alloc(true, |box, uniq| {
+    each_live_alloc(true, |alloc, uniq| {
         stats.n_total_boxes += 1;
         if uniq {
             stats.n_unique_boxes += 1;
         } else {
-            (*box).ref_count = managed::RC_IMMORTAL;
+            (*alloc).ref_count = managed::RC_IMMORTAL;
         }
         true
     });
@@ -97,10 +97,10 @@ pub unsafe fn annihilate() {
     // In this pass, unique-managed boxes may get freed, but not
     // managed boxes, so we must read the `next` field *after* the
     // callback, as the original value may have been freed.
-    each_live_alloc(false, |box, uniq| {
+    each_live_alloc(false, |alloc, uniq| {
         if !uniq {
-            let tydesc = (*box).type_desc;
-            let data = &(*box).data as *();
+            let tydesc = (*alloc).type_desc;
+            let data = &(*alloc).data as *();
             ((*tydesc).drop_glue)(data as *i8);
         }
         true
@@ -112,12 +112,12 @@ pub unsafe fn annihilate() {
     // unique-managed boxes, though I think that none of those are
     // left), so we must read the `next` field before, since it will
     // not be valid after.
-    each_live_alloc(true, |box, uniq| {
+    each_live_alloc(true, |alloc, uniq| {
         if !uniq {
             stats.n_bytes_freed +=
-                (*((*box).type_desc)).size
+                (*((*alloc).type_desc)).size
                 + mem::size_of::<raw::Box<()>>();
-            local_free(box as *i8);
+            local_free(alloc as *i8);
         }
         true
     });