---

yaml
---
r: 62943
b: refs/heads/snap-stage3
c: 231aea6
h: refs/heads/master
i:
  62941: 555c17e
  62939: 6d094ef
  62935: 8bed276
  62927: 32f2d23
  62911: 4926ace
v: v3

Author: catamorphism

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: ecd08b989ae006660929bce6b719d9f7bc34a7fe
+refs/heads/snap-stage3: 231aea6d6e464f2676eba4ce4c30f2126fe262b7
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/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/snap-stage3/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/snap-stage3/src/librustc/middle/typeck/astconv.rs

@@ -455,7 +455,7 @@ pub fn ast_ty_to_ty<AC:AstConv, RS:region_scope + Copy + 'static>(
           }
           _ => {
             tcx.sess.span_fatal(ast_ty.span,
-                                "found type name used as a variable");
+                                fmt!("found value name used as a type: %?", a_def));
           }
         }
       }

branches/snap-stage3/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/snap-stage3/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>() -> (server::Oneshot<T>, client::Oneshot<T>) {
+        pub fn init<T: Owned>() -> (client::Oneshot<T>, server::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 (port, chan) = oneshot::init();
+        let (chan, port) = 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>() -> (server::Open<T>, client::Open<T>) {
+        pub fn init<T: Owned>() -> (client::Open<T>, server::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 (s, c) = ::core::pipes::entangle();
+                    let (c, s) = ::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 (s, c) = ::core::pipes::entangle();
+                    let (c, s) = ::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 (s, c) = streamp::init();
+        let (c, s) = streamp::init();
 
         (Port {
             endp: Some(s)

branches/snap-stage3/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>)
-    -> (RecvPacketBuffered<Tstart, T>, SendPacketBuffered<Tstart, T>) {
+    -> (SendPacketBuffered<Tstart, T>, RecvPacketBuffered<Tstart, T>) {
     unsafe {
         let p = init(transmute_copy(&buffer), &mut buffer.data);
         forget(buffer);
-        (RecvPacketBuffered(p), SendPacketBuffered(p))
+        (SendPacketBuffered(p), RecvPacketBuffered(p))
     }
 }
 
@@ -775,9 +775,9 @@ pub fn RecvPacketBuffered<T,Tbuffer>(p: *mut Packet<T>)
     }
 }
 
-pub fn entangle<T>() -> (RecvPacket<T>, SendPacket<T>) {
+pub fn entangle<T>() -> (SendPacket<T>, RecvPacket<T>) {
     let p = packet();
-    (RecvPacket(p), SendPacket(p))
+    (SendPacket(p), RecvPacket(p))
 }
 
 /** Receives a message from one of two endpoints.

branches/snap-stage3/src/libsyntax/ext/pipes/pipec.rs

@@ -89,10 +89,10 @@ impl gen_send for message {
             }
             else {
                 let pat = match (this.dir, next.dir) {
-                  (send, send) => "(s, c)",
-                  (send, recv) => "(c, s)",
-                  (recv, send) => "(c, s)",
-                  (recv, recv) => "(s, c)"
+                  (send, send) => "(c, s)",
+                  (send, recv) => "(s, c)",
+                  (recv, send) => "(s, c)",
+                  (recv, recv) => "(c, s)"
                 };
 
                 body += fmt!("let %s = ::std::pipes::entangle();\n", pat);
@@ -317,13 +317,30 @@ impl gen_init for protocol {
         let start_state = self.states[0];
 
         let body = if !self.is_bounded() {
-            quote_expr!( ::std::pipes::entangle() )
+            match start_state.dir {
+              send => quote_expr!( ::std::pipes::entangle() ),
+              recv => {
+                quote_expr!({
+                    let (s, c) = ::std::pipes::entangle();
+                    (c, s)
+                })
+              }
+            }
         }
         else {
-            self.gen_init_bounded(ext_cx)
+            let body = self.gen_init_bounded(ext_cx);
+            match start_state.dir {
+              send => body,
+              recv => {
+                  quote_expr!({
+                      let (s, c) = $body;
+                      (c, s)
+                  })
+              }
+            }
         };
 
-        cx.parse_item(fmt!("pub fn init%s() -> (server::%s, client::%s)\
+        cx.parse_item(fmt!("pub fn init%s() -> (client::%s, server::%s)\
                             { pub use std::pipes::HasBuffer; %s }",
                            start_state.generics.to_source(cx),
                            start_state.to_ty(cx).to_source(cx),

branches/snap-stage3/src/test/auxiliary/reexported_static_methods.rs renamed to branches/snap-stage3/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/snap-stage3/src/test/bench/msgsend-ring-pipes.rs

@@ -73,7 +73,7 @@ fn main() {
     let num_tasks = uint::from_str(args[1]).get();
     let msg_per_task = uint::from_str(args[2]).get();
 
-    let (num_port, num_chan) = ring::init();
+    let (num_chan, num_port) = ring::init();
     let mut num_chan = Cell(num_chan);
 
     let start = time::precise_time_s();
@@ -83,7 +83,7 @@ fn main() {
 
     for uint::range(1u, num_tasks) |i| {
         //error!("spawning %?", i);
-        let (num_port, new_chan) = ring::init();
+        let (new_chan, num_port) = ring::init();
         let num_chan2 = Cell(num_chan.take());
         let num_port = Cell(num_port);
         let new_future = do future::spawn || {