---

yaml
---
r: 128355
b: refs/heads/master
c: 3f57c89
h: refs/heads/master
i:
  128353: 4d8e848
  128351: 0a8669d
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: af82adce751ec8bc983478ad201d148502bb4a69
+refs/heads/master: 3f57c8988dfd2eba8fb751fe72dde503a6ebf2c6
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a86d9ad15e339ab343a12513f9c90556f677b9ca
 refs/heads/try: 73b8f60b60d8a2a7ca5a7d49d59771350b867951

trunk/src/doc/guide-unsafe.md

@@ -537,11 +537,12 @@ 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]

trunk/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);
 }
 ~~~~
 

trunk/src/etc/emacs/rust-mode.el

@@ -170,7 +170,7 @@
 (defconst rust-mode-keywords
   '("as"
     "box" "break"
-    "continue" "crate"
+    "const" "continue" "crate"
     "do"
     "else" "enum" "extern"
     "false" "fn" "for"
@@ -182,7 +182,8 @@
     "self" "static" "struct" "super"
     "true" "trait" "type"
     "unsafe" "use"
-    "while"))
+    "virtual"
+    "where" "while"))
 
 (defconst rust-special-types
   '("u8" "i8"

trunk/src/etc/gedit/share/gtksourceview-3.0/language-specs/rust.lang

@@ -71,6 +71,8 @@
 		<keyword>trait</keyword>
 		<keyword>unsafe</keyword>
 		<keyword>use</keyword>
+		<keyword>virtual</keyword>
+		<keyword>where</keyword>
 		<keyword>while</keyword>
     </context>
 

trunk/src/etc/kate/rust.xml

@@ -19,6 +19,7 @@
 		<item> as </item>
 		<item> break </item>
 		<item> box </item>
+		<item> const </item>
 		<item> continue </item>
 		<item> crate </item>
 		<item> do </item>
@@ -44,6 +45,8 @@
 		<item> trait </item>
 		<item> unsafe </item>
 		<item> use </item>
+		<item> virtual </item>
+		<item> where </item>
 		<item> while </item>
 	</list>
 	<list name="traits">

trunk/src/etc/vim/ftplugin/rust.vim

@@ -56,6 +56,16 @@ 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
@@ -108,6 +118,10 @@ 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

trunk/src/etc/vim/syntax/rust.vim

@@ -11,17 +11,6 @@ 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
@@ -37,7 +26,7 @@ syn keyword   rustKeyword     fn nextgroup=rustFuncName skipwhite skipempty
 syn keyword   rustKeyword     for in if impl let
 syn keyword   rustKeyword     loop once proc pub
 syn keyword   rustKeyword     return super
-syn keyword   rustKeyword     unsafe virtual while
+syn keyword   rustKeyword     unsafe virtual where while
 syn keyword   rustKeyword     use nextgroup=rustModPath,rustModPathInUse skipwhite skipempty
 " FIXME: Scoped impl's name is also fallen in this category
 syn keyword   rustKeyword     mod trait struct enum type nextgroup=rustIdentifier skipwhite skipempty
@@ -95,7 +84,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
+syn keyword rustTrait Char UnicodeChar
 syn keyword rustTrait Clone
 syn keyword rustTrait PartialEq PartialOrd Eq Ord Equiv
 syn keyword rustEnum Ordering
@@ -113,18 +102,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 OwnedStr
-syn keyword rustTrait IntoMaybeOwned StrAllocating
+syn keyword rustTrait Str StrVector StrSlice
+syn keyword rustTrait IntoMaybeOwned StrAllocating UnicodeStrSlice
 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 MutableCloneableVector MutableOrdVector
-syn keyword rustTrait ImmutableVector MutableVector
-syn keyword rustTrait ImmutableEqVector ImmutableOrdVector
-syn keyword rustTrait Vector VectorVector
-syn keyword rustTrait MutableVectorAllocating
+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 String
 syn keyword rustTrait Vec
 

trunk/src/libcollections/bitv.rs

@@ -68,12 +68,11 @@ 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 {Collection, Mutable, Set, MutableSet, MutableSeq};
+use {Mutable, Set, MutableSet, MutableSeq};
 use vec::Vec;
 
 
@@ -1272,7 +1271,7 @@ impl BitvSet {
     /// let a = BitvSet::from_bitv(bitv::from_bytes([0b01101000]));
     /// let b = BitvSet::from_bitv(bitv::from_bytes([0b10100000]));
     ///
-    /// // Print 2, 4 in arbitrary order
+    /// // Print 1, 4 in arbitrary order
     /// for x in a.difference(&b) {
     ///     println!("{}", x);
     /// }

trunk/src/libcollections/btree.rs

@@ -11,6 +11,13 @@
 // btree.rs
 //
 
+// NB. this is not deprecated for removal, just deprecating the
+// current implementation. If the major pain-points are addressed
+// (overuse of by-value self and .clone), this can be removed.
+#![deprecated = "the current implementation is extremely inefficient, \
+                 prefer a HashMap, TreeMap or TrieMap"]
+#![allow(deprecated)]
+
 //! Starting implementation of a btree for rust.
 //! Structure inspired by github user davidhalperin's gist.
 
@@ -24,7 +31,7 @@ use alloc::boxed::Box;
 use core::fmt;
 use core::fmt::Show;
 
-use {Collection, MutableSeq};
+use MutableSeq;
 use vec::Vec;
 
 #[allow(missing_doc)]

trunk/src/libcollections/dlist.rs

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

trunk/src/libcollections/lib.rs

@@ -22,9 +22,12 @@
        html_playground_url = "http://play.rust-lang.org/")]
 
 #![feature(macro_rules, managed_boxes, default_type_params, phase, globs)]
-#![feature(unsafe_destructor)]
+#![feature(unsafe_destructor, import_shadowing)]
 #![no_std]
 
+// NOTE(stage0, pcwalton): Remove after snapshot.
+#![allow(unknown_features)]
+
 #[phase(plugin, link)] extern crate core;
 extern crate unicode;
 extern crate alloc;
@@ -36,11 +39,11 @@ extern crate alloc;
 #[cfg(test)] #[phase(plugin, link)] extern crate std;
 #[cfg(test)] #[phase(plugin, link)] extern crate log;
 
-use core::prelude::*;
+use core::prelude::Option;
 
-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;

trunk/src/libcollections/priority_queue.rs

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

trunk/src/libcollections/ringbuf.rs

@@ -18,11 +18,10 @@ 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, Collection, Mutable, MutableSeq};
+use {Deque, Mutable, MutableSeq};
 use vec::Vec;
 
 static INITIAL_CAPACITY: uint = 8u; // 2^3

trunk/src/libcollections/slice.rs

@@ -86,23 +86,22 @@ 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 {Collection, MutableSeq};
+use 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};
-pub use core::slice::{bytes, MutableCloneableSlice};
-pub use core::slice::{BinarySearchResult, Found, NotFound};
+pub use core::slice::{MutSplits, MutChunks, Splits};
+pub use core::slice::{bytes, ref_slice, MutableCloneableSlice};
+pub use core::slice::{Found, NotFound};
 
 // Functional utilities
 

trunk/src/libcollections/smallintmap.rs

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

trunk/src/libcollections/str.rs

@@ -69,15 +69,17 @@ 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 {Collection, Deque, MutableSeq};
+use {Deque, MutableSeq};
 use hash;
 use ringbuf::RingBuf;
 use string::String;
@@ -1680,7 +1682,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);
@@ -1692,7 +1694,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);