---

yaml
---
r: 65982
b: refs/heads/master
c: eb48c29
h: refs/heads/master
v: v3

Author: nikomatsakis

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 682bb4144ca3fddffee8ed2927e7552049fcf25c
+refs/heads/master: eb48c296817be7529a1757ac8d4798112717eaa9
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 18e3db7392d2d0697b7e27d6d986139960144d85
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9

trunk/src/libextra/deque.rs

@@ -264,31 +264,31 @@ mod tests {
     fn test_parameterized<T:Copy + Eq>(a: T, b: T, c: T, d: T) {
         let mut deq = Deque::new();
         assert_eq!(deq.len(), 0);
-        deq.add_front(a);
-        deq.add_front(b);
-        deq.add_back(c);
+        deq.add_front(copy a);
+        deq.add_front(copy b);
+        deq.add_back(copy c);
         assert_eq!(deq.len(), 3);
-        deq.add_back(d);
+        deq.add_back(copy d);
         assert_eq!(deq.len(), 4);
-        assert_eq!(*deq.peek_front(), b);
-        assert_eq!(*deq.peek_back(), d);
-        assert_eq!(deq.pop_front(), b);
-        assert_eq!(deq.pop_back(), d);
-        assert_eq!(deq.pop_back(), c);
-        assert_eq!(deq.pop_back(), a);
+        assert_eq!(copy *deq.peek_front(), copy b);
+        assert_eq!(copy *deq.peek_back(), copy d);
+        assert_eq!(deq.pop_front(), copy b);
+        assert_eq!(deq.pop_back(), copy d);
+        assert_eq!(deq.pop_back(), copy c);
+        assert_eq!(deq.pop_back(), copy a);
         assert_eq!(deq.len(), 0);
-        deq.add_back(c);
+        deq.add_back(copy c);
         assert_eq!(deq.len(), 1);
-        deq.add_front(b);
+        deq.add_front(copy b);
         assert_eq!(deq.len(), 2);
-        deq.add_back(d);
+        deq.add_back(copy d);
         assert_eq!(deq.len(), 3);
-        deq.add_front(a);
+        deq.add_front(copy a);
         assert_eq!(deq.len(), 4);
-        assert_eq!(*deq.get(0), a);
-        assert_eq!(*deq.get(1), b);
-        assert_eq!(*deq.get(2), c);
-        assert_eq!(*deq.get(3), d);
+        assert_eq!(copy *deq.get(0), copy a);
+        assert_eq!(copy *deq.get(1), copy b);
+        assert_eq!(copy *deq.get(2), copy c);
+        assert_eq!(copy *deq.get(3), copy d);
     }
 
     #[deriving(Eq)]

trunk/src/libextra/dlist.rs

@@ -111,7 +111,8 @@ pub fn from_elem<T>(data: T) -> @mut DList<T> {
 /// Creates a new dlist from a vector of elements, maintaining the same order
 pub fn from_vec<T:Copy>(vec: &[T]) -> @mut DList<T> {
     do vec.iter().fold(DList()) |list,data| {
-        list.push(*data); // Iterating left-to-right -- add newly to the tail.
+        // Iterating left-to-right -- add newly to the tail.
+        list.push(copy *data);
         list
     }
 }
@@ -460,35 +461,35 @@ impl<T> DList<T> {
 impl<T:Copy> DList<T> {
     /// Remove data from the head of the list. O(1).
     pub fn pop(@mut self) -> Option<T> {
-        self.pop_n().map(|nobe| nobe.data)
+        self.pop_n().map(|nobe| copy nobe.data)
     }
 
     /// Remove data from the tail of the list. O(1).
     pub fn pop_tail(@mut self) -> Option<T> {
-        self.pop_tail_n().map(|nobe| nobe.data)
+        self.pop_tail_n().map(|nobe| copy nobe.data)
     }
 
     /// Get data at the list's head. O(1).
     pub fn peek(@mut self) -> Option<T> {
-        self.peek_n().map(|nobe| nobe.data)
+        self.peek_n().map(|nobe| copy nobe.data)
     }
 
     /// Get data at the list's tail. O(1).
     pub fn peek_tail(@mut self) -> Option<T> {
-        self.peek_tail_n().map (|nobe| nobe.data)
+        self.peek_tail_n().map (|nobe| copy nobe.data)
     }
 
     /// Get data at the list's head, failing if empty. O(1).
-    pub fn head(@mut self) -> T { self.head_n().data }
+    pub fn head(@mut self) -> T { copy self.head_n().data }
 
     /// Get data at the list's tail, failing if empty. O(1).
-    pub fn tail(@mut self) -> T { self.tail_n().data }
+    pub fn tail(@mut self) -> T { copy self.tail_n().data }
 
     /// Get the elements of the list as a vector. O(n).
     pub fn to_vec(@mut self) -> ~[T] {
         let mut v = vec::with_capacity(self.size);
         for old_iter::eachi(&self) |index,data| {
-            v[index] = *data;
+            v[index] = copy *data;
         }
         v
     }

trunk/src/libextra/future.rs

@@ -57,7 +57,7 @@ priv enum FutureState<A> {
 impl<A:Copy> Future<A> {
     pub fn get(&mut self) -> A {
         //! Get the value of the future.
-        *(self.get_ref())
+        copy *(self.get_ref())
     }
 }
 

trunk/src/libextra/list.rs

@@ -27,7 +27,7 @@ pub enum MutList<T> {
 
 /// Create a list from a vector
 pub fn from_vec<T:Copy>(v: &[T]) -> @List<T> {
-    v.rev_iter().fold(@Nil::<T>, |t, h| @Cons(*h, t))
+    v.rev_iter().fold(@Nil::<T>, |t, h| @Cons(copy *h, t))
 }
 
 /**
@@ -61,7 +61,7 @@ pub fn find<T:Copy>(ls: @List<T>, f: &fn(&T) -> bool) -> Option<T> {
     loop {
         ls = match *ls {
           Cons(ref hd, tl) => {
-            if f(hd) { return Some(*hd); }
+            if f(hd) { return Some(copy *hd); }
             tl
           }
           Nil => return None

trunk/src/libextra/smallintmap.rs

@@ -179,7 +179,7 @@ impl<V:Copy> SmallIntMap<V> {
                            ff: &fn(uint, V, V) -> V) -> bool {
         let new_val = match self.find(&key) {
             None => val,
-            Some(orig) => ff(key, *orig, val)
+            Some(orig) => ff(key, copy *orig, val)
         };
         self.insert(key, new_val)
     }

trunk/src/libextra/sort.rs

@@ -37,7 +37,7 @@ pub fn merge_sort<T:Copy>(v: &[T], le: Le<T>) -> ~[T] {
 
         let v_len = end - begin;
         if v_len == 0 { return ~[]; }
-        if v_len == 1 { return ~[v[begin]]; }
+        if v_len == 1 { return ~[copy v[begin]]; }
 
         let mid = v_len / 2 + begin;
         let a = (begin, mid);
@@ -53,9 +53,9 @@ pub fn merge_sort<T:Copy>(v: &[T], le: Le<T>) -> ~[T] {
         let mut b_ix = 0;
         while a_ix < a_len && b_ix < b_len {
             if le(&a[a_ix], &b[b_ix]) {
-                rs.push(a[a_ix]);
+                rs.push(copy a[a_ix]);
                 a_ix += 1;
-            } else { rs.push(b[b_ix]); b_ix += 1; }
+            } else { rs.push(copy b[b_ix]); b_ix += 1; }
         }
         rs.push_all(vec::slice(a, a_ix, a_len));
         rs.push_all(vec::slice(b, b_ix, b_len));
@@ -106,7 +106,7 @@ pub fn quick_sort<T>(arr: &mut [T], compare_func: Le<T>) {
 
 fn qsort3<T:Copy + Ord + Eq>(arr: &mut [T], left: int, right: int) {
     if right <= left { return; }
-    let v: T = arr[right];
+    let v: T = copy arr[right];
     let mut i: int = left - 1;
     let mut j: int = right;
     let mut p: int = i;
@@ -233,7 +233,7 @@ fn binarysort<T:Copy + Ord>(array: &mut [T], start: uint) {
     if start == 0 { start += 1; }
 
     while start < size {
-        let pivot = array[start];
+        let pivot = copy array[start];
         let mut left = 0;
         let mut right = start;
         assert!(left <= right);
@@ -470,7 +470,7 @@ impl<T:Copy + Ord> MergeState<T> {
 
         let mut tmp = ~[];
         for uint::range(base1, base1+len1) |i| {
-            tmp.push(array[i]);
+            tmp.push(copy array[i]);
         }
 
         let mut c1 = 0;
@@ -580,7 +580,7 @@ impl<T:Copy + Ord> MergeState<T> {
 
         let mut tmp = ~[];
         for uint::range(base2, base2+len2) |i| {
-            tmp.push(array[i]);
+            tmp.push(copy array[i]);
         }
 
         let mut c1 = base1 + len1 - 1;
@@ -732,7 +732,7 @@ fn copy_vec<T:Copy>(dest: &mut [T],
     assert!(s1+from.len() <= dest.len());
 
     for from.eachi |i, v| {
-        dest[s1+i] = *v;
+        dest[s1+i] = copy *v;
     }
 }
 
@@ -1045,7 +1045,7 @@ mod big_tests {
     fn multiplyVec<T:Copy>(arr: &[T], num: uint) -> ~[T] {
         let size = arr.len();
         let res = do vec::from_fn(num) |i| {
-            arr[i % size]
+            copy arr[i % size]
         };
         res
     }

trunk/src/librustc/metadata/encoder.rs

@@ -1184,7 +1184,7 @@ fn create_index<T:Copy + Hash + IterBytes>(index: ~[entry<T>]) ->
     for uint::range(0u, 256u) |_i| { buckets.push(@mut ~[]); };
     for index.each |elt| {
         let h = elt.val.hash() as uint;
-        buckets[h % 256].push(*elt);
+        buckets[h % 256].push(copy *elt);
     }
 
     let mut buckets_frozen = ~[];

trunk/src/librustc/middle/trans/debuginfo.rs

@@ -200,8 +200,8 @@ fn cached_metadata<T:Copy>(cache: metadata_cache,
         let items = cache.get(&mdtag);
         for items.each |item| {
             let md: T = md_from_metadata::<T>(*item);
-            if eq_fn(md) {
-                return option::Some(md);
+            if eq_fn(copy md) {
+                return option::Some(copy md);
             }
         }
     }

trunk/src/librustc/middle/ty.rs

@@ -3694,16 +3694,16 @@ fn lookup_locally_or_in_crate_store<V:Copy>(
      */
 
     match map.find(&def_id) {
-        Some(&v) => { return v; }
+        Some(&ref v) => { return copy *v; }
         None => { }
     }
 
     if def_id.crate == ast::local_crate {
         fail!("No def'n found for %? in tcx.%s", def_id, descr);
     }
     let v = load_external();
-    map.insert(def_id, v);
-    return v;
+    map.insert(def_id, copy v);
+    return copy v;
 }
 
 pub fn trait_method(cx: ctxt, trait_did: ast::def_id, idx: uint) -> @Method {