---

yaml
---
r: 120637
b: refs/heads/dist-snap
c: 43f942f
h: refs/heads/master
i:
  120635: 61a5b0b
v: v3

Author: bors

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 1813e5aa1a03b0596b8de7abd1af31edf5d6098f
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 9a8379deb296b7a8b543fca635c52307d13f6daf
+refs/heads/dist-snap: 43f942f88656f6b6cb2ff143e496a8875ea157ac
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/mk/platform.mk

@@ -97,13 +97,6 @@ endef
 $(foreach cvar,CC CXX CPP CFLAGS CXXFLAGS CPPFLAGS,\
   $(eval $(call SET_FROM_CFG,$(cvar))))
 
-ifeq ($(CFG_USING_CLANG),1)
-  # The -Qunused-arguments sidesteps spurious warnings from clang
-  CFLAGS += -Qunused-arguments
-  CXXFLAGS += -Qunused-arguments
-  CPPFLAGS += -Qunused-arguments
-endif
-
 CFG_RLIB_GLOB=lib$(1)-*.rlib
 
 # x86_64-unknown-linux-gnu configuration
@@ -516,6 +509,21 @@ CFG_LDPATH_x86_64-unknown-freebsd :=
 CFG_RUN_x86_64-unknown-freebsd=$(2)
 CFG_RUN_TARG_x86_64-unknown-freebsd=$(call CFG_RUN_x86_64-unknown-freebsd,,$(2))
 
+
+# The -Qunused-arguments sidesteps spurious warnings from clang
+define FILTER_FLAGS
+  ifeq ($$(CFG_USING_CLANG),1)
+    ifneq ($(findstring clang,$$(shell $(CC_$(1)) -v)),)
+      CFG_GCCISH_CFLAGS_$(1) += -Qunused-arguments
+      CFG_GCCISH_CXXFLAGS_$(1) += -Qunused-arguments
+    endif
+  endif
+endef
+
+$(foreach target,$(CFG_TARGET),\
+  $(eval $(call FILTER_FLAGS,$(target))))
+
+
 ifeq ($(CFG_CCACHE_CPP2),1)
   CCACHE_CPP2=1
   export CCACHE_CPP

branches/dist-snap/src/libcollections/bitv.rs

@@ -13,7 +13,7 @@
 
 use std::cmp;
 use std::iter::RandomAccessIterator;
-use std::iter::{Rev, Enumerate, Repeat, Map, Zip};
+use std::iter::{Enumerate, Repeat, Map, Zip};
 use std::ops;
 use std::slice;
 use std::strbuf::StrBuf;
@@ -466,12 +466,6 @@ impl Bitv {
         Bits {bitv: self, next_idx: 0, end_idx: self.nbits}
     }
 
-    #[inline]
-    #[deprecated = "replaced by .iter().rev()"]
-    pub fn rev_iter<'a>(&'a self) -> Rev<Bits<'a>> {
-        self.iter().rev()
-    }
-
     /// Returns `true` if all bits are 0
     pub fn none(&self) -> bool {
       match self.rep {

branches/dist-snap/src/libcollections/dlist.rs

@@ -21,7 +21,6 @@
 // Backlinks over DList::prev are raw pointers that form a full chain in
 // the reverse direction.
 
-use std::iter::Rev;
 use std::iter;
 use std::mem;
 use std::ptr;
@@ -369,12 +368,6 @@ impl<T> DList<T> {
         Items{nelem: self.len(), head: &self.list_head, tail: self.list_tail}
     }
 
-    #[inline]
-    #[deprecated = "replaced by .iter().rev()"]
-    pub fn rev_iter<'a>(&'a self) -> Rev<Items<'a, T>> {
-        self.iter().rev()
-    }
-
     /// Provide a forward iterator with mutable references
     #[inline]
     pub fn mut_iter<'a>(&'a mut self) -> MutItems<'a, T> {
@@ -390,24 +383,12 @@ impl<T> DList<T> {
         }
     }
 
-    #[inline]
-    #[deprecated = "replaced by .mut_iter().rev()"]
-    pub fn mut_rev_iter<'a>(&'a mut self) -> Rev<MutItems<'a, T>> {
-        self.mut_iter().rev()
-    }
-
 
     /// Consume the list into an iterator yielding elements by value
     #[inline]
     pub fn move_iter(self) -> MoveItems<T> {
         MoveItems{list: self}
     }
-
-    #[inline]
-    #[deprecated = "replaced by .move_iter().rev()"]
-    pub fn move_rev_iter(self) -> Rev<MoveItems<T>> {
-        self.move_iter().rev()
-    }
 }
 
 impl<T: TotalOrd> DList<T> {

branches/dist-snap/src/libcollections/lru_cache.rs

@@ -92,7 +92,7 @@ impl<K: Hash + TotalEq, V> LruCache<K, V> {
         let cache = LruCache {
             map: HashMap::new(),
             max_size: capacity,
-            head: unsafe{ mem::transmute(box mem::uninit::<LruEntry<K, V>>()) },
+            head: unsafe{ mem::transmute(box mem::uninitialized::<LruEntry<K, V>>()) },
         };
         unsafe {
             (*cache.head).next = cache.head;

branches/dist-snap/src/libcollections/ringbuf.rs

@@ -14,7 +14,7 @@
 //! collections::deque::Deque`.
 
 use std::cmp;
-use std::iter::{Rev, RandomAccessIterator};
+use std::iter::RandomAccessIterator;
 
 use deque::Deque;
 
@@ -190,11 +190,6 @@ impl<T> RingBuf<T> {
         Items{index: 0, rindex: self.nelts, lo: self.lo, elts: self.elts.as_slice()}
     }
 
-    #[deprecated = "replaced by .iter().rev()"]
-    pub fn rev_iter<'a>(&'a self) -> Rev<Items<'a, T>> {
-        self.iter().rev()
-    }
-
     /// Front-to-back iterator which returns mutable values.
     pub fn mut_iter<'a>(&'a mut self) -> MutItems<'a, T> {
         let start_index = raw_index(self.lo, self.elts.len(), 0);
@@ -220,11 +215,6 @@ impl<T> RingBuf<T> {
                                  nelts: self.nelts }
         }
     }
-
-    #[deprecated = "replaced by .mut_iter().rev()"]
-    pub fn mut_rev_iter<'a>(&'a mut self) -> Rev<MutItems<'a, T>> {
-        self.mut_iter().rev()
-    }
 }
 
 /// RingBuf iterator

branches/dist-snap/src/libcollections/smallintmap.rs

@@ -15,7 +15,7 @@
 
 #![allow(missing_doc)]
 
-use std::iter::{Enumerate, FilterMap, Rev};
+use std::iter::{Enumerate, FilterMap};
 use std::mem::replace;
 use std::{vec, slice};
 
@@ -142,16 +142,6 @@ impl<V> SmallIntMap<V> {
         }
     }
 
-    #[deprecated = "replaced by .iter().rev()"]
-    pub fn rev_iter<'r>(&'r self) -> Rev<Entries<'r, V>> {
-        self.iter().rev()
-    }
-
-    #[deprecated = "replaced by .mut_iter().rev()"]
-    pub fn mut_rev_iter<'r>(&'r mut self) -> Rev<MutEntries<'r, V>> {
-        self.mut_iter().rev()
-    }
-
     /// Empties the hash map, moving all values into the specified closure
     pub fn move_iter(&mut self)
         -> FilterMap<(uint, Option<V>), (uint, V),
@@ -243,8 +233,6 @@ pub struct Entries<'a, T> {
 
 iterator!(impl Entries -> (uint, &'a T), get_ref)
 double_ended_iterator!(impl Entries -> (uint, &'a T), get_ref)
-#[deprecated = "replaced by Rev<Entries<'a, T>>"]
-pub type RevEntries<'a, T> = Rev<Entries<'a, T>>;
 
 pub struct MutEntries<'a, T> {
     front: uint,
@@ -254,8 +242,6 @@ pub struct MutEntries<'a, T> {
 
 iterator!(impl MutEntries -> (uint, &'a mut T), get_mut_ref)
 double_ended_iterator!(impl MutEntries -> (uint, &'a mut T), get_mut_ref)
-#[deprecated = "replaced by Rev<MutEntries<'a, T>"]
-pub type RevMutEntries<'a, T> = Rev<MutEntries<'a, T>>;
 
 #[cfg(test)]
 mod test_map {

branches/dist-snap/src/libcore/cell.rs

@@ -88,11 +88,10 @@
 //! ```
 //! extern crate collections;
 //!
-//! use collections::HashMap;
 //! use std::cell::RefCell;
 //!
 //! struct Graph {
-//!     edges: HashMap<uint, uint>,
+//!     edges: Vec<(uint, uint)>,
 //!     span_tree_cache: RefCell<Option<Vec<(uint, uint)>>>
 //! }
 //!

branches/dist-snap/src/libcore/finally.rs

@@ -20,7 +20,7 @@ also be used. See that function for more details.
 # Example
 
 ```
-use std::unstable::finally::Finally;
+use std::finally::Finally;
 
 (|| {
     // ...
@@ -75,7 +75,7 @@ impl<T> Finally<T> for fn() -> T {
  * # Example
  *
  * ```
- * use std::unstable::finally::try_finally;
+ * use std::finally::try_finally;
  *
  * struct State<'a> { buffer: &'a mut [u8], len: uint }
  * # let mut buf = [];

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

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! The Rust Core Library
+//! # The Rust Core Library
 //!
 //! The Rust Core Library is the dependency-free foundation of [The
 //! Rust Standard Library](../std/index.html). It is the portable glue
@@ -53,7 +53,7 @@
        html_root_url = "http://doc.rust-lang.org/")]
 
 #![no_std]
-#![feature(globs, macro_rules, managed_boxes, phase)]
+#![feature(globs, macro_rules, managed_boxes, phase, simd)]
 #![deny(missing_doc)]
 
 #[cfg(test)] extern crate realcore = "core";
@@ -124,6 +124,7 @@ pub mod iter;
 pub mod option;
 pub mod raw;
 pub mod result;
+pub mod simd;
 pub mod slice;
 pub mod str;
 pub mod tuple;

branches/dist-snap/src/libcore/mem.rs

@@ -26,7 +26,7 @@ pub fn size_of<T>() -> uint {
 
 /// Returns the size of the type that `_val` points to in bytes.
 #[inline]
-#[unstable = "the name of this function may change slightly before stabilizing"]
+#[stable]
 pub fn size_of_val<T>(_val: &T) -> uint {
     size_of::<T>()
 }
@@ -64,7 +64,7 @@ pub fn min_align_of<T>() -> uint {
 /// Returns the ABI-required minimum alignment of the type of the value that
 /// `_val` points to
 #[inline]
-#[unstable = "the name of this function may change slightly before stabilizing"]
+#[stable]
 pub fn min_align_of_val<T>(_val: &T) -> uint {
     min_align_of::<T>()
 }
@@ -90,7 +90,7 @@ pub fn align_of<T>() -> uint {
 /// as trait objects (in the future), returning the alignment for an arbitrary
 /// value at runtime.
 #[inline]
-#[unstable = "the name of this function may change slightly before stabilizing"]
+#[stable]
 pub fn align_of_val<T>(_val: &T) -> uint {
     align_of::<T>()
 }
@@ -117,7 +117,7 @@ pub fn pref_align_of_val<T>(val: &T) -> uint { align_of_val(val) }
 ///
 /// This is useful for FFI functions sometimes, but should generally be avoided.
 #[inline]
-#[unstable = "the name of this function is subject to change"]
+#[stable]
 pub unsafe fn zeroed<T>() -> T {
     intrinsics::init()
 }
@@ -136,7 +136,14 @@ pub unsafe fn init<T>() -> T { zeroed() }
 ///
 /// This is useful for FFI functions sometimes, but should generally be avoided.
 #[inline]
-#[unstable = "the name of this function is subject to change"]
+#[stable]
+pub unsafe fn uninitialized<T>() -> T {
+    intrinsics::uninit()
+}
+
+/// Deprecated, use `uninitialized` instead.
+#[inline]
+#[deprecated = "this function has been renamed to `uninitialized`"]
 pub unsafe fn uninit<T>() -> T {
     intrinsics::uninit()
 }
@@ -148,7 +155,7 @@ pub unsafe fn uninit<T>() -> T {
 /// contained at the location `dst`. This could leak allocations or resources,
 /// so care must be taken to previously deallocate the value at `dst`.
 #[inline]
-#[unstable = "the name of this function is subject to change"]
+#[stable]
 pub unsafe fn overwrite<T>(dst: *mut T, src: T) {
     intrinsics::move_val_init(&mut *dst, src)
 }
@@ -315,7 +322,7 @@ pub fn from_be64(x: u64) -> u64 { x }
 pub fn swap<T>(x: &mut T, y: &mut T) {
     unsafe {
         // Give ourselves some scratch space to work with
-        let mut t: T = uninit();
+        let mut t: T = uninitialized();
 
         // Perform the swap, `&mut` pointers never alias
         ptr::copy_nonoverlapping_memory(&mut t, &*x, 1);

branches/dist-snap/src/libcore/ptr.rs

@@ -10,23 +10,18 @@
 
 // FIXME: talk about offset, copy_memory, copy_nonoverlapping_memory
 
-//! Conveniences for working with unsafe pointers, the `*T`, and `*mut T` types.
+//! Operations on unsafe pointers, `*T`, and `*mut T`.
 //!
-//! Working with unsafe pointers in Rust is fairly uncommon,
-//! and often limited to some narrow use cases: holding
-//! an unsafe pointer when safe pointers are unsuitable;
-//! checking for null; and converting back to safe pointers.
-//! As a result, there is not yet an abundance of library code
-//! for working with unsafe pointers, and in particular,
-//! since pointer math is fairly uncommon in Rust, it is not
-//! all that convenient.
+//! Working with unsafe pointers in Rust is uncommon,
+//! typically limited to a few patterns.
 //!
 //! Use the [`null` function](fn.null.html) to create null pointers,
 //! the [`is_null`](trait.RawPtr.html#tymethod.is_null)
 //! and [`is_not_null`](trait.RawPtr.html#method.is_not_null)
 //! methods of the [`RawPtr` trait](trait.RawPtr.html) to check for null.
 //! The `RawPtr` trait is imported by the prelude, so `is_null` etc.
-//! work everywhere.
+//! work everywhere. The `RawPtr` also defines the `offset` method,
+//! for pointer math.
 //!
 //! # Common ways to create unsafe pointers
 //!
@@ -201,7 +196,7 @@ pub unsafe fn copy_memory<T>(dst: *mut T, src: *T, count: uint) {
 /// fn swap<T>(x: &mut T, y: &mut T) {
 ///     unsafe {
 ///         // Give ourselves some scratch space to work with
-///         let mut t: T = mem::uninit();
+///         let mut t: T = mem::uninitialized();
 ///
 ///         // Perform the swap, `&mut` pointers never alias
 ///         ptr::copy_nonoverlapping_memory(&mut t, &*x, 1);
@@ -244,7 +239,7 @@ pub unsafe fn zero_memory<T>(dst: *mut T, count: uint) {
 #[inline]
 pub unsafe fn swap<T>(x: *mut T, y: *mut T) {
     // Give ourselves some scratch space to work with
-    let mut tmp: T = mem::uninit();
+    let mut tmp: T = mem::uninitialized();
     let t: *mut T = &mut tmp;
 
     // Perform the swap
@@ -268,7 +263,7 @@ pub unsafe fn replace<T>(dest: *mut T, mut src: T) -> T {
 /// Reads the value from `*src` and returns it.
 #[inline(always)]
 pub unsafe fn read<T>(src: *T) -> T {
-    let mut tmp: T = mem::uninit();
+    let mut tmp: T = mem::uninitialized();
     copy_nonoverlapping_memory(&mut tmp, src, 1);
     tmp
 }
@@ -316,7 +311,7 @@ pub unsafe fn array_each<T>(arr: **T, cb: |*T|) {
     array_each_with_len(arr, len, cb);
 }
 
-/// Extension methods for raw pointers.
+/// Methods on raw pointers
 pub trait RawPtr<T> {
     /// Returns the null pointer.
     fn null() -> Self;