---

yaml
---
r: 128877
b: refs/heads/try
c: 7606f58
h: refs/heads/master
i:
  128875: e7a8e96
v: v3

Author: Jakub Wieczorek

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 07d86b46a949a94223da714e35b343243e4ecce4
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a86d9ad15e339ab343a12513f9c90556f677b9ca
-refs/heads/try: 921240e00aa3002c73fb3a8b240eb69118ee391e
+refs/heads/try: 7606f580a15da4e093eb51795304c983180a286f
 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/doc/rust.md

@@ -924,7 +924,9 @@ use_decl : "pub" ? "use" [ path "as" ident
 
 path_glob : ident [ "::" [ path_glob
                           | '*' ] ] ?
-          | '{' ident [ ',' ident ] * '}' ;
+          | '{' path_item [ ',' path_item ] * '}' ;
+
+path_item : ident | "mod" ;
 ~~~~
 
 A _use declaration_ creates one or more local name bindings synonymous
@@ -943,14 +945,18 @@ Use declarations support a number of convenient shortcuts:
   * Simultaneously binding a list of paths differing only in their final element,
     using the glob-like brace syntax `use a::b::{c,d,e,f};`
   * Binding all paths matching a given prefix, using the asterisk wildcard syntax `use a::b::*;`
+  * Simultaneously binding a list of paths differing only in their final element
+    and their immediate parent module, using the `mod` keyword, such as `use a::b::{mod, c, d};`
 
 An example of `use` declarations:
 
 ~~~~
 use std::iter::range_step;
 use std::option::{Some, None};
+use std::collections::hashmap::{mod, HashMap};
 
 # fn foo<T>(_: T){}
+# fn bar(map: HashMap<String, uint>, set: hashmap::HashSet<String>){}
 
 fn main() {
     // Equivalent to 'std::iter::range_step(0u, 10u, 2u);'
@@ -959,6 +965,11 @@ fn main() {
     // Equivalent to 'foo(vec![std::option::Some(1.0f64),
     // std::option::None]);'
     foo(vec![Some(1.0f64), None]);
+
+    // Both `hash` and `HashMap` are in scope.
+    let map = HashMap::new();
+    let set = hashmap::HashSet::new();
+    bar(map, set);
 }
 ~~~~
 

branches/try/src/etc/vim/ftplugin/rust.vim

@@ -56,16 +56,6 @@ if exists("g:loaded_delimitMate")
 	let b:delimitMate_excluded_regions = delimitMate#Get("excluded_regions") . ',rustLifetimeCandidate,rustGenericLifetimeCandidate'
 endif
 
-if has("folding") && exists('g:rust_fold') && g:rust_fold != 0
-	let b:rust_set_foldmethod=1
-	setlocal foldmethod=syntax
-	if g:rust_fold == 2
-		setlocal foldlevel<
-	else
-		setlocal foldlevel=99
-	endif
-endif
-
 if has('conceal') && exists('g:rust_conceal')
 	let b:rust_set_conceallevel=1
 	setlocal conceallevel=2
@@ -118,10 +108,6 @@ let b:undo_ftplugin = "
 		\|else
 		  \|unlet! b:delimitMate_excluded_regions
 		\|endif
-		\|if exists('b:rust_set_foldmethod')
-		  \|setlocal foldmethod< foldlevel<
-		  \|unlet b:rust_set_foldmethod
-		\|endif
 		\|if exists('b:rust_set_conceallevel')
 		  \|setlocal conceallevel<
 		  \|unlet b:rust_set_conceallevel

branches/try/src/etc/vim/syntax/rust.vim

@@ -11,6 +11,17 @@ elseif exists("b:current_syntax")
   finish
 endif
 
+" Fold settings {{{1
+
+if has("folding") && exists('g:rust_fold') && g:rust_fold != 0
+  setlocal foldmethod=syntax
+  if g:rust_fold == 2
+    setlocal foldlevel<
+  else
+    setlocal foldlevel=99
+  endif
+endif
+
 " Syntax definitions {{{1
 " Basic keywords {{{2
 syn keyword   rustConditional match if else
@@ -84,7 +95,7 @@ syn keyword   rustEnumVariant Ok Err
 syn keyword rustTrait Ascii AsciiCast OwnedAsciiCast AsciiStr
 syn keyword rustTrait IntoBytes
 syn keyword rustTrait ToCStr
-syn keyword rustTrait Char UnicodeChar
+syn keyword rustTrait Char
 syn keyword rustTrait Clone
 syn keyword rustTrait PartialEq PartialOrd Eq Ord Equiv
 syn keyword rustEnum Ordering
@@ -102,18 +113,18 @@ syn keyword rustTrait Box
 syn keyword rustTrait GenericPath Path PosixPath WindowsPath
 syn keyword rustTrait RawPtr
 syn keyword rustTrait Buffer Writer Reader Seek
-syn keyword rustTrait Str StrVector StrSlice
-syn keyword rustTrait IntoMaybeOwned StrAllocating UnicodeStrSlice
+syn keyword rustTrait Str StrVector StrSlice OwnedStr
+syn keyword rustTrait IntoMaybeOwned StrAllocating
 syn keyword rustTrait ToString IntoStr
 syn keyword rustTrait Tuple1 Tuple2 Tuple3 Tuple4
 syn keyword rustTrait Tuple5 Tuple6 Tuple7 Tuple8
 syn keyword rustTrait Tuple9 Tuple10 Tuple11 Tuple12
 syn keyword rustTrait CloneableVector ImmutableCloneableVector
-syn keyword rustTrait MutableCloneableSlice MutableOrdSlice
-syn keyword rustTrait ImmutableSlice MutableSlice
-syn keyword rustTrait ImmutablePartialEqSlice ImmutableOrdSlice
-syn keyword rustTrait Slice VectorVector
-syn keyword rustTrait MutableSliceAllocating
+syn keyword rustTrait MutableCloneableVector MutableOrdVector
+syn keyword rustTrait ImmutableVector MutableVector
+syn keyword rustTrait ImmutableEqVector ImmutableOrdVector
+syn keyword rustTrait Vector VectorVector
+syn keyword rustTrait MutableVectorAllocating
 syn keyword rustTrait String
 syn keyword rustTrait Vec
 

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).unwrap_or(0);
+            let len = c.encode_utf8(bytes);
             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).unwrap_or(0);
+            let len = c.encode_utf8(bytes);
             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)).unwrap_or(0);
+            let used = ch.encode_utf8(mem::transmute(slice));
             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};