Stop resolving static methods at the module level. Closes #4179

4 files changed, 25 insertions, 25 deletions

diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs
index 0e1b6852e7e..e72eaa08c3e 100644
--- a/src/libstd/ebml.rs
+++ b/src/libstd/ebml.rs
@@ -657,7 +657,7 @@ mod tests {
             };
             let ebml_doc = reader::Doc(@bytes);
             let deser = reader::Decoder(ebml_doc);
-            let v1 = serialize::decode(&deser);
+            let v1 = serialize::traits::Decodable::decode(&deser);
             debug!("v1 == %?", v1);
             assert v == v1;
         }
diff --git a/src/libstd/flatpipes.rs b/src/libstd/flatpipes.rs
index de7fda4ef82..52037969d24 100644
--- a/src/libstd/flatpipes.rs
+++ b/src/libstd/flatpipes.rs
@@ -324,7 +324,6 @@ pub mod flatteners {
 
     use serialize::{Encoder, Decoder,
                         Encodable, Decodable};
-    use serialize::decode;
 
     use core::io::{Writer, Reader, BytesWriter, ReaderUtil};
     use flatpipes::util::BufReader;
@@ -433,15 +432,15 @@ pub mod flatteners {
         let buf = vec::from_slice(buf);
         let buf_reader = @BufReader::new(move buf);
         let reader = buf_reader as @Reader;
-        let deser: D = from_reader(reader);
-        decode(&deser)
+        let deser: D = FromReader::from_reader(reader);
+        Decodable::decode(&deser)
     }
 
     pub fn serialize_value<D: Encoder FromWriter,
                        T: Encodable<D>>(val: &T) -> ~[u8] {
         let bytes_writer = @BytesWriter();
         let writer = bytes_writer as @Writer;
-        let ser = from_writer(writer);
+        let ser = FromWriter::from_writer(writer);
         val.encode(&ser);
         let bytes = bytes_writer.bytes.check_out(|bytes| move bytes);
         return move bytes;
diff --git a/src/libstd/serialize.rs b/src/libstd/serialize.rs
index a2c80914fd6..e32dda04579 100644
--- a/src/libstd/serialize.rs
+++ b/src/libstd/serialize.rs
@@ -298,7 +298,7 @@ pub impl<S: Encoder, T: Encodable<S>> ~T: Encodable<S> {
 
 pub impl<D: Decoder, T: Decodable<D>> ~T: Decodable<D> {
     static fn decode(&self, d: &D) -> ~T {
-        d.read_owned(|| ~decode(d))
+        d.read_owned(|| ~Decodable::decode(d))
     }
 }
 
@@ -310,7 +310,7 @@ pub impl<S: Encoder, T: Encodable<S>> @T: Encodable<S> {
 
 pub impl<D: Decoder, T: Decodable<D>> @T: Decodable<D> {
     static fn decode(&self, d: &D) -> @T {
-        d.read_managed(|| @decode(d))
+        d.read_managed(|| @Decodable::decode(d))
     }
 }
 
@@ -338,7 +338,7 @@ pub impl<D: Decoder, T: Decodable<D>> ~[T]: Decodable<D> {
     static fn decode(&self, d: &D) -> ~[T] {
         do d.read_owned_vec |len| {
             do vec::from_fn(len) |i| {
-                d.read_vec_elt(i, || decode(d))
+                d.read_vec_elt(i, || Decodable::decode(d))
             }
         }
     }
@@ -358,7 +358,7 @@ pub impl<D: Decoder, T: Decodable<D>> @[T]: Decodable<D> {
     static fn decode(&self, d: &D) -> @[T] {
         do d.read_managed_vec |len| {
             do at_vec::from_fn(len) |i| {
-                d.read_vec_elt(i, || decode(d))
+                d.read_vec_elt(i, || Decodable::decode(d))
             }
         }
     }
@@ -385,7 +385,8 @@ pub impl<D: Decoder, T: Decodable<D>> Option<T>: Decodable<D> {
             do d.read_enum_variant |i| {
                 match i {
                   0 => None,
-                  1 => Some(d.read_enum_variant_arg(0u, || decode(d))),
+                  1 => Some(d.read_enum_variant_arg(
+                      0u, || Decodable::decode(d))),
                   _ => fail(fmt!("Bad variant for option: %u", i))
                 }
             }
@@ -418,8 +419,8 @@ pub impl<
     static fn decode(&self, d: &D) -> (T0, T1) {
         do d.read_tup(2) {
             (
-                d.read_tup_elt(0, || decode(d)),
-                d.read_tup_elt(1, || decode(d))
+                d.read_tup_elt(0, || Decodable::decode(d)),
+                d.read_tup_elt(1, || Decodable::decode(d))
             )
         }
     }
@@ -453,9 +454,9 @@ pub impl<
     static fn decode(&self, d: &D) -> (T0, T1, T2) {
         do d.read_tup(3) {
             (
-                d.read_tup_elt(0, || decode(d)),
-                d.read_tup_elt(1, || decode(d)),
-                d.read_tup_elt(2, || decode(d))
+                d.read_tup_elt(0, || Decodable::decode(d)),
+                d.read_tup_elt(1, || Decodable::decode(d)),
+                d.read_tup_elt(2, || Decodable::decode(d))
             )
         }
     }
@@ -492,10 +493,10 @@ pub impl<
     static fn decode(&self, d: &D) -> (T0, T1, T2, T3) {
         do d.read_tup(4) {
             (
-                d.read_tup_elt(0, || decode(d)),
-                d.read_tup_elt(1, || decode(d)),
-                d.read_tup_elt(2, || decode(d)),
-                d.read_tup_elt(3, || decode(d))
+                d.read_tup_elt(0, || Decodable::decode(d)),
+                d.read_tup_elt(1, || Decodable::decode(d)),
+                d.read_tup_elt(2, || Decodable::decode(d)),
+                d.read_tup_elt(3, || Decodable::decode(d))
             )
         }
     }
@@ -536,11 +537,11 @@ pub impl<
       -> (T0, T1, T2, T3, T4) {
         do d.read_tup(5) {
             (
-                d.read_tup_elt(0, || decode(d)),
-                d.read_tup_elt(1, || decode(d)),
-                d.read_tup_elt(2, || decode(d)),
-                d.read_tup_elt(3, || decode(d)),
-                d.read_tup_elt(4, || decode(d))
+                d.read_tup_elt(0, || Decodable::decode(d)),
+                d.read_tup_elt(1, || Decodable::decode(d)),
+                d.read_tup_elt(2, || Decodable::decode(d)),
+                d.read_tup_elt(3, || Decodable::decode(d)),
+                d.read_tup_elt(4, || Decodable::decode(d))
             )
         }
     }
diff --git a/src/libstd/workcache.rs b/src/libstd/workcache.rs
index 1a997d4b709..9b7bbb1660f 100644
--- a/src/libstd/workcache.rs
+++ b/src/libstd/workcache.rs
@@ -15,7 +15,7 @@ use either::{Right,Left,Either};
 
 use json;
 use sha1;
-use serialize::{Encoder, Encodable, Decoder, Decodable, decode};
+use serialize::{Encoder, Encodable, Decoder, Decodable};
 
 /**
 *