---

yaml
---
r: 124895
b: refs/heads/master
c: 3e62ad3
h: refs/heads/master
i:
  124893: 2f6b0db
  124891: 65567d8
  124887: 528320d
  124879: d4f7dcb
  124863: 8af6036
v: v3

Author: sfackler

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: b13d6ea6c2f8e6ed6ced51648aadf7a1e7256220
+refs/heads/master: 3e62ad3fb95b96c224e64bd83c98bc94bad5ec65
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 9fc8394d3bce22ab483f98842434c84c396212ae
 refs/heads/try: ac70b438a8382389c9c9b59c66b14774bff46e10

trunk/src/doc/guide.md

@@ -624,10 +624,15 @@ let x = (let y = 5i); // found `let` in ident position
 The compiler is telling us here that it was expecting to see the beginning of
 an expression, and a `let` can only begin a statement, not an expression.
 
-Note that assigning to an already-bound variable (e.g. `y = 5i`) is still an
-expression, although its value is not particularly useful. Unlike C, where an
-assignment evaluates to the assigned value (e.g. `5i` in the previous example),
-in Rust the value of an assignment is the unit type `()` (which we'll cover later).
+However, assigning to a variable binding is an expression:
+
+```{rust}
+let x;
+let y = x = 5i;
+```
+
+In this case, we have an assignment expression (`x = 5`) whose value is
+being used as part of a `let` declaration statement (`let y = ...`).
 
 The second kind of statement in Rust is the **expression statement**. Its
 purpose is to turn any expression into a statement. In practical terms, Rust's

trunk/src/libcore/iter.rs

@@ -99,10 +99,9 @@ pub trait Iterator<A> {
     /// Advance the iterator and return the next value. Return `None` when the end is reached.
     fn next(&mut self) -> Option<A>;
 
-    /// Returns a lower and upper bound on the remaining length of the iterator.
+    /// Return a lower bound and upper bound on the remaining length of the iterator.
     ///
-    /// An upper bound of `None` means either there is no known upper bound, or the upper bound
-    /// does not fit within a `uint`.
+    /// The common use case for the estimate is pre-allocating space to store the results.
     #[inline]
     fn size_hint(&self) -> (uint, Option<uint>) { (0, None) }
 
@@ -645,9 +644,6 @@ pub trait Iterator<A> {
 }
 
 /// A range iterator able to yield elements from both ends
-///
-/// A `DoubleEndedIterator` can be thought of as a deque in that `next()` and `next_back()` exhaust
-/// elements from the *same* range, and do not work independently of each other.
 pub trait DoubleEndedIterator<A>: Iterator<A> {
     /// Yield an element from the end of the range, returning `None` if the range is empty.
     fn next_back(&mut self) -> Option<A>;
@@ -694,15 +690,12 @@ impl<'a, A, T: DoubleEndedIterator<&'a mut A>> MutableDoubleEndedIterator for T
 /// An object implementing random access indexing by `uint`
 ///
 /// A `RandomAccessIterator` should be either infinite or a `DoubleEndedIterator`.
-/// Calling `next()` or `next_back()` on a `RandomAccessIterator`
-/// reduces the indexable range accordingly. That is, `it.idx(1)` will become `it.idx(0)`
-/// after `it.next()` is called.
 pub trait RandomAccessIterator<A>: Iterator<A> {
     /// Return the number of indexable elements. At most `std::uint::MAX`
     /// elements are indexable, even if the iterator represents a longer range.
     fn indexable(&self) -> uint;
 
-    /// Return an element at an index, or `None` if the index is out of bounds
+    /// Return an element at an index
     fn idx(&mut self, index: uint) -> Option<A>;
 }
 

trunk/src/libcore/num/mod.rs

@@ -75,7 +75,6 @@ pub trait Zero: Add<Self, Self> {
     fn zero() -> Self;
 
     /// Returns `true` if `self` is equal to the additive identity.
-    #[inline]
     fn is_zero(&self) -> bool;
 }
 
@@ -90,20 +89,32 @@ macro_rules! zero_impl(
     }
 )
 
+macro_rules! zero_float_impl(
+    ($t:ty, $v:expr) => {
+        impl Zero for $t {
+            #[inline]
+            fn zero() -> $t { $v }
+
+            #[inline]
+            fn is_zero(&self) -> bool { *self == $v || *self == -$v }
+        }
+    }
+)
+
 zero_impl!(uint, 0u)
-zero_impl!(u8,   0u8)
-zero_impl!(u16,  0u16)
-zero_impl!(u32,  0u32)
-zero_impl!(u64,  0u64)
+zero_impl!(u8,  0u8)
+zero_impl!(u16, 0u16)
+zero_impl!(u32, 0u32)
+zero_impl!(u64, 0u64)
 
 zero_impl!(int, 0i)
 zero_impl!(i8,  0i8)
 zero_impl!(i16, 0i16)
 zero_impl!(i32, 0i32)
 zero_impl!(i64, 0i64)
 
-zero_impl!(f32, 0.0f32)
-zero_impl!(f64, 0.0f64)
+zero_float_impl!(f32, 0.0f32)
+zero_float_impl!(f64, 0.0f64)
 
 /// Returns the additive identity, `0`.
 #[inline(always)] pub fn zero<T: Zero>() -> T { Zero::zero() }

trunk/src/librustc/driver/config.rs

@@ -441,12 +441,6 @@ pub fn build_configuration(sess: &Session) -> ast::CrateConfig {
     if sess.opts.test {
         append_configuration(&mut user_cfg, InternedString::new("test"))
     }
-    // If the user requested GC, then add the GC cfg
-    append_configuration(&mut user_cfg, if sess.opts.gc {
-        InternedString::new("gc")
-    } else {
-        InternedString::new("nogc")
-    });
     user_cfg.move_iter().collect::<Vec<_>>().append(default_cfg.as_slice())
 }