librustc: Remove identifiers named `box`, since it's about to become a keyword.

10 files changed, 75 insertions, 70 deletions

diff --git a/src/libstd/at_vec.rs b/src/libstd/at_vec.rs
index 352d1abfb4b..7b1d29b664b 100644
--- a/src/libstd/at_vec.rs
+++ b/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>()
     }
 }
 
diff --git a/src/libstd/cast.rs b/src/libstd/cast.rs
index 08276082ebb..fde3ed3f0fe 100644
--- a/src/libstd/cast.rs
+++ b/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_managed_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");
diff --git a/src/libstd/cell.rs b/src/libstd/cell.rs
index cf886fbebe1..1a87de63058 100644
--- a/src/libstd/cell.rs
+++ b/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 {
diff --git a/src/libstd/cleanup.rs b/src/libstd/cleanup.rs
index 7b01a5c1b81..fbcf7dd4e90 100644
--- a/src/libstd/cleanup.rs
+++ b/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
     });
diff --git a/src/libstd/local_data.rs b/src/libstd/local_data.rs
index c75e7dde251..87fe5ac6f22 100644
--- a/src/libstd/local_data.rs
+++ b/src/libstd/local_data.rs
@@ -157,13 +157,13 @@ pub fn pop<T: 'static>(key: Key<T>) -> Option<T> {
 
                 // Move `data` into transmute to get out the memory that it
                 // owns, we must free it manually later.
-                let (_vtable, box): (uint, ~T) = unsafe {
+                let (_vtable, alloc): (uint, ~T) = unsafe {
                     cast::transmute(data)
                 };
 
-                // Now that we own `box`, we can just move out of it as we would
-                // with any other data.
-                return Some(*box);
+                // Now that we own `alloc`, we can just move out of it as we
+                // would with any other data.
+                return Some(*alloc);
             }
             _ => {}
         }
@@ -254,8 +254,8 @@ fn get_with<T:'static,
                     // compiler coercions to achieve a '&' pointer.
                     unsafe {
                         match *cast::transmute::<&TLSValue, &(uint, ~T)>(data){
-                            (_vtable, ref box) => {
-                                let value: &T = *box;
+                            (_vtable, ref alloc) => {
+                                let value: &T = *alloc;
                                 ret = f(Some(value));
                             }
                         }
diff --git a/src/libstd/rt/borrowck.rs b/src/libstd/rt/borrowck.rs
index 82f92bdb803..423981d9e91 100644
--- a/src/libstd/rt/borrowck.rs
+++ b/src/libstd/rt/borrowck.rs
@@ -28,7 +28,7 @@ static ALL_BITS: uint = FROZEN_BIT | MUT_BIT;
 
 #[deriving(Eq)]
 pub struct BorrowRecord {
-    priv box: *mut raw::Box<()>,
+    priv alloc: *mut raw::Box<()>,
     file: *c_char,
     priv line: size_t
 }
@@ -55,8 +55,9 @@ pub fn clear_task_borrow_list() {
 }
 
 #[cold]
-unsafe fn fail_borrowed(box: *mut raw::Box<()>, file: *c_char, line: size_t) -> ! {
-    debug_borrow("fail_borrowed: ", box, 0, 0, file, line);
+unsafe fn fail_borrowed(alloc: *mut raw::Box<()>, file: *c_char, line: size_t)
+                        -> ! {
+    debug_borrow("fail_borrowed: ", alloc, 0, 0, file, line);
 
     match try_take_task_borrow_list() {
         None => { // not recording borrows
@@ -67,7 +68,7 @@ unsafe fn fail_borrowed(box: *mut raw::Box<()>, file: *c_char, line: size_t) ->
             let mut msg = ~"borrowed";
             let mut sep = " at ";
             for entry in borrow_list.rev_iter() {
-                if entry.box == box {
+                if entry.alloc == alloc {
                     msg.push_str(sep);
                     let filename = str::raw::from_c_str(entry.file);
                     msg.push_str(filename);
@@ -153,7 +154,11 @@ pub unsafe fn record_borrow(a: *u8, old_ref_count: uint,
         debug_borrow("record_borrow:", a, old_ref_count, 0, file, line);
         swap_task_borrow_list(|borrow_list| {
             let mut borrow_list = borrow_list;
-            borrow_list.push(BorrowRecord {box: a, file: file, line: line});
+            borrow_list.push(BorrowRecord {
+                alloc: a,
+                file: file,
+                line: line,
+            });
             borrow_list
         })
     }
@@ -172,7 +177,7 @@ pub unsafe fn unrecord_borrow(a: *u8,
             let mut borrow_list = borrow_list;
             assert!(!borrow_list.is_empty());
             let br = borrow_list.pop();
-            if br.box != a || br.file != file || br.line != line {
+            if br.alloc != a || br.file != file || br.line != line {
                 let err = format!("wrong borrow found, br={:?}", br);
                 err.with_c_str(|msg_p| {
                     task::begin_unwind_raw(msg_p, file, line)
diff --git a/src/libstd/rt/deque.rs b/src/libstd/rt/deque.rs
index 44672984b64..770fc9ffa12 100644
--- a/src/libstd/rt/deque.rs
+++ b/src/libstd/rt/deque.rs
@@ -599,9 +599,9 @@ mod tests {
 
         let (threads, hits) = vec::unzip(range(0, NTHREADS).map(|_| {
             let s = s.clone();
-            let box = ~AtomicUint::new(0);
+            let unique_box = ~AtomicUint::new(0);
             let thread_box = unsafe {
-                *cast::transmute::<&~AtomicUint, **mut AtomicUint>(&box)
+                *cast::transmute::<&~AtomicUint,**mut AtomicUint>(&unique_box)
             };
             (do Thread::start {
                 unsafe {
@@ -617,7 +617,7 @@ mod tests {
                         }
                     }
                 }
-            }, box)
+            }, unique_box)
         }));
 
         let mut rng = rand::task_rng();
diff --git a/src/libstd/rt/global_heap.rs b/src/libstd/rt/global_heap.rs
index 3147e3c8a07..385bb0b276c 100644
--- a/src/libstd/rt/global_heap.rs
+++ b/src/libstd/rt/global_heap.rs
@@ -78,10 +78,10 @@ pub unsafe fn closure_exchange_malloc(td: *c_char, size: uintptr_t) -> *c_char {
     let total_size = get_box_size(size, (*td).align);
     let p = malloc_raw(total_size as uint);
 
-    let box = p as *mut raw::Box<()>;
-    (*box).type_desc = td;
+    let alloc = p as *mut raw::Box<()>;
+    (*alloc).type_desc = td;
 
-    box as *c_char
+    alloc as *c_char
 }
 
 // NB: Calls to free CANNOT be allowed to fail, as throwing an exception from
diff --git a/src/libstd/rt/local_heap.rs b/src/libstd/rt/local_heap.rs
index e364137de45..f2edc6e7ede 100644
--- a/src/libstd/rt/local_heap.rs
+++ b/src/libstd/rt/local_heap.rs
@@ -59,10 +59,10 @@ impl LocalHeap {
 
     pub fn alloc(&mut self, td: *TyDesc, size: uint) -> *mut Box {
         let total_size = global_heap::get_box_size(size, unsafe { (*td).align });
-        let box = self.memory_region.malloc(total_size);
+        let alloc = self.memory_region.malloc(total_size);
         {
             // Make sure that we can't use `mybox` outside of this scope
-            let mybox: &mut Box = unsafe { cast::transmute(box) };
+            let mybox: &mut Box = unsafe { cast::transmute(alloc) };
             // Clear out this box, and move it to the front of the live
             // allocations list
             mybox.type_desc = td;
@@ -70,11 +70,11 @@ impl LocalHeap {
             mybox.prev = ptr::mut_null();
             mybox.next = self.live_allocs;
             if !self.live_allocs.is_null() {
-                unsafe { (*self.live_allocs).prev = box; }
+                unsafe { (*self.live_allocs).prev = alloc; }
             }
-            self.live_allocs = box;
+            self.live_allocs = alloc;
         }
-        return box;
+        return alloc;
     }
 
     pub fn realloc(&mut self, ptr: *mut Box, size: uint) -> *mut Box {
@@ -97,10 +97,10 @@ impl LocalHeap {
         return new_box;
     }
 
-    pub fn free(&mut self, box: *mut Box) {
+    pub fn free(&mut self, alloc: *mut Box) {
         {
             // Make sure that we can't use `mybox` outside of this scope
-            let mybox: &mut Box = unsafe { cast::transmute(box) };
+            let mybox: &mut Box = unsafe { cast::transmute(alloc) };
             assert!(!mybox.type_desc.is_null());
 
             // Unlink it from the linked list
@@ -110,7 +110,7 @@ impl LocalHeap {
             if !mybox.next.is_null() {
                 unsafe { (*mybox.next).prev = mybox.prev; }
             }
-            if self.live_allocs == box {
+            if self.live_allocs == alloc {
                 self.live_allocs = mybox.next;
             }
 
@@ -126,7 +126,7 @@ impl LocalHeap {
             mybox.type_desc = ptr::null();
         }
 
-        self.memory_region.free(box);
+        self.memory_region.free(alloc);
     }
 }
 
@@ -175,7 +175,7 @@ impl AllocHeader {
     #[cfg(not(rtdebug))]
     fn update_size(&mut self, _size: u32) {}
 
-    fn box(&mut self) -> *mut Box {
+    fn as_box(&mut self) -> *mut Box {
         let myaddr: uint = unsafe { cast::transmute(self) };
         (myaddr + AllocHeader::size()) as *mut Box
     }
@@ -187,8 +187,8 @@ impl AllocHeader {
         return (header_size + ptr_size - 1) / ptr_size * ptr_size;
     }
 
-    fn from(box: *mut Box) -> *mut AllocHeader {
-        (box as uint - AllocHeader::size()) as *mut AllocHeader
+    fn from(a_box: *mut Box) -> *mut AllocHeader {
+        (a_box as uint - AllocHeader::size()) as *mut AllocHeader
     }
 }
 
@@ -204,12 +204,12 @@ impl MemoryRegion {
         self.claim(alloc);
         self.live_allocations += 1;
 
-        return alloc.box();
+        return alloc.as_box();
     }
 
-    fn realloc(&mut self, box: *mut Box, size: uint) -> *mut Box {
-        rtassert!(!box.is_null());
-        let orig_alloc = AllocHeader::from(box);
+    fn realloc(&mut self, alloc: *mut Box, size: uint) -> *mut Box {
+        rtassert!(!alloc.is_null());
+        let orig_alloc = AllocHeader::from(alloc);
         unsafe { (*orig_alloc).assert_sane(); }
 
         let total_size = size + AllocHeader::size();
@@ -222,12 +222,12 @@ impl MemoryRegion {
         alloc.assert_sane();
         alloc.update_size(size as u32);
         self.update(alloc, orig_alloc as *AllocHeader);
-        return alloc.box();
+        return alloc.as_box();
     }
 
-    fn free(&mut self, box: *mut Box) {
-        rtassert!(!box.is_null());
-        let alloc = AllocHeader::from(box);
+    fn free(&mut self, alloc: *mut Box) {
+        rtassert!(!alloc.is_null());
+        let alloc = AllocHeader::from(alloc);
         unsafe {
             (*alloc).assert_sane();
             self.release(cast::transmute(alloc));
diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs
index 1b238ede049..be9adc91e03 100644
--- a/src/libstd/vec.rs
+++ b/src/libstd/vec.rs
@@ -2280,10 +2280,10 @@ pub mod raw {
      */
     #[inline]
     pub unsafe fn init_elem<T>(v: &mut [T], i: uint, val: T) {
-        let mut box = Some(val);
+        let mut alloc = Some(val);
         v.as_mut_buf(|p, _len| {
             intrinsics::move_val_init(&mut(*ptr::mut_offset(p, i as int)),
-                                      box.take_unwrap());
+                                      alloc.take_unwrap());
         })
     }