---

yaml
---
r: 130199
b: refs/heads/master
c: 5b0d3ad
h: refs/heads/master
i:
  130197: 54d58d2
  130195: 7ffde8e
  130191: f99a48e
v: v3

Author: pczarn

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 074d3da7b09883658cd0d52d53ebac7ee74e9e28
+refs/heads/master: 5b0d3adf3debde4cd21e7adb1f434580386d7265
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 67b97ab6d2b7de9b69fd97dc171fcf8feec932ff
 refs/heads/try: 28d5878c1f0465c11c8e7a3085008b0c592d48d0

trunk/src/driver/driver.rs

@@ -9,9 +9,9 @@
 // except according to those terms.
 
 #[cfg(rustdoc)]
-extern crate "rustdoc" as this;
+extern crate this = "rustdoc";
 
 #[cfg(rustc)]
-extern crate "rustc" as this;
+extern crate this = "rustc";
 
 fn main() { this::main() }

trunk/src/libcollections/bitv.rs

@@ -95,6 +95,20 @@ fn match_words <'a,'b>(a: &'a Bitv, b: &'b Bitv) -> (MatchWords<'a>, MatchWords<
 static TRUE: bool = true;
 static FALSE: bool = false;
 
+#[deriving(Clone)]
+struct SmallBitv {
+    /// only the lowest nbits of this value are used. the rest is undefined.
+    bits: uint
+}
+
+#[deriving(Clone)]
+struct BigBitv {
+    storage: Vec<uint>
+}
+
+#[deriving(Clone)]
+enum BitvVariant { Big(BigBitv), Small(SmallBitv) }
+
 /// The bitvector type.
 ///
 /// # Example
@@ -1639,7 +1653,6 @@ impl<'a> Iterator<uint> for TwoBitPositions<'a> {
 #[cfg(test)]
 mod tests {
     use std::prelude::*;
-    use std::iter::range_step;
     use std::uint;
     use std::rand;
     use std::rand::Rng;
@@ -2033,14 +2046,12 @@ mod tests {
 
     #[test]
     fn test_bitv_iterator() {
-        let bools = vec![true, false, true, true];
+        let bools = [true, false, true, true];
         let bitv: Bitv = bools.iter().map(|n| *n).collect();
 
-        assert_eq!(bitv.iter().collect::<Vec<bool>>(), bools)
-
-        let long = Vec::from_fn(10000, |i| i % 2 == 0);
-        let bitv: Bitv = long.iter().map(|n| *n).collect();
-        assert_eq!(bitv.iter().collect::<Vec<bool>>(), long)
+        for (act, &ex) in bitv.iter().zip(bools.iter()) {
+            assert_eq!(ex, act);
+        }
     }
 
     #[test]
@@ -2050,12 +2061,6 @@ mod tests {
 
         let idxs: Vec<uint> = bitv.iter().collect();
         assert_eq!(idxs, vec!(0, 2, 3));
-
-        let long: BitvSet = range(0u, 10000).map(|n| n % 2 == 0).collect();
-        let real = range_step(0, 10000, 2).collect::<Vec<uint>>();
-
-        let idxs: Vec<uint> = long.iter().collect();
-        assert_eq!(idxs, real);
     }
 
     #[test]
@@ -2569,7 +2574,7 @@ mod tests {
     }
 
     #[bench]
-    fn bench_bitv_set_big_fixed(b: &mut Bencher) {
+    fn bench_bitv_big(b: &mut Bencher) {
         let mut r = rng();
         let mut bitv = Bitv::with_capacity(BENCH_BITS, false);
         b.iter(|| {
@@ -2581,19 +2586,7 @@ mod tests {
     }
 
     #[bench]
-    fn bench_bitv_set_big_variable(b: &mut Bencher) {
-        let mut r = rng();
-        let mut bitv = Bitv::with_capacity(BENCH_BITS, false);
-        b.iter(|| {
-            for i in range(0u, 100) {
-                bitv.set((r.next_u32() as uint) % BENCH_BITS, r.gen());
-            }
-            &bitv
-        })
-    }
-
-    #[bench]
-    fn bench_bitv_set_small(b: &mut Bencher) {
+    fn bench_bitv_small(b: &mut Bencher) {
         let mut r = rng();
         let mut bitv = Bitv::with_capacity(uint::BITS, false);
         b.iter(|| {
@@ -2605,7 +2598,7 @@ mod tests {
     }
 
     #[bench]
-    fn bench_bitvset_small(b: &mut Bencher) {
+    fn bench_bitv_set_small(b: &mut Bencher) {
         let mut r = rng();
         let mut bitv = BitvSet::new();
         b.iter(|| {
@@ -2617,7 +2610,7 @@ mod tests {
     }
 
     #[bench]
-    fn bench_bitvset_big(b: &mut Bencher) {
+    fn bench_bitv_set_big(b: &mut Bencher) {
         let mut r = rng();
         let mut bitv = BitvSet::new();
         b.iter(|| {

trunk/src/libcollections/dlist.rs

@@ -90,7 +90,7 @@ impl<T> Rawlink<T> {
     /// Convert the `Rawlink` into an Option value
     fn resolve_immut<'a>(&self) -> Option<&'a T> {
         unsafe {
-            self.p.as_ref()
+            mem::transmute(self.p.to_option())
         }
     }
 

trunk/src/libcollections/lib.rs

@@ -289,7 +289,7 @@ pub trait Set<T>: Collection {
 }
 
 /// A mutable collection of values which are distinct from one another that
-/// can be mutated.
+/// can be mutaed.
 pub trait MutableSet<T>: Set<T> + Mutable {
     /// Adds a value to the set. Returns `true` if the value was not already
     /// present in the set.

trunk/src/libcollections/ringbuf.rs

@@ -132,7 +132,7 @@ impl<T> RingBuf<T> {
               elts: Vec::from_fn(cmp::max(MINIMUM_CAPACITY, n), |_| None)}
     }
 
-    /// Retrieve an element in the `RingBuf` by index.
+    /// Retrieva an element in the `RingBuf` by index.
     ///
     /// Fails if there is no element with the given index.
     ///

trunk/src/libcollections/smallintmap.rs

@@ -324,7 +324,7 @@ impl<V:Clone> SmallIntMap<V> {
     /// Updates a value in the map. If the key already exists in the map,
     /// modifies the value with `ff` taking `oldval, newval`.
     /// Otherwise, sets the value to `newval`.
-    /// Returns `true` if the key did not already exist in the map.
+    /// Returasn `true` if the key did not already exist in the map.
     ///
     /// # Example
     ///

trunk/src/libcollections/str.rs

@@ -44,7 +44,7 @@
 //!
 //! # Representation
 //!
-//! Rust's string type, `str`, is a sequence of Unicode scalar values encoded as a
+//! Rust's string type, `str`, is a sequence of unicode scalar values encoded as a
 //! stream of UTF-8 bytes. All strings are guaranteed to be validly encoded UTF-8
 //! sequences. Additionally, strings are not null-terminated and can contain null
 //! bytes.

trunk/src/libcore/char.rs

@@ -201,7 +201,7 @@ pub fn escape_unicode(c: char, f: |char|) {
 /// - Tab, CR and LF are escaped as '\t', '\r' and '\n' respectively.
 /// - Single-quote, double-quote and backslash chars are backslash-escaped.
 /// - Any other chars in the range [0x20,0x7e] are not escaped.
-/// - Any other chars are given hex Unicode escapes; see `escape_unicode`.
+/// - Any other chars are given hex unicode escapes; see `escape_unicode`.
 ///
 pub fn escape_default(c: char, f: |char|) {
     match c {
@@ -290,7 +290,7 @@ pub trait Char {
     /// * Single-quote, double-quote and backslash chars are backslash-
     ///   escaped.
     /// * Any other chars in the range [0x20,0x7e] are not escaped.
-    /// * Any other chars are given hex Unicode escapes; see `escape_unicode`.
+    /// * Any other chars are given hex unicode escapes; see `escape_unicode`.
     fn escape_default(&self, f: |char|);
 
     /// Returns the amount of bytes this character would need if encoded in

trunk/src/libcore/fmt/mod.rs

@@ -461,28 +461,19 @@ impl<'a> Formatter<'a> {
         use char::Char;
         let align = match self.align {
             rt::AlignUnknown => default,
-            _ => self.align
+            rt::AlignLeft | rt::AlignRight => self.align
         };
-
-        let (pre_pad, post_pad) = match align {
-            rt::AlignLeft => (0u, padding),
-            rt::AlignRight | rt::AlignUnknown => (padding, 0u),
-            rt::AlignCenter => (padding / 2, (padding + 1) / 2),
-        };
-
+        if align == rt::AlignLeft {
+            try!(f(self));
+        }
         let mut fill = [0u8, ..4];
         let len = self.fill.encode_utf8(fill).unwrap_or(0);
-
-        for _ in range(0, pre_pad) {
+        for _ in range(0, padding) {
             try!(self.buf.write(fill.slice_to(len)));
         }
-
-        try!(f(self));
-
-        for _ in range(0, post_pad) {
-            try!(self.buf.write(fill.slice_to(len)));
+        if align == rt::AlignRight {
+            try!(f(self));
         }
-
         Ok(())
     }
 

trunk/src/libcore/fmt/rt.rs

@@ -43,8 +43,6 @@ pub enum Alignment {
     AlignLeft,
     /// Indication that contents should be right-aligned.
     AlignRight,
-    /// Indication that contents should be center-aligned.
-    AlignCenter,
     /// No alignment was requested.
     AlignUnknown,
 }

trunk/src/libcore/intrinsics.rs

@@ -311,7 +311,7 @@ extern "rust-intrinsic" {
 
     /// Gives the address for the return value of the enclosing function.
     ///
-    /// Using this intrinsic in a function that does not use an out pointer
+    /// Using this instrinsic in a function that does not use an out pointer
     /// will trigger a compiler error.
     pub fn return_address() -> *const u8;
 

trunk/src/libcore/ptr.rs

@@ -256,46 +256,27 @@ pub unsafe fn position<T>(buf: *const T, f: |&T| -> bool) -> uint {
 pub trait RawPtr<T> {
     /// Returns the null pointer.
     fn null() -> Self;
-
     /// Returns true if the pointer is equal to the null pointer.
     fn is_null(&self) -> bool;
-
     /// Returns true if the pointer is not equal to the null pointer.
     fn is_not_null(&self) -> bool { !self.is_null() }
-
     /// Returns the value of this pointer (ie, the address it points to)
     fn to_uint(&self) -> uint;
-
-    /// Returns `None` if the pointer is null, or else returns a reference to the
-    /// value wrapped in `Some`.
+    /// Returns `None` if the pointer is null, or else returns the value wrapped
+    /// in `Some`.
     ///
     /// # Safety Notes
     ///
-    /// While this method and its mutable counterpart are useful for null-safety,
-    /// it is important to note that this is still an unsafe operation because
-    /// the returned value could be pointing to invalid memory.
-    unsafe fn as_ref<'a>(&self) -> Option<&'a T>;
-
-    /// A synonym for `as_ref`, except with incorrect lifetime semantics
-    #[deprecated="Use `as_ref` instead"]
-    unsafe fn to_option<'a>(&'a self) -> Option<&'a T> {
-        mem::transmute(self.as_ref())
-    }
-
+    /// While this method is useful for null-safety, it is important to note
+    /// that this is still an unsafe operation because the returned value could
+    /// be pointing to invalid memory.
+    unsafe fn to_option(&self) -> Option<&T>;
     /// Calculates the offset from a pointer. The offset *must* be in-bounds of
     /// the object, or one-byte-past-the-end.  `count` is in units of T; e.g. a
     /// `count` of 3 represents a pointer offset of `3 * sizeof::<T>()` bytes.
     unsafe fn offset(self, count: int) -> Self;
 }
 
-/// Methods on mutable raw pointers
-pub trait RawMutPtr<T>{
-    /// Returns `None` if the pointer is null, or else returns a mutable reference
-    /// to the value wrapped in `Some`. As with `as_ref`, this is unsafe because
-    /// it cannot verify the validity of the returned pointer.
-    unsafe fn as_mut<'a>(&self) -> Option<&'a mut T>;
-}
-
 impl<T> RawPtr<T> for *const T {
     #[inline]
     fn null() -> *const T { null() }
@@ -312,7 +293,7 @@ impl<T> RawPtr<T> for *const T {
     }
 
     #[inline]
-    unsafe fn as_ref<'a>(&self) -> Option<&'a T> {
+    unsafe fn to_option(&self) -> Option<&T> {
         if self.is_null() {
             None
         } else {
@@ -337,7 +318,7 @@ impl<T> RawPtr<T> for *mut T {
     }
 
     #[inline]
-    unsafe fn as_ref<'a>(&self) -> Option<&'a T> {
+    unsafe fn to_option(&self) -> Option<&T> {
         if self.is_null() {
             None
         } else {
@@ -346,17 +327,6 @@ impl<T> RawPtr<T> for *mut T {
     }
 }
 
-impl<T> RawMutPtr<T> for *mut T {
-    #[inline]
-    unsafe fn as_mut<'a>(&self) -> Option<&'a mut T> {
-        if self.is_null() {
-            None
-        } else {
-            Some(&mut **self)
-        }
-    }
-}
-
 // Equality for pointers
 impl<T> PartialEq for *const T {
     #[inline]

trunk/src/libcore/str.rs

@@ -1128,7 +1128,7 @@ pub trait StrSlice<'a> {
     fn contains_char(&self, needle: char) -> bool;
 
     /// An iterator over the characters of `self`. Note, this iterates
-    /// over Unicode code-points, not Unicode graphemes.
+    /// over unicode code-points, not unicode graphemes.
     ///
     /// # Example
     ///
@@ -1505,7 +1505,7 @@ pub trait StrSlice<'a> {
     /// Pluck a character out of a string and return the index of the next
     /// character.
     ///
-    /// This function can be used to iterate over the Unicode characters of a
+    /// This function can be used to iterate over the unicode characters of a
     /// string.
     ///
     /// # Example
@@ -1549,7 +1549,7 @@ pub trait StrSlice<'a> {
     /// # Return value
     ///
     /// A record {ch: char, next: uint} containing the char value and the byte
-    /// index of the next Unicode character.
+    /// index of the next unicode character.
     ///
     /// # Failure
     ///
@@ -1559,7 +1559,7 @@ pub trait StrSlice<'a> {
 
     /// Given a byte position and a str, return the previous char and its position.
     ///
-    /// This function can be used to iterate over a Unicode string in reverse.
+    /// This function can be used to iterate over a unicode string in reverse.
     ///
     /// Returns 0 for next index if called on start index 0.
     ///