---

yaml
---
r: 165411
b: refs/heads/master
c: e0d4438
h: refs/heads/master
i:
  165409: aae7200
  165407: a8b3566
v: v3

Author: eddyb

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 2af8155bee8614a4e3bd1831f8927652c7475cc5
+refs/heads/master: e0d44386d334e13677e2d43ad9365d6b24350780
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 658529467d9d69ac9e09cacf98a6d61d781c2c76
 refs/heads/try: aee614fc4973262a5a68efc643026e2b1458d65b

trunk/mk/crates.mk

@@ -53,8 +53,7 @@ TARGET_CRATES := libc std flate arena term \
                  serialize getopts collections test time rand \
                  log regex graphviz core rbml alloc \
                  unicode
-RUSTC_CRATES := rustc rustc_typeck rustc_borrowck rustc_resolve rustc_driver \
-                rustc_trans rustc_back rustc_llvm
+RUSTC_CRATES := rustc rustc_typeck rustc_borrowck rustc_driver rustc_trans rustc_back rustc_llvm 
 HOST_CRATES := syntax $(RUSTC_CRATES) rustdoc regex_macros fmt_macros
 CRATES := $(TARGET_CRATES) $(HOST_CRATES)
 TOOLS := compiletest rustdoc rustc
@@ -68,12 +67,11 @@ DEPS_std := core libc rand alloc collections unicode \
 DEPS_graphviz := std
 DEPS_syntax := std term serialize log fmt_macros arena libc
 DEPS_rustc_driver := arena flate getopts graphviz libc rustc rustc_back rustc_borrowck \
-                     rustc_typeck rustc_resolve log syntax serialize rustc_llvm rustc_trans
+                     rustc_typeck log syntax serialize rustc_llvm rustc_trans
 DEPS_rustc_trans := arena flate getopts graphviz libc rustc rustc_back \
 	                log syntax serialize rustc_llvm
 DEPS_rustc_typeck := rustc syntax
 DEPS_rustc_borrowck := rustc log graphviz syntax
-DEPS_rustc_resolve := rustc log syntax
 DEPS_rustc := syntax flate arena serialize getopts rbml \
               time log graphviz rustc_llvm rustc_back
 DEPS_rustc_llvm := native:rustllvm libc std
@@ -120,11 +118,9 @@ DOC_CRATES := $(filter-out rustc, \
               $(filter-out rustc_trans, \
               $(filter-out rustc_typeck, \
               $(filter-out rustc_borrowck, \
-              $(filter-out rustc_resolve, \
               $(filter-out rustc_driver, \
-              $(filter-out syntax, $(CRATES))))))))
-COMPILER_DOC_CRATES := rustc rustc_trans rustc_borrowck rustc_resolve \
-                       rustc_typeck rustc_driver syntax
+              $(filter-out syntax, $(CRATES)))))))
+COMPILER_DOC_CRATES := rustc rustc_trans rustc_borrowck rustc_typeck rustc_driver syntax
 
 # This macro creates some simple definitions for each crate being built, just
 # some munging of all of the parameters above.

trunk/mk/tests.mk

@@ -21,8 +21,7 @@ $(eval $(call RUST_CRATE,coretest))
 
 TEST_TARGET_CRATES = $(filter-out core unicode,$(TARGET_CRATES)) coretest
 TEST_DOC_CRATES = $(DOC_CRATES)
-TEST_HOST_CRATES = $(filter-out rustc_typeck rustc_borrowck rustc_resolve rustc_trans,\
-                     $(HOST_CRATES))
+TEST_HOST_CRATES = $(filter-out rustc_typeck rustc_borrowck rustc_trans,$(HOST_CRATES))
 TEST_CRATES = $(TEST_TARGET_CRATES) $(TEST_HOST_CRATES)
 
 ######################################################################

trunk/src/compiletest/runtest.rs

@@ -1609,7 +1609,7 @@ fn _arm_exec_compiled_test(config: &Config,
                 stderr_out.as_slice());
 
     ProcRes {
-        status: process::ProcessExit::ExitStatus(exitcode),
+        status: process::ExitStatus(exitcode),
         stdout: stdout_out,
         stderr: stderr_out,
         cmdline: cmdline
@@ -1666,7 +1666,7 @@ fn compile_test_and_save_bitcode(config: &Config, props: &TestProps,
     // FIXME (#9639): This needs to handle non-utf8 paths
     let mut link_args = vec!("-L".to_string(),
                              aux_dir.as_str().unwrap().to_string());
-    let llvm_args = vec!("--emit=llvm-bc,obj".to_string(),
+    let llvm_args = vec!("--emit=bc,obj".to_string(),
                          "--crate-type=lib".to_string());
     link_args.extend(llvm_args.into_iter());
     let args = make_compile_args(config,

trunk/src/doc/guide.md

@@ -1,5 +1,5 @@
 /**
- * Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
+ * Copyright 2013 The Rust Project Developers. See the COPYRIGHT
  * file at the top-level directory of this distribution and at
  * http://rust-lang.org/COPYRIGHT.
  * With elements taken from Bootstrap v3.0.2 (MIT licensed).
@@ -209,6 +209,7 @@ pre {
 code {
     padding: 0 2px;
     color: #8D1A38;
+    white-space: pre-wrap;
 }
 pre code {
     padding: 0;

trunk/src/doc/rust.css

@@ -19,7 +19,7 @@ TMPFILE=`mktemp /tmp/rust-lldb-commands.XXXXXX`
 trap "rm -f $TMPFILE; exit" INT TERM EXIT
 
 # Find out where to look for the pretty printer Python module
-RUSTC_SYSROOT=`rustc --print sysroot`
+RUSTC_SYSROOT=`rustc -Zprint-sysroot`
 
 # Write the LLDB script to the tempfile
 echo "command script import \"$RUSTC_SYSROOT/lib/rustlib/etc/lldb_rust_formatters.py\"" >> $TMPFILE

trunk/src/etc/rust-lldb

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use prelude::*;
+use std::prelude::*;
 use std::rand;
 use std::rand::Rng;
 use test::Bencher;

trunk/src/libcollections/bench.rs

@@ -551,18 +551,9 @@ impl<T: Ord> BinaryHeap<T> {
     #[unstable = "matches collection reform specification, waiting for dust to settle"]
     pub fn is_empty(&self) -> bool { self.len() == 0 }
 
-    /// Clears the queue, returning an iterator over the removed elements.
-    #[inline]
-    #[unstable = "matches collection reform specification, waiting for dust to settle"]
-    pub fn drain<'a>(&'a mut self) -> Drain<'a, T> {
-        Drain {
-            iter: self.data.drain(),
-        }
-    }
-
     /// Drops all items from the queue.
     #[unstable = "matches collection reform specification, waiting for dust to settle"]
-    pub fn clear(&mut self) { self.drain(); }
+    pub fn clear(&mut self) { self.data.truncate(0) }
 }
 
 /// `BinaryHeap` iterator.
@@ -605,26 +596,6 @@ impl<T> DoubleEndedIterator<T> for MoveItems<T> {
 
 impl<T> ExactSizeIterator<T> for MoveItems<T> {}
 
-/// An iterator that drains a `BinaryHeap`.
-pub struct Drain<'a, T: 'a> {
-    iter: vec::Drain<'a, T>,
-}
-
-impl<'a, T: 'a> Iterator<T> for Drain<'a, T> {
-    #[inline]
-    fn next(&mut self) -> Option<T> { self.iter.next() }
-
-    #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
-}
-
-impl<'a, T: 'a> DoubleEndedIterator<T> for Drain<'a, T> {
-    #[inline]
-    fn next_back(&mut self) -> Option<T> { self.iter.next_back() }
-}
-
-impl<'a, T: 'a> ExactSizeIterator<T> for Drain<'a, T> {}
-
 impl<T: Ord> FromIterator<T> for BinaryHeap<T> {
     fn from_iter<Iter: Iterator<T>>(iter: Iter) -> BinaryHeap<T> {
         let vec: Vec<T> = iter.collect();
@@ -646,9 +617,10 @@ impl<T: Ord> Extend<T> for BinaryHeap<T> {
 
 #[cfg(test)]
 mod tests {
-    use prelude::*;
+    use std::prelude::*;
 
     use super::BinaryHeap;
+    use vec::Vec;
 
     #[test]
     fn test_iterator() {
@@ -848,14 +820,4 @@ mod tests {
             assert_eq!(q.pop().unwrap(), x);
         }
     }
-
-    #[test]
-    fn test_drain() {
-        let mut q: BinaryHeap<_> =
-            [9u, 8, 7, 6, 5, 4, 3, 2, 1].iter().cloned().collect();
-
-        assert_eq!(q.drain().take(5).count(), 5);
-
-        assert!(q.is_empty());
-    }
 }

trunk/src/libcollections/binary_heap.rs

@@ -1686,15 +1686,16 @@ impl<'a> Iterator<uint> for TwoBitPositions<'a> {
 
 #[cfg(test)]
 mod tests {
-    use prelude::*;
-    use core::iter::range_step;
-    use core::u32;
+    use std::prelude::*;
+    use std::iter::range_step;
     use std::rand;
     use std::rand::Rng;
+    use std::u32;
     use test::{Bencher, black_box};
 
     use super::{Bitv, BitvSet, from_fn, from_bytes};
     use bitv;
+    use vec::Vec;
 
     static BENCH_BITS : uint = 1 << 14;
 
@@ -2037,7 +2038,7 @@ mod tests {
     #[test]
     fn test_from_bytes() {
         let bitv = from_bytes(&[0b10110110, 0b00000000, 0b11111111]);
-        let str = concat!("10110110", "00000000", "11111111");
+        let str = format!("{}{}{}", "10110110", "00000000", "11111111");
         assert_eq!(bitv.to_string(), str);
     }
 

trunk/src/libcollections/bit.rs

@@ -131,12 +131,12 @@ pub enum Entry<'a, K:'a, V:'a> {
 /// A vacant Entry.
 pub struct VacantEntry<'a, K:'a, V:'a> {
     key: K,
-    stack: stack::SearchStack<'a, K, V, node::handle::Edge, node::handle::Leaf>,
+    stack: stack::SearchStack<'a, K, V, node::Edge, node::Leaf>,
 }
 
 /// An occupied Entry.
 pub struct OccupiedEntry<'a, K:'a, V:'a> {
-    stack: stack::SearchStack<'a, K, V, node::handle::KV, node::handle::LeafOrInternal>,
+    stack: stack::SearchStack<'a, K, V, node::KV, node::LeafOrInternal>,
 }
 
 impl<K: Ord, V> BTreeMap<K, V> {
@@ -496,8 +496,7 @@ mod stack {
     use core::kinds::marker;
     use core::mem;
     use super::BTreeMap;
-    use super::super::node::{mod, Node, Fit, Split, Internal, Leaf};
-    use super::super::node::handle;
+    use super::super::node::{mod, Node, Fit, Split, KV, Edge, Internal, Leaf, LeafOrInternal};
     use vec::Vec;
 
     /// A generic mutable reference, identical to `&mut` except for the fact that its lifetime
@@ -521,7 +520,7 @@ mod stack {
         }
     }
 
-    type StackItem<K, V> = node::Handle<*mut Node<K, V>, handle::Edge, handle::Internal>;
+    type StackItem<K, V> = node::Handle<*mut Node<K, V>, Edge, Internal>;
     type Stack<K, V> = Vec<StackItem<K, V>>;
 
     /// A `PartialSearchStack` handles the construction of a search stack.
@@ -596,9 +595,7 @@ mod stack {
         /// Pushes the requested child of the stack's current top on top of the stack. If the child
         /// exists, then a new PartialSearchStack is yielded. Otherwise, a VacantSearchStack is
         /// yielded.
-        pub fn push(mut self, mut edge: node::Handle<IdRef<'id, Node<K, V>>,
-                                                     handle::Edge,
-                                                     handle::Internal>)
+        pub fn push(mut self, mut edge: node::Handle<IdRef<'id, Node<K, V>>, Edge, Internal>)
                     -> PartialSearchStack<'a, K, V> {
             self.stack.push(edge.as_raw());
             PartialSearchStack {
@@ -620,7 +617,7 @@ mod stack {
         }
     }
 
-    impl<'a, K, V, NodeType> SearchStack<'a, K, V, handle::KV, NodeType> {
+    impl<'a, K, V, NodeType> SearchStack<'a, K, V, KV, NodeType> {
         /// Gets a reference to the value the stack points to.
         pub fn peek(&self) -> &V {
             unsafe { self.top.from_raw().into_kv().1 }
@@ -643,7 +640,7 @@ mod stack {
         }
     }
 
-    impl<'a, K, V> SearchStack<'a, K, V, handle::KV, handle::Leaf> {
+    impl<'a, K, V> SearchStack<'a, K, V, KV, Leaf> {
         /// Removes the key and value in the top element of the stack, then handles underflows as
         /// described in BTree's pop function.
         fn remove_leaf(mut self) -> V {
@@ -689,7 +686,7 @@ mod stack {
         }
     }
 
-    impl<'a, K, V> SearchStack<'a, K, V, handle::KV, handle::LeafOrInternal> {
+    impl<'a, K, V> SearchStack<'a, K, V, KV, LeafOrInternal> {
         /// Removes the key and value in the top element of the stack, then handles underflows as
         /// described in BTree's pop function.
         pub fn remove(self) -> V {
@@ -706,7 +703,7 @@ mod stack {
         /// leaves the tree in an inconsistent state that must be repaired by the caller by
         /// removing the entry in question. Specifically the key-value pair and its successor will
         /// become swapped.
-        fn into_leaf(mut self) -> SearchStack<'a, K, V, handle::KV, handle::Leaf> {
+        fn into_leaf(mut self) -> SearchStack<'a, K, V, KV, Leaf> {
             unsafe {
                 let mut top_raw = self.top;
                 let mut top = top_raw.from_raw_mut();
@@ -760,7 +757,7 @@ mod stack {
         }
     }
 
-    impl<'a, K, V> SearchStack<'a, K, V, handle::Edge, handle::Leaf> {
+    impl<'a, K, V> SearchStack<'a, K, V, Edge, Leaf> {
         /// Inserts the key and value into the top element in the stack, and if that node has to
         /// split recursively inserts the split contents into the next element stack until
         /// splits stop.
@@ -1335,7 +1332,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
 
 #[cfg(test)]
 mod test {
-    use prelude::*;
+    use std::prelude::*;
 
     use super::{BTreeMap, Occupied, Vacant};
 
@@ -1537,7 +1534,7 @@ mod test {
 
 #[cfg(test)]
 mod bench {
-    use prelude::*;
+    use std::prelude::*;
     use std::rand::{weak_rng, Rng};
     use test::{Bencher, black_box};