---

yaml
---
r: 23663
b: refs/heads/master
c: aea4220
h: refs/heads/master
i:
  23661: 62ab21d
  23659: 3573822
  23655: 22fdf99
  23647: df9ef05
v: v3

Author: brson

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 134e5c85a24cd622c2ce4e47d52bd2a1bb0e63e8
+refs/heads/master: aea422014bb16a799522acbae3c7986052dde056
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
 refs/heads/try: ffbe0e0e00374358b789b0037bcb3a577cd218be

trunk/src/cargo/cargo.rs

@@ -1499,8 +1499,7 @@ fn print_pkg(s: source, p: package) {
 fn print_source(s: source) {
     info(s.name + ~" (" + s.url + ~")");
 
-    let unsorted_pks = s.packages;  // to prevent illegal borrow?
-    let pks = sort::merge_sort(sys::shape_lt, unsorted_pks);
+    let pks = sort::merge_sort(sys::shape_lt, copy s.packages);
     let l = vec::len(pks);
 
     print(io::with_str_writer(|writer| {

trunk/src/libstd/base64.rs

@@ -1,5 +1,3 @@
-#[forbid(deprecated_mode)];
-#[forbid(deprecated_pattern)];
 #[deny(non_camel_case_types)];
 import io::Reader;
 

trunk/src/libstd/cell.rs

@@ -1,5 +1,3 @@
-#[forbid(deprecated_mode)];
-#[forbid(deprecated_pattern)];
 /// A dynamic, mutable location.
 ///
 /// Similar to a mutable option type, but friendlier.

trunk/src/libstd/fun_treemap.rs

@@ -1,6 +1,4 @@
 #[deny(non_camel_case_types)];
-#[forbid(deprecated_mode)];
-#[forbid(deprecated_pattern)];
 
 /*!
  * A functional key,value store that works on anything.
@@ -34,8 +32,8 @@ enum TreeNode<K, V> {
 fn init<K, V>() -> Treemap<K, V> { @Empty }
 
 /// Insert a value into the map
-fn insert<K: copy Eq Ord, V: copy>(m: Treemap<K, V>, +k: K, +v: V)
-  -> Treemap<K, V> {
+fn insert<K: copy Eq Ord, V: copy>(m: Treemap<K, V>, k: K, v: V)
+                                -> Treemap<K, V> {
     @match m {
        @Empty => Node(@k, @v, @Empty, @Empty),
        @Node(@kk, vv, left, right) => {
@@ -49,7 +47,7 @@ fn insert<K: copy Eq Ord, V: copy>(m: Treemap<K, V>, +k: K, +v: V)
 }
 
 /// Find a value based on the key
-fn find<K: Eq Ord, V: copy>(m: Treemap<K, V>, +k: K) -> Option<V> {
+fn find<K: Eq Ord, V: copy>(m: Treemap<K, V>, k: K) -> Option<V> {
     match *m {
       Empty => None,
       Node(@kk, @v, left, right) => {

trunk/src/libstd/map.rs

@@ -1,7 +1,6 @@
 //! A map type
 
-#[forbid(deprecated_mode)];
-#[forbid(deprecated_pattern)];
+#[warn(deprecated_mode)];
 
 import io::WriterUtil;
 import to_str::ToStr;

trunk/src/libstd/sort.rs

@@ -1,7 +1,4 @@
 //! Sorting methods
-#[forbid(deprecated_mode)];
-#[forbid(deprecated_pattern)];
-
 import vec::{len, push};
 import core::cmp::{Eq, Ord};
 
@@ -18,12 +15,12 @@ type le<T> = pure fn(v1: &T, v2: &T) -> bool;
  * Has worst case O(n log n) performance, best case O(n), but
  * is not space efficient. This is a stable sort.
  */
-fn merge_sort<T: copy>(le: le<T>, v: &[const T]) -> ~[T] {
+fn merge_sort<T: copy>(le: le<T>, v: ~[const T]) -> ~[T] {
     type slice = (uint, uint);
 
     return merge_sort_(le, v, (0u, len(v)));
 
-    fn merge_sort_<T: copy>(le: le<T>, v: &[const T], slice: slice)
+    fn merge_sort_<T: copy>(le: le<T>, v: ~[const T], slice: slice)
         -> ~[T] {
         let begin = slice.first();
         let end = slice.second();
@@ -38,7 +35,7 @@ fn merge_sort<T: copy>(le: le<T>, v: &[const T]) -> ~[T] {
         return merge(le, merge_sort_(le, v, a), merge_sort_(le, v, b));
     }
 
-    fn merge<T: copy>(le: le<T>, a: &[T], b: &[T]) -> ~[T] {
+    fn merge<T: copy>(le: le<T>, a: ~[T], b: ~[T]) -> ~[T] {
         let mut rs = ~[];
         vec::reserve(rs, len(a) + len(b));
         let a_len = len(a);
@@ -57,7 +54,7 @@ fn merge_sort<T: copy>(le: le<T>, v: &[const T]) -> ~[T] {
     }
 }
 
-fn part<T: copy>(compare_func: le<T>, arr: &[mut T], left: uint,
+fn part<T: copy>(compare_func: le<T>, arr: ~[mut T], left: uint,
                 right: uint, pivot: uint) -> uint {
     let pivot_value = arr[pivot];
     arr[pivot] <-> arr[right];
@@ -74,7 +71,7 @@ fn part<T: copy>(compare_func: le<T>, arr: &[mut T], left: uint,
     return storage_index;
 }
 
-fn qsort<T: copy>(compare_func: le<T>, arr: &[mut T], left: uint,
+fn qsort<T: copy>(compare_func: le<T>, arr: ~[mut T], left: uint,
              right: uint) {
     if right > left {
         let pivot = (left + right) / 2u;
@@ -93,12 +90,12 @@ fn qsort<T: copy>(compare_func: le<T>, arr: &[mut T], left: uint,
  * Has worst case O(n^2) performance, average case O(n log n).
  * This is an unstable sort.
  */
-fn quick_sort<T: copy>(compare_func: le<T>, arr: &[mut T]) {
+fn quick_sort<T: copy>(compare_func: le<T>, arr: ~[mut T]) {
     if len::<T>(arr) == 0u { return; }
     qsort::<T>(compare_func, arr, 0u, len::<T>(arr) - 1u);
 }
 
-fn qsort3<T: copy Ord Eq>(arr: &[mut T], left: int, right: int) {
+fn qsort3<T: copy Ord Eq>(arr: ~[mut T], left: int, right: int) {
     if right <= left { return; }
     let v: T = arr[right];
     let mut i: int = left - 1;
@@ -155,14 +152,14 @@ fn qsort3<T: copy Ord Eq>(arr: &[mut T], left: int, right: int) {
  *
  * This is an unstable sort.
  */
-fn quick_sort3<T: copy Ord Eq>(arr: &[mut T]) {
+fn quick_sort3<T: copy Ord Eq>(arr: ~[mut T]) {
     if arr.len() <= 1 { return; }
     qsort3(arr, 0, (arr.len() - 1) as int);
 }
 
 #[cfg(test)]
 mod test_qsort3 {
-    fn check_sort(v1: &[mut int], v2: &[mut int]) {
+    fn check_sort(v1: ~[mut int], v2: ~[mut int]) {
         let len = vec::len::<int>(v1);
         quick_sort3::<int>(v1);
         let mut i = 0u;
@@ -201,7 +198,7 @@ mod test_qsort3 {
 
 #[cfg(test)]
 mod test_qsort {
-    fn check_sort(v1: &[mut int], v2: &[mut int]) {
+    fn check_sort(v1: ~[mut int], v2: ~[mut int]) {
         let len = vec::len::<int>(v1);
         pure fn leual(a: &int, b: &int) -> bool { *a <= *b }
         quick_sort::<int>(leual, v1);
@@ -261,7 +258,7 @@ mod test_qsort {
 #[cfg(test)]
 mod tests {
 
-    fn check_sort(v1: &[int], v2: &[int]) {
+    fn check_sort(v1: ~[int], v2: ~[int]) {
         let len = vec::len::<int>(v1);
         pure fn le(a: &int, b: &int) -> bool { *a <= *b }
         let f = le;

trunk/src/libstd/unicode.rs

@@ -1,5 +1,3 @@
-#[forbid(deprecated_mode)];
-#[forbid(deprecated_pattern)];
 
 mod icu {
     type UBool = u8;
@@ -233,4 +231,4 @@ mod tests {
         assert (unicode::icu::is_upper('M'));
         assert (!unicode::icu::is_upper('m'));
     }
-}
+}

trunk/src/test/run-pass/issue-2989.rs

@@ -0,0 +1,33 @@
+use std;
+
+trait methods {
+    fn to_bytes() -> ~[u8];
+}
+
+impl (): methods {
+    fn to_bytes() -> ~[u8] {
+        vec::from_elem(0, 0)
+    }
+}
+
+// the position of this function is significant! - if it comes before methods
+// then it works, if it comes after it then it doesnt!
+fn to_bools(bitv: {storage: ~[u64]}) -> ~[bool] {
+    vec::from_fn(8, |i| {
+        let w = i / 64;
+        let b = i % 64;
+        let x = 1u64 & (bitv.storage[w] >> b);
+        x == 1u64
+    })
+}
+
+fn main() {
+    let bools = ~[false, false, true, false, false, true, true, false];
+    let bools2 = to_bools({storage: ~[0b01100100]});
+
+    for uint::range(0, 8) |i| {
+        io::println(#fmt("%u => %u vs %u", i, bools[i] as uint, bools2[i] as uint));
+    }
+
+    assert bools == bools2;
+}