---

yaml
---
r: 107652
b: refs/heads/dist-snap
c: 0f637eb
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: f64fdf524a434f0e5cd0bc91d09c144723f3c90d
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 988e4f0a1c2802921375271bdc19f03650c024d2
+refs/heads/dist-snap: 0f637ebd0634f0c8a96a5567d9eab82fc5a181c7
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/doc/guide-runtime.md

@@ -202,7 +202,7 @@ Some benefits of using libgreen are:
 
 M:N threading is built upon the concept of a pool of M OS threads (which
 libgreen refers to as schedulers), able to run N Rust tasks. This abstraction is
-encompassed in libgreen's [`SchedPool`][schedpool] type. This type allows for
+encompassed in libgreen's [`SchedPool`](green/struct.SchedPool.html) type. This type allows for
 fine-grained control over the pool of schedulers which will be used to run Rust
 tasks.
 

branches/dist-snap/src/libstd/comm/select.rs

@@ -199,11 +199,14 @@ impl Select {
                 if (*packet).decrement() {
                     Ok(())
                 } else {
+                    // Empty to_wake first to avoid tripping an assertion in
+                    // abort_selection in the disconnected case.
+                    let task = (*packet).to_wake.take_unwrap();
                     (*packet).abort_selection(false);
                     (*packet).selecting.store(false, SeqCst);
                     ready_index = i;
                     ready_id = (*packet).selection_id;
-                    Err((*packet).to_wake.take_unwrap())
+                    Err(task)
                 }
             });
 

branches/dist-snap/src/libstd/iter.rs

@@ -1366,7 +1366,7 @@ impl<'a, A, T: Iterator<A>> Peekable<A, T> {
     /// Check whether peekable iterator is empty or not.
     #[inline]
     pub fn is_empty(&mut self) -> bool {
-        self.peek().is_some()
+        self.peek().is_none()
     }
 }
 
@@ -2936,6 +2936,7 @@ mod tests {
         assert_eq!(ys, [5, 4, 3, 2, 1]);
     }
 
+    #[test]
     fn test_peekable_is_empty() {
         let a = [1];
         let mut it = a.iter().peekable();

branches/dist-snap/src/libstd/rt/mod.rs

@@ -41,16 +41,14 @@ out of `rt` as development proceeds.
 Several modules in `core` are clients of `rt`:
 
 * `std::task` - The user-facing interface to the Rust task model.
-* `std::task::local_data` - The interface to local data.
+* `std::local_data` - The interface to local data.
 * `std::gc` - The garbage collector.
 * `std::unstable::lang` - Miscellaneous lang items, some of which rely on `std::rt`.
 * `std::condition` - Uses local data.
 * `std::cleanup` - Local heap destruction.
 * `std::io` - In the future `std::io` will use an `rt` implementation.
 * `std::logging`
-* `std::pipes`
 * `std::comm`
-* `std::stackwalk`
 
 */