auto merge of #13773 : brson/rust/boxxy, r=alexcrichton

`box` is the way you allocate in future-rust.

Author: bors

src/etc/emacs/rust-mode.el

@@ -169,7 +169,7 @@
 ;; Font-locking definitions and helpers
 (defconst rust-mode-keywords
   '("as"
-    "break"
+    "box" "break"
     "continue" "crate"
     "do"
     "else" "enum" "extern"

src/libarena/lib.rs

@@ -517,7 +517,7 @@ mod tests {
     #[bench]
     pub fn bench_copy_nonarena(b: &mut Bencher) {
         b.iter(|| {
-            ~Point {
+            box Point {
                 x: 1,
                 y: 2,
                 z: 3,
@@ -569,7 +569,7 @@ mod tests {
     #[bench]
     pub fn bench_noncopy_nonarena(b: &mut Bencher) {
         b.iter(|| {
-            ~Noncopy {
+            box Noncopy {
                 string: "hello world".to_owned(),
                 array: vec!( 1, 2, 3, 4, 5 ),
             }

src/libcollections/btree.rs

@@ -377,8 +377,8 @@ impl<K: Clone + TotalOrd, V: Clone> Leaf<K, V> {
                                                               == Less);
             let branch_return = Node::new_branch(vec!(BranchElt::new(midpoint.key.clone(),
                                                                   midpoint.value.clone(),
-                                                             ~Node::new_leaf(left_leaf))),
-                                            ~Node::new_leaf(right_leaf));
+                                                             box Node::new_leaf(left_leaf))),
+                                            box Node::new_leaf(right_leaf));
             return (branch_return, true);
         }
         (Node::new_leaf(self.elts.clone()), true)
@@ -540,10 +540,10 @@ impl<K: Clone + TotalOrd, V: Clone> Branch<K, V> {
                     //so we can return false.
                     LeafNode(..) => {
                         if index.unwrap() == self.elts.len() {
-                            self.rightmost_child = ~new_branch.clone();
+                            self.rightmost_child = box new_branch.clone();
                         }
                         else {
-                            self.elts.get_mut(index.unwrap()).left = ~new_branch.clone();
+                            self.elts.get_mut(index.unwrap()).left = box new_branch.clone();
                         }
                         return (Node::new_branch(self.clone().elts,
                                                  self.clone().rightmost_child),
@@ -561,10 +561,10 @@ impl<K: Clone + TotalOrd, V: Clone> Branch<K, V> {
                 //and return it, saying we have inserted a new element.
                 LeafNode(..) => {
                     if index.unwrap() == self.elts.len() {
-                        self.rightmost_child = ~new_branch;
+                        self.rightmost_child = box new_branch;
                     }
                     else {
-                        self.elts.get_mut(index.unwrap()).left = ~new_branch;
+                        self.elts.get_mut(index.unwrap()).left = box new_branch;
                     }
                     return (Node::new_branch(self.clone().elts,
                                              self.clone().rightmost_child),
@@ -604,9 +604,9 @@ impl<K: Clone + TotalOrd, V: Clone> Branch<K, V> {
                 new_branch = Node::new_branch(
                     vec!(BranchElt::new(midpoint.clone().key,
                                      midpoint.clone().value,
-                                     ~Node::new_branch(new_left,
+                                     box Node::new_branch(new_left,
                                                        midpoint.clone().left))),
-                    ~Node::new_branch(new_right, self.clone().rightmost_child));
+                    box Node::new_branch(new_right, self.clone().rightmost_child));
                 return (new_branch, true);
             }
         }

src/libcollections/dlist.rs

@@ -238,7 +238,7 @@ impl<T> Deque<T> for DList<T> {
     ///
     /// O(1)
     fn push_front(&mut self, elt: T) {
-        self.push_front_node(~Node::new(elt))
+        self.push_front_node(box Node::new(elt))
     }
 
     /// Remove the first element and return it, or None if the list is empty
@@ -252,7 +252,7 @@ impl<T> Deque<T> for DList<T> {
     ///
     /// O(1)
     fn push_back(&mut self, elt: T) {
-        self.push_back_node(~Node::new(elt))
+        self.push_back_node(box Node::new(elt))
     }
 
     /// Remove the last element and return it, or None if the list is empty
@@ -555,7 +555,7 @@ impl<'a, A> MutItems<'a, A> {
 impl<'a, A> ListInsertion<A> for MutItems<'a, A> {
     #[inline]
     fn insert_next(&mut self, elt: A) {
-        self.insert_next_node(~Node::new(elt))
+        self.insert_next_node(box Node::new(elt))
     }
 
     #[inline]
@@ -675,19 +675,19 @@ mod tests {
         assert_eq!(m.pop_front(), None);
         assert_eq!(m.pop_back(), None);
         assert_eq!(m.pop_front(), None);
-        m.push_front(~1);
+        m.push_front(box 1);
         assert_eq!(m.pop_front(), Some(~1));
-        m.push_back(~2);
-        m.push_back(~3);
+        m.push_back(box 2);
+        m.push_back(box 3);
         assert_eq!(m.len(), 2);
         assert_eq!(m.pop_front(), Some(~2));
         assert_eq!(m.pop_front(), Some(~3));
         assert_eq!(m.len(), 0);
         assert_eq!(m.pop_front(), None);
-        m.push_back(~1);
-        m.push_back(~3);
-        m.push_back(~5);
-        m.push_back(~7);
+        m.push_back(box 1);
+        m.push_back(box 3);
+        m.push_back(box 5);
+        m.push_back(box 7);
         assert_eq!(m.pop_front(), Some(~1));
 
         let mut n = DList::new();

src/libcollections/lru_cache.rs

@@ -93,7 +93,7 @@ impl<K: Hash + TotalEq, V> LruCache<K, V> {
         let cache = LruCache {
             map: HashMap::new(),
             max_size: capacity,
-            head: unsafe{ cast::transmute(~mem::uninit::<LruEntry<K, V>>()) },
+            head: unsafe{ cast::transmute(box mem::uninit::<LruEntry<K, V>>()) },
         };
         unsafe {
             (*cache.head).next = cache.head;
@@ -111,7 +111,7 @@ impl<K: Hash + TotalEq, V> LruCache<K, V> {
                 (node_ptr, None)
             }
             None => {
-                let mut node = ~LruEntry::new(k, v);
+                let mut node = box LruEntry::new(k, v);
                 let node_ptr: *mut LruEntry<K, V> = &mut *node;
                 (node_ptr, Some(node))
             }

src/libcollections/priority_queue.rs

@@ -273,19 +273,19 @@ mod tests {
         let mut heap = PriorityQueue::from_vec(vec!(~2, ~4, ~9));
         assert_eq!(heap.len(), 3);
         assert!(*heap.top() == ~9);
-        heap.push(~11);
+        heap.push(box 11);
         assert_eq!(heap.len(), 4);
         assert!(*heap.top() == ~11);
-        heap.push(~5);
+        heap.push(box 5);
         assert_eq!(heap.len(), 5);
         assert!(*heap.top() == ~11);
-        heap.push(~27);
+        heap.push(box 27);
         assert_eq!(heap.len(), 6);
         assert!(*heap.top() == ~27);
-        heap.push(~3);
+        heap.push(box 3);
         assert_eq!(heap.len(), 7);
         assert!(*heap.top() == ~27);
-        heap.push(~103);
+        heap.push(box 103);
         assert_eq!(heap.len(), 8);
         assert!(*heap.top() == ~103);
     }

src/libcollections/smallintmap.rs

@@ -459,7 +459,7 @@ mod test_map {
     #[test]
     fn test_move_iter() {
         let mut m = SmallIntMap::new();
-        m.insert(1, ~2);
+        m.insert(1, box 2);
         let mut called = false;
         for (k, v) in m.move_iter() {
             assert!(!called);
@@ -468,7 +468,7 @@ mod test_map {
             assert_eq!(v, ~2);
         }
         assert!(called);
-        m.insert(2, ~1);
+        m.insert(2, box 1);
     }
 }
 

src/libcollections/treemap.rs

@@ -834,7 +834,7 @@ fn insert<K: TotalOrd, V>(node: &mut Option<~TreeNode<K, V>>,
         }
       }
       None => {
-       *node = Some(~TreeNode::new(key, value));
+       *node = Some(box TreeNode::new(key, value));
         None
       }
     }

src/libcollections/trie.rs

@@ -448,7 +448,7 @@ fn insert<T>(count: &mut uint, child: &mut Child<T>, key: uint, value: T,
     // have to move out of `child`.
     match mem::replace(child, Nothing) {
         External(stored_key, stored_value) => {
-            let mut new = ~TrieNode::new();
+            let mut new = box TrieNode::new();
             insert(&mut new.count,
                    &mut new.children[chunk(stored_key, idx)],
                    stored_key, stored_value, idx + 1);

src/libgreen/basic.rs

@@ -23,7 +23,7 @@ use std::unstable::sync::Exclusive;
 
 /// This is the only exported function from this module.
 pub fn event_loop() -> ~EventLoop:Send {
-    ~BasicLoop::new() as ~EventLoop:Send
+    box BasicLoop::new() as ~EventLoop:Send
 }
 
 struct BasicLoop {
@@ -143,7 +143,7 @@ impl EventLoop for BasicLoop {
     fn pausable_idle_callback(&mut self, cb: ~Callback:Send)
         -> ~PausableIdleCallback:Send
     {
-        let callback = ~BasicPausable::new(self, cb);
+        let callback = box BasicPausable::new(self, cb);
         rtassert!(self.idle.is_none());
         unsafe {
             let cb_ptr: &*mut BasicPausable = cast::transmute(&callback);
@@ -156,7 +156,7 @@ impl EventLoop for BasicLoop {
         let id = self.next_remote;
         self.next_remote += 1;
         self.remotes.push((id, f));
-        ~BasicRemote::new(self.messages.clone(), id) as ~RemoteCallback:Send
+        box BasicRemote::new(self.messages.clone(), id) as ~RemoteCallback:Send
     }
 
     fn io<'a>(&'a mut self) -> Option<&'a mut IoFactory> { None }