---

yaml
---
r: 128871
b: refs/heads/try
c: 13079c1
h: refs/heads/master
i:
  128869: 414bbff
  128867: 1701ede
  128863: 173705b
v: v3

Author: Kimundi

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 07d86b46a949a94223da714e35b343243e4ecce4
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a86d9ad15e339ab343a12513f9c90556f677b9ca
-refs/heads/try: 4a5654f960ca1f979e2ddf1efa57fa750dbd1dff
+refs/heads/try: 13079c1a85c2f3391966cc108a48f2313596d78d
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/doc/guide-unsafe.md

@@ -537,12 +537,11 @@ extern crate core;
 use core::prelude::*;
 
 use core::mem;
+use core::raw::Slice;
 
 #[no_mangle]
 pub extern fn dot_product(a: *const u32, a_len: u32,
                           b: *const u32, b_len: u32) -> u32 {
-    use core::raw::Slice;
-
     // Convert the provided arrays into Rust slices.
     // The core::raw module guarantees that the Slice
     // structure has the same memory layout as a &[T]

branches/try/src/libcollections/bitv.rs

@@ -68,11 +68,12 @@ use core::default::Default;
 use core::fmt;
 use core::iter::Take;
 use core::iter;
+use core::ops::Index;
 use core::slice;
 use core::uint;
 use std::hash;
 
-use {Mutable, Set, MutableSet, MutableSeq};
+use {Collection, Mutable, Set, MutableSet, MutableSeq};
 use vec::Vec;
 
 

branches/try/src/libcollections/btree.rs

@@ -24,7 +24,7 @@ use alloc::boxed::Box;
 use core::fmt;
 use core::fmt::Show;
 
-use MutableSeq;
+use {Collection, MutableSeq};
 use vec::Vec;
 
 #[allow(missing_doc)]

branches/try/src/libcollections/dlist.rs

@@ -31,7 +31,7 @@ use core::mem;
 use core::ptr;
 use std::hash::{Writer, Hash};
 
-use {Mutable, Deque, MutableSeq};
+use {Collection, Mutable, Deque, MutableSeq};
 
 /// A doubly-linked list.
 pub struct DList<T> {

branches/try/src/libcollections/lib.rs

@@ -22,12 +22,9 @@
        html_playground_url = "http://play.rust-lang.org/")]
 
 #![feature(macro_rules, managed_boxes, default_type_params, phase, globs)]
-#![feature(unsafe_destructor, import_shadowing)]
+#![feature(unsafe_destructor)]
 #![no_std]
 
-// NOTE(stage0, pcwalton): Remove after snapshot.
-#![allow(unknown_features)]
-
 #[phase(plugin, link)] extern crate core;
 extern crate unicode;
 extern crate alloc;
@@ -39,11 +36,11 @@ extern crate alloc;
 #[cfg(test)] #[phase(plugin, link)] extern crate std;
 #[cfg(test)] #[phase(plugin, link)] extern crate log;
 
-use core::prelude::Option;
+use core::prelude::*;
 
+pub use core::collections::Collection;
 pub use bitv::{Bitv, BitvSet};
 pub use btree::BTree;
-pub use core::prelude::Collection;
 pub use dlist::DList;
 pub use enum_set::EnumSet;
 pub use priority_queue::PriorityQueue;

branches/try/src/libcollections/priority_queue.rs

@@ -154,7 +154,7 @@ use core::default::Default;
 use core::mem::{zeroed, replace, swap};
 use core::ptr;
 
-use {Mutable, MutableSeq};
+use {Collection, Mutable, MutableSeq};
 use slice;
 use vec::Vec;
 

branches/try/src/libcollections/ringbuf.rs

@@ -18,10 +18,11 @@ use core::prelude::*;
 use core::cmp;
 use core::default::Default;
 use core::fmt;
+use core::iter::RandomAccessIterator;
 use core::iter;
 use std::hash::{Writer, Hash};
 
-use {Deque, Mutable, MutableSeq};
+use {Deque, Collection, Mutable, MutableSeq};
 use vec::Vec;
 
 static INITIAL_CAPACITY: uint = 8u; // 2^3

branches/try/src/libcollections/slice.rs

@@ -86,22 +86,23 @@ for &x in numbers.iter() {
 
 #![doc(primitive = "slice")]
 
+use core::prelude::*;
+
 use core::cmp;
 use core::mem::size_of;
 use core::mem;
-use core::prelude::{Clone, Collection, Greater, Iterator, Less, None, Option};
-use core::prelude::{Ord, Ordering, RawPtr, Some, range};
 use core::ptr;
 use core::iter::{range_step, MultiplicativeIterator};
 
-use MutableSeq;
+use {Collection, MutableSeq};
 use vec::Vec;
 
+pub use core::slice::{ref_slice, mut_ref_slice, Splits, Windows};
 pub use core::slice::{Chunks, Slice, ImmutableSlice, ImmutablePartialEqSlice};
 pub use core::slice::{ImmutableOrdSlice, MutableSlice, Items, MutItems};
-pub use core::slice::{MutSplits, MutChunks, Splits};
-pub use core::slice::{bytes, ref_slice, MutableCloneableSlice};
-pub use core::slice::{Found, NotFound};
+pub use core::slice::{MutSplits, MutChunks};
+pub use core::slice::{bytes, MutableCloneableSlice};
+pub use core::slice::{BinarySearchResult, Found, NotFound};
 
 // Functional utilities
 

branches/try/src/libcollections/smallintmap.rs

@@ -21,7 +21,7 @@ use core::iter;
 use core::iter::{Enumerate, FilterMap};
 use core::mem::replace;
 
-use {Mutable, Map, MutableMap, MutableSeq};
+use {Collection, Mutable, Map, MutableMap, MutableSeq};
 use {vec, slice};
 use vec::Vec;
 use hash;

branches/try/src/libcollections/str.rs

@@ -69,17 +69,15 @@ is the same as `&[u8]`.
 
 #![doc(primitive = "str")]
 
+use core::prelude::*;
+
 use core::default::Default;
 use core::fmt;
 use core::cmp;
 use core::iter::AdditiveIterator;
 use core::mem;
-use core::prelude::{Char, Clone, Collection, Eq, Equiv, ImmutableSlice};
-use core::prelude::{Iterator, MutableSlice, None, Option, Ord, Ordering};
-use core::prelude::{PartialEq, PartialOrd, Result, Slice, Some, Tuple2};
-use core::prelude::{range};
 
-use {Deque, MutableSeq};
+use {Collection, Deque, MutableSeq};
 use hash;
 use ringbuf::RingBuf;
 use string::String;
@@ -1682,7 +1680,7 @@ mod tests {
     fn test_chars_decoding() {
         let mut bytes = [0u8, ..4];
         for c in range(0u32, 0x110000).filter_map(|c| ::core::char::from_u32(c)) {
-            let len = c.encode_utf8(bytes);
+            let len = c.encode_utf8(bytes).unwrap_or(0);
             let s = ::core::str::from_utf8(bytes.slice_to(len)).unwrap();
             if Some(c) != s.chars().next() {
                 fail!("character {:x}={} does not decode correctly", c as u32, c);
@@ -1694,7 +1692,7 @@ mod tests {
     fn test_chars_rev_decoding() {
         let mut bytes = [0u8, ..4];
         for c in range(0u32, 0x110000).filter_map(|c| ::core::char::from_u32(c)) {
-            let len = c.encode_utf8(bytes);
+            let len = c.encode_utf8(bytes).unwrap_or(0);
             let s = ::core::str::from_utf8(bytes.slice_to(len)).unwrap();
             if Some(c) != s.chars().rev().next() {
                 fail!("character {:x}={} does not decode correctly", c as u32, c);

branches/try/src/libcollections/string.rs

@@ -20,8 +20,9 @@ use core::mem;
 use core::ptr;
 // FIXME: ICE's abound if you import the `Slice` type while importing `Slice` trait
 use RawSlice = core::raw::Slice;
+use core::slice::Slice;
 
-use {Mutable, MutableSeq};
+use {Collection, Mutable, MutableSeq};
 use hash;
 use str;
 use str::{CharRange, StrAllocating, MaybeOwned, Owned};
@@ -502,7 +503,7 @@ impl String {
                 data: self.vec.as_ptr().offset(cur_len as int),
                 len: 4,
             };
-            let used = ch.encode_utf8(mem::transmute(slice));
+            let used = ch.encode_utf8(mem::transmute(slice)).unwrap_or(0);
             self.vec.set_len(cur_len + used);
         }
     }

branches/try/src/libcollections/treemap.rs

@@ -40,7 +40,7 @@ use core::mem::{replace, swap};
 use core::ptr;
 use std::hash::{Writer, Hash};
 
-use {Mutable, Set, MutableSet, MutableMap, Map, MutableSeq};
+use {Collection, Mutable, Set, MutableSet, MutableMap, Map, MutableSeq};
 use vec::Vec;
 
 /// This is implemented as an AA tree, which is a simplified variation of

branches/try/src/libcollections/trie.rs

@@ -23,7 +23,7 @@ use core::uint;
 use core::iter;
 use std::hash::{Writer, Hash};
 
-use {Mutable, Map, MutableMap, Set, MutableSet};
+use {Collection, Mutable, Map, MutableMap, Set, MutableSet};
 use slice::{Items, MutItems};
 use slice;
 

branches/try/src/libcollections/vec.rs

@@ -14,15 +14,17 @@ use core::prelude::*;
 
 use alloc::heap::{allocate, reallocate, deallocate};
 use RawSlice = core::raw::Slice;
+use core::slice::Slice;
 use core::cmp::max;
 use core::default::Default;
 use core::fmt;
 use core::mem;
+use core::num::{CheckedMul, CheckedAdd};
 use core::num;
 use core::ptr;
 use core::uint;
 
-use {Mutable, MutableSeq};
+use {Collection, Mutable, MutableSeq};
 use slice::{MutableOrdSlice, MutableSliceAllocating, CloneableVector};
 use slice::{Items, MutItems};
 

branches/try/src/libcore/char.rs

@@ -18,6 +18,7 @@
 use mem::transmute;
 use option::{None, Option, Some};
 use iter::range_step;
+use collections::Collection;
 
 // UTF-8 ranges and tags for encoding characters
 static TAG_CONT: u8    = 0b1000_0000u8;
@@ -27,7 +28,6 @@ static TAG_FOUR_B: u8  = 0b1111_0000u8;
 static MAX_ONE_B: u32   =     0x80u32;
 static MAX_TWO_B: u32   =    0x800u32;
 static MAX_THREE_B: u32 =  0x10000u32;
-static MAX_FOUR_B:  u32 = 0x200000u32;
 
 /*
     Lu  Uppercase_Letter        an uppercase letter
@@ -217,14 +217,14 @@ pub fn escape_default(c: char, f: |char|) {
 }
 
 /// Returns the amount of bytes this `char` would need if encoded in UTF-8
+#[inline]
 pub fn len_utf8_bytes(c: char) -> uint {
     let code = c as u32;
     match () {
         _ if code < MAX_ONE_B   => 1u,
         _ if code < MAX_TWO_B   => 2u,
         _ if code < MAX_THREE_B => 3u,
-        _ if code < MAX_FOUR_B  => 4u,
-        _                       => fail!("invalid character!"),
+        _  => 4u,
     }
 }
 
@@ -297,21 +297,19 @@ pub trait Char {
     /// UTF-8.
     fn len_utf8_bytes(&self) -> uint;
 
-    /// Encodes this character as UTF-8 into the provided byte buffer.
-    ///
-    /// The buffer must be at least 4 bytes long or a runtime failure may
-    /// occur.
+    /// Encodes this character as UTF-8 into the provided byte buffer,
+    /// and then returns the number of bytes written.
     ///
-    /// This will then return the number of bytes written to the slice.
-    fn encode_utf8(&self, dst: &mut [u8]) -> uint;
+    /// If the buffer is not large enough, nothing will be written into it
+    /// and a `None` will be returned.
+    fn encode_utf8(&self, dst: &mut [u8]) -> Option<uint>;
 
-    /// Encodes this character as UTF-16 into the provided `u16` buffer.
+    /// Encodes this character as UTF-16 into the provided `u16` buffer,
+    /// and then returns the number of `u16`s written.
     ///
-    /// The buffer must be at least 2 elements long or a runtime failure may
-    /// occur.
-    ///
-    /// This will then return the number of `u16`s written to the slice.
-    fn encode_utf16(&self, dst: &mut [u16]) -> uint;
+    /// If the buffer is not large enough, nothing will be written into it
+    /// and a `None` will be returned.
+    fn encode_utf16(&self, dst: &mut [u16]) -> Option<uint>;
 }
 
 impl Char for char {
@@ -325,45 +323,52 @@ impl Char for char {
 
     fn escape_default(&self, f: |char|) { escape_default(*self, f) }
 
+    #[inline]
     fn len_utf8_bytes(&self) -> uint { len_utf8_bytes(*self) }
 
-    fn encode_utf8<'a>(&self, dst: &'a mut [u8]) -> uint {
+    #[inline]
+    fn encode_utf8<'a>(&self, dst: &'a mut [u8]) -> Option<uint> {
+        // Marked #[inline] to allow llvm optimizing it away
         let code = *self as u32;
-        if code < MAX_ONE_B {
+        if code < MAX_ONE_B && dst.len() >= 1 {
             dst[0] = code as u8;
-            1
-        } else if code < MAX_TWO_B {
+            Some(1)
+        } else if code < MAX_TWO_B && dst.len() >= 2 {
             dst[0] = (code >> 6u & 0x1F_u32) as u8 | TAG_TWO_B;
             dst[1] = (code & 0x3F_u32) as u8 | TAG_CONT;
-            2
-        } else if code < MAX_THREE_B {
+            Some(2)
+        } else if code < MAX_THREE_B && dst.len() >= 3  {
             dst[0] = (code >> 12u & 0x0F_u32) as u8 | TAG_THREE_B;
             dst[1] = (code >>  6u & 0x3F_u32) as u8 | TAG_CONT;
             dst[2] = (code & 0x3F_u32) as u8 | TAG_CONT;
-            3
-        } else {
+            Some(3)
+        } else if dst.len() >= 4 {
             dst[0] = (code >> 18u & 0x07_u32) as u8 | TAG_FOUR_B;
             dst[1] = (code >> 12u & 0x3F_u32) as u8 | TAG_CONT;
             dst[2] = (code >>  6u & 0x3F_u32) as u8 | TAG_CONT;
             dst[3] = (code & 0x3F_u32) as u8 | TAG_CONT;
-            4
+            Some(4)
+        } else {
+            None
         }
     }
 
-    fn encode_utf16(&self, dst: &mut [u16]) -> uint {
+    #[inline]
+    fn encode_utf16(&self, dst: &mut [u16]) -> Option<uint> {
+        // Marked #[inline] to allow llvm optimizing it away
         let mut ch = *self as u32;
-        if (ch & 0xFFFF_u32) == ch {
+        if (ch & 0xFFFF_u32) == ch  && dst.len() >= 1 {
             // The BMP falls through (assuming non-surrogate, as it should)
-            assert!(ch <= 0xD7FF_u32 || ch >= 0xE000_u32);
             dst[0] = ch as u16;
-            1
-        } else {
+            Some(1)
+        } else if dst.len() >= 2 {
             // Supplementary planes break into surrogates.
-            assert!(ch >= 0x1_0000_u32 && ch <= 0x10_FFFF_u32);
             ch -= 0x1_0000_u32;
             dst[0] = 0xD800_u16 | ((ch >> 10) as u16);
             dst[1] = 0xDC00_u16 | ((ch as u16) & 0x3FF_u16);
-            2
+            Some(2)
+        } else {
+            None
         }
     }
 }