---

yaml
---
r: 149278
b: refs/heads/try2
c: 6fe775e
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 58678dc229a8e2db141314a17e7bc0ea09b8a08a
+refs/heads/try2: 6fe775e2b5eaa77dd49c1d9a234c67d52e5f9087
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libstd/comm/shared.rs

@@ -18,6 +18,7 @@
 /// module. You'll also note that the implementation of the shared and stream
 /// channels are quite similar, and this is no coincidence!
 
+use cmp;
 use int;
 use iter::Iterator;
 use kinds::Send;
@@ -35,6 +36,9 @@ use mpsc = sync::mpsc_queue;
 
 static DISCONNECTED: int = int::MIN;
 static FUDGE: int = 1024;
+#[cfg(test)]
+static MAX_STEALS: int = 5;
+#[cfg(not(test))]
 static MAX_STEALS: int = 1 << 20;
 
 pub struct Packet<T> {
@@ -307,7 +311,11 @@ impl<T: Send> Packet<T> {
                         DISCONNECTED => {
                             self.cnt.store(DISCONNECTED, atomics::SeqCst);
                         }
-                        n => { self.steals -= n; }
+                        n => {
+                            let m = cmp::min(n, self.steals);
+                            self.steals -= m;
+                            self.cnt.fetch_add(n - m, atomics::SeqCst);
+                        }
                     }
                     assert!(self.steals >= 0);
                 }

branches/try2/src/libstd/comm/stream.rs

@@ -17,6 +17,7 @@
 /// High level implementation details can be found in the comment of the parent
 /// module.
 
+use cmp;
 use comm::Port;
 use int;
 use iter::Iterator;
@@ -32,6 +33,9 @@ use sync::atomics;
 use vec::OwnedVector;
 
 static DISCONNECTED: int = int::MIN;
+#[cfg(test)]
+static MAX_STEALS: int = 5;
+#[cfg(not(test))]
 static MAX_STEALS: int = 1 << 20;
 
 pub struct Packet<T> {
@@ -198,19 +202,28 @@ impl<T: Send> Packet<T> {
     pub fn try_recv(&mut self) -> Result<T, Failure<T>> {
         match self.queue.pop() {
             // If we stole some data, record to that effect (this will be
-            // factored into cnt later on). Note that we don't allow steals to
-            // grow without bound in order to prevent eventual overflow of
-            // either steals or cnt as an overflow would have catastrophic
-            // results. Also note that we don't unconditionally set steals to 0
-            // because it can be true that steals > cnt.
+            // factored into cnt later on).
+            //
+            // Note that we don't allow steals to grow without bound in order to
+            // prevent eventual overflow of either steals or cnt as an overflow
+            // would have catastrophic results. Sometimes, steals > cnt, but
+            // other times cnt > steals, so we don't know the relation between
+            // steals and cnt. This code path is executed only rarely, so we do
+            // a pretty slow operation, of swapping 0 into cnt, taking steals
+            // down as much as possible (without going negative), and then
+            // adding back in whatever we couldn't factor into steals.
             Some(data) => {
                 self.steals += 1;
                 if self.steals > MAX_STEALS {
                     match self.cnt.swap(0, atomics::SeqCst) {
                         DISCONNECTED => {
                             self.cnt.store(DISCONNECTED, atomics::SeqCst);
                         }
-                        n => { self.steals -= n; }
+                        n => {
+                            let m = cmp::min(n, self.steals);
+                            self.steals -= m;
+                            self.cnt.fetch_add(n - m, atomics::SeqCst);
+                        }
                     }
                     assert!(self.steals >= 0);
                 }

branches/try2/src/libstd/num/f32.rs

@@ -867,7 +867,6 @@ impl num::FromStrRadix for f32 {
 #[cfg(test)]
 mod tests {
     use f32::*;
-    use prelude::*;
 
     use num::*;
     use num;

branches/try2/src/libstd/num/f64.rs

@@ -869,7 +869,6 @@ impl num::FromStrRadix for f64 {
 #[cfg(test)]
 mod tests {
     use f64::*;
-    use prelude::*;
 
     use num::*;
     use num;

branches/try2/src/libstd/task.rs

@@ -65,7 +65,6 @@ use rt::task::Task;
 use str::{Str, SendStr, IntoMaybeOwned};
 
 #[cfg(test)] use any::{AnyOwnExt, AnyRefExt};
-#[cfg(test)] use ptr;
 #[cfg(test)] use result;
 
 /// Indicates the manner in which a task exited.

branches/try2/src/test/compile-fail/borrowck-move-from-subpath-of-borrowed-path.rs

@@ -0,0 +1,19 @@
+// Copyright 2014 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.
+
+// verify that an error is raised when trying to move out of a
+// borrowed path.
+
+fn main() {
+    let a = ~~2;
+    let b = &a;
+
+    let z = *a; //~ ERROR: cannot move out of `*a` because it is borrowed
+}