---

yaml
---
r: 159806
b: refs/heads/try
c: 04dd61d
h: refs/heads/master
v: v3

Author: nrc

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: e09d98603e608c9e47d4c89f7b4dca87a4b56da3
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 9c96a79a74f10bed18b031ce0ac4126c56d6cfb3
-refs/heads/try: 73aaeb0fbdb14290b68288324e678068d2cfa6be
+refs/heads/try: 04dd61d1ecb0675cb0f9cd548ef3870e1e071822
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try/mk/main.mk

@@ -148,13 +148,12 @@ endif
 # libraries, so in the interest of space, prefer dynamic linking throughout the
 # compilation process.
 #
-# Note though that these flags are omitted for the *bins* in stage2+. This means
-# that the snapshot will be generated with a statically linked rustc so we only
-# have to worry about the distribution of one file (with its native dynamic
+# Note though that these flags are omitted for stage2+. This means that the
+# snapshot will be generated with a statically linked rustc so we only have to
+# worry about the distribution of one file (with its native dynamic
 # dependencies)
 RUSTFLAGS_STAGE0 += -C prefer-dynamic
 RUSTFLAGS_STAGE1 += -C prefer-dynamic
-RUST_LIB_FLAGS_ST2 += -C prefer-dynamic
 
 # Landing pads require a lot of codegen. We can get through bootstrapping faster
 # by not emitting them.

branches/try/mk/target.mk

@@ -17,9 +17,9 @@ export CFG_COMPILER_HOST_TRIPLE
 # code, make sure that these common warnings are denied by default. These can
 # be overridden during development temporarily. For stage0, we allow warnings
 # which may be bugs in stage0 (should be fixed in stage1+)
-RUST_LIB_FLAGS_ST0 += -W warnings
-RUST_LIB_FLAGS_ST1 += -D warnings
-RUST_LIB_FLAGS_ST2 += -D warnings
+WFLAGS_ST0 = -W warnings
+WFLAGS_ST1 = -D warnings
+WFLAGS_ST2 = -D warnings
 
 # Macro that generates the full list of dependencies for a crate at a particular
 # stage/target/host tuple.
@@ -80,7 +80,7 @@ $$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$(4): \
 	$$(call REMOVE_ALL_OLD_GLOB_MATCHES, \
 	    $$(dir $$@)$$(call CFG_RLIB_GLOB,$(4)))
 	$$(STAGE$(1)_T_$(2)_H_$(3)) \
-		$$(RUST_LIB_FLAGS_ST$(1)) \
+		$$(WFLAGS_ST$(1)) \
 		-L "$$(RT_OUTPUT_DIR_$(2))" \
 		-L "$$(LLVM_LIBDIR_$(2))" \
 		-L "$$(dir $$(LLVM_STDCPP_LOCATION_$(2)))" \

branches/try/src/compiletest/runtest.rs

@@ -444,7 +444,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
                 //waiting 1 second for gdbserver start
                 timer::sleep(Duration::milliseconds(1000));
                 let result = task::try(proc() {
-                    tcp::TcpStream::connect("127.0.0.1:5039").unwrap();
+                    tcp::TcpStream::connect("127.0.0.1", 5039).unwrap();
                 });
                 if result.is_err() {
                     continue;

branches/try/src/doc/guide.md

@@ -4601,24 +4601,20 @@ returns `true` or `false`. The new iterator `filter()` produces
 only the elements that that closure returns `true` for:
 
 ```{rust}
-for i in range(1i, 100i).filter(|&x| x % 2 == 0) {
+for i in range(1i, 100i).filter(|x| x % 2 == 0) {
     println!("{}", i);
 }
 ```
 
 This will print all of the even numbers between one and a hundred.
-(Note that because `filter` doesn't consume the elements that are
-being iterated over, it is passed a reference to each element, and
-thus the filter predicate uses the `&x` pattern to extract the integer
-itself.)
 
 You can chain all three things together: start with an iterator, adapt it
 a few times, and then consume the result. Check it out:
 
 ```{rust}
 range(1i, 1000i)
-    .filter(|&x| x % 2 == 0)
-    .filter(|&x| x % 3 == 0)
+    .filter(|x| x % 2 == 0)
+    .filter(|x| x % 3 == 0)
     .take(5)
     .collect::<Vec<int>>();
 ```

branches/try/src/doc/reference.md

@@ -1961,10 +1961,8 @@ On an `extern` block, the following attributes are interpreted:
   name and type. This is feature gated and the exact behavior is
   implementation-defined (due to variety of linker invocation syntax).
 - `link` - indicate that a native library should be linked to for the
-  declarations in this block to be linked correctly. `link` supports an optional `kind`
-  key with three possible values: `dylib`, `static`, and `framework`. See [external blocks](#external-blocks) for more about external blocks. Two
-  examples: `#[link(name = "readline")]` and
-  `#[link(name = "CoreFoundation", kind = "framework")]`.
+  declarations in this block to be linked correctly. See [external
+  blocks](#external-blocks)
 
 On declarations inside an `extern` block, the following attributes are
 interpreted:

branches/try/src/etc/unicode.py

@@ -283,7 +283,7 @@ def load_east_asian_width(want_widths, except_cats):
     return widths
 
 def escape_char(c):
-    if c <= 0x7f:
+    if c <= 0xff:
         return "'\\x%2.2x'" % c
     if c <= 0xffff:
         return "'\\u%4.4x'" % c
@@ -293,7 +293,7 @@ def emit_bsearch_range_table(f):
     f.write("""
 fn bsearch_range_table(c: char, r: &'static [(char,char)]) -> bool {
     use core::cmp::{Equal, Less, Greater};
-    use core::slice::SlicePrelude;
+    use core::slice::ImmutableSlice;
     r.binary_search(|&(lo,hi)| {
         if lo <= c && c <= hi { Equal }
         else if hi < c { Less }
@@ -351,7 +351,7 @@ def emit_conversions_module(f, lowerupper, upperlower):
     f.write("pub mod conversions {")
     f.write("""
     use core::cmp::{Equal, Less, Greater};
-    use core::slice::SlicePrelude;
+    use core::slice::ImmutableSlice;
     use core::tuple::Tuple2;
     use core::option::{Option, Some, None};
     use core::slice;
@@ -390,7 +390,7 @@ def emit_conversions_module(f, lowerupper, upperlower):
 
 def emit_grapheme_module(f, grapheme_table, grapheme_cats):
     f.write("""pub mod grapheme {
-    use core::slice::SlicePrelude;
+    use core::slice::ImmutableSlice;
     use core::slice;
 
     #[allow(non_camel_case_types)]
@@ -430,7 +430,7 @@ def emit_grapheme_module(f, grapheme_table, grapheme_cats):
 def emit_charwidth_module(f, width_table):
     f.write("pub mod charwidth {\n")
     f.write("    use core::option::{Option, Some, None};\n")
-    f.write("    use core::slice::SlicePrelude;\n")
+    f.write("    use core::slice::ImmutableSlice;\n")
     f.write("    use core::slice;\n")
     f.write("""
     fn bsearch_range_value_table(c: char, is_cjk: bool, r: &'static [(char, char, u8, u8)]) -> u8 {
@@ -530,7 +530,7 @@ def comp_pfun(char):
     f.write("""
     fn bsearch_range_value_table(c: char, r: &'static [(char, char, u8)]) -> u8 {
         use core::cmp::{Equal, Less, Greater};
-        use core::slice::SlicePrelude;
+        use core::slice::ImmutableSlice;
         use core::slice;
         match r.binary_search(|&(lo, hi, _)| {
             if lo <= c && c <= hi { Equal }

branches/try/src/liballoc/boxed.rs

@@ -61,16 +61,12 @@ impl<T: Clone> Clone for Box<T> {
     }
 }
 
-// NOTE(stage0): remove impl after a snapshot
-#[cfg(stage0)]
 impl<T:PartialEq> PartialEq for Box<T> {
     #[inline]
     fn eq(&self, other: &Box<T>) -> bool { *(*self) == *(*other) }
     #[inline]
     fn ne(&self, other: &Box<T>) -> bool { *(*self) != *(*other) }
 }
-// NOTE(stage0): remove impl after a snapshot
-#[cfg(stage0)]
 impl<T:PartialOrd> PartialOrd for Box<T> {
     #[inline]
     fn partial_cmp(&self, other: &Box<T>) -> Option<Ordering> {
@@ -85,50 +81,14 @@ impl<T:PartialOrd> PartialOrd for Box<T> {
     #[inline]
     fn gt(&self, other: &Box<T>) -> bool { *(*self) > *(*other) }
 }
-// NOTE(stage0): remove impl after a snapshot
-#[cfg(stage0)]
 impl<T: Ord> Ord for Box<T> {
     #[inline]
     fn cmp(&self, other: &Box<T>) -> Ordering {
         (**self).cmp(&**other)
     }
 }
-// NOTE(stage0): remove impl after a snapshot
-#[cfg(stage0)]
 impl<T: Eq> Eq for Box<T> {}
 
-#[cfg(not(stage0))]  // NOTE(stage0): remove cfg after a snapshot
-impl<Sized? T: PartialEq> PartialEq for Box<T> {
-    #[inline]
-    fn eq(&self, other: &Box<T>) -> bool { PartialEq::eq(&**self, &**other) }
-    #[inline]
-    fn ne(&self, other: &Box<T>) -> bool { PartialEq::ne(&**self, &**other) }
-}
-#[cfg(not(stage0))]  // NOTE(stage0): remove cfg after a snapshot
-impl<Sized? T: PartialOrd> PartialOrd for Box<T> {
-    #[inline]
-    fn partial_cmp(&self, other: &Box<T>) -> Option<Ordering> {
-        PartialOrd::partial_cmp(&**self, &**other)
-    }
-    #[inline]
-    fn lt(&self, other: &Box<T>) -> bool { PartialOrd::lt(&**self, &**other) }
-    #[inline]
-    fn le(&self, other: &Box<T>) -> bool { PartialOrd::le(&**self, &**other) }
-    #[inline]
-    fn ge(&self, other: &Box<T>) -> bool { PartialOrd::ge(&**self, &**other) }
-    #[inline]
-    fn gt(&self, other: &Box<T>) -> bool { PartialOrd::gt(&**self, &**other) }
-}
-#[cfg(not(stage0))]  // NOTE(stage0): remove cfg after a snapshot
-impl<Sized? T: Ord> Ord for Box<T> {
-    #[inline]
-    fn cmp(&self, other: &Box<T>) -> Ordering {
-        Ord::cmp(&**self, &**other)
-    }
-}
-#[cfg(not(stage0))]  // NOTE(stage0): remove cfg after a snapshot
-impl<Sized? T: Eq> Eq for Box<T> {}
-
 /// Extension methods for an owning `Any` trait object.
 #[unstable = "post-DST and coherence changes, this will not be a trait but \
               rather a direct `impl` on `Box<Any>`"]

branches/try/src/libarena/lib.rs

@@ -132,7 +132,7 @@ impl Drop for Arena {
 
 #[inline]
 fn round_up(base: uint, align: uint) -> uint {
-    (base.checked_add(&(align - 1))).unwrap() & !(align - 1)
+    (base.checked_add(&(align - 1))).unwrap() & !(&(align - 1))
 }
 
 // Walk down a chunk, running the destructors for any objects stored

branches/try/src/libcollections/binary_heap.rs

@@ -162,8 +162,6 @@ use core::ptr;
 use slice;
 use vec::Vec;
 
-// FIXME(conventions): implement into_iter
-
 /// A priority queue implemented with a binary heap.
 ///
 /// This will be a max-heap.
@@ -186,7 +184,6 @@ impl<T: Ord> BinaryHeap<T> {
     /// use std::collections::BinaryHeap;
     /// let pq: BinaryHeap<uint> = BinaryHeap::new();
     /// ```
-    #[unstable = "matches collection reform specification, waiting for dust to settle"]
     pub fn new() -> BinaryHeap<T> { BinaryHeap{data: vec!(),} }
 
     /// Creates an empty `BinaryHeap` with a specific capacity.
@@ -200,7 +197,6 @@ impl<T: Ord> BinaryHeap<T> {
     /// use std::collections::BinaryHeap;
     /// let pq: BinaryHeap<uint> = BinaryHeap::with_capacity(10u);
     /// ```
-    #[unstable = "matches collection reform specification, waiting for dust to settle"]
     pub fn with_capacity(capacity: uint) -> BinaryHeap<T> {
         BinaryHeap { data: Vec::with_capacity(capacity) }
     }
@@ -238,7 +234,6 @@ impl<T: Ord> BinaryHeap<T> {
     ///     println!("{}", x);
     /// }
     /// ```
-    #[unstable = "matches collection reform specification, waiting for dust to settle"]
     pub fn iter<'a>(&'a self) -> Items<'a, T> {
         Items { iter: self.data.iter() }
     }
@@ -273,19 +268,10 @@ impl<T: Ord> BinaryHeap<T> {
     /// let pq: BinaryHeap<uint> = BinaryHeap::with_capacity(100u);
     /// assert!(pq.capacity() >= 100u);
     /// ```
-    #[unstable = "matches collection reform specification, waiting for dust to settle"]
     pub fn capacity(&self) -> uint { self.data.capacity() }
 
-    /// Reserves the minimum capacity for exactly `additional` more elements to be inserted in the
-    /// given `BinaryHeap`. Does nothing if the capacity is already sufficient.
-    ///
-    /// Note that the allocator may give the collection more space than it requests. Therefore
-    /// capacity can not be relied upon to be precisely minimal. Prefer `reserve` if future
-    /// insertions are expected.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the new capacity overflows `uint`.
+    /// Reserves capacity for exactly `n` elements in the `BinaryHeap`.
+    /// Do nothing if the capacity is already sufficient.
     ///
     /// # Example
     ///
@@ -294,17 +280,12 @@ impl<T: Ord> BinaryHeap<T> {
     ///
     /// let mut pq: BinaryHeap<uint> = BinaryHeap::new();
     /// pq.reserve_exact(100u);
-    /// assert!(pq.capacity() >= 100u);
+    /// assert!(pq.capacity() == 100u);
     /// ```
-    #[unstable = "matches collection reform specification, waiting for dust to settle"]
-    pub fn reserve_exact(&mut self, additional: uint) { self.data.reserve_exact(additional) }
+    pub fn reserve_exact(&mut self, n: uint) { self.data.reserve_exact(n) }
 
-    /// Reserves capacity for at least `additional` more elements to be inserted in the
-    /// `BinaryHeap`. The collection may reserve more space to avoid frequent reallocations.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the new capacity overflows `uint`.
+    /// Reserves capacity for at least `n` elements in the `BinaryHeap`.
+    /// Do nothing if the capacity is already sufficient.
     ///
     /// # Example
     ///
@@ -315,15 +296,8 @@ impl<T: Ord> BinaryHeap<T> {
     /// pq.reserve(100u);
     /// assert!(pq.capacity() >= 100u);
     /// ```
-    #[unstable = "matches collection reform specification, waiting for dust to settle"]
-    pub fn reserve(&mut self, additional: uint) {
-        self.data.reserve(additional)
-    }
-
-    /// Discards as much additional capacity as possible.
-    #[unstable = "matches collection reform specification, waiting for dust to settle"]
-    pub fn shrink_to_fit(&mut self) {
-        self.data.shrink_to_fit()
+    pub fn reserve(&mut self, n: uint) {
+        self.data.reserve(n)
     }
 
     /// Removes the greatest item from a queue and returns it, or `None` if it
@@ -340,7 +314,6 @@ impl<T: Ord> BinaryHeap<T> {
     /// assert_eq!(pq.pop(), Some(1i));
     /// assert_eq!(pq.pop(), None);
     /// ```
-    #[unstable = "matches collection reform specification, waiting for dust to settle"]
     pub fn pop(&mut self) -> Option<T> {
         match self.data.pop() {
             None           => { None }
@@ -369,7 +342,6 @@ impl<T: Ord> BinaryHeap<T> {
     /// assert_eq!(pq.len(), 3);
     /// assert_eq!(pq.top(), Some(&5i));
     /// ```
-    #[unstable = "matches collection reform specification, waiting for dust to settle"]
     pub fn push(&mut self, item: T) {
         self.data.push(item);
         let new_len = self.len() - 1;
@@ -523,15 +495,12 @@ impl<T: Ord> BinaryHeap<T> {
     }
 
     /// Returns the length of the queue.
-    #[unstable = "matches collection reform specification, waiting for dust to settle"]
     pub fn len(&self) -> uint { self.data.len() }
 
     /// Returns true if the queue contains no elements
-    #[unstable = "matches collection reform specification, waiting for dust to settle"]
     pub fn is_empty(&self) -> bool { self.len() == 0 }
 
     /// Drops all items from the queue.
-    #[unstable = "matches collection reform specification, waiting for dust to settle"]
     pub fn clear(&mut self) { self.data.truncate(0) }
 }
 
@@ -559,7 +528,8 @@ impl<T: Ord> Extendable<T> for BinaryHeap<T> {
     fn extend<Iter: Iterator<T>>(&mut self, mut iter: Iter) {
         let (lower, _) = iter.size_hint();
 
-        self.reserve(lower);
+        let len = self.capacity();
+        self.reserve(len + lower);
 
         for elem in iter {
             self.push(elem);