---

yaml
---
r: 217459
b: refs/heads/tmp
c: 2051b3e
h: refs/heads/master
i:
  217457: b49c26c
  217455: 565c086
v: v3

Author: dotdash

[refs]

@@ -25,7 +25,7 @@ refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
 refs/heads/beta: 2ad26e850ed5dfedda8c96d7315aee50145ceedd
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: 378a370ff2057afeb1eae86eb6e78c476866a4a6
+refs/heads/tmp: 2051b3e28fc245b44d82336cca31b25bbd637688
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: a5286998df566e736b32f6795bfc3803bdaf453d
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828

branches/tmp/RELEASES.md

@@ -13,9 +13,10 @@ Highlights
   * A `symlink_metadata` function has been added.
   * The `fs::Metadata` structure now lowers to its OS counterpart, providing
     access to all underlying information.
-* The compiler now contains extended explanations of many errors. When an error
-  with an explanation occurs the compiler suggests using the `--explain` flag
-  to read the explanation. Error explanations are also [available online][err-index].
+* The compiler contains extended explanations of many errors.  When it
+  emits such an error it also suggests using the `--explain` flag to
+  read the extended explanations, which are also [cataloged on the web
+  site][err].
 * Thanks to multiple [improvements][sk] to [type checking][pre], as
   well as other work, the time to bootstrap the compiler decreased by
   32%.
@@ -87,7 +88,7 @@ Misc
 [`IntoIterator`]: http://doc.rust-lang.org/nightly/std/iter/trait.IntoIterator.html
 [`From`]: http://doc.rust-lang.org/nightly/std/convert/trait.From.html
 [rf]: https://github.com/rust-lang/rust/pull/24491
-[err-index]: http://doc.rust-lang.org/error-index.html
+[err]: http://doc.rust-lang.org/error-index.html
 [sk]: https://github.com/rust-lang/rust/pull/24615
 [pre]: https://github.com/rust-lang/rust/pull/25323
 [file]: https://github.com/rust-lang/rust/pull/24598

branches/tmp/configure

@@ -899,18 +899,6 @@ then
     fi
 fi
 
-# If the clang isn't already enabled, check for GCC, and if it is missing, turn
-# on clang as a backup.
-if [ -z "$CFG_ENABLE_CLANG" ]
-then
-  CFG_GCC_VERSION=$("$CFG_GCC" --version 2>&1)
-  if [ $? -ne 0 ]
-  then
-    step_msg "GCC not installed, will try using Clang"
-    CFG_ENABLE_CLANG=1
-  fi
-fi
-
 # Okay, at this point, we have made up our minds about whether we are
 # going to force CFG_ENABLE_CLANG or not; save the setting if so.
 if [ ! -z "$CFG_ENABLE_CLANG" ]
@@ -932,7 +920,7 @@ then
     LLVM_VERSION=$($LLVM_CONFIG --version)
 
     case $LLVM_VERSION in
-        (3.[5-7]*)
+        (3.[5-6]*)
             msg "found ok version of LLVM: $LLVM_VERSION"
             ;;
         (*)

branches/tmp/src/doc/trpl/ffi.md

@@ -309,8 +309,8 @@ and invokes callbacks from there.
 In these cases access to Rust data structures inside the callbacks is
 especially unsafe and proper synchronization mechanisms must be used.
 Besides classical synchronization mechanisms like mutexes, one possibility in
-Rust is to use channels (in `std::sync::mpsc`) to forward data from the C
-thread that invoked the callback into a Rust thread.
+Rust is to use channels (in `std::comm`) to forward data from the C thread
+that invoked the callback into a Rust thread.
 
 If an asynchronous callback targets a special object in the Rust address space
 it is also absolutely necessary that no more callbacks are performed by the

branches/tmp/src/etc/unicode.py

@@ -372,6 +372,13 @@ def emit_conversions_module(f, to_upper, to_lower, to_title):
         }
     }
 
+    pub fn to_title(c: char) -> [char; 3] {
+        match bsearch_case_table(c, to_titlecase_table) {
+            None        => [c, '\\0', '\\0'],
+            Some(index) => to_titlecase_table[index].1
+        }
+    }
+
     fn bsearch_case_table(c: char, table: &'static [(char, [char; 3])]) -> Option<usize> {
         match table.binary_search_by(|&(key, _)| {
             if c == key { Equal }
@@ -393,6 +400,9 @@ def emit_conversions_module(f, to_upper, to_lower, to_title):
     emit_table(f, "to_uppercase_table",
         sorted(to_upper.iteritems(), key=operator.itemgetter(0)),
         is_pub=False, t_type = t_type, pfun=pfun)
+    emit_table(f, "to_titlecase_table",
+        sorted(to_title.iteritems(), key=operator.itemgetter(0)),
+        is_pub=False, t_type = t_type, pfun=pfun)
     f.write("}\n\n")
 
 def emit_grapheme_module(f, grapheme_table, grapheme_cats):

branches/tmp/src/liballoc/arc.rs

@@ -77,7 +77,7 @@ use core::atomic;
 use core::atomic::Ordering::{Relaxed, Release, Acquire, SeqCst};
 use core::fmt;
 use core::cmp::Ordering;
-use core::mem::{align_of_val, size_of_val};
+use core::mem::{min_align_of_val, size_of_val};
 use core::intrinsics::drop_in_place;
 use core::mem;
 use core::nonzero::NonZero;
@@ -241,7 +241,7 @@ impl<T: ?Sized> Arc<T> {
 
         if self.inner().weak.fetch_sub(1, Release) == 1 {
             atomic::fence(Acquire);
-            deallocate(ptr as *mut u8, size_of_val(&*ptr), align_of_val(&*ptr))
+            deallocate(ptr as *mut u8, size_of_val(&*ptr), min_align_of_val(&*ptr))
         }
     }
 }
@@ -565,7 +565,7 @@ impl<T: ?Sized> Drop for Weak<T> {
             atomic::fence(Acquire);
             unsafe { deallocate(ptr as *mut u8,
                                 size_of_val(&*ptr),
-                                align_of_val(&*ptr)) }
+                                min_align_of_val(&*ptr)) }
         }
     }
 }

branches/tmp/src/liballoc/rc.rs

@@ -162,7 +162,7 @@ use core::fmt;
 use core::hash::{Hasher, Hash};
 use core::intrinsics::{assume, drop_in_place};
 use core::marker::{self, Unsize};
-use core::mem::{self, align_of, size_of, align_of_val, size_of_val, forget};
+use core::mem::{self, min_align_of, size_of, min_align_of_val, size_of_val, forget};
 use core::nonzero::NonZero;
 use core::ops::{CoerceUnsized, Deref};
 use core::ptr;
@@ -246,7 +246,7 @@ impl<T> Rc<T> {
                 // destruct the box and skip our Drop
                 // we can ignore the refcounts because we know we're unique
                 deallocate(*rc._ptr as *mut u8, size_of::<RcBox<T>>(),
-                            align_of::<RcBox<T>>());
+                            min_align_of::<RcBox<T>>());
                 forget(rc);
                 Ok(val)
             }
@@ -496,7 +496,7 @@ impl<T: ?Sized> Drop for Rc<T> {
                     if self.weak() == 0 {
                         deallocate(ptr as *mut u8,
                                    size_of_val(&*ptr),
-                                   align_of_val(&*ptr))
+                                   min_align_of_val(&*ptr))
                     }
                 }
             }
@@ -805,7 +805,7 @@ impl<T: ?Sized> Drop for Weak<T> {
                 // the strong pointers have disappeared.
                 if self.weak() == 0 {
                     deallocate(ptr as *mut u8, size_of_val(&*ptr),
-                               align_of_val(&*ptr))
+                               min_align_of_val(&*ptr))
                 }
             }
         }

branches/tmp/src/libarena/lib.rs

@@ -244,7 +244,7 @@ impl<'longer_than_self> Arena<'longer_than_self> {
     fn alloc_copy<T, F>(&self, op: F) -> &mut T where F: FnOnce() -> T {
         unsafe {
             let ptr = self.alloc_copy_inner(mem::size_of::<T>(),
-                                            mem::align_of::<T>());
+                                            mem::min_align_of::<T>());
             let ptr = ptr as *mut T;
             ptr::write(&mut (*ptr), op());
             return &mut *ptr;
@@ -300,7 +300,7 @@ impl<'longer_than_self> Arena<'longer_than_self> {
             let tydesc = get_tydesc::<T>();
             let (ty_ptr, ptr) =
                 self.alloc_noncopy_inner(mem::size_of::<T>(),
-                                         mem::align_of::<T>());
+                                         mem::min_align_of::<T>());
             let ty_ptr = ty_ptr as *mut usize;
             let ptr = ptr as *mut T;
             // Write in our tydesc along with a bit indicating that it
@@ -393,7 +393,7 @@ struct TypedArenaChunk<T> {
 
 fn calculate_size<T>(capacity: usize) -> usize {
     let mut size = mem::size_of::<TypedArenaChunk<T>>();
-    size = round_up(size, mem::align_of::<T>());
+    size = round_up(size, mem::min_align_of::<T>());
     let elem_size = mem::size_of::<T>();
     let elems_size = elem_size.checked_mul(capacity).unwrap();
     size = size.checked_add(elems_size).unwrap();
@@ -405,7 +405,7 @@ impl<T> TypedArenaChunk<T> {
     unsafe fn new(next: *mut TypedArenaChunk<T>, capacity: usize)
            -> *mut TypedArenaChunk<T> {
         let size = calculate_size::<T>(capacity);
-        let chunk = allocate(size, mem::align_of::<TypedArenaChunk<T>>())
+        let chunk = allocate(size, mem::min_align_of::<TypedArenaChunk<T>>())
                     as *mut TypedArenaChunk<T>;
         if chunk.is_null() { alloc::oom() }
         (*chunk).next = next;
@@ -431,7 +431,7 @@ impl<T> TypedArenaChunk<T> {
         let size = calculate_size::<T>(self.capacity);
         let self_ptr: *mut TypedArenaChunk<T> = self;
         deallocate(self_ptr as *mut u8, size,
-                   mem::align_of::<TypedArenaChunk<T>>());
+                   mem::min_align_of::<TypedArenaChunk<T>>());
         if !next.is_null() {
             let capacity = (*next).capacity;
             (*next).destroy(capacity);
@@ -444,7 +444,7 @@ impl<T> TypedArenaChunk<T> {
         let this: *const TypedArenaChunk<T> = self;
         unsafe {
             mem::transmute(round_up(this.offset(1) as usize,
-                                    mem::align_of::<T>()))
+                                    mem::min_align_of::<T>()))
         }
     }
 

branches/tmp/src/libcollections/btree/node.rs

@@ -163,12 +163,12 @@ fn test_offset_calculation() {
 }
 
 fn calculate_allocation_generic<K, V>(capacity: usize, is_leaf: bool) -> (usize, usize) {
-    let (keys_size, keys_align) = (capacity * mem::size_of::<K>(), mem::align_of::<K>());
-    let (vals_size, vals_align) = (capacity * mem::size_of::<V>(), mem::align_of::<V>());
+    let (keys_size, keys_align) = (capacity * mem::size_of::<K>(), mem::min_align_of::<K>());
+    let (vals_size, vals_align) = (capacity * mem::size_of::<V>(), mem::min_align_of::<V>());
     let (edges_size, edges_align) = if is_leaf {
         (0, 1)
     } else {
-        ((capacity + 1) * mem::size_of::<Node<K, V>>(), mem::align_of::<Node<K, V>>())
+        ((capacity + 1) * mem::size_of::<Node<K, V>>(), mem::min_align_of::<Node<K, V>>())
     };
 
     calculate_allocation(
@@ -181,11 +181,11 @@ fn calculate_allocation_generic<K, V>(capacity: usize, is_leaf: bool) -> (usize,
 fn calculate_offsets_generic<K, V>(capacity: usize, is_leaf: bool) -> (usize, usize) {
     let keys_size = capacity * mem::size_of::<K>();
     let vals_size = capacity * mem::size_of::<V>();
-    let vals_align = mem::align_of::<V>();
+    let vals_align = mem::min_align_of::<V>();
     let edges_align = if is_leaf {
         1
     } else {
-        mem::align_of::<Node<K, V>>()
+        mem::min_align_of::<Node<K, V>>()
     };
 
     calculate_offsets(

branches/tmp/src/libcollections/vec.rs

@@ -219,7 +219,7 @@ impl<T> Vec<T> {
         } else {
             let size = capacity.checked_mul(mem::size_of::<T>())
                                .expect("capacity overflow");
-            let ptr = unsafe { allocate(size, mem::align_of::<T>()) };
+            let ptr = unsafe { allocate(size, mem::min_align_of::<T>()) };
             if ptr.is_null() { ::alloc::oom() }
             unsafe { Vec::from_raw_parts(ptr as *mut T, 0, capacity) }
         }
@@ -393,7 +393,7 @@ impl<T> Vec<T> {
                 let ptr = reallocate(*self.ptr as *mut u8,
                                      self.cap * mem::size_of::<T>(),
                                      self.len * mem::size_of::<T>(),
-                                     mem::align_of::<T>()) as *mut T;
+                                     mem::min_align_of::<T>()) as *mut T;
                 if ptr.is_null() { ::alloc::oom() }
                 self.ptr = Unique::new(ptr);
             }
@@ -866,9 +866,9 @@ impl<T> Vec<T> {
             // FIXME: Assert statically that the types `T` and `U` have the
             // same minimal alignment in case they are not zero-sized.
 
-            // These asserts are necessary because the `align_of` of the
+            // These asserts are necessary because the `min_align_of` of the
             // types are passed to the allocator by `Vec`.
-            assert!(mem::align_of::<T>() == mem::align_of::<U>());
+            assert!(mem::min_align_of::<T>() == mem::min_align_of::<U>());
 
             // This `as isize` cast is safe, because the size of the elements of the
             // vector is not 0, and:
@@ -1269,9 +1269,9 @@ impl<T> Vec<T> {
 #[inline(never)]
 unsafe fn alloc_or_realloc<T>(ptr: *mut T, old_size: usize, size: usize) -> *mut T {
     if old_size == 0 {
-        allocate(size, mem::align_of::<T>()) as *mut T
+        allocate(size, mem::min_align_of::<T>()) as *mut T
     } else {
-        reallocate(ptr as *mut u8, old_size, size, mem::align_of::<T>()) as *mut T
+        reallocate(ptr as *mut u8, old_size, size, mem::min_align_of::<T>()) as *mut T
     }
 }
 
@@ -1280,7 +1280,7 @@ unsafe fn dealloc<T>(ptr: *mut T, len: usize) {
     if mem::size_of::<T>() != 0 {
         deallocate(ptr as *mut u8,
                    len * mem::size_of::<T>(),
-                   mem::align_of::<T>())
+                   mem::min_align_of::<T>())
     }
 }
 
@@ -1482,7 +1482,7 @@ impl<T> FromIterator<T> for Vec<T> {
             None => return Vec::new(),
             Some(element) => {
                 let (lower, _) = iterator.size_hint();
-                let mut vector = Vec::with_capacity(lower.saturating_add(1));
+                let mut vector = Vec::with_capacity(1 + lower);
                 unsafe {
                     ptr::write(vector.get_unchecked_mut(0), element);
                     vector.set_len(1);
@@ -1570,11 +1570,10 @@ impl<T> Vec<T> {
             let len = self.len();
             if len == self.capacity() {
                 let (lower, _) = iterator.size_hint();
-                self.reserve(lower.saturating_add(1));
+                self.reserve(lower + 1);
             }
             unsafe {
                 ptr::write(self.get_unchecked_mut(len), element);
-                // NB can't overflow since we would have had to alloc the address space
                 self.set_len(len + 1);
             }
         }

branches/tmp/src/libcollections/vec_deque.rs

@@ -67,7 +67,7 @@ impl<T> Drop for VecDeque<T> {
             if mem::size_of::<T>() != 0 {
                 heap::deallocate(*self.ptr as *mut u8,
                                  self.cap * mem::size_of::<T>(),
-                                 mem::align_of::<T>())
+                                 mem::min_align_of::<T>())
             }
         }
     }
@@ -172,7 +172,7 @@ impl<T> VecDeque<T> {
 
         let ptr = unsafe {
             if mem::size_of::<T>() != 0 {
-                let ptr = heap::allocate(size, mem::align_of::<T>())  as *mut T;;
+                let ptr = heap::allocate(size, mem::min_align_of::<T>())  as *mut T;;
                 if ptr.is_null() { ::alloc::oom() }
                 Unique::new(ptr)
             } else {
@@ -340,7 +340,7 @@ impl<T> VecDeque<T> {
                     let ptr = heap::reallocate(*self.ptr as *mut u8,
                                                old,
                                                new,
-                                               mem::align_of::<T>()) as *mut T;
+                                               mem::min_align_of::<T>()) as *mut T;
                     if ptr.is_null() { ::alloc::oom() }
                     self.ptr = Unique::new(ptr);
                 }
@@ -460,7 +460,7 @@ impl<T> VecDeque<T> {
                     let ptr = heap::reallocate(*self.ptr as *mut u8,
                                                old,
                                                new_size,
-                                               mem::align_of::<T>()) as *mut T;
+                                               mem::min_align_of::<T>()) as *mut T;
                     if ptr.is_null() { ::alloc::oom() }
                     self.ptr = Unique::new(ptr);
                 }

branches/tmp/src/libcollectionstest/lib.rs

@@ -9,6 +9,7 @@
 // except according to those terms.
 
 #![feature(append)]
+#![feature(bit_vec_append_split_off)]
 #![feature(bitset)]
 #![feature(bitvec)]
 #![feature(box_syntax)]