---

yaml
---
r: 101899
b: refs/heads/master
c: 58a2b7d
h: refs/heads/master
i:
  101897: 95d214c
  101895: bb277f7
v: v3

Author: brson

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 0ba6d4885fc71ca7156e1fe689edb939e1d9d418
+refs/heads/master: 58a2b7da077b0372e4a06cdf55d1fe08800fbfec
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6e7f170fedd3c526a643c0b2d13863acd982be02
 refs/heads/try: a97642026c18a624ff6ea01075dd9550f8ed07ff

trunk/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/,*)

trunk/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 \

trunk/src/doc/index.md

@@ -24,27 +24,24 @@ li {list-style-type: none; }
 
 # Libraries
 
-* [The standard library, `libstd`](std/index.html)
-* [The extra library, `libextra`](extra/index.html)
-
-* [The M:N runtime library, `libgreen`](green/index.html)
-* [The 1:1 runtime library, `libnative`](native/index.html)
-
-* [The Rust libuv library, `librustuv`](rustuv/index.html)
-
-* [The Rust parser, `libsyntax`](syntax/index.html)
-* [The Rust compiler, `librustc`](rustc/index.html)
+* [The standard library, `std`](std/index.html)
 
 * [The `arena` allocation library](arena/index.html)
-* [The `num` arbitrary precision numerics library](num/index.html)
 * [The `collections` library](collections/index.html)
+* [The `extra` library of extra stuff](extra/index.html)
 * [The `flate` compression library](flate/index.html)
 * [The `fourcc` four-character code library](fourcc/index.html)
 * [The `getopts` argument parsing library](getopts/index.html)
 * [The `glob` file path matching library](glob/index.html)
+* [The `green` M:N runtime library](green/index.html)
+* [The `native` 1:1 threading runtime](native/index.html)
+* [The `num` arbitrary precision numerics library](num/index.html)
+* [The `rustc` compiler](rustc/index.html)
+* [The `rustuv` M:N I/O library](rustuv/index.html)
 * [The `semver` version collation library](semver/index.html)
 * [The `serialize` value encoding/decoding library](serialize/index.html)
 * [The `sync` library for concurrency-enabled mechanisms and primitives](sync/index.html)
+* [The `syntax` library, the Rust parser](syntax/index.html)
 * [The `term` terminal-handling library](term/index.html)
 * [The `uuid` 128-bit universally unique identifier library](uuid/index.html)
 

trunk/src/etc/vim/syntax/rust.vim

@@ -95,9 +95,13 @@ syn keyword rustTrait Buffer Writer Reader Seek
 syn keyword rustTrait Str StrVector StrSlice OwnedStr IntoMaybeOwned
 syn keyword rustTrait IterBytes
 syn keyword rustTrait ToStr IntoStr
+syn keyword rustTrait CloneableTuple ImmutableTuple
 syn keyword rustTrait Tuple1 Tuple2 Tuple3 Tuple4
 syn keyword rustTrait Tuple5 Tuple6 Tuple7 Tuple8
 syn keyword rustTrait Tuple9 Tuple10 Tuple11 Tuple12
+syn keyword rustTrait ImmutableTuple1 ImmutableTuple2 ImmutableTuple3 ImmutableTuple4
+syn keyword rustTrait ImmutableTuple5 ImmutableTuple6 ImmutableTuple7 ImmutableTuple8
+syn keyword rustTrait ImmutableTuple9 ImmutableTuple10 ImmutableTuple11 ImmutableTuple12
 syn keyword rustTrait ImmutableEqVector ImmutableTotalOrdVector ImmutableCloneableVector
 syn keyword rustTrait OwnedVector OwnedCloneableVector OwnedEqVector MutableVector
 syn keyword rustTrait Vector VectorVector CloneableVector ImmutableVector

trunk/src/libcollections/btree.rs

@@ -500,15 +500,15 @@ impl<K: Clone + TotalOrd, V: Clone> Branch<K, V> {
                     let new_outcome = self.clone().rightmost_child.insert(k.clone(),
                                                                        v.clone(),
                                                                        ub.clone());
-                    new_branch = new_outcome.clone().val0();
-                    outcome = new_outcome.val1();
+                    new_branch = new_outcome.clone().n0();
+                    outcome = new_outcome.n1();
                 }
                 else {
                     let new_outcome = self.clone().elts[index.unwrap()].left.insert(k.clone(),
                                                                                  v.clone(),
                                                                                  ub.clone());
-                    new_branch = new_outcome.clone().val0();
-                    outcome = new_outcome.val1();
+                    new_branch = new_outcome.clone().n0();
+                    outcome = new_outcome.n1();
                 }
                 //Check to see whether a branch or a leaf was returned from the
                 //tree traversal.

trunk/src/libnative/io/process.rs

@@ -529,7 +529,7 @@ fn with_envp<T>(env: Option<~[(~str, ~str)]>, cb: |*c_void| -> T) -> T {
             let mut tmps = vec::with_capacity(env.len());
 
             for pair in env.iter() {
-                let kv = format!("{}={}", *pair.ref0(), *pair.ref1());
+                let kv = format!("{}={}", pair.first(), pair.second());
                 tmps.push(kv.to_c_str());
             }
 
@@ -553,7 +553,7 @@ fn with_envp<T>(env: Option<~[(~str, ~str)]>, cb: |*mut c_void| -> T) -> T {
             let mut blk = ~[];
 
             for pair in env.iter() {
-                let kv = format!("{}={}", *pair.ref0(), *pair.ref1());
+                let kv = format!("{}={}", pair.first(), pair.second());
                 blk.push_all(kv.as_bytes());
                 blk.push(0);
             }

trunk/src/librustc/middle/trans/consts.rs

@@ -599,7 +599,7 @@ fn const_expr_unadjusted(cx: @CrateContext, e: &ast::Expr,
                 const_eval::const_uint(i) => i as uint,
                 _ => cx.sess.span_bug(count.span, "count must be integral const expression.")
             };
-            let vs = vec::from_elem(n, const_expr(cx, elem, is_local).val0());
+            let vs = vec::from_elem(n, const_expr(cx, elem, is_local).first());
             let v = if vs.iter().any(|vi| val_ty(*vi) != llunitty) {
                 C_struct(vs, false)
             } else {

trunk/src/librustc/middle/ty.rs

@@ -4604,7 +4604,7 @@ pub fn determine_inherited_purity(parent: (ast::Purity, ast::NodeId),
     // purity inferred for it, then check it under its parent's purity.
     // Otherwise, use its own
     match child_sigil {
-        ast::BorrowedSigil if child.val0() == ast::ImpureFn => parent,
+        ast::BorrowedSigil if child.first() == ast::ImpureFn => parent,
         _ => child
     }
 }

trunk/src/librustdoc/html/render.rs

@@ -1379,11 +1379,11 @@ fn render_methods(w: &mut Writer, it: &clean::Item) -> fmt::Result {
         match c.impls.find(&it.id) {
             Some(v) => {
                 let mut non_trait = v.iter().filter(|p| {
-                    p.ref0().trait_.is_none()
+                    p.n0_ref().trait_.is_none()
                 });
                 let non_trait = non_trait.to_owned_vec();
                 let mut traits = v.iter().filter(|p| {
-                    p.ref0().trait_.is_some()
+                    p.n0_ref().trait_.is_some()
                 });
                 let traits = traits.to_owned_vec();
 

trunk/src/librustdoc/lib.rs

@@ -262,7 +262,7 @@ fn rust_input(cratefile: &str, matches: &getopts::Matches) -> Output {
     let mut pm = plugins::PluginManager::new(Path::new(path));
     for pass in passes.iter() {
         let plugin = match PASSES.iter().position(|&(p, _, _)| p == *pass) {
-            Some(i) => PASSES[i].val1(),
+            Some(i) => PASSES[i].n1(),
             None => {
                 error!("unknown pass {}, skipping", *pass);
                 continue

trunk/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);
                 }

trunk/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);
                 }

trunk/src/libstd/iter.rs

@@ -2611,7 +2611,7 @@ mod tests {
         assert_eq!(vi.size_hint(), (10, Some(10)));
 
         assert_eq!(c.take(5).size_hint(), (5, Some(5)));
-        assert_eq!(c.skip(5).size_hint().val1(), None);
+        assert_eq!(c.skip(5).size_hint().second(), None);
         assert_eq!(c.take_while(|_| false).size_hint(), (0, None));
         assert_eq!(c.skip_while(|_| false).size_hint(), (0, None));
         assert_eq!(c.enumerate().size_hint(), (uint::MAX, None));

trunk/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;

trunk/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;

trunk/src/libstd/prelude.rs

@@ -67,6 +67,10 @@ pub use io::{Buffer, Writer, Reader, Seek};
 pub use str::{Str, StrVector, StrSlice, OwnedStr, IntoMaybeOwned};
 pub use to_bytes::IterBytes;
 pub use to_str::{ToStr, IntoStr};
+pub use tuple::{CloneableTuple, ImmutableTuple};
+pub use tuple::{ImmutableTuple1, ImmutableTuple2, ImmutableTuple3, ImmutableTuple4};
+pub use tuple::{ImmutableTuple5, ImmutableTuple6, ImmutableTuple7, ImmutableTuple8};
+pub use tuple::{ImmutableTuple9, ImmutableTuple10, ImmutableTuple11, ImmutableTuple12};
 pub use tuple::{Tuple1, Tuple2, Tuple3, Tuple4};
 pub use tuple::{Tuple5, Tuple6, Tuple7, Tuple8};
 pub use tuple::{Tuple9, Tuple10, Tuple11, Tuple12};

trunk/src/libstd/str.rs

@@ -567,14 +567,14 @@ impl<'a> Iterator<&'a str> for StrSplits<'a> {
 // Helper functions used for Unicode normalization
 fn canonical_sort(comb: &mut [(char, u8)]) {
     use iter::range;
-    use tuple::Tuple2;
+    use tuple::CloneableTuple;
 
     let len = comb.len();
     for i in range(0, len) {
         let mut swapped = false;
         for j in range(1, len-i) {
-            let classA = *comb[j-1].ref1();
-            let classB = *comb[j].ref1();
+            let classA = comb[j-1].second();
+            let classB = comb[j].second();
             if classA != 0 && classB != 0 && classA > classB {
                 comb.swap(j-1, j);
                 swapped = true;

trunk/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.

trunk/src/libstd/to_str.rs

@@ -40,6 +40,17 @@ impl ToStr for () {
     fn to_str(&self) -> ~str { ~"()" }
 }
 
+impl<A:ToStr> ToStr for (A,) {
+    #[inline]
+    fn to_str(&self) -> ~str {
+        match *self {
+            (ref a,) => {
+                format!("({},)", (*a).to_str())
+            }
+        }
+    }
+}
+
 impl<A:ToStr+Hash+Eq, B:ToStr> ToStr for HashMap<A, B> {
     #[inline]
     fn to_str(&self) -> ~str {
@@ -80,6 +91,36 @@ impl<A:ToStr+Hash+Eq> ToStr for HashSet<A> {
     }
 }
 
+impl<A:ToStr,B:ToStr> ToStr for (A, B) {
+    #[inline]
+    fn to_str(&self) -> ~str {
+        // FIXME(#4653): this causes an llvm assertion
+        //let &(ref a, ref b) = self;
+        match *self {
+            (ref a, ref b) => {
+                format!("({}, {})", (*a).to_str(), (*b).to_str())
+            }
+        }
+    }
+}
+
+impl<A:ToStr,B:ToStr,C:ToStr> ToStr for (A, B, C) {
+    #[inline]
+    fn to_str(&self) -> ~str {
+        // FIXME(#4653): this causes an llvm assertion
+        //let &(ref a, ref b, ref c) = self;
+        match *self {
+            (ref a, ref b, ref c) => {
+                format!("({}, {}, {})",
+                    (*a).to_str(),
+                    (*b).to_str(),
+                    (*c).to_str()
+                )
+            }
+        }
+    }
+}
+
 impl<'a,A:ToStr> ToStr for &'a [A] {
     #[inline]
     fn to_str(&self) -> ~str {
@@ -137,6 +178,13 @@ mod tests {
         assert_eq!((~"hi").to_str(), ~"hi");
     }
 
+    #[test]
+    fn test_tuple_types() {
+        assert_eq!((1, 2).to_str(), ~"(1, 2)");
+        assert_eq!((~"a", ~"b", false).to_str(), ~"(a, b, false)");
+        assert_eq!(((), ((), 100)).to_str(), ~"((), ((), 100))");
+    }
+
     #[test]
     fn test_vectors() {
         let x: ~[int] = ~[];