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

Author: brson

src/librustc/metadata/decoder.rs

@@ -25,7 +25,7 @@ use reader = std::ebml::reader;
 use std::ebml;
 use std::map::HashMap;
 use std::map;
-use std::serialize::decode;
+use std::serialize::traits::Decodable;
 use syntax::ast_map;
 use syntax::attr;
 use syntax::diagnostic::span_handler;
@@ -284,7 +284,7 @@ fn item_ty_param_bounds(item: ebml::Doc, tcx: ty::ctxt, cdata: cmd)
 
 fn item_ty_region_param(item: ebml::Doc) -> Option<ty::region_variance> {
     reader::maybe_get_doc(item, tag_region_param).map(|doc| {
-        decode(&reader::Decoder(*doc))
+        Decodable::decode(&reader::Decoder(*doc))
     })
 }
 

src/librustc/middle/astencode.rs

@@ -28,7 +28,8 @@ use std::ebml::writer::Encoder;
 use std::ebml;
 use std::map::HashMap;
 use std::serialize;
-use std::serialize::{Encodable, EncoderHelpers, DecoderHelpers, decode};
+use std::serialize::{Encodable, EncoderHelpers, DecoderHelpers};
+use std::serialize::traits::Decodable;
 use syntax::ast;
 use syntax::ast_map;
 use syntax::ast_util;
@@ -117,7 +118,7 @@ fn decode_inlined_item(cdata: cstore::crate_metadata,
         debug!("> Decoding inlined fn: %s::?",
                ast_map::path_to_str(path, tcx.sess.parse_sess.interner));
         let ast_dsr = &reader::Decoder(ast_doc);
-        let from_id_range = decode(ast_dsr);
+        let from_id_range = Decodable::decode(ast_dsr);
         let to_id_range = reserve_id_range(dcx.tcx.sess, from_id_range);
         let xcx = extended_decode_ctxt_(@{dcx: dcx,
                                           from_id_range: from_id_range,
@@ -210,7 +211,7 @@ trait def_id_decoder_helpers {
 impl<D: serialize::Decoder> D: def_id_decoder_helpers {
 
     fn read_def_id(xcx: extended_decode_ctxt) -> ast::def_id {
-        let did: ast::def_id = decode(&self);
+        let did: ast::def_id = Decodable::decode(&self);
         did.tr(xcx)
     }
 }
@@ -287,7 +288,7 @@ fn simplify_ast(ii: ast::inlined_item) -> ast::inlined_item {
 fn decode_ast(par_doc: ebml::Doc) -> ast::inlined_item {
     let chi_doc = par_doc[c::tag_tree as uint];
     let d = &reader::Decoder(chi_doc);
-    decode(d)
+    Decodable::decode(d)
 }
 
 fn renumber_ast(xcx: extended_decode_ctxt, ii: ast::inlined_item)
@@ -332,7 +333,7 @@ fn encode_def(ebml_w: writer::Encoder, def: ast::def) {
 
 fn decode_def(xcx: extended_decode_ctxt, doc: ebml::Doc) -> ast::def {
     let dsr = &reader::Decoder(doc);
-    let def: ast::def = decode(dsr);
+    let def: ast::def = Decodable::decode(dsr);
     def.tr(xcx)
 }
 
@@ -430,7 +431,7 @@ trait ebml_decoder_helper {
 
 impl reader::Decoder: ebml_decoder_helper {
     fn read_freevar_entry(xcx: extended_decode_ctxt) -> freevar_entry {
-        let fv: freevar_entry = decode(&self);
+        let fv: freevar_entry = Decodable::decode(&self);
         fv.tr(xcx)
     }
 }
@@ -473,12 +474,13 @@ impl reader::Decoder: read_method_map_entry_helper {
                  }),
              explicit_self:
                  self.read_field(~"explicit_self", 2u, || {
-                    let self_type: ast::self_ty_ = decode(&self);
+                    let self_type: ast::self_ty_ = Decodable::decode(&self);
                     self_type
                  }),
              origin:
                  self.read_field(~"origin", 1u, || {
-                     let method_origin: method_origin = decode(&self);
+                     let method_origin: method_origin =
+                         Decodable::decode(&self);
                      method_origin.tr(xcx)
                  })}
         }
@@ -926,7 +928,7 @@ impl reader::Decoder: ebml_decoder_decoder_helpers {
                     @self.read_to_vec(|| self.read_bounds(xcx) )
                 }),
                 region_param: self.read_field(~"region_param", 1u, || {
-                    decode(&self)
+                    Decodable::decode(&self)
                 }),
                 ty: self.read_field(~"ty", 2u, || {
                     self.read_ty(xcx)
@@ -990,11 +992,11 @@ fn decode_side_tables(xcx: extended_decode_ctxt,
                 dcx.maps.vtable_map.insert(id,
                                            val_dsr.read_vtable_res(xcx));
             } else if tag == (c::tag_table_adjustments as uint) {
-                let adj: @ty::AutoAdjustment = @decode(val_dsr);
+                let adj: @ty::AutoAdjustment = @Decodable::decode(val_dsr);
                 adj.tr(xcx);
                 dcx.tcx.adjustments.insert(id, adj);
             } else if tag == (c::tag_table_value_mode as uint) {
-                let vm: ty::ValueMode = decode(val_dsr);
+                let vm: ty::ValueMode = Decodable::decode(val_dsr);
                 dcx.tcx.value_modes.insert(id, vm);
             } else {
                 xcx.dcx.tcx.sess.bug(
@@ -1020,7 +1022,7 @@ fn encode_item_ast(ebml_w: writer::Encoder, item: @ast::item) {
 fn decode_item_ast(par_doc: ebml::Doc) -> @ast::item {
     let chi_doc = par_doc[c::tag_tree as uint];
     let d = &reader::Decoder(chi_doc);
-    @decode(d)
+    @Decodable::decode(d)
 }
 
 #[cfg(test)]

src/librustc/middle/resolve.rs

@@ -1336,17 +1336,6 @@ impl Resolver {
                                 Some(local_def(item.id)),
                                 ty_m.purity);
 
-                            // For now, add to both the trait module and the
-                            // enclosing module, for backwards compatibility.
-                            let (method_name_bindings, _) =
-                                self.add_child(ident,
-                                               new_parent,
-                                               ForbidDuplicateValues,
-                                               ty_m.span);
-                            method_name_bindings.define_value(Public,
-                                                              def,
-                                                              ty_m.span);
-
                             let (method_name_bindings, _) =
                                 self.add_child(ident,
                                                module_parent_opt.get(),

src/librusti/rusti.rc

@@ -272,8 +272,9 @@ fn run(repl: Repl, input: ~str) -> Repl {
                 vtable_map: vtable_map};
 
     debug!("translation");
+    let path = ~path::GenericPath::from_str("<repl>");
     let (llmod, _) = trans::base::trans_crate(sess, crate, ty_cx,
-                                              ~path::from_str("<repl>"),
+                                              path,
                                               exp_map2, maps);
     let pm = llvm::LLVMCreatePassManager();
 

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;
         }

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;

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))
             )
         }
     }

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};
 
 /**
 *

src/test/auxiliary/static-methods-crate.rs

@@ -36,7 +36,7 @@ impl bool: read {
 }
 
 fn read<T: read Copy>(s: ~str) -> T {
-    match readMaybe(s) {
+    match read::readMaybe(s) {
       Some(x) => x,
       _ => fail ~"read failed!"
     }

src/test/run-pass/auto-encode.rs

@@ -22,7 +22,7 @@ use std::ebml;
 use EBReader = std::ebml::reader;
 use EBWriter = std::ebml::writer;
 use io::Writer;
-use std::serialize::{Encodable, Decodable, decode};
+use std::serialize::traits::{Encodable, Decodable};
 use std::prettyprint;
 use std::time;
 
@@ -47,7 +47,7 @@ fn test_ebml<A:
         a1.encode(ebml_w)
     };
     let d = EBReader::Doc(@move bytes);
-    let a2: A = decode(&EBReader::Decoder(d));
+    let a2: A = Decodable::decode(&EBReader::Decoder(d));
     assert *a1 == a2;
 }
 

src/test/run-pass/static-fn-inline-xc.rs

@@ -16,5 +16,5 @@ extern mod mycore(name ="static_fn_inline_xc_aux");
 use mycore::num;
 
 fn main() {
-    let _1:float = num::from_int2(1i);
+    let _1:float = num::Num2::from_int2(1i);
 }

src/test/run-pass/static-fn-trait-xc.rs

@@ -6,5 +6,5 @@ extern mod mycore(name ="static_fn_trait_xc_aux");
 use mycore::num;
 
 fn main() {
-    let _1:float = num::from_int2(1i);
+    let _1:float = num::Num2::from_int2(1i);
 }

src/test/run-pass/static-method-in-trait-with-tps-intracrate.rs

@@ -30,6 +30,6 @@ impl FromThinAir: Deserializer {
 
 fn main() {
     let d = FromThinAir { dummy: () };
-    let i: int = deserialize(&d);
+    let i: int = Deserializable::deserialize(&d);
     assert i == 22;
 }

src/test/run-pass/static-method-test.rs

@@ -18,7 +18,7 @@ trait bool_like {
 }
 
 fn andand<T: bool_like Copy>(x1: T, x2: T) -> T {
-    select(x1, x2, x1)
+    bool_like::select(x1, x2, x1)
 }
 
 impl bool: bool_like {
@@ -57,7 +57,7 @@ impl<A> ~[A]: buildable<A> {
 
 #[inline(always)]
 pure fn build<A, B: buildable<A>>(builder: fn(push: pure fn(+v: A))) -> B {
-    build_sized(4, builder)
+    buildable::build_sized(4, builder)
 }
 
 /// Apply a function to each element of an iterable and return the results
@@ -71,7 +71,7 @@ fn map<T, IT: BaseIter<T>, U, BU: buildable<U>>
 }
 
 fn seq_range<BT: buildable<int>>(lo: uint, hi: uint) -> BT {
-    do build_sized(hi-lo) |push| {
+    do buildable::build_sized(hi-lo) |push| {
         for uint::range(lo, hi) |i| {
             push(i as int);
         }
@@ -87,7 +87,7 @@ fn main() {
     let v: ~[int] = map(&[1,2,3], |x| 1+x);
     assert v == ~[2, 3, 4];
 
-    assert select(true, 9, 14) == 9;
+    assert bool_like::select(true, 9, 14) == 9;
     assert !andand(true, false);
     assert andand(7, 12) == 12;
     assert andand(0, 12) == 0;

src/test/run-pass/static-method-xcrate.rs

@@ -14,7 +14,7 @@
 
 extern mod static_methods_crate;
 use static_methods_crate::read;
-use readMaybeRenamed = static_methods_crate::readMaybe;
+use readMaybeRenamed = static_methods_crate::read::readMaybe;
 
 fn main() {
     let result: int = read(~"5");