librustc: Remove all uses of `static` from functions. rs=destatic

33 files changed, 108 insertions, 108 deletions

diff --git a/src/libcore/bool.rs b/src/libcore/bool.rs
index 512855d8f86..388542c9934 100644
--- a/src/libcore/bool.rs
+++ b/src/libcore/bool.rs
@@ -49,7 +49,7 @@ pub pure fn is_false(v: bool) -> bool { !v }
 
 /// Parse logic value from `s`
 impl FromStr for bool {
-    static pure fn from_str(s: &str) -> Option<bool> {
+    pure fn from_str(s: &str) -> Option<bool> {
         if s == "true" {
             Some(true)
         } else if s == "false" {
diff --git a/src/libcore/dlist.rs b/src/libcore/dlist.rs
index 5a230da877f..ef3deb11a95 100644
--- a/src/libcore/dlist.rs
+++ b/src/libcore/dlist.rs
@@ -126,7 +126,7 @@ pub fn concat<T>(lists: @mut DList<@mut DList<T>>) -> @mut DList<T> {
 }
 
 priv impl<T> DList<T> {
-    static pure fn new_link(data: T) -> DListLink<T> {
+    pure fn new_link(data: T) -> DListLink<T> {
         Some(@mut DListNode {
             data: data,
             linked: true,
diff --git a/src/libcore/from_str.rs b/src/libcore/from_str.rs
index 166ba2252a9..f3577d66cff 100644
--- a/src/libcore/from_str.rs
+++ b/src/libcore/from_str.rs
@@ -13,5 +13,5 @@
 use option::Option;
 
 pub trait FromStr {
-    static pure fn from_str(s: &str) -> Option<Self>;
+    pure fn from_str(s: &str) -> Option<Self>;
 }
diff --git a/src/libcore/hashmap.rs b/src/libcore/hashmap.rs
index 68a55792077..0ca7c4b540d 100644
--- a/src/libcore/hashmap.rs
+++ b/src/libcore/hashmap.rs
@@ -373,7 +373,7 @@ pub mod linear {
 
     pub impl<K:Hash + IterBytes + Eq,V> LinearMap<K, V> {
         /// Create an empty LinearMap
-        static fn new() -> LinearMap<K, V> {
+        fn new() -> LinearMap<K, V> {
             linear_map_with_capacity(INITIAL_CAPACITY)
         }
 
@@ -639,7 +639,7 @@ pub mod linear {
 
     pub impl <T:Hash + IterBytes + Eq> LinearSet<T> {
         /// Create an empty LinearSet
-        static fn new() -> LinearSet<T> { LinearSet{map: LinearMap::new()} }
+        fn new() -> LinearSet<T> { LinearSet{map: LinearMap::new()} }
 
         /// Reserve space for at least `n` elements in the hash table.
         fn reserve_at_least(&mut self, n: uint) {
diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs
index 816dc6d2255..2042584add7 100644
--- a/src/libcore/iter.rs
+++ b/src/libcore/iter.rs
@@ -89,8 +89,8 @@ pub trait Buildable<A> {
      *             as an argument a function that will push an element
      *             onto the sequence being constructed.
      */
-     static pure fn build_sized(size: uint,
-                                builder: &fn(push: &pure fn(A))) -> Self;
+     pure fn build_sized(size: uint,
+                         builder: &fn(push: &pure fn(A))) -> Self;
 }
 
 #[inline(always)]
diff --git a/src/libcore/num/f32.rs b/src/libcore/num/f32.rs
index 54521abea9e..d7f0b4be621 100644
--- a/src/libcore/num/f32.rs
+++ b/src/libcore/num/f32.rs
@@ -277,12 +277,12 @@ impl cmp::Ord for f32 {
 
 impl num::Zero for f32 {
     #[inline(always)]
-    static pure fn zero() -> f32 { 0.0 }
+    pure fn zero() -> f32 { 0.0 }
 }
 
 impl num::One for f32 {
     #[inline(always)]
-    static pure fn one() -> f32 { 1.0 }
+    pure fn one() -> f32 { 1.0 }
 }
 
 impl NumCast for f32 {
@@ -290,7 +290,7 @@ impl NumCast for f32 {
      * Cast `n` to an `f32`
      */
     #[inline(always)]
-    static pure fn from<N:NumCast>(n: N) -> f32 { n.to_f32() }
+    pure fn from<N:NumCast>(n: N) -> f32 { n.to_f32() }
 
     #[inline(always)] pure fn to_u8(&self)    -> u8    { *self as u8    }
     #[inline(always)] pure fn to_u16(&self)   -> u16   { *self as u16   }
@@ -568,12 +568,12 @@ pub pure fn from_str_radix(num: &str, rdx: uint) -> Option<f32> {
 
 impl from_str::FromStr for f32 {
     #[inline(always)]
-    static pure fn from_str(val: &str) -> Option<f32> { from_str(val) }
+    pure fn from_str(val: &str) -> Option<f32> { from_str(val) }
 }
 
 impl num::FromStrRadix for f32 {
     #[inline(always)]
-    static pure fn from_str_radix(val: &str, rdx: uint) -> Option<f32> {
+    pure fn from_str_radix(val: &str, rdx: uint) -> Option<f32> {
         from_str_radix(val, rdx)
     }
 }
diff --git a/src/libcore/num/f64.rs b/src/libcore/num/f64.rs
index a2cf629dc9f..7acb7ac462e 100644
--- a/src/libcore/num/f64.rs
+++ b/src/libcore/num/f64.rs
@@ -304,7 +304,7 @@ impl NumCast for f64 {
      * Cast `n` to an `f64`
      */
     #[inline(always)]
-    static pure fn from<N:NumCast>(n: N) -> f64 { n.to_f64() }
+    pure fn from<N:NumCast>(n: N) -> f64 { n.to_f64() }
 
     #[inline(always)] pure fn to_u8(&self)    -> u8    { *self as u8    }
     #[inline(always)] pure fn to_u16(&self)   -> u16   { *self as u16   }
@@ -325,12 +325,12 @@ impl NumCast for f64 {
 
 impl num::Zero for f64 {
     #[inline(always)]
-    static pure fn zero() -> f64 { 0.0 }
+    pure fn zero() -> f64 { 0.0 }
 }
 
 impl num::One for f64 {
     #[inline(always)]
-    static pure fn one() -> f64 { 1.0 }
+    pure fn one() -> f64 { 1.0 }
 }
 
 #[cfg(notest)]
@@ -592,12 +592,12 @@ pub pure fn from_str_radix(num: &str, rdx: uint) -> Option<f64> {
 
 impl from_str::FromStr for f64 {
     #[inline(always)]
-    static pure fn from_str(val: &str) -> Option<f64> { from_str(val) }
+    pure fn from_str(val: &str) -> Option<f64> { from_str(val) }
 }
 
 impl num::FromStrRadix for f64 {
     #[inline(always)]
-    static pure fn from_str_radix(val: &str, rdx: uint) -> Option<f64> {
+    pure fn from_str_radix(val: &str, rdx: uint) -> Option<f64> {
         from_str_radix(val, rdx)
     }
 }
diff --git a/src/libcore/num/float.rs b/src/libcore/num/float.rs
index 1cceddf51a1..f1026ce6608 100644
--- a/src/libcore/num/float.rs
+++ b/src/libcore/num/float.rs
@@ -304,12 +304,12 @@ pub pure fn from_str_radix(num: &str, radix: uint) -> Option<float> {
 
 impl from_str::FromStr for float {
     #[inline(always)]
-    static pure fn from_str(val: &str) -> Option<float> { from_str(val) }
+    pure fn from_str(val: &str) -> Option<float> { from_str(val) }
 }
 
 impl num::FromStrRadix for float {
     #[inline(always)]
-    static pure fn from_str_radix(val: &str, radix: uint) -> Option<float> {
+    pure fn from_str_radix(val: &str, radix: uint) -> Option<float> {
         from_str_radix(val, radix)
     }
 }
@@ -408,12 +408,12 @@ impl Ord for float {
 
 impl num::Zero for float {
     #[inline(always)]
-    static pure fn zero() -> float { 0.0 }
+    pure fn zero() -> float { 0.0 }
 }
 
 impl num::One for float {
     #[inline(always)]
-    static pure fn one() -> float { 1.0 }
+    pure fn one() -> float { 1.0 }
 }
 
 impl NumCast for float {
@@ -421,7 +421,7 @@ impl NumCast for float {
      * Cast `n` to a `float`
      */
     #[inline(always)]
-    static pure fn from<N:NumCast>(n: N) -> float { n.to_float() }
+    pure fn from<N:NumCast>(n: N) -> float { n.to_float() }
 
     #[inline(always)] pure fn to_u8(&self)    -> u8    { *self as u8    }
     #[inline(always)] pure fn to_u16(&self)   -> u16   { *self as u16   }
diff --git a/src/libcore/num/int-template.rs b/src/libcore/num/int-template.rs
index cef8542823a..599bd0f1c68 100644
--- a/src/libcore/num/int-template.rs
+++ b/src/libcore/num/int-template.rs
@@ -163,12 +163,12 @@ impl Eq for T {
 
 impl num::Zero for T {
     #[inline(always)]
-    static pure fn zero() -> T { 0 }
+    pure fn zero() -> T { 0 }
 }
 
 impl num::One for T {
     #[inline(always)]
-    static pure fn one() -> T { 1 }
+    pure fn one() -> T { 1 }
 }
 
 #[cfg(notest)]
@@ -221,14 +221,14 @@ pub pure fn parse_bytes(buf: &[u8], radix: uint) -> Option<T> {
 
 impl FromStr for T {
     #[inline(always)]
-    static pure fn from_str(s: &str) -> Option<T> {
+    pure fn from_str(s: &str) -> Option<T> {
         from_str(s)
     }
 }
 
 impl FromStrRadix for T {
     #[inline(always)]
-    static pure fn from_str_radix(&self, s: &str, radix: uint) -> Option<T> {
+    pure fn from_str_radix(s: &str, radix: uint) -> Option<T> {
         from_str_radix(s, radix)
     }
 }
diff --git a/src/libcore/num/int-template/i16.rs b/src/libcore/num/int-template/i16.rs
index 3c4ca532be7..04bd205f53d 100644
--- a/src/libcore/num/int-template/i16.rs
+++ b/src/libcore/num/int-template/i16.rs
@@ -22,7 +22,7 @@ impl NumCast for i16 {
      * Cast `n` to a `i16`
      */
     #[inline(always)]
-    static pure fn from<N:NumCast>(n: N) -> i16 { n.to_i16() }
+    pure fn from<N:NumCast>(n: N) -> i16 { n.to_i16() }
 
     #[inline(always)] pure fn to_u8(&self)    -> u8    { *self as u8    }
     #[inline(always)] pure fn to_u16(&self)   -> u16   { *self as u16   }
diff --git a/src/libcore/num/int-template/i32.rs b/src/libcore/num/int-template/i32.rs
index 30eb4437d57..1cdd93c411e 100644
--- a/src/libcore/num/int-template/i32.rs
+++ b/src/libcore/num/int-template/i32.rs
@@ -22,7 +22,7 @@ impl NumCast for i32 {
      * Cast `n` to a `i32`
      */
     #[inline(always)]
-    static pure fn from<N:NumCast>(n: N) -> i32 { n.to_i32() }
+    pure fn from<N:NumCast>(n: N) -> i32 { n.to_i32() }
 
     #[inline(always)] pure fn to_u8(&self)    -> u8    { *self as u8    }
     #[inline(always)] pure fn to_u16(&self)   -> u16   { *self as u16   }
diff --git a/src/libcore/num/int-template/i64.rs b/src/libcore/num/int-template/i64.rs
index 61736cf9587..2a7c155f8b5 100644
--- a/src/libcore/num/int-template/i64.rs
+++ b/src/libcore/num/int-template/i64.rs
@@ -22,7 +22,7 @@ impl NumCast for i64 {
      * Cast `n` to a `i64`
      */
     #[inline(always)]
-    static pure fn from<N:NumCast>(n: N) -> i64 { n.to_i64() }
+    pure fn from<N:NumCast>(n: N) -> i64 { n.to_i64() }
 
     #[inline(always)] pure fn to_u8(&self)    -> u8    { *self as u8    }
     #[inline(always)] pure fn to_u16(&self)   -> u16   { *self as u16   }
diff --git a/src/libcore/num/int-template/i8.rs b/src/libcore/num/int-template/i8.rs
index e70811adff1..ac1dc76c264 100644
--- a/src/libcore/num/int-template/i8.rs
+++ b/src/libcore/num/int-template/i8.rs
@@ -22,7 +22,7 @@ impl NumCast for i8 {
      * Cast `n` to a `i8`
      */
     #[inline(always)]
-    static pure fn from<N:NumCast>(n: N) -> i8 { n.to_i8() }
+    pure fn from<N:NumCast>(n: N) -> i8 { n.to_i8() }
 
     #[inline(always)] pure fn to_u8(&self)    -> u8    { *self as u8    }
     #[inline(always)] pure fn to_u16(&self)   -> u16   { *self as u16   }
diff --git a/src/libcore/num/int-template/int.rs b/src/libcore/num/int-template/int.rs
index f007cc5b119..0bd52491a63 100644
--- a/src/libcore/num/int-template/int.rs
+++ b/src/libcore/num/int-template/int.rs
@@ -63,7 +63,7 @@ impl NumCast for int {
      * Cast `n` to a `int`
      */
     #[inline(always)]
-    static pure fn from<N:NumCast>(n: N) -> int { n.to_int() }
+    pure fn from<N:NumCast>(n: N) -> int { n.to_int() }
 
     #[inline(always)] pure fn to_u8(&self)    -> u8    { *self as u8    }
     #[inline(always)] pure fn to_u16(&self)   -> u16   { *self as u16   }
diff --git a/src/libcore/num/num.rs b/src/libcore/num/num.rs
index a462aed8be0..fe829f6193b 100644
--- a/src/libcore/num/num.rs
+++ b/src/libcore/num/num.rs
@@ -18,15 +18,15 @@ pub mod strconv;
 
 pub trait IntConvertible {
     pure fn to_int(&self) -> int;
-    static pure fn from_int(n: int) -> Self;
+    pure fn from_int(n: int) -> Self;
 }
 
 pub trait Zero {
-    static pure fn zero() -> Self;
+    pure fn zero() -> Self;
 }
 
 pub trait One {
-    static pure fn one() -> Self;
+    pure fn one() -> Self;
 }
 
 pub pure fn abs<T:Ord + Zero + Neg<T>>(v: T) -> T {
@@ -67,7 +67,7 @@ pub pure fn cast<T:NumCast,U:NumCast>(n: T) -> U {
  * An interface for generic numeric type casts
  */
 pub trait NumCast {
-    static pure fn from<T:NumCast>(n: T) -> Self;
+    pure fn from<T:NumCast>(n: T) -> Self;
 
     pure fn to_u8(&self) -> u8;
     pure fn to_u16(&self) -> u16;
@@ -91,7 +91,7 @@ pub trait ToStrRadix {
 }
 
 pub trait FromStrRadix {
-    static pub pure fn from_str_radix(str: &str, radix: uint) -> Option<Self>;
+    pub pure fn from_str_radix(str: &str, radix: uint) -> Option<Self>;
 }
 
 // Generic math functions:
diff --git a/src/libcore/num/strconv.rs b/src/libcore/num/strconv.rs
index 28e57a354c8..0bf20f55b2f 100644
--- a/src/libcore/num/strconv.rs
+++ b/src/libcore/num/strconv.rs
@@ -66,10 +66,10 @@ pure fn is_neg_zero<T:Eq+One+Zero+NumStrConv+Div<T,T>>(num: &T) -> bool {
 }
 
 pub trait NumStrConv {
-    static pure fn NaN()      -> Option<Self>;
-    static pure fn inf()      -> Option<Self>;
-    static pure fn neg_inf()  -> Option<Self>;
-    static pure fn neg_zero() -> Option<Self>;
+    pure fn NaN()      -> Option<Self>;
+    pure fn inf()      -> Option<Self>;
+    pure fn neg_inf()  -> Option<Self>;
+    pure fn neg_zero() -> Option<Self>;
 
     pure fn round_to_zero(&self)   -> Self;
     pure fn fractional_part(&self) -> Self;
@@ -78,13 +78,13 @@ pub trait NumStrConv {
 macro_rules! impl_NumStrConv_Floating (($t:ty) => (
     impl NumStrConv for $t {
         #[inline(always)]
-        static pure fn NaN()      -> Option<$t> { Some( 0.0 / 0.0) }
+        pure fn NaN()      -> Option<$t> { Some( 0.0 / 0.0) }
         #[inline(always)]
-        static pure fn inf()      -> Option<$t> { Some( 1.0 / 0.0) }
+        pure fn inf()      -> Option<$t> { Some( 1.0 / 0.0) }
         #[inline(always)]
-        static pure fn neg_inf()  -> Option<$t> { Some(-1.0 / 0.0) }
+        pure fn neg_inf()  -> Option<$t> { Some(-1.0 / 0.0) }
         #[inline(always)]
-        static pure fn neg_zero() -> Option<$t> { Some(-0.0      ) }
+        pure fn neg_zero() -> Option<$t> { Some(-0.0      ) }
 
         #[inline(always)]
         pure fn round_to_zero(&self) -> $t {
@@ -102,10 +102,10 @@ macro_rules! impl_NumStrConv_Floating (($t:ty) => (
 
 macro_rules! impl_NumStrConv_Integer (($t:ty) => (
     impl NumStrConv for $t {
-        #[inline(always)] static pure fn NaN()      -> Option<$t> { None }
-        #[inline(always)] static pure fn inf()      -> Option<$t> { None }
-        #[inline(always)] static pure fn neg_inf()  -> Option<$t> { None }
-        #[inline(always)] static pure fn neg_zero() -> Option<$t> { None }
+        #[inline(always)] pure fn NaN()      -> Option<$t> { None }
+        #[inline(always)] pure fn inf()      -> Option<$t> { None }
+        #[inline(always)] pure fn neg_inf()  -> Option<$t> { None }
+        #[inline(always)] pure fn neg_zero() -> Option<$t> { None }
 
         #[inline(always)] pure fn round_to_zero(&self)   -> $t { *self }
         #[inline(always)] pure fn fractional_part(&self) -> $t {     0 }
diff --git a/src/libcore/num/uint-template.rs b/src/libcore/num/uint-template.rs
index 9abbfb03d7a..1e56c37bab0 100644
--- a/src/libcore/num/uint-template.rs
+++ b/src/libcore/num/uint-template.rs
@@ -129,12 +129,12 @@ impl Eq for T {
 
 impl num::Zero for T {
     #[inline(always)]
-    static pure fn zero() -> T { 0 }
+    pure fn zero() -> T { 0 }
 }
 
 impl num::One for T {
     #[inline(always)]
-    static pure fn one() -> T { 1 }
+    pure fn one() -> T { 1 }
 }
 
 #[cfg(notest)]
@@ -187,14 +187,14 @@ pub pure fn parse_bytes(buf: &[u8], radix: uint) -> Option<T> {
 
 impl FromStr for T {
     #[inline(always)]
-    static pure fn from_str(s: &str) -> Option<T> {
+    pure fn from_str(s: &str) -> Option<T> {
         from_str(s)
     }
 }
 
 impl FromStrRadix for T {
     #[inline(always)]
-    static pure fn from_str_radix(&self, s: &str, radix: uint) -> Option<T> {
+    pure fn from_str_radix(s: &str, radix: uint) -> Option<T> {
         from_str_radix(s, radix)
     }
 }
diff --git a/src/libcore/num/uint-template/u16.rs b/src/libcore/num/uint-template/u16.rs
index 16a1d620929..84406d5ed49 100644
--- a/src/libcore/num/uint-template/u16.rs
+++ b/src/libcore/num/uint-template/u16.rs
@@ -24,7 +24,7 @@ impl NumCast for u16 {
      * Cast `n` to a `u16`
      */
     #[inline(always)]
-    static pure fn from<N:NumCast>(n: N) -> u16 { n.to_u16() }
+    pure fn from<N:NumCast>(n: N) -> u16 { n.to_u16() }
 
     #[inline(always)] pure fn to_u8(&self)    -> u8    { *self as u8    }
     #[inline(always)] pure fn to_u16(&self)   -> u16   { *self          }
diff --git a/src/libcore/num/uint-template/u32.rs b/src/libcore/num/uint-template/u32.rs
index cf92feb6427..94d2c9b75f1 100644
--- a/src/libcore/num/uint-template/u32.rs
+++ b/src/libcore/num/uint-template/u32.rs
@@ -24,7 +24,7 @@ impl NumCast for u32 {
      * Cast `n` to a `u32`
      */
     #[inline(always)]
-    static pure fn from<N:NumCast>(n: N) -> u32 { n.to_u32() }
+    pure fn from<N:NumCast>(n: N) -> u32 { n.to_u32() }
 
     #[inline(always)] pure fn to_u8(&self)    -> u8    { *self as u8    }
     #[inline(always)] pure fn to_u16(&self)   -> u16   { *self as u16   }
diff --git a/src/libcore/num/uint-template/u64.rs b/src/libcore/num/uint-template/u64.rs
index 269d8e185f3..06d2efeeda7 100644
--- a/src/libcore/num/uint-template/u64.rs
+++ b/src/libcore/num/uint-template/u64.rs
@@ -24,7 +24,7 @@ impl NumCast for u64 {
      * Cast `n` to a `u64`
      */
     #[inline(always)]
-    static pure fn from<N:NumCast>(n: N) -> u64 { n.to_u64() }
+    pure fn from<N:NumCast>(n: N) -> u64 { n.to_u64() }
 
     #[inline(always)] pure fn to_u8(&self)    -> u8    { *self as u8    }
     #[inline(always)] pure fn to_u16(&self)   -> u16   { *self as u16   }
diff --git a/src/libcore/num/uint-template/u8.rs b/src/libcore/num/uint-template/u8.rs
index 44428abdb4f..31cb21473a8 100644
--- a/src/libcore/num/uint-template/u8.rs
+++ b/src/libcore/num/uint-template/u8.rs
@@ -31,7 +31,7 @@ impl NumCast for u8 {
      * Cast `n` to a `u8`
      */
     #[inline(always)]
-    static pure fn from<N:NumCast>(n: N) -> u8 { n.to_u8() }
+    pure fn from<N:NumCast>(n: N) -> u8 { n.to_u8() }
 
     #[inline(always)] pure fn to_u8(&self)    -> u8    { *self          }
     #[inline(always)] pure fn to_u16(&self)   -> u16   { *self as u16   }
diff --git a/src/libcore/num/uint-template/uint.rs b/src/libcore/num/uint-template/uint.rs
index f73ff4442ce..3b17f4f5327 100644
--- a/src/libcore/num/uint-template/uint.rs
+++ b/src/libcore/num/uint-template/uint.rs
@@ -215,7 +215,7 @@ impl NumCast for uint {
      * Cast `n` to a `uint`
      */
     #[inline(always)]
-    static pure fn from<N:NumCast>(n: N) -> uint { n.to_uint() }
+    pure fn from<N:NumCast>(n: N) -> uint { n.to_uint() }
 
     #[inline(always)] pure fn to_u8(&self)    -> u8    { *self as u8    }
     #[inline(always)] pure fn to_u16(&self)   -> u16   { *self as u16   }
diff --git a/src/libcore/path.rs b/src/libcore/path.rs
index df4a3fdfb9e..7189ecaadda 100644
--- a/src/libcore/path.rs
+++ b/src/libcore/path.rs
@@ -43,7 +43,7 @@ pub pure fn PosixPath(s: &str) -> PosixPath {
 }
 
 pub trait GenericPath {
-    static pure fn from_str(&str) -> Self;
+    pure fn from_str(&str) -> Self;
 
     pure fn dirname(&self) -> ~str;
     pure fn filename(&self) -> Option<~str>;
@@ -380,7 +380,7 @@ impl ToStr for PosixPath {
 // PosixPath and WindowsPath, most of their methods are common.
 impl GenericPath for PosixPath {
 
-    static pure fn from_str(s: &str) -> PosixPath {
+    pure fn from_str(s: &str) -> PosixPath {
         let mut components = str::split_nonempty(s, |c| c == '/');
         let is_absolute = (s.len() != 0 && s[0] == '/' as u8);
         return PosixPath { is_absolute: is_absolute,
@@ -563,7 +563,7 @@ impl ToStr for WindowsPath {
 
 impl GenericPath for WindowsPath {
 
-    static pure fn from_str(s: &str) -> WindowsPath {
+    pure fn from_str(s: &str) -> WindowsPath {
         let host;
         let device;
         let rest;
diff --git a/src/libcore/rand.rs b/src/libcore/rand.rs
index 4cb5e58b733..6902cd4ef69 100644
--- a/src/libcore/rand.rs
+++ b/src/libcore/rand.rs
@@ -22,95 +22,95 @@ use libc::size_t;
 
 /// A type that can be randomly generated using an RNG
 pub trait Rand {
-    static fn rand(rng: @rand::Rng) -> Self;
+    fn rand(rng: @rand::Rng) -> Self;
 }
 
 impl Rand for int {
-    static fn rand(rng: @rand::Rng) -> int {
+    fn rand(rng: @rand::Rng) -> int {
         rng.gen_int()
     }
 }
 
 impl Rand for i8 {
-    static fn rand(rng: @rand::Rng) -> i8 {
+    fn rand(rng: @rand::Rng) -> i8 {
         rng.gen_i8()
     }
 }
 
 impl Rand for i16 {
-    static fn rand(rng: @rand::Rng) -> i16 {
+    fn rand(rng: @rand::Rng) -> i16 {
         rng.gen_i16()
     }
 }
 
 impl Rand for i32 {
-    static fn rand(rng: @rand::Rng) -> i32 {
+    fn rand(rng: @rand::Rng) -> i32 {
         rng.gen_i32()
     }
 }
 
 impl Rand for i64 {
-    static fn rand(rng: @rand::Rng) -> i64 {
+    fn rand(rng: @rand::Rng) -> i64 {
         rng.gen_i64()
     }
 }
 
 impl Rand for u8 {
-    static fn rand(rng: @rand::Rng) -> u8 {
+    fn rand(rng: @rand::Rng) -> u8 {
         rng.gen_u8()
     }
 }
 
 impl Rand for u16 {
-    static fn rand(rng: @rand::Rng) -> u16 {
+    fn rand(rng: @rand::Rng) -> u16 {
         rng.gen_u16()
     }
 }
 
 impl Rand for u32 {
-    static fn rand(rng: @rand::Rng) -> u32 {
+    fn rand(rng: @rand::Rng) -> u32 {
         rng.gen_u32()
     }
 }
 
 impl Rand for u64 {
-    static fn rand(rng: @rand::Rng) -> u64 {
+    fn rand(rng: @rand::Rng) -> u64 {
         rng.gen_u64()
     }
 }
 
 impl Rand for float {
-    static fn rand(rng: @rand::Rng) -> float {
+    fn rand(rng: @rand::Rng) -> float {
         rng.gen_float()
     }
 }
 
 impl Rand for f32 {
-    static fn rand(rng: @rand::Rng) -> f32 {
+    fn rand(rng: @rand::Rng) -> f32 {
         rng.gen_f32()
     }
 }
 
 impl Rand for f64 {
-    static fn rand(rng: @rand::Rng) -> f64 {
+    fn rand(rng: @rand::Rng) -> f64 {
         rng.gen_f64()
     }
 }
 
 impl Rand for char {
-    static fn rand(rng: @rand::Rng) -> char {
+    fn rand(rng: @rand::Rng) -> char {
         rng.gen_char()
     }
 }
 
 impl Rand for bool {
-    static fn rand(rng: @rand::Rng) -> bool {
+    fn rand(rng: @rand::Rng) -> bool {
         rng.gen_bool()
     }
 }
 
 impl<T:Rand> Rand for Option<T> {
-    static fn rand(rng: @rand::Rng) -> Option<T> {
+    fn rand(rng: @rand::Rng) -> Option<T> {
         if rng.gen_bool() {
             Some(Rand::rand(rng))
         } else {
diff --git a/src/libcore/rt/context.rs b/src/libcore/rt/context.rs
index dfb7bdf04c3..8da80f7a4e8 100644
--- a/src/libcore/rt/context.rs
+++ b/src/libcore/rt/context.rs
@@ -19,14 +19,14 @@ use cast::{transmute, transmute_mut_unsafe,
 pub struct Context(~Registers);
 
 pub impl Context {
-    static fn empty() -> Context {
+    fn empty() -> Context {
         Context(new_regs())
     }
 
     /// Create a new context that will resume execution by running ~fn()
     /// # Safety Note
     /// The `start` closure must remain valid for the life of the Task
-    static fn new(start: &~fn(), stack: &mut StackSegment) -> Context {
+    fn new(start: &~fn(), stack: &mut StackSegment) -> Context {
 
         // The C-ABI function that is the task entry point
         extern fn task_start_wrapper(f: &~fn()) { (*f)() }
@@ -49,7 +49,7 @@ pub impl Context {
         return Context(regs);
     }
 
-    static fn swap(out_context: &mut Context, in_context: &Context) {
+    fn swap(out_context: &mut Context, in_context: &Context) {
         let out_regs: &mut Registers = match out_context {
             &Context(~ref mut r) => r
         };
diff --git a/src/libcore/rt/sched.rs b/src/libcore/rt/sched.rs
index 60dbc8b82da..4a140458fd3 100644
--- a/src/libcore/rt/sched.rs
+++ b/src/libcore/rt/sched.rs
@@ -50,11 +50,11 @@ pub struct Scheduler {
 // complaining
 type UnsafeTaskReceiver = sys::Closure;
 trait HackAroundBorrowCk {
-    static fn from_fn(&fn(&mut Scheduler, ~Task)) -> Self;
+    fn from_fn(&fn(&mut Scheduler, ~Task)) -> Self;
     fn to_fn(self) -> &fn(&mut Scheduler, ~Task);
 }
 impl HackAroundBorrowCk for UnsafeTaskReceiver {
-    static fn from_fn(f: &fn(&mut Scheduler, ~Task)) -> UnsafeTaskReceiver {
+    fn from_fn(f: &fn(&mut Scheduler, ~Task)) -> UnsafeTaskReceiver {
         unsafe { transmute(f) }
     }
     fn to_fn(self) -> &fn(&mut Scheduler, ~Task) {
@@ -70,7 +70,7 @@ enum CleanupJob {
 
 pub impl Scheduler {
 
-    static pub fn new(event_loop: ~EventLoopObject) -> Scheduler {
+    pub fn new(event_loop: ~EventLoopObject) -> Scheduler {
         Scheduler {
             event_loop: event_loop,
             task_queue: WorkQueue::new(),
@@ -114,7 +114,7 @@ pub impl Scheduler {
         return tlsched.take_scheduler();
     }
 
-    static fn local(f: &fn(&mut Scheduler)) {
+    fn local(f: &fn(&mut Scheduler)) {
         let mut tlsched = ThreadLocalScheduler::new();
         f(tlsched.get_scheduler());
     }
@@ -296,7 +296,7 @@ pub struct Task {
 }
 
 impl Task {
-    static pub fn new(stack_pool: &mut StackPool, start: ~fn()) -> Task {
+    pub fn new(stack_pool: &mut StackPool, start: ~fn()) -> Task {
         // XXX: Putting main into a ~ so it's a thin pointer and can
         // be passed to the spawn function.  Another unfortunate
         // allocation
@@ -337,7 +337,7 @@ impl Task {
 struct ThreadLocalScheduler(tls::Key);
 
 impl ThreadLocalScheduler {
-    static fn new() -> ThreadLocalScheduler {
+    fn new() -> ThreadLocalScheduler {
         unsafe {
             // NB: This assumes that the TLS key has been created prior.
             // Currently done in rust_start.
diff --git a/src/libcore/rt/stack.rs b/src/libcore/rt/stack.rs
index b5e7d4f3aa2..9b164eb08fa 100644
--- a/src/libcore/rt/stack.rs
+++ b/src/libcore/rt/stack.rs
@@ -15,7 +15,7 @@ pub struct StackSegment {
 }
 
 pub impl StackSegment {
-    static fn new(size: uint) -> StackSegment {
+    fn new(size: uint) -> StackSegment {
         // Crate a block of uninitialized values
         let mut stack = vec::with_capacity(size);
         unsafe {
@@ -37,7 +37,7 @@ pub impl StackSegment {
 pub struct StackPool(());
 
 impl StackPool {
-    static pub fn new() -> StackPool { StackPool(()) }
+    pub fn new() -> StackPool { StackPool(()) }
 
     fn take_segment(&self, min_size: uint) -> StackSegment {
         StackSegment::new(min_size)
diff --git a/src/libcore/rt/thread.rs b/src/libcore/rt/thread.rs
index 5dccf90096e..c45e4295ab1 100644
--- a/src/libcore/rt/thread.rs
+++ b/src/libcore/rt/thread.rs
@@ -20,7 +20,7 @@ struct Thread {
 }
 
 impl Thread {
-    static pub fn start(main: ~fn()) -> Thread {
+    pub fn start(main: ~fn()) -> Thread {
         fn substart(main: &fn()) -> *raw_thread {
             unsafe { rust_raw_thread_start(&main) }
         }
diff --git a/src/libcore/rt/uv.rs b/src/libcore/rt/uv.rs
index e57d0f51870..251f2a4a12b 100644
--- a/src/libcore/rt/uv.rs
+++ b/src/libcore/rt/uv.rs
@@ -74,7 +74,7 @@ impl Callback for NullCallback { }
 
 /// A type that wraps a native handle
 trait NativeHandle<T> {
-    static pub fn from_native_handle(T) -> Self;
+    pub fn from_native_handle(T) -> Self;
     pub fn native_handle(&self) -> T;
 }
 
@@ -86,7 +86,7 @@ pub struct Loop {
 }
 
 pub impl Loop {
-    static fn new() -> Loop {
+    fn new() -> Loop {
         let handle = unsafe { uvll::loop_new() };
         fail_unless!(handle.is_not_null());
         NativeHandle::from_native_handle(handle)
@@ -102,7 +102,7 @@ pub impl Loop {
 }
 
 impl NativeHandle<*uvll::uv_loop_t> for Loop {
-    static fn from_native_handle(handle: *uvll::uv_loop_t) -> Loop {
+    fn from_native_handle(handle: *uvll::uv_loop_t) -> Loop {
         Loop { handle: handle }
     }
     fn native_handle(&self) -> *uvll::uv_loop_t {
@@ -132,7 +132,7 @@ type IdleCallback = ~fn(IdleWatcher, Option<UvError>);
 impl Callback for IdleCallback { }
 
 pub impl IdleWatcher {
-    static fn new(loop_: &mut Loop) -> IdleWatcher {
+    fn new(loop_: &mut Loop) -> IdleWatcher {
         unsafe {
             let handle = uvll::idle_new();
             fail_unless!(handle.is_not_null());
@@ -177,7 +177,7 @@ pub impl IdleWatcher {
 }
 
 impl NativeHandle<*uvll::uv_idle_t> for IdleWatcher {
-    static fn from_native_handle(handle: *uvll::uv_idle_t) -> IdleWatcher {
+    fn from_native_handle(handle: *uvll::uv_idle_t) -> IdleWatcher {
         IdleWatcher(handle)
     }
     fn native_handle(&self) -> *uvll::uv_idle_t {
@@ -307,7 +307,7 @@ pub impl StreamWatcher {
 }
 
 impl NativeHandle<*uvll::uv_stream_t> for StreamWatcher {
-    static fn from_native_handle(
+    fn from_native_handle(
         handle: *uvll::uv_stream_t) -> StreamWatcher {
         StreamWatcher(handle)
     }
@@ -328,7 +328,7 @@ type ConnectionCallback = ~fn(StreamWatcher, Option<UvError>);
 impl Callback for ConnectionCallback { }
 
 pub impl TcpWatcher {
-    static fn new(loop_: &mut Loop) -> TcpWatcher {
+    fn new(loop_: &mut Loop) -> TcpWatcher {
         unsafe {
             let size = size_of::<uvll::uv_tcp_t>() as size_t;
             let handle = malloc(size) as *uvll::uv_tcp_t;
@@ -421,7 +421,7 @@ pub impl TcpWatcher {
 }
 
 impl NativeHandle<*uvll::uv_tcp_t> for TcpWatcher {
-    static fn from_native_handle(handle: *uvll::uv_tcp_t) -> TcpWatcher {
+    fn from_native_handle(handle: *uvll::uv_tcp_t) -> TcpWatcher {
         TcpWatcher(handle)
     }
     fn native_handle(&self) -> *uvll::uv_tcp_t {
@@ -441,7 +441,7 @@ impl Request for ConnectRequest { }
 
 impl ConnectRequest {
 
-    static fn new() -> ConnectRequest {
+    fn new() -> ConnectRequest {
         let connect_handle = unsafe {
             malloc(size_of::<uvll::uv_connect_t>() as size_t)
         };
@@ -465,7 +465,7 @@ impl ConnectRequest {
 }
 
 impl NativeHandle<*uvll::uv_connect_t> for ConnectRequest {
-    static fn from_native_handle(
+    fn from_native_handle(
         handle: *uvll:: uv_connect_t) -> ConnectRequest {
         ConnectRequest(handle)
     }
@@ -480,7 +480,7 @@ impl Request for WriteRequest { }
 
 impl WriteRequest {
 
-    static fn new() -> WriteRequest {
+    fn new() -> WriteRequest {
         let write_handle = unsafe {
             malloc(size_of::<uvll::uv_write_t>() as size_t)
         };
@@ -503,7 +503,7 @@ impl WriteRequest {
 }
 
 impl NativeHandle<*uvll::uv_write_t> for WriteRequest {
-    static fn from_native_handle(handle: *uvll:: uv_write_t) -> WriteRequest {
+    fn from_native_handle(handle: *uvll:: uv_write_t) -> WriteRequest {
         WriteRequest(handle)
     }
     fn native_handle(&self) -> *uvll::uv_write_t {
diff --git a/src/libcore/rt/uvio.rs b/src/libcore/rt/uvio.rs
index a971ed92b7e..58a4a65ca90 100644
--- a/src/libcore/rt/uvio.rs
+++ b/src/libcore/rt/uvio.rs
@@ -29,14 +29,14 @@ pub struct UvEventLoop {
 }
 
 pub impl UvEventLoop {
-    static fn new() -> UvEventLoop {
+    fn new() -> UvEventLoop {
         UvEventLoop {
             uvio: UvIoFactory(Loop::new())
         }
     }
 
     /// A convenience constructor
-    static fn new_scheduler() -> Scheduler {
+    fn new_scheduler() -> Scheduler {
         Scheduler::new(~UvEventLoop::new())
     }
 }
@@ -221,7 +221,7 @@ impl TcpListener for UvTcpListener {
 pub struct UvStream(StreamWatcher);
 
 impl UvStream {
-    static fn new(watcher: StreamWatcher) -> UvStream {
+    fn new(watcher: StreamWatcher) -> UvStream {
         UvStream(watcher)
     }
 
diff --git a/src/libcore/rt/work_queue.rs b/src/libcore/rt/work_queue.rs
index 1be2eb26e62..dfa88b783c5 100644
--- a/src/libcore/rt/work_queue.rs
+++ b/src/libcore/rt/work_queue.rs
@@ -15,7 +15,7 @@ pub struct WorkQueue<T> {
 }
 
 pub impl<T> WorkQueue<T> {
-    static fn new() -> WorkQueue<T> {
+    fn new() -> WorkQueue<T> {
         WorkQueue {
             queue: ~[]
         }
diff --git a/src/libcore/trie.rs b/src/libcore/trie.rs
index 3b9d3ad4b73..7afe7e0d3d4 100644
--- a/src/libcore/trie.rs
+++ b/src/libcore/trie.rs
@@ -139,7 +139,7 @@ impl<T> Map<uint, T> for TrieMap<T> {
 pub impl<T> TrieMap<T> {
     /// Create an empty TrieMap
     #[inline(always)]
-    static pure fn new() -> TrieMap<T> {
+    pure fn new() -> TrieMap<T> {
         TrieMap{root: TrieNode::new(), length: 0}
     }
 
@@ -192,7 +192,7 @@ impl Mutable for TrieSet {
 impl TrieSet {
     /// Create an empty TrieSet
     #[inline(always)]
-    static pure fn new() -> TrieSet {
+    pure fn new() -> TrieSet {
         TrieSet{map: TrieMap::new()}
     }
 
@@ -220,7 +220,7 @@ struct TrieNode<T> {
 
 impl<T> TrieNode<T> {
     #[inline(always)]
-    static pure fn new() -> TrieNode<T> {
+    pure fn new() -> TrieNode<T> {
         // FIXME: #5244: [Nothing, ..SIZE] should be possible without Copy
         TrieNode{count: 0,
                  children: [Nothing, Nothing, Nothing, Nothing,
diff --git a/src/libcore/unstable/extfmt.rs b/src/libcore/unstable/extfmt.rs
index 28f810c3a28..766dd1a37a0 100644
--- a/src/libcore/unstable/extfmt.rs
+++ b/src/libcore/unstable/extfmt.rs
@@ -140,7 +140,7 @@ pub mod ct {
     }
 
     pub impl<T> Parsed<T> {
-        static pure fn new(&self, val: T, next: uint) -> Parsed<T> {
+        pure fn new(val: T, next: uint) -> Parsed<T> {
             Parsed {val: val, next: next}
         }
     }