---

yaml
---
r: 190971
b: refs/heads/auto
c: fad4c38
h: refs/heads/master
i:
  190969: 7dcb84d
  190967: d7ec9a8
v: v3

Author: Manishearth

[refs]

@@ -10,7 +10,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: f5765793b650e45e8c9bc89dfc7a4dc628123cb7
+refs/heads/auto: fad4c380e8da106baca0c6259306be6e3574d4ba
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/configure

@@ -461,7 +461,10 @@ case $CFG_CPUTYPE in
         CFG_CPUTYPE=aarch64
         ;;
 
-    powerpc)
+    # At some point, when ppc64[le] support happens, this will need to do
+    # something clever. For now it's safe to assume that we're only ever
+    # interested in building 32 bit.
+    powerpc | ppc | ppc64)
         CFG_CPUTYPE=powerpc
         ;;
 

branches/auto/mk/dist.mk

@@ -53,6 +53,7 @@ PKG_FILES := \
       driver                                   \
       etc                                      \
       $(foreach crate,$(CRATES),lib$(crate))   \
+      libcollectionstest                       \
       libcoretest                              \
       libbacktrace                             \
       rt                                       \

branches/auto/mk/target.mk

@@ -72,6 +72,7 @@ $$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$(4): CFG_COMPILER_HOST_TRIPLE = $(2)
 $$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$(4): \
 		$$(CRATEFILE_$(4)) \
 		$$(CRATE_FULLDEPS_$(1)_T_$(2)_H_$(3)_$(4)) \
+		$$(LLVM_CONFIG_$(2)) \
 		$$(TSREQ$(1)_T_$(2)_H_$(3)) \
 		| $$(TLIB$(1)_T_$(2)_H_$(3))/
 	@$$(call E, rustc: $$(@D)/lib$(4))

branches/auto/mk/tests.mk

@@ -19,7 +19,10 @@
 DEPS_coretest :=
 $(eval $(call RUST_CRATE,coretest))
 
-TEST_TARGET_CRATES = $(filter-out core unicode,$(TARGET_CRATES)) coretest
+DEPS_collectionstest :=
+$(eval $(call RUST_CRATE,collectionstest))
+
+TEST_TARGET_CRATES = $(filter-out core unicode,$(TARGET_CRATES)) collectionstest coretest
 TEST_DOC_CRATES = $(DOC_CRATES)
 TEST_HOST_CRATES = $(filter-out rustc_typeck rustc_borrowck rustc_resolve rustc_trans rustc_lint,\
                      $(HOST_CRATES))

branches/auto/src/compiletest/compiletest.rs

@@ -20,7 +20,6 @@
 #![feature(std_misc)]
 #![feature(test)]
 #![feature(core)]
-#![feature(net)]
 #![feature(path_ext)]
 
 #![deny(warnings)]

branches/auto/src/doc/intro.md

@@ -140,7 +140,7 @@ right at home if you've used tools like [Bundler](http://bundler.io/),
 [npm](https://www.npmjs.org/), or [pip](https://pip.pypa.io/en/latest/).
 There's no `Makefile`s or endless `autotools` output here. (Rust's tooling does
 [play nice with external libraries written in those
-tools](http://crates.io/native-build.html), if you need to.)
+tools](http://doc.crates.io/build-script.html), if you need to.)
 
 Enough about tools, let's talk code!
 

branches/auto/src/doc/reference.md

@@ -1961,16 +1961,18 @@ module through the rules above. It essentially allows public access into the
 re-exported item. For example, this program is valid:
 
 ```
-pub use self::implementation as api;
+pub use self::implementation::api;
 
 mod implementation {
-    pub fn f() {}
+    pub mod api {
+        pub fn f() {}
+    }
 }
 
 # fn main() {}
 ```
 
-This means that any external crate referencing `implementation::f` would
+This means that any external crate referencing `implementation::api::f` would
 receive a privacy violation, while the path `api::f` would be allowed.
 
 When re-exporting a private item, it can be thought of as allowing the "privacy

branches/auto/src/liballoc/arc.rs

@@ -94,7 +94,7 @@ use heap::deallocate;
 /// With simple pipes, without `Arc`, a copy would have to be made for each
 /// task.
 ///
-/// ```rust
+/// ```
 /// use std::sync::Arc;
 /// use std::thread;
 ///

branches/auto/src/liballoc/boxed.rs

@@ -64,7 +64,7 @@ use core::raw::TraitObject;
 ///
 /// The following two examples are equivalent:
 ///
-/// ```rust
+/// ```
 /// #![feature(box_syntax)]
 /// use std::boxed::HEAP;
 ///

branches/auto/src/liballoc/heap.rs

@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#[cfg(stage0)]
 #[cfg(not(test))]
 use core::ptr::PtrExt;
 
@@ -387,7 +388,6 @@ mod imp {
 mod test {
     extern crate test;
     use self::test::Bencher;
-    use core::ptr::PtrExt;
     use boxed::Box;
     use heap;
 

branches/auto/src/liballoc/rc.rs

@@ -159,7 +159,10 @@ use core::nonzero::NonZero;
 use core::ops::{Deref, Drop};
 use core::option::Option;
 use core::option::Option::{Some, None};
+#[cfg(stage0)]
 use core::ptr::{self, PtrExt};
+#[cfg(not(stage0))]
+use core::ptr;
 use core::result::Result;
 use core::result::Result::{Ok, Err};
 use core::intrinsics::assume;

branches/auto/src/libarena/lib.rs

@@ -46,6 +46,7 @@ use std::intrinsics::{TyDesc, get_tydesc};
 use std::intrinsics;
 use std::marker;
 use std::mem;
+#[cfg(stage0)]
 use std::num::{Int, UnsignedInt};
 use std::ptr;
 use std::rc::Rc;

branches/auto/src/libcollections/binary_heap.rs

@@ -163,6 +163,11 @@ use vec::{self, Vec};
 /// A priority queue implemented with a binary heap.
 ///
 /// This will be a max-heap.
+///
+/// It is a logic error for an item to be modified in such a way that the
+/// item's ordering relative to any other item, as determined by the `Ord`
+/// trait, changes while it is in the heap. This is normally only possible
+/// through `Cell`, `RefCell`, global state, I/O, or unsafe code.
 #[derive(Clone)]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct BinaryHeap<T> {
@@ -688,218 +693,3 @@ impl<T: Ord> Extend<T> for BinaryHeap<T> {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use prelude::*;
-
-    use super::BinaryHeap;
-
-    #[test]
-    fn test_iterator() {
-        let data = vec![5, 9, 3];
-        let iterout = [9, 5, 3];
-        let heap = BinaryHeap::from_vec(data);
-        let mut i = 0;
-        for el in &heap {
-            assert_eq!(*el, iterout[i]);
-            i += 1;
-        }
-    }
-
-    #[test]
-    fn test_iterator_reverse() {
-        let data = vec![5, 9, 3];
-        let iterout = vec![3, 5, 9];
-        let pq = BinaryHeap::from_vec(data);
-
-        let v: Vec<_> = pq.iter().rev().cloned().collect();
-        assert_eq!(v, iterout);
-    }
-
-    #[test]
-    fn test_move_iter() {
-        let data = vec![5, 9, 3];
-        let iterout = vec![9, 5, 3];
-        let pq = BinaryHeap::from_vec(data);
-
-        let v: Vec<_> = pq.into_iter().collect();
-        assert_eq!(v, iterout);
-    }
-
-    #[test]
-    fn test_move_iter_size_hint() {
-        let data = vec![5, 9];
-        let pq = BinaryHeap::from_vec(data);
-
-        let mut it = pq.into_iter();
-
-        assert_eq!(it.size_hint(), (2, Some(2)));
-        assert_eq!(it.next(), Some(9));
-
-        assert_eq!(it.size_hint(), (1, Some(1)));
-        assert_eq!(it.next(), Some(5));
-
-        assert_eq!(it.size_hint(), (0, Some(0)));
-        assert_eq!(it.next(), None);
-    }
-
-    #[test]
-    fn test_move_iter_reverse() {
-        let data = vec![5, 9, 3];
-        let iterout = vec![3, 5, 9];
-        let pq = BinaryHeap::from_vec(data);
-
-        let v: Vec<_> = pq.into_iter().rev().collect();
-        assert_eq!(v, iterout);
-    }
-
-    #[test]
-    fn test_peek_and_pop() {
-        let data = vec![2, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1];
-        let mut sorted = data.clone();
-        sorted.sort();
-        let mut heap = BinaryHeap::from_vec(data);
-        while !heap.is_empty() {
-            assert_eq!(heap.peek().unwrap(), sorted.last().unwrap());
-            assert_eq!(heap.pop().unwrap(), sorted.pop().unwrap());
-        }
-    }
-
-    #[test]
-    fn test_push() {
-        let mut heap = BinaryHeap::from_vec(vec![2, 4, 9]);
-        assert_eq!(heap.len(), 3);
-        assert!(*heap.peek().unwrap() == 9);
-        heap.push(11);
-        assert_eq!(heap.len(), 4);
-        assert!(*heap.peek().unwrap() == 11);
-        heap.push(5);
-        assert_eq!(heap.len(), 5);
-        assert!(*heap.peek().unwrap() == 11);
-        heap.push(27);
-        assert_eq!(heap.len(), 6);
-        assert!(*heap.peek().unwrap() == 27);
-        heap.push(3);
-        assert_eq!(heap.len(), 7);
-        assert!(*heap.peek().unwrap() == 27);
-        heap.push(103);
-        assert_eq!(heap.len(), 8);
-        assert!(*heap.peek().unwrap() == 103);
-    }
-
-    #[test]
-    fn test_push_unique() {
-        let mut heap = BinaryHeap::<Box<_>>::from_vec(vec![box 2, box 4, box 9]);
-        assert_eq!(heap.len(), 3);
-        assert!(*heap.peek().unwrap() == box 9);
-        heap.push(box 11);
-        assert_eq!(heap.len(), 4);
-        assert!(*heap.peek().unwrap() == box 11);
-        heap.push(box 5);
-        assert_eq!(heap.len(), 5);
-        assert!(*heap.peek().unwrap() == box 11);
-        heap.push(box 27);
-        assert_eq!(heap.len(), 6);
-        assert!(*heap.peek().unwrap() == box 27);
-        heap.push(box 3);
-        assert_eq!(heap.len(), 7);
-        assert!(*heap.peek().unwrap() == box 27);
-        heap.push(box 103);
-        assert_eq!(heap.len(), 8);
-        assert!(*heap.peek().unwrap() == box 103);
-    }
-
-    #[test]
-    fn test_push_pop() {
-        let mut heap = BinaryHeap::from_vec(vec![5, 5, 2, 1, 3]);
-        assert_eq!(heap.len(), 5);
-        assert_eq!(heap.push_pop(6), 6);
-        assert_eq!(heap.len(), 5);
-        assert_eq!(heap.push_pop(0), 5);
-        assert_eq!(heap.len(), 5);
-        assert_eq!(heap.push_pop(4), 5);
-        assert_eq!(heap.len(), 5);
-        assert_eq!(heap.push_pop(1), 4);
-        assert_eq!(heap.len(), 5);
-    }
-
-    #[test]
-    fn test_replace() {
-        let mut heap = BinaryHeap::from_vec(vec![5, 5, 2, 1, 3]);
-        assert_eq!(heap.len(), 5);
-        assert_eq!(heap.replace(6).unwrap(), 5);
-        assert_eq!(heap.len(), 5);
-        assert_eq!(heap.replace(0).unwrap(), 6);
-        assert_eq!(heap.len(), 5);
-        assert_eq!(heap.replace(4).unwrap(), 5);
-        assert_eq!(heap.len(), 5);
-        assert_eq!(heap.replace(1).unwrap(), 4);
-        assert_eq!(heap.len(), 5);
-    }
-
-    fn check_to_vec(mut data: Vec<i32>) {
-        let heap = BinaryHeap::from_vec(data.clone());
-        let mut v = heap.clone().into_vec();
-        v.sort();
-        data.sort();
-
-        assert_eq!(v, data);
-        assert_eq!(heap.into_sorted_vec(), data);
-    }
-
-    #[test]
-    fn test_to_vec() {
-        check_to_vec(vec![]);
-        check_to_vec(vec![5]);
-        check_to_vec(vec![3, 2]);
-        check_to_vec(vec![2, 3]);
-        check_to_vec(vec![5, 1, 2]);
-        check_to_vec(vec![1, 100, 2, 3]);
-        check_to_vec(vec![1, 3, 5, 7, 9, 2, 4, 6, 8, 0]);
-        check_to_vec(vec![2, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1]);
-        check_to_vec(vec![9, 11, 9, 9, 9, 9, 11, 2, 3, 4, 11, 9, 0, 0, 0, 0]);
-        check_to_vec(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-        check_to_vec(vec![10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]);
-        check_to_vec(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 1, 2]);
-        check_to_vec(vec![5, 4, 3, 2, 1, 5, 4, 3, 2, 1, 5, 4, 3, 2, 1]);
-    }
-
-    #[test]
-    fn test_empty_pop() {
-        let mut heap = BinaryHeap::<i32>::new();
-        assert!(heap.pop().is_none());
-    }
-
-    #[test]
-    fn test_empty_peek() {
-        let empty = BinaryHeap::<i32>::new();
-        assert!(empty.peek().is_none());
-    }
-
-    #[test]
-    fn test_empty_replace() {
-        let mut heap = BinaryHeap::new();
-        assert!(heap.replace(5).is_none());
-    }
-
-    #[test]
-    fn test_from_iter() {
-        let xs = vec![9, 8, 7, 6, 5, 4, 3, 2, 1];
-
-        let mut q: BinaryHeap<_> = xs.iter().rev().cloned().collect();
-
-        for &x in &xs {
-            assert_eq!(q.pop().unwrap(), x);
-        }
-    }
-
-    #[test]
-    fn test_drain() {
-        let mut q: BinaryHeap<_> = [9, 8, 7, 6, 5, 4, 3, 2, 1].iter().cloned().collect();
-
-        assert_eq!(q.drain().take(5).count(), 5);
-
-        assert!(q.is_empty());
-    }
-}