---

yaml
---
r: 73662
b: refs/heads/dist-snap
c: ddbd1aa
h: refs/heads/master
v: v3

Author: luqmana

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
 refs/heads/incoming: b50030718cf28f2a5a81857a26b57442734fe854
-refs/heads/dist-snap: 24e85ac82d000a71276eb4cf2090bd176a3638bf
+refs/heads/dist-snap: ddbd1aa883b0325f09492113a483c9c888e7576a
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/librustc/metadata/encoder.rs

@@ -374,90 +374,50 @@ fn encode_path(ecx: @EncodeContext,
 fn encode_reexported_static_method(ecx: @EncodeContext,
                                    ebml_w: &mut writer::Encoder,
                                    exp: &middle::resolve::Export2,
-                                   method_def_id: def_id,
-                                   method_ident: ident) {
-    debug!("(encode reexported static method) %s::%s",
-            *exp.name, *ecx.tcx.sess.str_of(method_ident));
+                                   m: @ty::Method) {
+    debug!("(encode static trait method) reexport '%s::%s'",
+            *exp.name, *ecx.tcx.sess.str_of(m.ident));
     ebml_w.start_tag(tag_items_data_item_reexport);
     ebml_w.start_tag(tag_items_data_item_reexport_def_id);
-    ebml_w.wr_str(def_to_str(method_def_id));
+    ebml_w.wr_str(def_to_str(m.def_id));
     ebml_w.end_tag();
     ebml_w.start_tag(tag_items_data_item_reexport_name);
-    ebml_w.wr_str(*exp.name + "::" + *ecx.tcx.sess.str_of(method_ident));
+    ebml_w.wr_str(*exp.name + "::" + *ecx.tcx.sess.str_of(m.ident));
     ebml_w.end_tag();
     ebml_w.end_tag();
 }
 
-fn encode_reexported_static_base_methods(ecx: @EncodeContext,
-                                         ebml_w: &mut writer::Encoder,
-                                         exp: &middle::resolve::Export2)
-                                         -> bool {
-    match ecx.tcx.base_impls.find(&exp.def_id) {
-        Some(implementations) => {
-            for implementations.each |&base_impl| {
-                for base_impl.methods.each |&m| {
-                    if m.explicit_self == ast::sty_static {
-                        encode_reexported_static_method(ecx, ebml_w, exp,
-                                                        m.did, m.ident);
-                    }
-                }
-            }
-
-            true
-        }
-        None => { false }
-    }
-}
-
-fn encode_reexported_static_trait_methods(ecx: @EncodeContext,
-                                          ebml_w: &mut writer::Encoder,
-                                          exp: &middle::resolve::Export2)
-                                          -> bool {
-    match ecx.tcx.trait_methods_cache.find(&exp.def_id) {
-        Some(methods) => {
-            for methods.each |&m| {
-                if m.explicit_self == ast::sty_static {
-                    encode_reexported_static_method(ecx, ebml_w, exp,
-                                                    m.def_id, m.ident);
-                }
-            }
-
-            true
-        }
-        None => { false }
-    }
-}
-
 fn encode_reexported_static_methods(ecx: @EncodeContext,
                                     ebml_w: &mut writer::Encoder,
                                     mod_path: &[ast_map::path_elt],
                                     exp: &middle::resolve::Export2) {
-    match ecx.tcx.items.find(&exp.def_id.node) {
-        Some(&ast_map::node_item(item, path)) => {
-            let original_name = ecx.tcx.sess.str_of(item.ident);
-
-            //
-            // We don't need to reexport static methods on items
-            // declared in the same module as our `pub use ...` since
-            // that's done when we encode the item itself.
-            //
-            // The only exception is when the reexport *changes* the
-            // name e.g. `pub use Foo = self::Bar` -- we have
-            // encoded metadata for static methods relative to Bar,
-            // but not yet for Foo.
-            //
-            if mod_path != *path || *exp.name != *original_name {
-                if !encode_reexported_static_base_methods(ecx, ebml_w, exp) {
-                    if encode_reexported_static_trait_methods(ecx, ebml_w, exp) {
-                        debug!(fmt!("(encode reexported static methods) %s \
-                                    [trait]",
-                                    *original_name));
+    match ecx.tcx.trait_methods_cache.find(&exp.def_id) {
+        Some(methods) => {
+            match ecx.tcx.items.find(&exp.def_id.node) {
+                Some(&ast_map::node_item(item, path)) => {
+                    let original_name = ecx.tcx.sess.str_of(item.ident);
+
+                    //
+                    // We don't need to reexport static methods on traits
+                    // declared in the same module as our `pub use ...` since
+                    // that's done when we encode the trait item.
+                    //
+                    // The only exception is when the reexport *changes* the
+                    // name e.g. `pub use Foo = self::Bar` -- we have
+                    // encoded metadata for static methods relative to Bar,
+                    // but not yet for Foo.
+                    //
+                    if mod_path != *path || *exp.name != *original_name {
+                        for methods.each |&m| {
+                            if m.explicit_self == ast::sty_static {
+                                encode_reexported_static_method(ecx,
+                                                                ebml_w,
+                                                                exp, m);
+                            }
+                        }
                     }
                 }
-                else {
-                    debug!(fmt!("(encode reexported static methods) %s [base]",
-                                *original_name));
-                }
+                _ => {}
             }
         }
         _ => {}

branches/dist-snap/src/librustc/middle/ty.rs

@@ -307,9 +307,6 @@ struct ctxt_ {
     // Maps a trait onto a mapping from self-ty to impl
     trait_impls: @mut HashMap<ast::def_id, @mut HashMap<t, @Impl>>,
 
-    // Maps a base type to its impl
-    base_impls: @mut HashMap<ast::def_id, @mut ~[@Impl]>,
-
     // Set of used unsafe nodes (functions or blocks). Unsafe nodes not
     // present in this set can be warned about.
     used_unsafe: @mut HashSet<ast::node_id>,
@@ -975,7 +972,6 @@ pub fn mk_ctxt(s: session::Session,
         destructor_for_type: @mut HashMap::new(),
         destructors: @mut HashSet::new(),
         trait_impls: @mut HashMap::new(),
-        base_impls:  @mut HashMap::new(),
         used_unsafe: @mut HashSet::new(),
         used_mut_nodes: @mut HashSet::new(),
      }
@@ -3704,21 +3700,6 @@ pub fn trait_method(cx: ctxt, trait_did: ast::def_id, idx: uint) -> @Method {
     ty::method(cx, method_def_id)
 }
 
-
-pub fn add_base_impl(cx: ctxt, base_def_id: def_id, implementation: @Impl) {
-    let implementations;
-    match cx.base_impls.find(&base_def_id) {
-        None => {
-            implementations = @mut ~[];
-            cx.base_impls.insert(base_def_id, implementations);
-        }
-        Some(&existing) => {
-            implementations = existing;
-        }
-    }
-    implementations.push(implementation);
-}
-
 pub fn trait_methods(cx: ctxt, trait_did: ast::def_id) -> @~[@Method] {
     match cx.trait_methods_cache.find(&trait_did) {
         Some(&methods) => methods,

branches/dist-snap/src/librustc/middle/typeck/coherence.rs

@@ -146,7 +146,7 @@ pub fn get_base_type_def_id(inference_context: @mut InferCtxt,
                 }
                 _ => {
                     fail!("get_base_type() returned a type that wasn't an \
-                           enum, struct, or trait");
+                           enum, class, or trait");
                 }
             }
         }
@@ -313,7 +313,6 @@ impl CoherenceChecker {
                             implementation = existing_implementation;
                         }
                     }
-
                     self.add_inherent_method(base_type_def_id,
                                              implementation);
                 }
@@ -435,8 +434,6 @@ impl CoherenceChecker {
         }
 
         implementation_list.push(implementation);
-
-        ty::add_base_impl(self.crate_context.tcx, base_def_id, implementation);
     }
 
     pub fn add_trait_method(&self, trait_id: def_id, implementation: @Impl) {

branches/dist-snap/src/test/auxiliary/reexported_static_methods.rs renamed to branches/dist-snap/src/test/auxiliary/mod_trait_with_static_methods_lib.rs

@@ -10,8 +10,6 @@
 
 pub use sub_foo::Foo;
 pub use Baz = self::Bar;
-pub use sub_foo::Boz;
-pub use sub_foo::Bort;
 
 pub trait Bar {
     pub fn bar() -> Self;
@@ -30,24 +28,4 @@ pub mod sub_foo {
         pub fn foo() -> int { 42 }
     }
 
-    pub struct Boz {
-        unused_str: ~str
-    }
-
-    pub impl Boz {
-        pub fn boz(i: int) -> bool {
-            i > 0
-        }
-    }
-
-    pub enum Bort {
-        Bort1,
-        Bort2
-    }
-
-    pub impl Bort {
-        pub fn bort() -> ~str {
-            ~"bort()"
-        }
-    }
 }

branches/dist-snap/src/test/run-pass/reexported-static-methods-cross-crate.rs renamed to branches/dist-snap/src/test/run-pass/trait_with_static_methods_cross_crate.rs

@@ -9,17 +9,13 @@
 // except according to those terms.
 
 // xfail-fast
-// aux-build:reexported_static_methods.rs
-extern mod reexported_static_methods;
+// aux-build:mod_trait_with_static_methods_lib.rs
+extern mod mod_trait_with_static_methods_lib;
 
-use reexported_static_methods::Foo;
-use reexported_static_methods::Baz;
-use reexported_static_methods::Boz;
-use reexported_static_methods::Bort;
+use mod_trait_with_static_methods_lib::Foo;
+use mod_trait_with_static_methods_lib::Baz;
 
 pub fn main() {
     assert_eq!(42, Foo::foo());
     assert_eq!(84, Baz::bar());
-    assert!(Boz::boz(1));
-    assert_eq!(~"bort()", Bort::bort());
 }

branches/dist-snap/src/test/run-pass/unit-like-struct-drop-run.rs

@@ -0,0 +1,28 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Make sure the destructor is run for unit-like structs.
+
+use std::task;
+
+struct Foo;
+
+impl Drop for Foo {
+    fn finalize(&self) {
+        fail!("This failure should happen.");
+    }
+}
+
+fn main() {
+    let x = do task::try {
+        let _b = Foo;
+    };
+    assert_eq!(x, Err(()));
+}