---

yaml
---
r: 30276
b: refs/heads/incoming
c: 49c9ac1
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: d324a424d8f84b1eb049b12cf34182bda91b0024
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
-refs/heads/incoming: ffa5d76a784512f1e6a5de50d2e058270f3fd92f
+refs/heads/incoming: 49c9ac175f07505f2113feaca3546d4b8b44dfa8
 refs/heads/dist-snap: 2f32a1581f522e524009138b33b1c7049ced668d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/src/libcore/flate.rs

@@ -55,6 +55,7 @@ fn inflate_buf(buf: &[const u8]) -> ~[u8] {
 }
 
 #[test]
+#[allow(non_implicitly_copyable_typarams)]
 fn test_flate_round_trip() {
     let r = rand::Rng();
     let mut words = ~[];

branches/incoming/src/libcore/future.rs

@@ -174,66 +174,69 @@ proto! future_pipe (
     }
 )
 
-#[test]
-fn test_from_value() {
-    let f = from_value(~"snail");
-    assert get(&f) == ~"snail";
-}
+#[allow(non_implicitly_copyable_typarams)]
+mod test {
+    #[test]
+    fn test_from_value() {
+        let f = from_value(~"snail");
+        assert get(&f) == ~"snail";
+    }
 
-#[test]
-fn test_from_port() {
-    let (po, ch) = future_pipe::init();
-    future_pipe::server::completed(ch, ~"whale");
-    let f = from_port(po);
-    assert get(&f) == ~"whale";
-}
+    #[test]
+    fn test_from_port() {
+        let (po, ch) = future_pipe::init();
+        future_pipe::server::completed(ch, ~"whale");
+        let f = from_port(po);
+        assert get(&f) == ~"whale";
+    }
 
-#[test]
-fn test_from_fn() {
-    let f = from_fn(|| ~"brail");
-    assert get(&f) == ~"brail";
-}
+    #[test]
+    fn test_from_fn() {
+        let f = from_fn(|| ~"brail");
+        assert get(&f) == ~"brail";
+    }
 
-#[test]
-fn test_interface_get() {
-    let f = from_value(~"fail");
-    assert f.get() == ~"fail";
-}
+    #[test]
+    fn test_interface_get() {
+        let f = from_value(~"fail");
+        assert f.get() == ~"fail";
+    }
 
-#[test]
-fn test_with() {
-    let f = from_value(~"nail");
-    assert with(&f, |v| *v) == ~"nail";
-}
+    #[test]
+    fn test_with() {
+        let f = from_value(~"nail");
+        assert with(&f, |v| copy *v) == ~"nail";
+    }
 
-#[test]
-fn test_get_ref_method() {
-    let f = from_value(22);
-    assert *f.get_ref() == 22;
-}
+    #[test]
+    fn test_get_ref_method() {
+        let f = from_value(22);
+        assert *f.get_ref() == 22;
+    }
 
-#[test]
-fn test_get_ref_fn() {
-    let f = from_value(22);
-    assert *get_ref(&f) == 22;
-}
+    #[test]
+    fn test_get_ref_fn() {
+        let f = from_value(22);
+        assert *get_ref(&f) == 22;
+    }
 
-#[test]
-fn test_interface_with() {
-    let f = from_value(~"kale");
-    assert f.with(|v| *v) == ~"kale";
-}
+    #[test]
+    fn test_interface_with() {
+        let f = from_value(~"kale");
+        assert f.with(|v| copy *v) == ~"kale";
+    }
 
-#[test]
-fn test_spawn() {
-    let f = spawn(|| ~"bale");
-    assert get(&f) == ~"bale";
-}
+    #[test]
+    fn test_spawn() {
+        let f = spawn(|| ~"bale");
+        assert get(&f) == ~"bale";
+    }
 
-#[test]
-#[should_fail]
-#[ignore(cfg(target_os = "win32"))]
-fn test_futurefail() {
-    let f = spawn(|| fail);
-    let _x: ~str = get(&f);
-}
+    #[test]
+    #[should_fail]
+    #[ignore(cfg(target_os = "win32"))]
+    fn test_futurefail() {
+        let f = spawn(|| fail);
+        let _x: ~str = get(&f);
+    }
+}

branches/incoming/src/libcore/os.rs

@@ -827,6 +827,7 @@ fn arch() -> ~str { ~"x86_64" }
 fn arch() -> str { ~"arm" }
 
 #[cfg(test)]
+#[allow(non_implicitly_copyable_typarams)]
 mod tests {
 
     #[test]
@@ -893,7 +894,7 @@ mod tests {
         let e = env();
         assert vec::len(e) > 0u;
         for vec::each(e) |p| {
-            let (n, v) = p;
+            let (n, v) = copy p;
             log(debug, n);
             let v2 = getenv(n);
             // MingW seems to set some funky environment variables like
@@ -909,7 +910,7 @@ mod tests {
 
         let mut e = env();
         setenv(n, ~"VALUE");
-        assert !vec::contains(e, (n, ~"VALUE"));
+        assert !vec::contains(e, (copy n, ~"VALUE"));
 
         e = env();
         assert vec::contains(e, (n, ~"VALUE"));

branches/incoming/src/libcore/result.rs

@@ -376,6 +376,7 @@ impl<T:Eq,U:Eq> Result<T,U> : Eq {
 }
 
 #[cfg(test)]
+#[allow(non_implicitly_copyable_typarams)]
 mod tests {
     fn op1() -> result::Result<int, ~str> { result::Ok(666) }
 

branches/incoming/src/libcore/str.rs

@@ -3099,7 +3099,7 @@ mod tests {
                0x000a_u16 ]) ];
 
         for vec::each(pairs) |p| {
-            let (s, u) = p;
+            let (s, u) = copy p;
             assert to_utf16(s) == u;
             assert from_utf16(u) == s;
             assert from_utf16(to_utf16(s)) == s;

branches/incoming/src/libcore/to_str.rs

@@ -84,6 +84,7 @@ impl<A: ToStr> ~A: ToStr {
 }
 
 #[cfg(test)]
+#[allow(non_implicitly_copyable_typarams)]
 mod tests {
     #[test]
     fn test_simple_types() {

branches/incoming/src/libcore/tuple.rs

@@ -144,6 +144,7 @@ impl<A: Ord, B: Ord, C: Ord> (A, B, C): Ord {
 }
 
 #[test]
+#[allow(non_implicitly_copyable_typarams)]
 fn test_tuple() {
     assert (948, 4039.48).first() == 948;
     assert (34.5, ~"foo").second() == ~"foo";

branches/incoming/src/libcore/vec.rs

@@ -2381,19 +2381,19 @@ mod tests {
         let mut results: ~[~[int]];
 
         results = ~[];
-        permute(~[], |v| vec::push(results, v));
+        permute(~[], |v| vec::push(results, copy v));
         assert results == ~[~[]];
 
         results = ~[];
-        permute(~[7], |v| results += ~[v]);
+        permute(~[7], |v| results += ~[copy v]);
         assert results == ~[~[7]];
 
         results = ~[];
-        permute(~[1,1], |v| results += ~[v]);
+        permute(~[1,1], |v| results += ~[copy v]);
         assert results == ~[~[1,1],~[1,1]];
 
         results = ~[];
-        permute(~[5,2,0], |v| results += ~[v]);
+        permute(~[5,2,0], |v| results += ~[copy v]);
         assert results ==
             ~[~[5,2,0],~[5,0,2],~[2,5,0],~[2,0,5],~[0,5,2],~[0,2,5]];
     }