---

yaml
---
r: 158077
b: refs/heads/master
c: 1571aba
h: refs/heads/master
i:
  158075: 7cbf177
v: v3

Author: bkoropoff

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: dbb9c99911a72bcfdb590472493126c4f1924a1d
+refs/heads/master: 1571abae53d77f36352b543a595969f1ef21503b
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 1b2ad7831f1745bf4a4709a1fa1772afb47c933c
 refs/heads/try: 98bd84a3300f974f400a3eeb56567ad3f77b13f0

trunk/mk/main.mk

@@ -100,9 +100,7 @@ endif
 CFG_RUSTC_FLAGS := $(RUSTFLAGS)
 CFG_GCCISH_CFLAGS :=
 CFG_GCCISH_LINK_FLAGS :=
-
-# Turn off broken quarantine (see jemalloc/jemalloc#161)
-CFG_JEMALLOC_FLAGS := --disable-fill
+CFG_JEMALLOC_FLAGS :=
 
 ifdef CFG_DISABLE_OPTIMIZE
   $(info cfg: disabling rustc optimization (CFG_DISABLE_OPTIMIZE))

trunk/src/compiletest/runtest.rs

@@ -627,7 +627,7 @@ fn find_rust_src_root(config: &Config) -> Option<Path> {
     let path_postfix = Path::new("src/etc/lldb_batchmode.py");
 
     while path.pop() {
-        if path.join(&path_postfix).is_file() {
+        if path.join(path_postfix.clone()).is_file() {
             return Some(path);
         }
     }

trunk/src/doc/guide-testing.md

@@ -287,7 +287,7 @@ The benchmarking runner offers two ways to avoid this. Either, the
 closure that the `iter` method receives can return an arbitrary value
 which forces the optimizer to consider the result used and ensures it
 cannot remove the computation entirely. This could be done for the
-example above by adjusting the `b.iter` call to
+example above by adjusting the `bh.iter` call to
 
 ~~~
 # struct X; impl X { fn iter<T>(&self, _: || -> T) {} } let b = X;

trunk/src/doc/guide.md

@@ -777,7 +777,7 @@ fn add_one(x: int) -> int {
      x + 1;
 }
 
-help: consider removing this semicolon:
+note: consider removing this semicolon:
      x + 1;
           ^
 ```
@@ -4467,19 +4467,18 @@ see why consumers matter.
 
 ## Iterators
 
-As we've said before, an iterator is something that we can call the
-`.next()` method on repeatedly, and it gives us a sequence of things.
-Because you need to call the method, this means that iterators
-are **lazy** and don't need to generate all of the values upfront.
-This code, for example, does not actually generate the numbers
-`1-100`, and just creates a value that represents the sequence:
+As we've said before, an iterator is something that we can call the `.next()`
+method on repeatedly, and it gives us a sequence of things. Because you need
+to call the method, this means that iterators are **lazy**. This code, for
+example, does not actually generate the numbers `1-100`, and just creates a
+value that represents the sequence:
 
 ```{rust}
 let nums = range(1i, 100i);
 ```
 
 Since we didn't do anything with the range, it didn't generate the sequence.
-Let's add the consumer:
+Once we add the consumer:
 
 ```{rust}
 let nums = range(1i, 100i).collect::<Vec<int>>();
@@ -4508,8 +4507,8 @@ std::iter::count(1i, 5i);
 ```
 
 This iterator counts up from one, adding five each time. It will give
-you a new integer every time, forever (well, technically, until it reaches the
-maximum number representable by an `int`). But since iterators are lazy,
+you a new integer every time, forever. Well, technically, until the
+maximum number that an `int` can represent. But since iterators are lazy,
 that's okay! You probably don't want to use `collect()` on it, though...
 
 That's enough about iterators. Iterator adapters are the last concept
@@ -5252,8 +5251,8 @@ to do something that it can't currently do? You may be able to write a macro
 to extend Rust's capabilities.
 
 You've already used one macro extensively: `println!`. When we invoke
-a Rust macro, we need to use the exclamation mark (`!`). There are two reasons
-why this is so: the first is that it makes it clear when you're using a
+a Rust macro, we need to use the exclamation mark (`!`). There's two reasons
+that this is true: the first is that it makes it clear when you're using a
 macro. The second is that macros allow for flexible syntax, and so Rust must
 be able to tell where a macro starts and ends. The `!(...)` helps with this.
 
@@ -5268,7 +5267,7 @@ println!("x is: {}", x);
 
 The `println!` macro does a few things:
 
-1. It parses the string to find any `{}`s.
+1. It parses the string to find any `{}`s
 2. It checks that the number of `{}`s matches the number of other arguments.
 3. It generates a bunch of Rust code, taking this in mind.
 
@@ -5277,8 +5276,8 @@ Rust will generate code that takes all of the types into account. If
 `println!` was a function, it could still do this type checking, but it
 would happen at run time rather than compile time.
 
-We can check this out using a special flag to `rustc`. Put this code in a file
-called `print.rs`:
+We can check this out using a special flag to `rustc`. This code, in a file
+`print.rs`:
 
 ```{rust}
 fn main() {
@@ -5287,7 +5286,7 @@ fn main() {
 }
 ```
 
-You can have the macros expanded like this: `rustc print.rs --pretty=expanded` – which will
+Can have its macros expanded like this: `rustc print.rs --pretty=expanded`, will
 give us this huge result:
 
 ```{rust,ignore}
@@ -5326,12 +5325,12 @@ invoke the `println_args` function with the generated arguments.
 This is the code that Rust actually compiles. You can see all of the extra
 information that's here. We get all of the type safety and options that it
 provides, but at compile time, and without needing to type all of this out.
-This is how macros are powerful: without them you would need to type all of
-this by hand to get a type-checked `println`.
+This is how macros are powerful. Without them, you would need to type all of
+this by hand to get a type checked `println`.
 
 For more on macros, please consult [the Macros Guide](guide-macros.html).
-Macros are a very advanced and still slightly experimental feature, but they don't
-require a deep understanding to be called, since they look just like functions. The
+Macros are a very advanced and still slightly experimental feature, but don't
+require a deep understanding to call, since they look just like functions. The
 Guide can help you if you want to write your own.
 
 # Unsafe
@@ -5348,8 +5347,8 @@ keyword, which indicates that the function may not behave properly.
 
 Second, if you'd like to create some sort of shared-memory data structure, Rust
 won't allow it, because memory must be owned by a single owner. However, if
-you're planning on making access to that shared memory safe – such as with a
-mutex – _you_ know that it's safe, but Rust can't know. Writing an `unsafe`
+you're planning on making access to that shared memory safe, such as with a
+mutex, _you_ know that it's safe, but Rust can't know. Writing an `unsafe`
 block allows you to ask the compiler to trust you. In this case, the _internal_
 implementation of the mutex is considered unsafe, but the _external_ interface
 we present is safe. This allows it to be effectively used in normal Rust, while

trunk/src/doc/intro.md

@@ -494,14 +494,14 @@ non-deterministic aspect:
 $ cargo run
    Compiling hello_world v0.0.1 (file:///Users/you/src/hello_world)
      Running `target/hello_world`
-numbers[1] is 3
-numbers[0] is 2
-numbers[2] is 4
+numbers[1] is 2
+numbers[0] is 1
+numbers[2] is 3
 $ cargo run
      Running `target/hello_world`
-numbers[2] is 4
-numbers[1] is 3
-numbers[0] is 2
+numbers[2] is 3
+numbers[1] is 2
+numbers[0] is 1
 ```
 
 Each time, we get a slightly different output, because each thread works in a

trunk/src/doc/reference.md

@@ -400,11 +400,11 @@ An _integer literal_ has one of four forms:
 * A _decimal literal_ starts with a *decimal digit* and continues with any
   mixture of *decimal digits* and _underscores_.
 * A _hex literal_ starts with the character sequence `U+0030` `U+0078`
-  (`0x`) and continues as any mixture of hex digits and underscores.
+  (`0x`) and continues as any mixture hex digits and underscores.
 * An _octal literal_ starts with the character sequence `U+0030` `U+006F`
-  (`0o`) and continues as any mixture of octal digits and underscores.
+  (`0o`) and continues as any mixture octal digits and underscores.
 * A _binary literal_ starts with the character sequence `U+0030` `U+0062`
-  (`0b`) and continues as any mixture of binary digits and underscores.
+  (`0b`) and continues as any mixture binary digits and underscores.
 
 An integer literal may be followed (immediately, without any spaces) by an
 _integer suffix_, which changes the type of the literal. There are two kinds of
@@ -944,10 +944,10 @@ An example of `use` declarations:
 ```
 use std::iter::range_step;
 use std::option::{Some, None};
-use std::collections::hash_map::{mod, HashMap};
+use std::collections::hashmap::{mod, HashMap};
 
-fn foo<T>(_: T){}
-fn bar(map1: HashMap<String, uint>, map2: hash_map::HashMap<String, uint>){}
+# 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);'
@@ -957,10 +957,10 @@ fn main() {
     // std::option::None]);'
     foo(vec![Some(1.0f64), None]);
 
-    // Both `hash_map` and `HashMap` are in scope.
-    let map1 = HashMap::new();
-    let map2 = hash_map::HashMap::new();
-    bar(map1, map2);
+    // Both `hash` and `HashMap` are in scope.
+    let map = HashMap::new();
+    let set = hashmap::HashSet::new();
+    bar(map, set);
 }
 ```
 
@@ -2100,15 +2100,15 @@ plugins](guide-plugin.html#lint-plugins) can provide additional lint checks.
 ```{.ignore}
 mod m1 {
     // Missing documentation is ignored here
-    #[allow(missing_docs)]
+    #[allow(missing_doc)]
     pub fn undocumented_one() -> int { 1 }
 
     // Missing documentation signals a warning here
-    #[warn(missing_docs)]
+    #[warn(missing_doc)]
     pub fn undocumented_too() -> int { 2 }
 
     // Missing documentation signals an error here
-    #[deny(missing_docs)]
+    #[deny(missing_doc)]
     pub fn undocumented_end() -> int { 3 }
 }
 ```
@@ -2117,16 +2117,16 @@ This example shows how one can use `allow` and `warn` to toggle a particular
 check on and off.
 
 ```{.ignore}
-#[warn(missing_docs)]
+#[warn(missing_doc)]
 mod m2{
-    #[allow(missing_docs)]
+    #[allow(missing_doc)]
     mod nested {
         // Missing documentation is ignored here
         pub fn undocumented_one() -> int { 1 }
 
         // Missing documentation signals a warning here,
         // despite the allow above.
-        #[warn(missing_docs)]
+        #[warn(missing_doc)]
         pub fn undocumented_two() -> int { 2 }
     }
 
@@ -2139,10 +2139,10 @@ This example shows how one can use `forbid` to disallow uses of `allow` for
 that lint check.
 
 ```{.ignore}
-#[forbid(missing_docs)]
+#[forbid(missing_doc)]
 mod m3 {
     // Attempting to toggle warning signals an error here
-    #[allow(missing_docs)]
+    #[allow(missing_doc)]
     /// Returns 2.
     pub fn undocumented_too() -> int { 2 }
 }
@@ -4096,7 +4096,7 @@ cause transitions between the states. The lifecycle states of a task are:
 
 * running
 * blocked
-* panicked
+* panicked 
 * dead
 
 A task begins its lifecycle &mdash; once it has been spawned &mdash; in the

trunk/src/doc/rust.css

@@ -62,10 +62,6 @@ body {
     font-size: 18px;
     color: #333;
     line-height: 1.428571429;
-
-    -webkit-font-feature-settings: "kern", "liga";
-    -moz-font-feature-settings: "kern", "liga";
-    font-feature-settings: "kern", "liga";
 }
 @media (min-width: 768px) {
     body {

trunk/src/etc/unicode.py

@@ -34,7 +34,7 @@
 
 // NOTE: The following code was generated by "src/etc/unicode.py", do not edit directly
 
-#![allow(missing_docs, non_uppercase_statics, non_snake_case)]
+#![allow(missing_doc, non_uppercase_statics, non_snake_case)]
 '''
 
 # Mapping taken from Table 12 from:

trunk/src/etc/vim/autoload/rust.vim

@@ -178,14 +178,14 @@ function! s:WithPath(func, ...)
 			call mkdir(tmpdir)
 
 			let save_cwd = getcwd()
-			silent exe 'lcd' fnameescape(tmpdir)
+			silent exe 'lcd' tmpdir
 
 			let path = 'unnamed.rs'
 
 			let save_mod = &mod
 			set nomod
 
-			silent exe 'keepalt write! ' . fnameescape(path)
+			silent exe 'keepalt write! ' . path
 			if pathisempty
 				silent keepalt 0file
 			endif
@@ -195,10 +195,10 @@ function! s:WithPath(func, ...)
 
 		call call(a:func, [path] + a:000)
 	finally
-		if exists("save_mod")   | let &mod = save_mod                    | endif
-		if exists("save_write") | let &write = save_write                | endif
-		if exists("save_cwd")   | silent exe 'lcd' fnameescape(save_cwd) | endif
-		if exists("tmpdir")     | silent call s:RmDir(tmpdir)            | endif
+		if exists("save_mod")   | let &mod = save_mod          | endif
+		if exists("save_write") | let &write = save_write      | endif
+		if exists("save_cwd")   | silent exe 'lcd' save_cwd    | endif
+		if exists("tmpdir")     | silent call s:RmDir(tmpdir)  | endif
 	endtry
 endfunction
 

trunk/src/libcollections/bit.rs renamed to trunk/src/libcollections/bitv.rs

@@ -8,9 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// FIXME(Gankro): Bitv and BitvSet are very tightly coupled. Ideally (for maintenance),
-// they should be in separate files/modules, with BitvSet only using Bitv's public API.
-
 //! Collections implemented with bit vectors.
 //!
 //! # Example
@@ -1657,7 +1654,7 @@ mod tests {
     use std::rand::Rng;
     use test::Bencher;
 
-    use super::{Bitv, BitvSet, from_fn, from_bytes};
+    use bitv::{Bitv, BitvSet, from_fn, from_bytes};
     use bitv;
     use vec::Vec;
 

trunk/src/libcollections/btree/map.rs

@@ -23,7 +23,7 @@ use core::default::Default;
 use core::{iter, fmt, mem};
 use core::fmt::Show;
 
-use ring_buf::RingBuf;
+use ringbuf::RingBuf;
 
 /// A map based on a B-Tree.
 ///

trunk/src/libcollections/btree/mod.rs

@@ -8,6 +8,27 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+pub use self::map::BTreeMap;
+pub use self::map::Entries;
+pub use self::map::MutEntries;
+pub use self::map::MoveEntries;
+pub use self::map::Keys;
+pub use self::map::Values;
+pub use self::map::Entry;
+pub use self::map::Occupied;
+pub use self::map::Vacant;
+pub use self::map::OccupiedEntry;
+pub use self::map::VacantEntry;
+
+pub use self::set::BTreeSet;
+pub use self::set::Items;
+pub use self::set::MoveItems;
+pub use self::set::DifferenceItems;
+pub use self::set::UnionItems;
+pub use self::set::SymDifferenceItems;
+pub use self::set::IntersectionItems;
+
+
 mod node;
-pub mod map;
-pub mod set;
+mod map;
+mod set;

trunk/src/libcollections/btree/set.rs

@@ -13,7 +13,7 @@
 
 use core::prelude::*;
 
-use btree_map::{BTreeMap, Keys, MoveEntries};
+use super::{BTreeMap, Keys, MoveEntries};
 use std::hash::Hash;
 use core::default::Default;
 use core::{iter, fmt};