---

yaml
---
r: 65523
b: refs/heads/master
c: ecd08b9
h: refs/heads/master
i:
  65521: 82276b6
  65519: 0dadfb3
v: v3

Author: Nick Desaulniers

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 75f1b7f96fa4e91244a96ba92f615f3213d97519
+refs/heads/master: ecd08b989ae006660929bce6b719d9f7bc34a7fe
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 18e3db7392d2d0697b7e27d6d986139960144d85
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9

trunk/src/librustc/metadata/encoder.rs

@@ -374,50 +374,90 @@ fn encode_path(ecx: @EncodeContext,
 fn encode_reexported_static_method(ecx: @EncodeContext,
                                    ebml_w: &mut writer::Encoder,
                                    exp: &middle::resolve::Export2,
-                                   m: @ty::Method) {
-    debug!("(encode static trait method) reexport '%s::%s'",
-            *exp.name, *ecx.tcx.sess.str_of(m.ident));
+                                   method_def_id: def_id,
+                                   method_ident: ident) {
+    debug!("(encode reexported static method) %s::%s",
+            *exp.name, *ecx.tcx.sess.str_of(method_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(m.def_id));
+    ebml_w.wr_str(def_to_str(method_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(m.ident));
+    ebml_w.wr_str(*exp.name + "::" + *ecx.tcx.sess.str_of(method_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.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);
-                            }
-                        }
+    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));
                     }
                 }
-                _ => {}
+                else {
+                    debug!(fmt!("(encode reexported static methods) %s [base]",
+                                *original_name));
+                }
             }
         }
         _ => {}

trunk/src/librustc/middle/trans/expr.rs

@@ -727,8 +727,14 @@ fn trans_def_dps_unadjusted(bcx: block, ref_expr: @ast::expr,
             }
         }
         ast::def_struct(*) => {
-            // Nothing to do here.
-            // FIXME #6572: May not be true in the case of classes with destructors.
+            let ty = expr_ty(bcx, ref_expr);
+            match ty::get(ty).sty {
+                ty::ty_struct(did, _) if ty::has_dtor(ccx.tcx, did) => {
+                    let repr = adt::represent_type(ccx, ty);
+                    adt::trans_start_init(bcx, repr, lldest, 0);
+                }
+                _ => {}
+            }
             return bcx;
         }
         _ => {

trunk/src/librustc/middle/ty.rs

@@ -307,6 +307,9 @@ 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>,
@@ -972,6 +975,7 @@ 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(),
      }
@@ -3700,6 +3704,21 @@ 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,

trunk/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, class, or trait");
+                           enum, struct, or trait");
                 }
             }
         }
@@ -313,6 +313,7 @@ impl CoherenceChecker {
                             implementation = existing_implementation;
                         }
                     }
+
                     self.add_inherent_method(base_type_def_id,
                                              implementation);
                 }
@@ -434,6 +435,8 @@ 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) {

trunk/src/libstd/comm.rs

@@ -376,7 +376,7 @@ mod pipesy {
         priv use core::kinds::Owned;
         use ptr::to_mut_unsafe_ptr;
 
-        pub fn init<T: Owned>() -> (client::Oneshot<T>, server::Oneshot<T>) {
+        pub fn init<T: Owned>() -> (server::Oneshot<T>, client::Oneshot<T>) {
             pub use core::pipes::HasBuffer;
 
             let buffer = ~::core::pipes::Buffer {
@@ -466,7 +466,7 @@ mod pipesy {
 
     /// Initialiase a (send-endpoint, recv-endpoint) oneshot pipe pair.
     pub fn oneshot<T: Owned>() -> (PortOne<T>, ChanOne<T>) {
-        let (chan, port) = oneshot::init();
+        let (port, chan) = oneshot::init();
         (PortOne::new(port), ChanOne::new(chan))
     }
 
@@ -550,7 +550,7 @@ mod pipesy {
     pub mod streamp {
         priv use core::kinds::Owned;
 
-        pub fn init<T: Owned>() -> (client::Open<T>, server::Open<T>) {
+        pub fn init<T: Owned>() -> (server::Open<T>, client::Open<T>) {
             pub use core::pipes::HasBuffer;
             ::core::pipes::entangle()
         }
@@ -567,7 +567,7 @@ mod pipesy {
                 ::core::option::Option<Open<T>> {
                 {
                     use super::data;
-                    let (c, s) = ::core::pipes::entangle();
+                    let (s, c) = ::core::pipes::entangle();
                     let message = data(x_0, s);
                     if ::core::pipes::send(pipe, message) {
                         ::core::pipes::rt::make_some(c)
@@ -579,7 +579,7 @@ mod pipesy {
             pub fn data<T: Owned>(pipe: Open<T>, x_0: T) -> Open<T> {
                 {
                     use super::data;
-                    let (c, s) = ::core::pipes::entangle();
+                    let (s, c) = ::core::pipes::entangle();
                     let message = data(x_0, s);
                     ::core::pipes::send(pipe, message);
                     c
@@ -615,7 +615,7 @@ mod pipesy {
 
     */
     pub fn stream<T:Owned>() -> (Port<T>, Chan<T>) {
-        let (c, s) = streamp::init();
+        let (s, c) = streamp::init();
 
         (Port {
             endp: Some(s)

trunk/src/libstd/hashmap.rs

@@ -425,10 +425,9 @@ impl<K: Hash + Eq, V> HashMap<K, V> {
         }
     }
 
-    /// Modify and return the value corresponding to the key in the map, or
-    /// insert and return a new value if it doesn't exist.
-    pub fn mangle<'a,A>(&'a mut self, k: K, a: A, not_found: &fn(&K, A) -> V,
-                        found: &fn(&K, &mut V, A)) -> &'a mut V {
+    /// Return the value corresponding to the key in the map, or insert
+    /// and return the value if it doesn't exist.
+    pub fn find_or_insert<'a>(&'a mut self, k: K, v: V) -> &'a V {
         if self.size >= self.resize_at {
             // n.b.: We could also do this after searching, so
             // that we do not resize if this call to insert is
@@ -442,37 +441,46 @@ impl<K: Hash + Eq, V> HashMap<K, V> {
         let hash = k.hash_keyed(self.k0, self.k1) as uint;
         let idx = match self.bucket_for_key_with_hash(hash, &k) {
             TableFull => fail!("Internal logic error"),
-            FoundEntry(idx) => { found(&k, self.mut_value_for_bucket(idx), a); idx }
+            FoundEntry(idx) => idx,
             FoundHole(idx) => {
-                let v = not_found(&k, a);
-                self.buckets[idx] = Some(Bucket{hash: hash, key: k, value: v});
+                self.buckets[idx] = Some(Bucket{hash: hash, key: k,
+                                     value: v});
                 self.size += 1;
                 idx
-            }
+            },
         };
 
-        self.mut_value_for_bucket(idx)
-    }
-
-    /// Return the value corresponding to the key in the map, or insert
-    /// and return the value if it doesn't exist.
-    pub fn find_or_insert<'a>(&'a mut self, k: K, v: V) -> &'a mut V {
-        self.mangle(k, v, |_k, a| a, |_k,_v,_a| ())
+        self.value_for_bucket(idx)
     }
 
     /// Return the value corresponding to the key in the map, or create,
     /// insert, and return a new value if it doesn't exist.
     pub fn find_or_insert_with<'a>(&'a mut self, k: K, f: &fn(&K) -> V)
-                               -> &'a mut V {
-        self.mangle(k, (), |k,_a| f(k), |_k,_v,_a| ())
-    }
+                                   -> &'a V {
+        if self.size >= self.resize_at {
+            // n.b.: We could also do this after searching, so
+            // that we do not resize if this call to insert is
+            // simply going to update a key in place.  My sense
+            // though is that it's worse to have to search through
+            // buckets to find the right spot twice than to just
+            // resize in this corner case.
+            self.expand();
+        }
 
-    /// Insert a key-value pair into the map if the key is not already present.
-    /// Otherwise, modify the existing value for the key.
-    /// Returns the new or modified value for the key.
-    pub fn insert_or_update_with<'a>(&'a mut self, k: K, v: V,
-                                     f: &fn(&K, &mut V)) -> &'a mut V {
-        self.mangle(k, v, |_k,a| a, |k,v,_a| f(k,v))
+        let hash = k.hash_keyed(self.k0, self.k1) as uint;
+        let idx = match self.bucket_for_key_with_hash(hash, &k) {
+            TableFull => fail!("Internal logic error"),
+            FoundEntry(idx) => idx,
+            FoundHole(idx) => {
+                let v = f(&k);
+                self.buckets[idx] = Some(Bucket{hash: hash, key: k,
+                                     value: v});
+                self.size += 1;
+                idx
+            },
+        };
+
+        self.value_for_bucket(idx)
     }
 
     /// Calls a function on each element of a hash map, destroying the hash
@@ -755,22 +763,15 @@ mod test_map {
     #[test]
     fn test_find_or_insert() {
         let mut m = HashMap::new::<int, int>();
-        assert_eq!(*m.find_or_insert(1, 2), 2);
-        assert_eq!(*m.find_or_insert(1, 3), 2);
+        assert_eq!(m.find_or_insert(1, 2), &2);
+        assert_eq!(m.find_or_insert(1, 3), &2);
     }
 
     #[test]
     fn test_find_or_insert_with() {
         let mut m = HashMap::new::<int, int>();
-        assert_eq!(*m.find_or_insert_with(1, |_| 2), 2);
-        assert_eq!(*m.find_or_insert_with(1, |_| 3), 2);
-    }
-
-    #[test]
-    fn test_insert_or_update_with() {
-        let mut m = HashMap::new::<int, int>();
-        assert_eq!(*m.insert_or_update_with(1, 2, |_,x| *x+=1), 2);
-        assert_eq!(*m.insert_or_update_with(1, 2, |_,x| *x+=1), 3);
+        assert_eq!(m.find_or_insert_with(1, |_| 2), &2);
+        assert_eq!(m.find_or_insert_with(1, |_| 3), &2);
     }
 
     #[test]

trunk/src/libstd/pipes.rs

@@ -237,11 +237,11 @@ pub fn packet<T>() -> *mut Packet<T> {
 pub fn entangle_buffer<T:Owned,Tstart:Owned>(
     mut buffer: ~Buffer<T>,
     init: &fn(*libc::c_void, x: &mut T) -> *mut Packet<Tstart>)
-    -> (SendPacketBuffered<Tstart, T>, RecvPacketBuffered<Tstart, T>) {
+    -> (RecvPacketBuffered<Tstart, T>, SendPacketBuffered<Tstart, T>) {
     unsafe {
         let p = init(transmute_copy(&buffer), &mut buffer.data);
         forget(buffer);
-        (SendPacketBuffered(p), RecvPacketBuffered(p))
+        (RecvPacketBuffered(p), SendPacketBuffered(p))
     }
 }
 
@@ -775,9 +775,9 @@ pub fn RecvPacketBuffered<T,Tbuffer>(p: *mut Packet<T>)
     }
 }
 
-pub fn entangle<T>() -> (SendPacket<T>, RecvPacket<T>) {
+pub fn entangle<T>() -> (RecvPacket<T>, SendPacket<T>) {
     let p = packet();
-    (SendPacket(p), RecvPacket(p))
+    (RecvPacket(p), SendPacket(p))
 }
 
 /** Receives a message from one of two endpoints.