std: Eliminate deprecated patterns

Author: brson

src/libstd/arc.rs

@@ -1,6 +1,5 @@
 // NB: transitionary, de-mode-ing.
 #[forbid(deprecated_mode)];
-#[forbid(deprecated_pattern)];
 /**
  * Concurrency-enabled mechanisms for sharing mutable and/or immutable state
  * between tasks.

src/libstd/arena.rs

@@ -23,7 +23,6 @@
 // to waste time running the destructors of POD.
 
 #[forbid(deprecated_mode)];
-#[forbid(deprecated_pattern)];
 
 export Arena, arena_with_size;
 

src/libstd/base64.rs

@@ -1,5 +1,4 @@
 #[forbid(deprecated_mode)];
-#[forbid(deprecated_pattern)];
 use io::Reader;
 
 pub trait ToBase64 {

src/libstd/bitv.rs

@@ -1,5 +1,4 @@
 #[forbid(deprecated_mode)];
-#[forbid(deprecated_pattern)];
 
 use vec::{to_mut, from_elem};
 
@@ -241,22 +240,22 @@ priv impl Bitv {
             self.die();
         }
         match self.rep {
-          Small(s) => match other.rep {
-            Small(s1) => match op {
-              Union      => s.union(s1,      self.nbits),
-              Intersect  => s.intersect(s1,  self.nbits),
-              Assign     => s.become(s1,     self.nbits),
-              Difference => s.difference(s1, self.nbits)
+          Small(ref s) => match other.rep {
+            Small(ref s1) => match op {
+              Union      => s.union(*s1,      self.nbits),
+              Intersect  => s.intersect(*s1,  self.nbits),
+              Assign     => s.become(*s1,     self.nbits),
+              Difference => s.difference(*s1, self.nbits)
             },
             Big(_) => self.die()
           },
-          Big(s) => match other.rep {
+          Big(ref s) => match other.rep {
             Small(_) => self.die(),
-            Big(s1) => match op {
-              Union      => s.union(s1,      self.nbits),
-              Intersect  => s.intersect(s1,  self.nbits),
-              Assign     => s.become(s1,     self.nbits),
-              Difference => s.difference(s1, self.nbits)
+            Big(ref s1) => match op {
+              Union      => s.union(*s1,      self.nbits),
+              Intersect  => s.intersect(*s1,  self.nbits),
+              Assign     => s.become(*s1,     self.nbits),
+              Difference => s.difference(*s1, self.nbits)
             }
           }
         }
@@ -297,10 +296,10 @@ impl Bitv {
     #[inline(always)]
     fn clone() -> ~Bitv {
         ~match self.rep {
-          Small(b) => {
+          Small(ref b) => {
             Bitv{nbits: self.nbits, rep: Small(~SmallBitv{bits: b.bits})}
           }
-          Big(b) => {
+          Big(ref b) => {
             let st = to_mut(from_elem(self.nbits / uint_bits + 1, 0));
             let len = st.len();
             for uint::range(0, len) |i| { st[i] = b.storage[i]; };
@@ -314,8 +313,8 @@ impl Bitv {
     pure fn get(i: uint) -> bool {
        assert (i < self.nbits);
        match self.rep {
-         Big(b)   => b.get(i),
-         Small(s) => s.get(i)
+         Big(ref b)   => b.get(i),
+         Small(ref s) => s.get(i)
        }
     }
 
@@ -328,8 +327,8 @@ impl Bitv {
     fn set(i: uint, x: bool) {
       assert (i < self.nbits);
       match self.rep {
-        Big(b)   => b.set(i, x),
-        Small(s) => s.set(i, x)
+        Big(ref b)   => b.set(i, x),
+        Small(ref s) => s.set(i, x)
       }
     }
 
@@ -343,12 +342,12 @@ impl Bitv {
     fn equal(v1: Bitv) -> bool {
       if self.nbits != v1.nbits { return false; }
       match self.rep {
-        Small(b) => match v1.rep {
-          Small(b1) => b.equals(b1, self.nbits),
+        Small(ref b) => match v1.rep {
+          Small(ref b1) => b.equals(*b1, self.nbits),
           _ => false
         },
-        Big(s) => match v1.rep {
-          Big(s1) => s.equals(s1, self.nbits),
+        Big(ref s) => match v1.rep {
+          Big(ref s1) => s.equals(*s1, self.nbits),
           Small(_) => return false
         }
       }
@@ -358,25 +357,25 @@ impl Bitv {
     #[inline(always)]
     fn clear() {
         match self.rep {
-          Small(b) => b.clear(),
-          Big(s) => for s.each_storage() |w| { w = 0u }
+          Small(ref b) => b.clear(),
+          Big(ref s) => for s.each_storage() |w| { w = 0u }
         }
     }
 
     /// Set all bits to 1
     #[inline(always)]
     fn set_all() {
       match self.rep {
-        Small(b) => b.set_all(),
-        Big(s) => for s.each_storage() |w| { w = !0u } }
+        Small(ref b) => b.set_all(),
+        Big(ref s) => for s.each_storage() |w| { w = !0u } }
     }
 
     /// Invert all bits
     #[inline(always)]
     fn invert() {
       match self.rep {
-        Small(b) => b.invert(),
-        Big(s) => for s.each_storage() |w| { w = !w } }
+        Small(ref b) => b.invert(),
+        Big(ref s) => for s.each_storage() |w| { w = !w } }
     }
 
     /**
@@ -395,7 +394,7 @@ impl Bitv {
     #[inline(always)]
     fn is_true() -> bool {
       match self.rep {
-        Small(b) => b.is_true(self.nbits),
+        Small(ref b) => b.is_true(self.nbits),
         _ => {
           for self.each() |i| { if !i { return false; } }
           true
@@ -415,7 +414,7 @@ impl Bitv {
     /// Returns true if all bits are 0
     fn is_false() -> bool {
       match self.rep {
-        Small(b) => b.is_false(self.nbits),
+        Small(ref b) => b.is_false(self.nbits),
         Big(_) => {
           for self.each() |i| { if i { return false; } }
           true

src/libstd/cell.rs

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

src/libstd/cmp.rs

@@ -1,5 +1,4 @@
 #[forbid(deprecated_mode)];
-#[forbid(deprecated_pattern)];
 /// Additional general-purpose comparison functionality.
 
 const fuzzy_epsilon: float = 1.0e-6;

src/libstd/comm.rs

@@ -6,7 +6,6 @@ Higher level communication abstractions.
 
 // NB: transitionary, de-mode-ing.
 #[forbid(deprecated_mode)];
-#[forbid(deprecated_pattern)];
 
 use pipes::{Channel, Recv, Chan, Port, Selectable};
 

src/libstd/dbg.rs

@@ -1,5 +1,4 @@
 #[forbid(deprecated_mode)];
-#[forbid(deprecated_pattern)];
 //! Unsafe debugging functions for inspecting values.
 
 use cast::reinterpret_cast;

src/libstd/deque.rs

@@ -1,6 +1,5 @@
 //! A deque. Untested as of yet. Likely buggy
 #[forbid(deprecated_mode)];
-#[forbid(deprecated_pattern)];
 #[forbid(non_camel_case_types)];
 
 use option::{Some, None};
@@ -46,7 +45,7 @@ fn create<T: Copy>() -> Deque<T> {
         move rv
     }
     fn get<T: Copy>(elts: &DVec<Cell<T>>, i: uint) -> T {
-        match (*elts).get_elt(i) { Some(t) => t, _ => fail }
+        match (*elts).get_elt(i) { Some(move t) => t, _ => fail }
     }
 
     type Repr<T> = {mut nelts: uint,

src/libstd/fun_treemap.rs

@@ -1,5 +1,4 @@
 #[warn(deprecated_mode)];
-#[forbid(deprecated_pattern)];
 
 /*!
  * A functional key,value store that works on anything.
@@ -37,7 +36,7 @@ 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) => {
+       @Node(@copy kk, vv, left, right) => {
          if k < kk {
              Node(@kk, vv, insert(left, k, v), right)
          } else if k == kk {
@@ -51,10 +50,10 @@ fn insert<K: Copy Eq Ord, V: Copy>(m: Treemap<K, V>, +k: K, +v: 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) => {
-        if k == kk {
+      Node(@ref kk, @copy v, left, right) => {
+        if k == *kk {
             Some(v)
-        } else if k < kk { find(left, move k) } else { find(right, move k) }
+        } else if k < *kk { find(left, move k) } else { find(right, move k) }
       }
     }
 }
@@ -68,11 +67,9 @@ fn traverse<K, V: Copy>(m: Treemap<K, V>, f: fn((&K), (&V))) {
         matches to me, so I changed it. but that may be a
         de-optimization -- tjc
        */
-      Node(@k, @v, left, right) => {
-        // copy v to make aliases work out
-        let v1 = v;
+      Node(@ref k, @ref v, left, right) => {
         traverse(left, f);
-        f(&k, &v1);
+        f(k, v);
         traverse(right, f);
       }
     }

src/libstd/getopts.rs

@@ -63,7 +63,6 @@
  */
 
 #[forbid(deprecated_mode)];
-#[forbid(deprecated_pattern)];
 
 use core::cmp::Eq;
 use core::result::{Err, Ok};
@@ -110,9 +109,9 @@ fn mkname(nm: &str) -> Name {
 impl Name : Eq {
     pure fn eq(other: &Name) -> bool {
         match self {
-            Long(e0a) => {
+            Long(ref e0a) => {
                 match (*other) {
-                    Long(e0b) => e0a == e0b,
+                    Long(ref e0b) => e0a == e0b,
                     _ => false
                 }
             }
@@ -177,7 +176,7 @@ fn is_arg(arg: &str) -> bool {
 fn name_str(nm: &Name) -> ~str {
     return match *nm {
       Short(ch) => str::from_char(ch),
-      Long(s) => s
+      Long(copy s) => s
     };
 }
 
@@ -200,12 +199,12 @@ enum Fail_ {
 /// Convert a `fail_` enum into an error string
 fn fail_str(+f: Fail_) -> ~str {
     return match f {
-      ArgumentMissing(nm) => ~"Argument to option '" + nm + ~"' missing.",
-      UnrecognizedOption(nm) => ~"Unrecognized option: '" + nm + ~"'.",
-      OptionMissing(nm) => ~"Required option '" + nm + ~"' missing.",
-      OptionDuplicated(nm) => ~"Option '" + nm + ~"' given more than once.",
-      UnexpectedArgument(nm) => {
-        ~"Option " + nm + ~" does not take an argument."
+      ArgumentMissing(ref nm) => ~"Argument to option '" + *nm + ~"' missing.",
+      UnrecognizedOption(ref nm) => ~"Unrecognized option: '" + *nm + ~"'.",
+      OptionMissing(ref nm) => ~"Required option '" + *nm + ~"' missing.",
+      OptionDuplicated(ref nm) => ~"Option '" + *nm + ~"' given more than once.",
+      UnexpectedArgument(ref nm) => {
+        ~"Option " + *nm + ~" does not take an argument."
       }
     };
 }
@@ -382,7 +381,7 @@ fn opts_present(+mm: Matches, names: &[~str]) -> bool {
  * argument
  */
 fn opt_str(+mm: Matches, nm: &str) -> ~str {
-    return match opt_val(mm, nm) { Val(s) => s, _ => fail };
+    return match opt_val(mm, nm) { Val(copy s) => s, _ => fail };
 }
 
 /**
@@ -394,7 +393,7 @@ fn opt_str(+mm: Matches, nm: &str) -> ~str {
 fn opts_str(+mm: Matches, names: &[~str]) -> ~str {
     for vec::each(names) |nm| {
         match opt_val(mm, *nm) {
-          Val(s) => return s,
+          Val(copy s) => return s,
           _ => ()
         }
     }
@@ -411,7 +410,7 @@ fn opts_str(+mm: Matches, names: &[~str]) -> ~str {
 fn opt_strs(+mm: Matches, nm: &str) -> ~[~str] {
     let mut acc: ~[~str] = ~[];
     for vec::each(opt_vals(mm, nm)) |v| {
-        match *v { Val(s) => acc.push(s), _ => () }
+        match *v { Val(copy s) => acc.push(s), _ => () }
     }
     return acc;
 }
@@ -420,7 +419,7 @@ fn opt_strs(+mm: Matches, nm: &str) -> ~[~str] {
 fn opt_maybe_str(+mm: Matches, nm: &str) -> Option<~str> {
     let vals = opt_vals(mm, nm);
     if vec::len::<Optval>(vals) == 0u { return None::<~str>; }
-    return match vals[0] { Val(s) => Some::<~str>(s), _ => None::<~str> };
+    return match vals[0] { Val(copy s) => Some::<~str>(s), _ => None::<~str> };
 }
 
 
@@ -434,7 +433,7 @@ fn opt_maybe_str(+mm: Matches, nm: &str) -> Option<~str> {
 fn opt_default(+mm: Matches, nm: &str, def: &str) -> Option<~str> {
     let vals = opt_vals(mm, nm);
     if vec::len::<Optval>(vals) == 0u { return None::<~str>; }
-    return match vals[0] { Val(s) => Some::<~str>(s),
+    return match vals[0] { Val(copy s) => Some::<~str>(s),
                            _      => Some::<~str>(str::from_slice(def)) }
 }