---

yaml
---
r: 149279
b: refs/heads/try2
c: bf6abf8
h: refs/heads/master
i:
  149277: a3ecc47
  149275: a01e8ff
  149271: 68c5893
  149263: 87f6a66
  149247: 20e2686
v: v3

Author: brendanzab

[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: 6fe775e2b5eaa77dd49c1d9a234c67d52e5f9087
+refs/heads/try2: bf6abf8cb3d1e169c1baab8d266bd43c58dfbcc6
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/mk/main.mk

@@ -45,7 +45,7 @@ CFG_VERSION_WIN = $(subst -pre,,$(CFG_RELEASE))
 # and include all of the .d files in one fell swoop.
 ALL_OBJ_FILES :=
 
-ifneq ($(NO_MKFILE_DEPS),)
+ifneq ($(NO_MAKEFILE_DEPS),)
 MKFILE_DEPS :=
 else
 MKFILE_DEPS := config.stamp $(call rwildcard,$(CFG_SRC_DIR)mk/,*)

branches/try2/mk/tests.mk

@@ -174,6 +174,16 @@ endif
 check: cleantestlibs cleantmptestlogs tidy all check-stage2
 	$(Q)$(CFG_PYTHON) $(S)src/etc/check-summary.py tmp/*.log
 
+check-notidy: cleantestlibs cleantmptestlogs all check-stage2
+	$(Q)$(CFG_PYTHON) $(S)src/etc/check-summary.py tmp/*.log
+
+check-full: cleantestlibs cleantmptestlogs tidy \
+            all check-stage1 check-stage2 check-stage3
+	$(Q)$(CFG_PYTHON) $(S)src/etc/check-summary.py tmp/*.log
+
+check-test: cleantestlibs cleantmptestlogs all check-stage2-rfail
+	$(Q)$(CFG_PYTHON) $(S)src/etc/check-summary.py tmp/*.log
+
 check-lite: cleantestlibs cleantmptestlogs \
 	$(foreach crate,$(TARGET_CRATES),check-stage2-$(crate)) \
 	check-stage2-rpass \

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

@@ -18,7 +18,6 @@
 /// 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;
@@ -36,9 +35,6 @@ 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> {
@@ -311,11 +307,7 @@ impl<T: Send> Packet<T> {
                         DISCONNECTED => {
                             self.cnt.store(DISCONNECTED, atomics::SeqCst);
                         }
-                        n => {
-                            let m = cmp::min(n, self.steals);
-                            self.steals -= m;
-                            self.cnt.fetch_add(n - m, atomics::SeqCst);
-                        }
+                        n => { self.steals -= n; }
                     }
                     assert!(self.steals >= 0);
                 }

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

@@ -17,7 +17,6 @@
 /// High level implementation details can be found in the comment of the parent
 /// module.
 
-use cmp;
 use comm::Port;
 use int;
 use iter::Iterator;
@@ -33,9 +32,6 @@ 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> {
@@ -202,28 +198,19 @@ 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. 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.
+            // 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.
             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 => {
-                            let m = cmp::min(n, self.steals);
-                            self.steals -= m;
-                            self.cnt.fetch_add(n - m, atomics::SeqCst);
-                        }
+                        n => { self.steals -= n; }
                     }
                     assert!(self.steals >= 0);
                 }

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

@@ -867,6 +867,7 @@ 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,6 +869,7 @@ impl num::FromStrRadix for f64 {
 #[cfg(test)]
 mod tests {
     use f64::*;
+    use prelude::*;
 
     use num::*;
     use num;

branches/try2/src/libstd/task.rs

@@ -65,6 +65,7 @@ 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/libstd/tuple.rs

@@ -15,6 +15,8 @@
 use clone::Clone;
 #[cfg(not(test))] use cmp::*;
 #[cfg(not(test))] use default::Default;
+use fmt;
+use result::{Ok, Err};
 
 /// Method extensions to pairs where both types satisfy the `Clone` bound
 pub trait CloneableTuple<T, U> {
@@ -176,6 +178,12 @@ macro_rules! tuple_impls {
                     ($({ let x: $T = Default::default(); x},)+)
                 }
             }
+
+            impl<$($T: fmt::Show),+> fmt::Show for ($($T,)+) {
+                fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                    write_tuple!(f.buf, $(self.$get_ref_fn()),+)
+                }
+            }
         )+
     }
 }
@@ -202,6 +210,17 @@ macro_rules! lexical_cmp {
     ($a:expr, $b:expr) => { ($a).cmp($b) };
 }
 
+macro_rules! write_tuple {
+    ($buf:expr, $x:expr) => (
+        write!($buf, "({},)", *$x)
+    );
+    ($buf:expr, $hd:expr, $($tl:expr),+) => ({
+        if_ok!(write!($buf, "("));
+        if_ok!(write!($buf, "{}", *$hd));
+        $(if_ok!(write!($buf, ", {}", *$tl));)+
+        write!($buf, ")")
+    });
+}
 
 tuple_impls! {
     (Tuple1, ImmutableTuple1) {
@@ -422,4 +441,11 @@ mod tests {
         assert_eq!(small.cmp(&big), Less);
         assert_eq!(big.cmp(&small), Greater);
     }
+
+    #[test]
+    fn test_show() {
+        assert_eq!(format!("{}", (1,)), ~"(1,)");
+        assert_eq!(format!("{}", (1, true)), ~"(1, true)");
+        assert_eq!(format!("{}", (1, ~"hi", true)), ~"(1, hi, true)");
+    }
 }