---

yaml
---
r: 166483
b: refs/heads/snap-stage3
c: 6948a2d
h: refs/heads/master
i:
  166481: bb2a205
  166479: 68927cd
v: v3

Author: jroesch

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 18842f89f084c52588fe7cffe07f87bf6e90796a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: f673e9841f58a2196efd3b757804efa2575f8b79
+refs/heads/snap-stage3: 6948a2df318d1bc2d668d8b29a653f15db1653d8
 refs/heads/try: f5d619caf9f32458680fae55526b99582ca682dd
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

branches/snap-stage3/mk/cfg/x86_64-unknown-dragonfly.mk

@@ -7,9 +7,9 @@ CFG_LIB_NAME_x86_64-unknown-dragonfly=lib$(1).so
 CFG_STATIC_LIB_NAME_x86_64-unknown-dragonfly=lib$(1).a
 CFG_LIB_GLOB_x86_64-unknown-dragonfly=lib$(1)-*.so
 CFG_LIB_DSYM_GLOB_x86_64-unknown-dragonfly=$(1)-*.dylib.dSYM
-CFG_JEMALLOC_CFLAGS_x86_64-unknown-dragonfly := -m64 -I/usr/include -I/usr/local/include $(CFLAGS)
-CFG_GCCISH_CFLAGS_x86_64-unknown-dragonfly := -Wall -Werror -g -fPIC -m64 -I/usr/include -I/usr/local/include $(CFLAGS)
-CFG_GCCISH_LINK_FLAGS_x86_64-unknown-dragonfly := -shared -fPIC -g -pthread  -lrt -m64
+CFG_JEMALLOC_CFLAGS_x86_64-unknown-dragonfly := -I/usr/include -I/usr/local/include $(CFLAGS)
+CFG_GCCISH_CFLAGS_x86_64-unknown-dragonfly := -Wall -Werror -g -fPIC -I/usr/include -I/usr/local/include $(CFLAGS)
+CFG_GCCISH_LINK_FLAGS_x86_64-unknown-dragonfly := -shared -fPIC -g -pthread  -lrt
 CFG_GCCISH_DEF_FLAG_x86_64-unknown-dragonfly := -Wl,--export-dynamic,--dynamic-list=
 CFG_GCCISH_PRE_LIB_FLAGS_x86_64-unknown-dragonfly := -Wl,-whole-archive
 CFG_GCCISH_POST_LIB_FLAGS_x86_64-unknown-dragonfly := -Wl,-no-whole-archive

branches/snap-stage3/src/doc/complement-bugreport.md

@@ -34,7 +34,7 @@ miss out on valid bug reports.
 It generally helps our diagnosis to include your specific OS (for example: Mac OS X 10.8.3,
 Windows 7, Ubuntu 12.04) and your hardware architecture (for example: i686, x86_64).
 It's also helpful to provide the exact version and host by copying the output of
-re-running the erroneous rustc command with the `--version --verbose` flags, which will
+re-running the erroneous rustc command with the `--version=verbose` flag, which will
 produce something like this:
 
 ```text

branches/snap-stage3/src/doc/reference.md

@@ -640,7 +640,7 @@ names, and invoked through a consistent syntax: `name!(...)`. Examples include:
 * `stringify!` : pretty-print the Rust expression given as an argument
 * `include!` : include the Rust expression in the given file
 * `include_str!` : include the contents of the given file as a string
-* `include_bytes!` : include the contents of the given file as a binary blob
+* `include_bin!` : include the contents of the given file as a binary blob
 * `error!`, `warn!`, `info!`, `debug!` : provide diagnostic information.
 
 All of the above extensions are expressions with values.

branches/snap-stage3/src/etc/rustup.sh

@@ -441,7 +441,7 @@ install_package() {
     install_script="$2"
 
     msg "Extracting ${tarball_name}"
-    (cd "${CFG_TMP_DIR}" && "${CFG_TAR}" -xzf "${tarball_name}")
+    (cd "${CFG_TMP_DIR}" && "${CFG_TAR}" -xvf "${tarball_name}")
     if [ $? -ne 0 ]; then
         rm -Rf "${CFG_TMP_DIR}"
         err "failed to unpack installer"

branches/snap-stage3/src/etc/snapshot.py

@@ -37,7 +37,6 @@ def scrub(b):
     "macos": ["bin/rustc"],
     "winnt": ["bin/rustc.exe"],
     "freebsd": ["bin/rustc"],
-    "dragonfly": ["bin/rustc"],
     }
 
 winnt_runtime_deps_32 = ["libgcc_s_dw2-1.dll",
@@ -87,8 +86,6 @@ def get_kernel(triple):
         return "macos"
     if os_name == "freebsd":
         return "freebsd"
-    if os_name == "dragonfly":
-        return "dragonfly"
     return "linux"
 
 def get_cpu(triple):

branches/snap-stage3/src/libcollections/ring_buf.rs

@@ -1295,6 +1295,9 @@ impl<A: PartialEq> PartialEq for RingBuf<A> {
         self.len() == other.len() &&
             self.iter().zip(other.iter()).all(|(a, b)| a.eq(b))
     }
+    fn ne(&self, other: &RingBuf<A>) -> bool {
+        !self.eq(other)
+    }
 }
 
 impl<A: Eq> Eq for RingBuf<A> {}

branches/snap-stage3/src/libcollections/vec_map.rs

@@ -60,6 +60,7 @@ use vec::Vec;
 /// months.clear();
 /// assert!(months.is_empty());
 /// ```
+#[deriving(PartialEq, Eq)]
 pub struct VecMap<V> {
     v: Vec<Option<V>>,
 }
@@ -491,14 +492,6 @@ impl<V:Clone> VecMap<V> {
     }
 }
 
-impl<V: PartialEq> PartialEq for VecMap<V> {
-    fn eq(&self, other: &VecMap<V>) -> bool {
-        iter::order::eq(self.iter(), other.iter())
-    }
-}
-
-impl<V: Eq> Eq for VecMap<V> {}
-
 impl<V: PartialOrd> PartialOrd for VecMap<V> {
     #[inline]
     fn partial_cmp(&self, other: &VecMap<V>) -> Option<Ordering> {
@@ -962,10 +955,6 @@ mod test_map {
         assert!(a != b);
         assert!(b.insert(5, 19).is_none());
         assert!(a == b);
-
-        a = VecMap::new();
-        b = VecMap::with_capacity(1);
-        assert!(a == b);
     }
 
     #[test]

branches/snap-stage3/src/libcore/fmt/float.rs

@@ -18,8 +18,8 @@ use char;
 use char::Char;
 use fmt;
 use iter::{range, DoubleEndedIteratorExt};
-use num::{cast, Float, ToPrimitive};
-use num::FpCategory as Fp;
+use num::{Float, FPNaN, FPInfinite, ToPrimitive};
+use num::cast;
 use ops::FnOnce;
 use result::Result::Ok;
 use slice::{mod, SliceExt};
@@ -109,11 +109,11 @@ pub fn float_to_str_bytes_common<T: Float, U, F>(
     let _1: T = Float::one();
 
     match num.classify() {
-        Fp::Nan => return f("NaN".as_bytes()),
-        Fp::Infinite if num > _0 => {
+        FPNaN => return f("NaN".as_bytes()),
+        FPInfinite if num > _0 => {
             return f("inf".as_bytes());
         }
-        Fp::Infinite if num < _0 => {
+        FPInfinite if num < _0 => {
             return f("-inf".as_bytes());
         }
         _ => {}

branches/snap-stage3/src/libcore/iter.rs

@@ -2542,64 +2542,6 @@ impl<A: Int> Iterator<A> for RangeStepInclusive<A> {
     }
 }
 
-
-/// The `Step` trait identifies objects which can be stepped over in both
-/// directions. The `steps_between` function provides a way to
-/// compare two Step objects (it could be provided using `step()` and `Ord`,
-/// but the implementation would be so inefficient as to be useless).
-#[unstable = "Trait is unstable."]
-pub trait Step: Ord {
-    /// Change self to the next object.
-    fn step(&mut self);
-    /// Change self to the previous object.
-    fn step_back(&mut self);
-    /// The steps_between two step objects.
-    /// a should always be less than b, so the result should never be negative.
-    /// Return None if it is not possible to calculate steps_between without
-    /// overflow.
-    fn steps_between(a: &Self, b: &Self) -> Option<uint>;
-}
-
-macro_rules! step_impl {
-    ($($t:ty)*) => ($(
-        #[unstable = "Trait is unstable."]
-        impl Step for $t {
-            #[inline]
-            fn step(&mut self) { *self += 1; }
-            #[inline]
-            fn step_back(&mut self) { *self -= 1; }
-            #[inline]
-            fn steps_between(a: &$t, b: &$t) -> Option<uint> {
-                debug_assert!(a < b);
-                Some((*a - *b) as uint)
-            }
-        }
-    )*)
-}
-
-macro_rules! step_impl_no_between {
-    ($($t:ty)*) => ($(
-        #[unstable = "Trait is unstable."]
-        impl Step for $t {
-            #[inline]
-            fn step(&mut self) { *self += 1; }
-            #[inline]
-            fn step_back(&mut self) { *self -= 1; }
-            #[inline]
-            fn steps_between(_a: &$t, _b: &$t) -> Option<uint> {
-                None
-            }
-        }
-    )*)
-}
-
-step_impl!(uint u8 u16 u32 int i8 i16 i32);
-#[cfg(target_word_size = "64")]
-step_impl!(u64 i64);
-#[cfg(target_word_size = "32")]
-step_impl_no_between!(u64 i64);
-
-
 /// An iterator that repeats an element endlessly
 #[deriving(Clone)]
 #[stable]

branches/snap-stage3/src/libcore/lib.rs

@@ -59,7 +59,7 @@
 #![allow(unknown_features, raw_pointer_deriving)]
 #![feature(globs, intrinsics, lang_items, macro_rules, phase)]
 #![feature(simd, unsafe_destructor, slicing_syntax)]
-#![feature(default_type_params, unboxed_closures, associated_types)]
+#![feature(default_type_params, unboxed_closures)]
 #![deny(missing_docs)]
 
 mod macros;

branches/snap-stage3/src/libcore/num/f32.rs

@@ -18,8 +18,7 @@
 
 use intrinsics;
 use mem;
-use num::Float;
-use num::FpCategory as Fp;
+use num::{Float, FPNormal, FPCategory, FPZero, FPSubnormal, FPInfinite, FPNaN};
 use num::from_str_radix;
 use option::Option;
 
@@ -157,23 +156,23 @@ impl Float for f32 {
     /// Returns `true` if the number is neither zero, infinite, subnormal or NaN.
     #[inline]
     fn is_normal(self) -> bool {
-        self.classify() == Fp::Normal
+        self.classify() == FPNormal
     }
 
     /// Returns the floating point category of the number. If only one property
     /// is going to be tested, it is generally faster to use the specific
     /// predicate instead.
-    fn classify(self) -> Fp {
+    fn classify(self) -> FPCategory {
         const EXP_MASK: u32 = 0x7f800000;
         const MAN_MASK: u32 = 0x007fffff;
 
         let bits: u32 = unsafe { mem::transmute(self) };
         match (bits & MAN_MASK, bits & EXP_MASK) {
-            (0, 0)        => Fp::Zero,
-            (_, 0)        => Fp::Subnormal,
-            (0, EXP_MASK) => Fp::Infinite,
-            (_, EXP_MASK) => Fp::Nan,
-            _             => Fp::Normal,
+            (0, 0)        => FPZero,
+            (_, 0)        => FPSubnormal,
+            (0, EXP_MASK) => FPInfinite,
+            (_, EXP_MASK) => FPNaN,
+            _             => FPNormal,
         }
     }
 

branches/snap-stage3/src/libcore/num/f64.rs

@@ -18,8 +18,7 @@
 
 use intrinsics;
 use mem;
-use num::Float;
-use num::FpCategory as Fp;
+use num::{Float, FPNormal, FPCategory, FPZero, FPSubnormal, FPInfinite, FPNaN};
 use num::from_str_radix;
 use option::Option;
 
@@ -165,23 +164,23 @@ impl Float for f64 {
     /// Returns `true` if the number is neither zero, infinite, subnormal or NaN.
     #[inline]
     fn is_normal(self) -> bool {
-        self.classify() == Fp::Normal
+        self.classify() == FPNormal
     }
 
     /// Returns the floating point category of the number. If only one property
     /// is going to be tested, it is generally faster to use the specific
     /// predicate instead.
-    fn classify(self) -> Fp {
+    fn classify(self) -> FPCategory {
         const EXP_MASK: u64 = 0x7ff0000000000000;
         const MAN_MASK: u64 = 0x000fffffffffffff;
 
         let bits: u64 = unsafe { mem::transmute(self) };
         match (bits & MAN_MASK, bits & EXP_MASK) {
-            (0, 0)        => Fp::Zero,
-            (_, 0)        => Fp::Subnormal,
-            (0, EXP_MASK) => Fp::Infinite,
-            (_, EXP_MASK) => Fp::Nan,
-            _             => Fp::Normal,
+            (0, 0)        => FPZero,
+            (_, 0)        => FPSubnormal,
+            (0, EXP_MASK) => FPInfinite,
+            (_, EXP_MASK) => FPNaN,
+            _             => FPNormal,
         }
     }
 

branches/snap-stage3/src/libcore/num/mod.rs

@@ -15,6 +15,8 @@
 #![stable]
 #![allow(missing_docs)]
 
+pub use self::FPCategory::*;
+
 use {int, i8, i16, i32, i64};
 use {uint, u8, u16, u32, u64};
 use {f32, f64};
@@ -1220,17 +1222,17 @@ impl_num_cast! { f64,   to_f64 }
 /// Used for representing the classification of floating point numbers
 #[deriving(Copy, PartialEq, Show)]
 #[unstable = "may be renamed"]
-pub enum FpCategory {
+pub enum FPCategory {
     /// "Not a Number", often obtained by dividing by zero
-    Nan,
+    FPNaN,
     /// Positive or negative infinity
-    Infinite ,
+    FPInfinite ,
     /// Positive or negative zero
-    Zero,
-    /// De-normalized floating point representation (less precise than `Normal`)
-    Subnormal,
+    FPZero,
+    /// De-normalized floating point representation (less precise than `FPNormal`)
+    FPSubnormal,
     /// A regular floating point number
-    Normal,
+    FPNormal,
 }
 
 /// A built-in floating point number.
@@ -1275,7 +1277,7 @@ pub trait Float
     /// Returns true if this number is neither zero, infinite, denormal, or NaN.
     fn is_normal(self) -> bool;
     /// Returns the category that this number falls into.
-    fn classify(self) -> FpCategory;
+    fn classify(self) -> FPCategory;
 
     // FIXME (#5527): These should be associated constants