---

yaml
---
r: 148891
b: refs/heads/try2
c: 6c41192
h: refs/heads/master
i:
  148889: 06ed495
  148887: bbe48da
v: v3

Author: alexcrichton

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: cdc678945fec211b06b6ec4ba059b8259dfeb2c2
+refs/heads/try2: 6c41192c4188ee3155d44a05a5e41e61088f1938
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libextra/lib.rs

@@ -34,11 +34,6 @@ Rust extras are part of the standard Rust distribution.
 #[deny(non_camel_case_types)];
 #[deny(missing_doc)];
 
-#[cfg(stage0)]
-macro_rules! if_ok (
-    ($e:expr) => (match $e { Ok(e) => e, Err(e) => return Err(e) })
-)
-
 // Utility modules
 
 pub mod c_vec;

branches/try2/src/libextra/priority_queue.rs

@@ -51,14 +51,10 @@ impl<T:Ord> PriorityQueue<T> {
     /// Returns the number of elements the queue can hold without reallocating
     pub fn capacity(&self) -> uint { self.data.capacity() }
 
-    /// Reserve capacity for exactly n elements in the PriorityQueue.
-    /// Do nothing if the capacity is already sufficient.
-    pub fn reserve_exact(&mut self, n: uint) { self.data.reserve_exact(n) }
-
-    /// Reserve capacity for at least n elements in the PriorityQueue.
-    /// Do nothing if the capacity is already sufficient.
-    pub fn reserve(&mut self, n: uint) {
-        self.data.reserve(n)
+    pub fn reserve(&mut self, n: uint) { self.data.reserve(n) }
+
+    pub fn reserve_at_least(&mut self, n: uint) {
+        self.data.reserve_at_least(n)
     }
 
     /// Pop the greatest item from the queue - fails if empty
@@ -207,7 +203,7 @@ impl<T: Ord> Extendable<T> for PriorityQueue<T> {
         let (lower, _) = iter.size_hint();
 
         let len = self.capacity();
-        self.reserve(len + lower);
+        self.reserve_at_least(len + lower);
 
         for elem in *iter {
             self.push(elem);

branches/try2/src/libextra/ringbuf.rs

@@ -168,8 +168,8 @@ impl<T> RingBuf<T> {
     /// # Arguments
     ///
     /// * n - The number of elements to reserve space for
-    pub fn reserve_exact(&mut self, n: uint) {
-        self.elts.reserve_exact(n);
+    pub fn reserve(&mut self, n: uint) {
+        self.elts.reserve(n);
     }
 
     /// Reserve capacity for at least `n` elements in the given RingBuf,
@@ -182,8 +182,8 @@ impl<T> RingBuf<T> {
     /// # Arguments
     ///
     /// * n - The number of elements to reserve space for
-    pub fn reserve(&mut self, n: uint) {
-        self.elts.reserve(n);
+    pub fn reserve_at_least(&mut self, n: uint) {
+        self.elts.reserve_at_least(n);
     }
 
     /// Front-to-back iterator.
@@ -641,26 +641,26 @@ mod tests {
     }
 
     #[test]
-    fn test_reserve_exact() {
+    fn test_reserve() {
         let mut d = RingBuf::new();
         d.push_back(0u64);
-        d.reserve_exact(50);
+        d.reserve(50);
         assert_eq!(d.elts.capacity(), 50);
         let mut d = RingBuf::new();
         d.push_back(0u32);
-        d.reserve_exact(50);
+        d.reserve(50);
         assert_eq!(d.elts.capacity(), 50);
     }
 
     #[test]
-    fn test_reserve() {
+    fn test_reserve_at_least() {
         let mut d = RingBuf::new();
         d.push_back(0u64);
-        d.reserve(50);
+        d.reserve_at_least(50);
         assert_eq!(d.elts.capacity(), 64);
         let mut d = RingBuf::new();
         d.push_back(0u32);
-        d.reserve(50);
+        d.reserve_at_least(50);
         assert_eq!(d.elts.capacity(), 64);
     }
 

branches/try2/src/librustc/lib.rs

@@ -54,11 +54,6 @@ use syntax::diagnostic::Emitter;
 use syntax::diagnostic;
 use syntax::parse;
 
-#[cfg(stage0)]
-macro_rules! if_ok (
-    ($e:expr) => (match $e { Ok(e) => e, Err(e) => return Err(e) })
-)
-
 pub mod middle {
     pub mod trans;
     pub mod ty;

branches/try2/src/librustc/middle/trans/adt.rs

@@ -46,7 +46,6 @@
 use std::container::Map;
 use std::libc::c_ulonglong;
 use std::option::{Option, Some, None};
-use std::num::{Bitwise};
 
 use lib::llvm::{ValueRef, True, IntEQ, IntNE};
 use middle::trans::_match;
@@ -425,22 +424,19 @@ fn generic_type_of(cx: &CrateContext, r: &Repr, name: Option<&str>, sizing: bool
             let align = most_aligned.align;
             let discr_ty = ll_inttype(cx, ity);
             let discr_size = machine::llsize_of_alloc(cx, discr_ty) as u64;
-            let align_units = (size + align - 1) / align - 1;
             let pad_ty = match align {
-                1 => Type::array(&Type::i8(), align_units),
-                2 => Type::array(&Type::i16(), align_units),
-                4 => Type::array(&Type::i32(), align_units),
-                8 if machine::llalign_of_min(cx, Type::i64()) == 8 =>
-                                 Type::array(&Type::i64(), align_units),
-                a if a.population_count() == 1 => Type::array(&Type::vector(&Type::i32(), a / 4),
-                                                              align_units),
+                1 => Type::i8(),
+                2 => Type::i16(),
+                4 => Type::i32(),
+                8 if machine::llalign_of_min(cx, Type::i64()) == 8 => Type::i64(),
                 _ => fail!("Unsupported enum alignment: {:?}", align)
             };
             assert_eq!(machine::llalign_of_min(cx, pad_ty) as u64, align);
+            let align_units = (size + align - 1) / align;
             assert_eq!(align % discr_size, 0);
             let fields = ~[discr_ty,
-                           Type::array(&discr_ty, align / discr_size - 1),
-                           pad_ty];
+              Type::array(&discr_ty, align / discr_size - 1),
+              Type::array(&pad_ty, align_units - 1)];
             match name {
                 None => Type::struct_(fields, false),
                 Some(name) => {

branches/try2/src/libstd/fmt/mod.rs

@@ -493,11 +493,6 @@ use util;
 use vec::ImmutableVector;
 use vec;
 
-// NOTE this is just because the `prelude::*` import above includes
-// default::Default, so the reexport doesn't work.
-#[cfg(stage0)]
-pub use Default = fmt::Show; // export required for `format!()` etc.
-
 pub mod parse;
 pub mod rt;
 

branches/try2/src/libstd/hashmap.rs

@@ -384,7 +384,7 @@ impl<K: Hash + Eq, V> HashMap<K, V> {
     }
 
     /// Reserve space for at least `n` elements in the hash table.
-    pub fn reserve(&mut self, n: uint) {
+    pub fn reserve_at_least(&mut self, n: uint) {
         if n > self.buckets.len() {
             let buckets = n * 4 / 3 + 1;
             self.resize(num::next_power_of_two(buckets));
@@ -793,8 +793,8 @@ impl<T:Hash + Eq> HashSet<T> {
     }
 
     /// Reserve space for at least `n` elements in the hash table.
-    pub fn reserve(&mut self, n: uint) {
-        self.map.reserve(n)
+    pub fn reserve_at_least(&mut self, n: uint) {
+        self.map.reserve_at_least(n)
     }
 
     /// Returns true if the hash set contains a value equivalent to the

branches/try2/src/libstd/reflect.rs

@@ -446,15 +446,4 @@ impl<V:TyVisitor + MovePtr> TyVisitor for MovePtrAdaptor<V> {
         if ! self.inner.visit_type() { return false; }
         true
     }
-
-    // NOTE remove after next snapshot
-    #[cfg(stage0)]
-    fn visit_closure_ptr(&mut self, ck: uint) -> bool {
-        self.align_to::<proc()>();
-        if ! self.inner.visit_closure_ptr(ck) {
-            return false
-        }
-        self.bump_past::<proc()>();
-        true
-    }
 }

branches/try2/src/libstd/repr.rs

@@ -602,10 +602,6 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
     fn visit_param(&mut self, _i: uint) -> bool { true }
     fn visit_self(&mut self) -> bool { true }
     fn visit_type(&mut self) -> bool { true }
-
-    // NOTE remove after next snapshot
-    #[cfg(stage0)]
-    fn visit_closure_ptr(&mut self, _ck: uint) -> bool { true }
 }
 
 pub fn write_repr<T>(writer: &mut io::Writer, object: &T) -> io::IoResult<()> {

branches/try2/src/libstd/str.rs

@@ -91,7 +91,7 @@ use iter::{Iterator, FromIterator, Extendable, range};
 use iter::{Filter, AdditiveIterator, Map};
 use iter::{Rev, DoubleEndedIterator, ExactSize};
 use libc;
-use num::Saturating;
+use num::{Saturating, checked_next_power_of_two};
 use option::{None, Option, Some};
 use ptr;
 use ptr::RawPtr;
@@ -163,7 +163,12 @@ pub fn from_char(ch: char) -> ~str {
 
 /// Convert a vector of chars to a string
 pub fn from_chars(chs: &[char]) -> ~str {
-    chs.iter().map(|c| *c).collect()
+    let mut buf = ~"";
+    buf.reserve(chs.len());
+    for ch in chs.iter() {
+        buf.push_char(*ch)
+    }
+    buf
 }
 
 #[doc(hidden)]
@@ -847,7 +852,8 @@ pub fn utf16_chars(v: &[u16], f: |char|) {
 
 /// Allocates a new string from the utf-16 slice provided
 pub fn from_utf16(v: &[u16]) -> ~str {
-    let mut buf = with_capacity(v.len());
+    let mut buf = ~"";
+    buf.reserve(v.len());
     utf16_chars(v, |ch| buf.push_char(ch));
     buf
 }
@@ -2090,15 +2096,17 @@ impl<'a> StrSlice<'a> for &'a str {
     }
 
     fn escape_default(&self) -> ~str {
-        let mut out = with_capacity(self.len());
+        let mut out: ~str = ~"";
+        out.reserve_at_least(self.len());
         for c in self.chars() {
             c.escape_default(|c| out.push_char(c));
         }
         out
     }
 
     fn escape_unicode(&self) -> ~str {
-        let mut out = with_capacity(self.len());
+        let mut out: ~str = ~"";
+        out.reserve_at_least(self.len());
         for c in self.chars() {
             c.escape_unicode(|c| out.push_char(c));
         }
@@ -2422,7 +2430,7 @@ pub trait OwnedStr {
     ///
     /// * s - A string
     /// * n - The number of bytes to reserve space for
-    fn reserve_exact(&mut self, n: uint);
+    fn reserve(&mut self, n: uint);
 
     /// Reserves capacity for at least `n` bytes in the given string.
     ///
@@ -2440,7 +2448,7 @@ pub trait OwnedStr {
     ///
     /// * s - A string
     /// * n - The number of bytes to reserve space for
-    fn reserve(&mut self, n: uint);
+    fn reserve_at_least(&mut self, n: uint);
 
     /// Returns the number of single-byte characters the string can hold without
     /// reallocating
@@ -2466,7 +2474,7 @@ impl OwnedStr for ~str {
     #[inline]
     fn push_str_no_overallocate(&mut self, rhs: &str) {
         let new_cap = self.len() + rhs.len();
-        self.reserve_exact(new_cap);
+        self.reserve(new_cap);
         self.push_str(rhs);
     }
 
@@ -2545,17 +2553,15 @@ impl OwnedStr for ~str {
     }
 
     #[inline]
-    fn reserve_exact(&mut self, n: uint) {
+    fn reserve(&mut self, n: uint) {
         unsafe {
-            raw::as_owned_vec(self).reserve_exact(n)
+            raw::as_owned_vec(self).reserve(n)
         }
     }
 
     #[inline]
-    fn reserve(&mut self, n: uint) {
-        unsafe {
-            raw::as_owned_vec(self).reserve(n)
-        }
+    fn reserve_at_least(&mut self, n: uint) {
+        self.reserve(checked_next_power_of_two(n).unwrap_or(n))
     }
 
     #[inline]
@@ -2613,7 +2619,7 @@ impl Extendable<char> for ~str {
     fn extend<T: Iterator<char>>(&mut self, iterator: &mut T) {
         let (lower, _) = iterator.size_hint();
         let reserve = lower + self.len();
-        self.reserve(reserve);
+        self.reserve_at_least(reserve);
         for ch in *iterator {
             self.push_char(ch)
         }