---

yaml
---
r: 44991
b: refs/heads/master
c: 876b6ba
h: refs/heads/master
i:
  44989: 80ec474
  44987: eb36ec6
  44983: f6274e9
  44975: 28b2cc2
  44959: c331704
  44927: 40b6eeb
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 7782aa82d2238371f8d62ed8122d05c2cc225317
+refs/heads/master: 876b6ba792f83f1b50d1356e7305f334b5ba2f05
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d9689399d091c3265f00434a69c551a61c28dc
 refs/heads/try: ef355f6332f83371e4acf04fc4eb940ab41d78d3

trunk/src/libcore/bool.rs

@@ -12,8 +12,6 @@
 //! Boolean logic
 
 use option::{None, Option, Some};
-use from_str::FromStr;
-
 #[cfg(notest)] use cmp;
 
 /// Negation / inverse
@@ -48,15 +46,13 @@ pub pure fn is_true(v: bool) -> bool { v }
 pub pure fn is_false(v: bool) -> bool { !v }
 
 /// Parse logic value from `s`
-impl FromStr for bool {
-    static pure fn from_str(s: &str) -> Option<bool> {
-        if s == "true" {
-            Some(true)
-        } else if s == "false" {
-            Some(false)
-        } else {
-            None
-        }
+pub pure fn from_str(s: &str) -> Option<bool> {
+    if s == "true" {
+        Some(true)
+    } else if s == "false" {
+        Some(false)
+    } else {
+        None
     }
 }
 
@@ -83,10 +79,8 @@ impl cmp::Eq for bool {
 
 #[test]
 pub fn test_bool_from_str() {
-    use from_str::FromStr;
-
     do all_values |v| {
-        assert Some(v) == FromStr::from_str(to_str(v))
+        assert Some(v) == from_str(to_str(v))
     }
 }
 

trunk/src/libcore/comm.rs

@@ -104,64 +104,98 @@ pub fn stream<T:Owned>() -> (Port<T>, Chan<T>) {
     (Port_(Port_ { endp: Some(s) }), Chan_(Chan_{ endp: Some(c) }))
 }
 
+// Add an inherent method so that imports of GenericChan are not
+// required.
+#[cfg(stage1)]
+#[cfg(stage2)]
+pub impl<T: Owned> Chan<T> {
+    fn send(&self, x: T) { chan_send(self, x) }
+    fn try_send(&self, x: T) -> bool { chan_try_send(self, x) }
+}
+
 impl<T: Owned> GenericChan<T> for Chan<T> {
-    fn send(&self, x: T) {
-        let mut endp = None;
-        endp <-> self.endp;
-        self.endp = Some(
-            streamp::client::data(unwrap(endp), x))
-    }
+    fn send(&self, x: T) { chan_send(self, x) }
 }
 
-impl<T: Owned> GenericSmartChan<T> for Chan<T> {
+#[inline(always)]
+fn chan_send<T:Owned>(self: &Chan<T>, x: T) {
+    let mut endp = None;
+    endp <-> self.endp;
+    self.endp = Some(
+        streamp::client::data(unwrap(endp), x))
+}
 
+impl<T: Owned> GenericSmartChan<T> for Chan<T> {
     fn try_send(&self, x: T) -> bool {
-        let mut endp = None;
-        endp <-> self.endp;
-        match streamp::client::try_data(unwrap(endp), x) {
-            Some(next) => {
-                self.endp = Some(next);
-                true
-            }
-            None => false
-        }
+        chan_try_send(self, x)
     }
 }
 
-impl<T: Owned> GenericPort<T> for Port<T> {
-    fn recv(&self) -> T {
-        let mut endp = None;
-        endp <-> self.endp;
-        let streamp::data(x, endp) = recv(unwrap(endp));
-        self.endp = Some(endp);
-        x
+#[inline(always)]
+fn chan_try_send<T:Owned>(self: &Chan<T>, x: T) -> bool {
+    let mut endp = None;
+    endp <-> self.endp;
+    match streamp::client::try_data(unwrap(endp), x) {
+        Some(next) => {
+            self.endp = Some(next);
+            true
+        }
+        None => false
     }
+}
 
-    fn try_recv(&self) -> Option<T> {
-        let mut endp = None;
-        endp <-> self.endp;
-        match try_recv(unwrap(endp)) {
-          Some(streamp::data(x, endp)) => {
+// Use an inherent impl so that imports are not required:
+#[cfg(stage1)]
+#[cfg(stage2)]
+pub impl<T: Owned> Port<T> {
+    fn recv(&self) -> T { port_recv(self) }
+    fn try_recv(&self) -> Option<T> { port_try_recv(self) }
+    pure fn peek(&self) -> bool { port_peek(self) }
+}
+
+impl<T: Owned> GenericPort<T> for Port<T> {
+    // These two calls will prefer the inherent versions above:
+    fn recv(&self) -> T { port_recv(self) }
+    fn try_recv(&self) -> Option<T> { port_try_recv(self) }
+}
+
+#[inline(always)]
+fn port_recv<T:Owned>(self: &Port<T>) -> T {
+    let mut endp = None;
+    endp <-> self.endp;
+    let streamp::data(x, endp) = recv(unwrap(endp));
+    self.endp = Some(endp);
+    x
+}
+
+#[inline(always)]
+fn port_try_recv<T:Owned>(self: &Port<T>) -> Option<T> {
+    let mut endp = None;
+    endp <-> self.endp;
+    match try_recv(unwrap(endp)) {
+        Some(streamp::data(x, endp)) => {
             self.endp = Some(endp);
             Some(x)
-          }
-          None => None
         }
+        None => None
     }
 }
 
 impl<T: Owned> Peekable<T> for Port<T> {
-    pure fn peek(&self) -> bool {
-        unsafe {
-            let mut endp = None;
-            endp <-> self.endp;
-            let peek = match &endp {
-              &Some(ref endp) => peek(endp),
-              &None => fail!(~"peeking empty stream")
-            };
-            self.endp <-> endp;
-            peek
-        }
+    pure fn peek(&self) -> bool { port_peek(self) }
+}
+
+#[inline(always)]
+pure fn port_peek<T:Owned>(self: &Port<T>) -> bool {
+    unsafe {
+        let mut endp = None;
+        endp <-> self.endp;
+        let peek = match &endp {
+            &Some(ref endp) => peek(endp),
+            &None => fail!(~"peeking empty stream")
+        };
+        self.endp <-> endp;
+        peek
     }
 }
 
@@ -187,8 +221,16 @@ pub fn PortSet<T: Owned>() -> PortSet<T>{
     }
 }
 
-pub impl<T: Owned> PortSet<T> {
+// Use an inherent impl so that imports are not required:
+#[cfg(stage1)]
+#[cfg(stage2)]
+pub impl<T:Owned> PortSet<T> {
+    fn recv(&self) -> T { port_set_recv(self) }
+    fn try_recv(&self) -> Option<T> { port_set_try_recv(self) }
+    pure fn peek(&self) -> bool { port_set_peek(self) }
+}
 
+pub impl<T: Owned> PortSet<T> {
     fn add(&self, port: Port<T>) {
         self.ports.push(port)
     }
@@ -200,69 +242,89 @@ pub impl<T: Owned> PortSet<T> {
     }
 }
 
-impl<T: Owned> GenericPort<T> for PortSet<T> {
-
-    fn try_recv(&self) -> Option<T> {
-        let mut result = None;
-        // we have to swap the ports array so we aren't borrowing
-        // aliasable mutable memory.
-        let mut ports = ~[];
-        ports <-> self.ports;
-        while result.is_none() && ports.len() > 0 {
-            let i = wait_many(ports);
-            match ports[i].try_recv() {
-                Some(m) => {
-                  result = Some(m);
-                }
-                None => {
-                    // Remove this port.
-                    let _ = ports.swap_remove(i);
-                }
+impl<T:Owned> GenericPort<T> for PortSet<T> {
+    fn try_recv(&self) -> Option<T> { port_set_try_recv(self) }
+    fn recv(&self) -> T { port_set_recv(self) }
+}
+
+#[inline(always)]
+fn port_set_recv<T:Owned>(self: &PortSet<T>) -> T {
+    port_set_try_recv(self).expect("port_set: endpoints closed")
+}
+
+#[inline(always)]
+fn port_set_try_recv<T:Owned>(self: &PortSet<T>) -> Option<T> {
+    let mut result = None;
+    // we have to swap the ports array so we aren't borrowing
+    // aliasable mutable memory.
+    let mut ports = ~[];
+    ports <-> self.ports;
+    while result.is_none() && ports.len() > 0 {
+        let i = wait_many(ports);
+        match ports[i].try_recv() {
+            Some(m) => {
+                result = Some(m);
+            }
+            None => {
+                // Remove this port.
+                let _ = ports.swap_remove(i);
             }
         }
-        ports <-> self.ports;
-        result
     }
-
-    fn recv(&self) -> T {
-        self.try_recv().expect("port_set: endpoints closed")
-    }
-
+    ports <-> self.ports;
+    result
 }
 
 impl<T: Owned> Peekable<T> for PortSet<T> {
-    pure fn peek(&self) -> bool {
-        // It'd be nice to use self.port.each, but that version isn't
-        // pure.
-        for vec::each(self.ports) |p| {
-            if p.peek() { return true }
-        }
-        false
+    pure fn peek(&self) -> bool { port_set_peek(self) }
+}
+
+#[inline(always)]
+pure fn port_set_peek<T:Owned>(self: &PortSet<T>) -> bool {
+    // It'd be nice to use self.port.each, but that version isn't
+    // pure.
+    for vec::each(self.ports) |p| {
+        if p.peek() { return true }
     }
+    false
 }
 
+
 /// A channel that can be shared between many senders.
 pub type SharedChan<T> = unstable::Exclusive<Chan<T>>;
 
+#[cfg(stage1)]
+#[cfg(stage2)]
+pub impl<T: Owned> SharedChan<T> {
+    fn send(&self, x: T) { shared_chan_send(self, x) }
+    fn try_send(&self, x: T) -> bool { shared_chan_try_send(self, x) }
+}
+
 impl<T: Owned> GenericChan<T> for SharedChan<T> {
-    fn send(&self, x: T) {
-        let mut xx = Some(x);
-        do self.with_imm |chan| {
-            let mut x = None;
-            x <-> xx;
-            chan.send(option::unwrap(x))
-        }
+    fn send(&self, x: T) { shared_chan_send(self, x) }
+}
+
+#[inline(always)]
+fn shared_chan_send<T:Owned>(self: &SharedChan<T>, x: T) {
+    let mut xx = Some(x);
+    do self.with_imm |chan| {
+        let mut x = None;
+        x <-> xx;
+        chan.send(option::unwrap(x))
     }
 }
 
 impl<T: Owned> GenericSmartChan<T> for SharedChan<T> {
-    fn try_send(&self, x: T) -> bool {
-        let mut xx = Some(x);
-        do self.with_imm |chan| {
-            let mut x = None;
-            x <-> xx;
-            chan.try_send(option::unwrap(x))
-        }
+    fn try_send(&self, x: T) -> bool { shared_chan_try_send(self, x) }
+}
+
+#[inline(always)]
+fn shared_chan_try_send<T:Owned>(self: &SharedChan<T>, x: T) -> bool {
+    let mut xx = Some(x);
+    do self.with_imm |chan| {
+        let mut x = None;
+        x <-> xx;
+        chan.try_send(option::unwrap(x))
     }
 }
 

trunk/src/libcore/from_str.rs

@@ -15,3 +15,4 @@ use option::Option;
 pub trait FromStr {
     static pure fn from_str(s: &str) -> Option<Self>;
 }
+