---

yaml
---
r: 128891
b: refs/heads/try
c: 8c9bdda
h: refs/heads/master
i:
  128889: d0f2ce8
  128887: e3e24a8
v: v3

Author: Gankra

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 07d86b46a949a94223da714e35b343243e4ecce4
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a86d9ad15e339ab343a12513f9c90556f677b9ca
-refs/heads/try: 0d8738f9b52b62991e9c7b44a9d01a13c1398475
+refs/heads/try: 8c9bdda89b93bcb4c3b0ffb1b91b9c73318c5304
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/doc/README.md

@@ -19,7 +19,7 @@ for the 'std' and 'extra' libraries.
 To generate HTML documentation from one source file/crate, do something like:
 
 ~~~~
-rustdoc --output html-doc/ --output-format html ../src/libstd/path.rs
+rustdoc --output-dir html-doc/ --output-format html ../src/libstd/path.rs
 ~~~~
 
 (This, of course, requires a working build of the `rustdoc` tool.)

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,9 +924,7 @@ use_decl : "pub" ? "use" [ path "as" ident
 
 path_glob : ident [ "::" [ path_glob
                           | '*' ] ] ?
-          | '{' path_item [ ',' path_item ] * '}' ;
-
-path_item : ident | "mod" ;
+          | '{' ident [ ',' ident ] * '}' ;
 ~~~~
 
 A _use declaration_ creates one or more local name bindings synonymous
@@ -945,18 +943,14 @@ 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);'
@@ -965,11 +959,6 @@ 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/emacs/rust-mode.el

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

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

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

branches/try/src/etc/kate/rust.xml

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

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
@@ -26,7 +37,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 where while
+syn keyword   rustKeyword     unsafe virtual 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
@@ -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,13 +68,33 @@ 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;
 
+// Take two BitV's, and return iterators of their words, where the shorter one
+// has been padded with 0's
+macro_rules! match_words(
+    ($a_expr:expr, $b_expr:expr) => ({
+        let a = $a_expr;
+        let b = $b_expr;
+        let a_len = a.storage.len();
+        let b_len = b.storage.len();
+
+        // have to uselessly pretend to pad the longer one for type matching
+        if a_len < b_len {
+            (a.mask_words(0).chain(iter::Repeat::new(0u).enumerate().take(b_len).skip(a_len)),
+             b.mask_words(0).chain(iter::Repeat::new(0u).enumerate().take(0).skip(0)))
+        } else {
+            (a.mask_words(0).chain(iter::Repeat::new(0u).enumerate().take(0).skip(0)),
+             b.mask_words(0).chain(iter::Repeat::new(0u).enumerate().take(a_len).skip(b_len)))
+        }
+    })
+)
 
 static TRUE: bool = true;
 static FALSE: bool = false;
@@ -969,7 +989,7 @@ impl<'a> RandomAccessIterator<bool> for Bits<'a> {
 /// assert!(bv.eq_vec([true, true, false, true,
 ///                    false, false, false, false]));
 /// ```
-#[deriving(Clone, PartialEq, Eq, PartialOrd, Ord)]
+#[deriving(Clone)]
 pub struct BitvSet(Bitv);
 
 impl Default for BitvSet {
@@ -992,6 +1012,32 @@ impl Extendable<bool> for BitvSet {
     }
 }
 
+impl PartialOrd for BitvSet {
+    #[inline]
+    fn partial_cmp(&self, other: &BitvSet) -> Option<Ordering> {
+        let (a_iter, b_iter) = match_words!(self.get_ref(), other.get_ref());
+        iter::order::partial_cmp(a_iter, b_iter)
+    }
+}
+
+impl Ord for BitvSet {
+    #[inline]
+    fn cmp(&self, other: &BitvSet) -> Ordering {
+        let (a_iter, b_iter) = match_words!(self.get_ref(), other.get_ref());
+        iter::order::cmp(a_iter, b_iter)
+    }
+}
+
+impl cmp::PartialEq for BitvSet {
+    #[inline]
+    fn eq(&self, other: &BitvSet) -> bool {
+        let (a_iter, b_iter) = match_words!(self.get_ref(), other.get_ref());
+        iter::order::eq(a_iter, b_iter)
+    }
+}
+
+impl cmp::Eq for BitvSet {}
+
 impl BitvSet {
     /// Create a new bit vector set with initially no contents.
     ///
@@ -1141,10 +1187,18 @@ impl BitvSet {
         // Unwrap Bitvs
         let &BitvSet(ref mut self_bitv) = self;
         let &BitvSet(ref other_bitv) = other;
+
         // Expand the vector if necessary
         self_bitv.reserve(other_bitv.capacity());
-        // Apply values
-        for (i, w) in other_bitv.mask_words(0) {
+
+        // virtually pad other with 0's for equal lengths
+        let self_len = self_bitv.storage.len();
+        let other_len =  other_bitv.storage.len();
+        let mut other_words = other_bitv.mask_words(0)
+         .chain(iter::Repeat::new(0u).enumerate().take(self_len).skip(other_len));
+
+        // Apply values found in other
+        for (i, w) in other_words {
             let old = self_bitv.storage[i];
             let new = f(old, w);
             *self_bitv.storage.get_mut(i) = new;
@@ -1271,7 +1325,7 @@ impl BitvSet {
     /// let a = BitvSet::from_bitv(bitv::from_bytes([0b01101000]));
     /// let b = BitvSet::from_bitv(bitv::from_bytes([0b10100000]));
     ///
-    /// // Print 1, 4 in arbitrary order
+    /// // Print 2, 4 in arbitrary order
     /// for x in a.difference(&b) {
     ///     println!("{}", x);
     /// }
@@ -2213,6 +2267,64 @@ mod tests {
         assert!(set1.is_subset(&set2)); // { 2 }  { 2, 4 }
     }
 
+    #[test]
+    fn test_bitv_set_intersect_with() {
+        // Explicitly 0'ed bits
+        let mut a = BitvSet::from_bitv(from_bytes([0b10100010]));
+        let mut b = BitvSet::from_bitv(from_bytes([0b00000000]));
+        let c = a.clone();
+        a.intersect_with(&b);
+        b.intersect_with(&c);
+        assert!(a.is_empty());
+        assert!(b.is_empty());
+
+        // Uninitialized bits should behave like 0's
+        let mut a = BitvSet::from_bitv(from_bytes([0b10100010]));
+        let mut b = BitvSet::new();
+        let c = a.clone();
+        a.intersect_with(&b);
+        b.intersect_with(&c);
+        assert!(a.is_empty());
+        assert!(b.is_empty());
+
+        // Standard
+        let mut a = BitvSet::from_bitv(from_bytes([0b10100010]));
+        let mut b = BitvSet::from_bitv(from_bytes([0b01100010]));
+        let c = a.clone();
+        a.intersect_with(&b);
+        b.intersect_with(&c);
+        assert_eq!(a.len(), 2);
+        assert_eq!(b.len(), 2);
+    }
+
+    #[test]
+    fn test_bitv_set_eq() {
+        let a = BitvSet::from_bitv(from_bytes([0b10100010]));
+        let b = BitvSet::from_bitv(from_bytes([0b00000000]));
+        let c = BitvSet::new();
+
+        assert!(a == a);
+        assert!(a != b);
+        assert!(a != c);
+        assert!(b == b);
+        assert!(b == c);
+        assert!(c == c);
+    }
+
+    #[test]
+    fn test_bitv_set_cmp() {
+        let a = BitvSet::from_bitv(from_bytes([0b10100010]));
+        let b = BitvSet::from_bitv(from_bytes([0b00000000]));
+        let c = BitvSet::new();
+
+        assert_eq!(a.cmp(&b), Greater);
+        assert_eq!(a.cmp(&c), Greater);
+        assert_eq!(b.cmp(&a), Less);
+        assert_eq!(b.cmp(&c), Equal);
+        assert_eq!(c.cmp(&a), Less);
+        assert_eq!(c.cmp(&b), Equal);
+    }
+
     #[test]
     fn test_bitv_remove() {
         let mut a = BitvSet::new();