Auto merge of #21439 - alexcrichton:rollup, r=alexcrichton

Continuation of https://github.com/rust-lang/rust/pull/21428
2025-06-04 19:29:07 +00:00 · 2015-01-20 23:03:09 +00:00 · 2015-01-20 23:03:09 +00:00 · 29bd9a06ef
commit 29bd9a06ef
parent 583c5c589e 631896dc19
79 changed files with 498 additions and 299 deletions
--- a/man/rustdoc.1
+++ b/man/rustdoc.1
@ -35,9 +35,27 @@ space-separated list of plugins to run (default: '')
 --plugin-path <val>
 directory to load plugins from (default: /tmp/rustdoc_ng/plugins)
 .TP
 --target <val>
 target triple to document
 .TP
 --crate-name <val>
 specify the name of this crate
 .TP
 -L --library-path <val>
 directory to add to crate search path
 .TP
 --cfg <val>
 pass a --cfg to rustc
 .TP
 --extern <val>
 pass an --extern to rustc
 .TP
 --test
 run code examples as tests
 .TP
 --test-args <val>
 pass arguments to the test runner
 .TP
 --html-in-header <val>
 file to add to <head>
 .TP
@ -47,8 +65,20 @@ file to add in <body>, before content
 --html-after-content <val>
 file to add in <body>, after content
 .TP
 --markdown-css <val>
 CSS files to include via <link> in a rendered Markdown file
 .TP
 --markdown-playground-url <val>
 URL to send code snippets to
 .TP
 --markdown-no-toc
 don't include table of contents
 .TP
 -h, --help
 Print help
 .TP
 -V, --version
 Print rustdoc's version
 .SH "OUTPUT FORMATS"
--- a/mk/tests.mk
+++ b/mk/tests.mk
@ -38,16 +38,14 @@ ifdef CHECK_IGNORED
  TESTARGS += --ignored
 endif
 TEST_BENCH =
 # Arguments to the cfail/rfail/rpass/bench tests
 ifdef CFG_VALGRIND
  CTEST_RUNTOOL = --runtool "$(CFG_VALGRIND)"
  TEST_BENCH =
 endif
 ifdef PLEASE_BENCH
-  TEST_BENCH = --bench
+  TESTARGS += --bench
 endif
 # Arguments to the perf tests
--- a/src/doc/guide-crates.md
+++ b/src/doc/guide-crates.md
@ -1,4 +1,4 @@
 % The (old) Rust Crates and Modules Guide
-This content has moved into the
+This content has moved into
 [the Rust Programming Language book](book/crates-and-modules.html).
--- a/src/doc/guide-error-handling.md
+++ b/src/doc/guide-error-handling.md
@ -1,4 +1,4 @@
 % Error Handling in Rust
-This content has moved into the
+This content has moved into
 [the Rust Programming Language book](book/error-handling.html).
--- a/src/doc/guide-ffi.md
+++ b/src/doc/guide-ffi.md
@ -1,4 +1,4 @@
 % The (old) Rust Foreign Function Interface Guide
-This content has moved into the
+This content has moved into
 [the Rust Programming Language book](book/ffi.html).
--- a/src/doc/guide-macros.md
+++ b/src/doc/guide-macros.md
@ -1,4 +1,4 @@
 % The (old) Rust Macros Guide
-This content has moved into the
+This content has moved into
 [the Rust Programming Language book](book/macros.html).
--- a/src/doc/guide-ownership.md
+++ b/src/doc/guide-ownership.md
@ -1,4 +1,4 @@
 % The (old) Rust Ownership Guide
-This content has moved into the
+This content has moved into
 [the Rust Programming Language book](book/ownership.html).
--- a/src/doc/guide-plugins.md
+++ b/src/doc/guide-plugins.md
@ -1,4 +1,4 @@
 % The (old) Rust Compiler Plugins Guide
-This content has moved into the
+This content has moved into
 [the Rust Programming Language book](book/plugins.html).
--- a/src/doc/guide-pointers.md
+++ b/src/doc/guide-pointers.md
@ -1,4 +1,4 @@
 % The (old) Rust Pointer Guide
-This content has moved into the
+This content has moved into
 [the Rust Programming Language book](book/pointers.html).
--- a/src/doc/guide-strings.md
+++ b/src/doc/guide-strings.md
@ -1,4 +1,4 @@
 % The (old) Guide to Rust Strings
-This content has moved into the
+This content has moved into
 [the Rust Programming Language book](book/strings.html).
--- a/src/doc/guide-tasks.md
+++ b/src/doc/guide-tasks.md
@ -1,4 +1,4 @@
 % The (old) Rust Threads and Communication Guide
-This content has moved into the
+This content has moved into
 [the Rust Programming Language book](book/tasks.html).
--- a/src/doc/guide-testing.md
+++ b/src/doc/guide-testing.md
@ -1,4 +1,4 @@
 % The (old) Rust Testing Guide
-This content has moved into the
+This content has moved into
 [the Rust Programming Language book](book/testing.html).
--- a/src/doc/guide-unsafe.md
+++ b/src/doc/guide-unsafe.md
@ -1,4 +1,4 @@
 % Writing Safe Low-level and Unsafe Code in Rust
-This content has moved into the
+This content has moved into
 [the Rust Programming Language book](book/unsafe.html).
--- a/src/doc/guide.md
+++ b/src/doc/guide.md
@ -1,4 +1,4 @@
 % The (old) Rust Guide
-This content has moved into the
+This content has moved into
 [the Rust Programming Language book](book/README.html).
--- a/src/doc/reference.md
+++ b/src/doc/reference.md
@ -257,10 +257,10 @@ cases mentioned in [Number literals](#number-literals) below.
 | [Number literals](#number-literals)`*` | Example | Exponentiation | Suffixes |
 |----------------------------------------|---------|----------------|----------|
-| Decimal integer | `98_222i` | `N/A` | Integer suffixes |
+| Decimal integer | `98_222is` | `N/A` | Integer suffixes |
-| Hex integer | `0xffi` | `N/A` | Integer suffixes |
+| Hex integer | `0xffis` | `N/A` | Integer suffixes |
-| Octal integer | `0o77i` | `N/A` | Integer suffixes |
+| Octal integer | `0o77is` | `N/A` | Integer suffixes |
-| Binary integer | `0b1111_0000i` | `N/A` | Integer suffixes |
+| Binary integer | `0b1111_0000is` | `N/A` | Integer suffixes |
 | Floating-point | `123.0E+77f64` | `Optional` | Floating-point suffixes |
 `*` All number literals allow `_` as a visual separator: `1_234.0E+18f64`
@ -268,7 +268,7 @@ cases mentioned in [Number literals](#number-literals) below.
 ##### Suffixes
 | Integer | Floating-point |
 |---------|----------------|
-| `i` (`int`), `u` (`uint`), `u8`, `i8`, `u16`, `i16`, `u32`, `i32`, `u64`, `i64` | `f32`, `f64` |
+| `is` (`isize`), `us` (`usize`), `u8`, `i8`, `u16`, `i16`, `u32`, `i32`, `u64`, `i64` | `f32`, `f64` |
 #### Character and string literals
@ -468,7 +468,7 @@ Like any literal, an integer literal may be followed (immediately,
 without any spaces) by an _integer suffix_, which forcibly sets the
 type of the literal. There are 10 valid values for an integer suffix:
-* The `i` and `u` suffixes give the literal type `int` or `uint`,
+* The `is` and `us` suffixes give the literal type `isize` or `usize`,
  respectively.
 * Each of the signed and unsigned machine types `u8`, `i8`,
  `u16`, `i16`, `u32`, `i32`, `u64` and `i64`
@ -483,9 +483,9 @@ context overconstrains the type, it is also considered a static type error.
 Examples of integer literals of various forms:
 ```
-123i;                              // type int
+123is;                             // type isize
-123u;                              // type uint
+123us;                             // type usize
-123_u;                             // type uint
+123_us;                            // type usize
 0xff_u8;                           // type u8
 0o70_i16;                          // type i16
 0b1111_1111_1001_0000_i32;         // type i32
@ -578,8 +578,8 @@ Two examples of paths with type arguments:
 # struct HashMap<K, V>;
 # fn f() {
 # fn id<T>(t: T) -> T { t }
-type T = HashMap<int,String>;  // Type arguments used in a type expression
+type T = HashMap<i32,String>; // Type arguments used in a type expression
-let x = id::<int>(10);       // Type arguments used in a call expression
+let x  = id::<i32>(10);       // Type arguments used in a call expression
 # }
 ```
@ -971,7 +971,7 @@ path_glob : ident [ "::" [ path_glob
                          | '*' ] ] ?
          | '{' path_item [ ',' path_item ] * '}' ;
-path_item : ident | "mod" ;
+path_item : ident | "self" ;
 ```
 A _use declaration_ creates one or more local name bindings synonymous with
@ -991,22 +991,22 @@ Use declarations support a number of convenient shortcuts:
 * 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
+  and their immediate parent module, using the `self` keyword, such as
-  `use a::b::{mod, c, d};`
+  `use a::b::{self, c, d};`
 An example of `use` declarations:
 ```
 use std::iter::range_step;
 use std::option::Option::{Some, None};
-use std::collections::hash_map::{mod, HashMap};
+use std::collections::hash_map::{self, HashMap};
 fn foo<T>(_: T){}
-fn bar(map1: HashMap<String, uint>, map2: hash_map::HashMap<String, uint>){}
+fn bar(map1: HashMap<String, usize>, map2: hash_map::HashMap<String, usize>){}
 fn main() {
-    // Equivalent to 'std::iter::range_step(0u, 10u, 2u);'
+    // Equivalent to 'std::iter::range_step(0us, 10, 2);'
-    range_step(0u, 10u, 2u);
+    range_step(0us, 10, 2);
    // Equivalent to 'foo(vec![std::option::Option::Some(1.0f64),
    // std::option::Option::None]);'
@ -1104,7 +1104,7 @@ interpreted as an implicit `return` expression applied to the final-expression.
 An example of a function:
 ```
-fn add(x: int, y: int) -> int {
+fn add(x: i32, y: i32) -> i32 {
    return x + y;
 }
 ```
@ -1113,7 +1113,7 @@ As with `let` bindings, function arguments are irrefutable patterns, so any
 pattern that is valid in a let binding is also valid as an argument.
 ```
-fn first((value, _): (int, int)) -> int { value }
+fn first((value, _): (i32, i32)) -> i32 { value }
 ```
@ -1139,8 +1139,8 @@ used as a type name.
 When a generic function is referenced, its type is instantiated based on the
 context of the reference. For example, calling the `iter` function defined
-above on `[1, 2]` will instantiate type parameter `T` with `int`, and require
+above on `[1, 2]` will instantiate type parameter `T` with `isize`, and require
-the closure parameter to have type `fn(int)`.
+the closure parameter to have type `fn(isize)`.
 The type parameters can also be explicitly supplied in a trailing
 [path](#paths) component after the function name. This might be necessary if
@ -1272,7 +1272,7 @@ typecheck:
 ```
 # fn my_err(s: &str) -> ! { panic!() }
-fn f(i: int) -> int {
+fn f(i: i32) -> i32 {
   if i == 42 {
     return 42;
   }
@ -1283,7 +1283,7 @@ fn f(i: int) -> int {
 ```
 This will not compile without the `!` annotation on `my_err`, since the `else`
-branch of the conditional in `f` does not return an `int`, as required by the
+branch of the conditional in `f` does not return an `i32`, as required by the
 signature of `f`. Adding the `!` annotation to `my_err` informs the
 typechecker that, should control ever enter `my_err`, no further type judgments
 about `f` need to hold, since control will never resume in any context that
@ -1301,18 +1301,18 @@ modifier.
 ```
 // Declares an extern fn, the ABI defaults to "C"
-extern fn new_int() -> int { 0 }
+extern fn new_i32() -> i32 { 0 }
 // Declares an extern fn with "stdcall" ABI
-extern "stdcall" fn new_int_stdcall() -> int { 0 }
+extern "stdcall" fn new_i32_stdcall() -> i32 { 0 }
 ```
 Unlike normal functions, extern fns have an `extern "ABI" fn()`. This is the
 same type as the functions declared in an extern block.
 ```
-# extern fn new_int() -> int { 0 }
+# extern fn new_i32() -> i32 { 0 }
-let fptr: extern "C" fn() -> int = new_int;
+let fptr: extern "C" fn() -> i32 = new_i32;
 ```
 Extern functions may be called directly from Rust code as Rust uses large,
@ -1348,18 +1348,18 @@ keyword `struct`.
 An example of a `struct` item and its use:
 ```
-struct Point {x: int, y: int}
+struct Point {x: i32, y: i32}
 let p = Point {x: 10, y: 11};
-let px: int = p.x;
+let px: i32 = p.x;
 ```
 A _tuple structure_ is a nominal [tuple type](#tuple-types), also defined with
 the keyword `struct`. For example:
 ```
-struct Point(int, int);
+struct Point(i32, i32);
 let p = Point(10, 11);
-let px: int = match p { Point(x, _) => x };
+let px: i32 = match p { Point(x, _) => x };
 ```
 A _unit-like struct_ is a structure without any fields, defined by leaving off
@ -1457,14 +1457,14 @@ a type derived from those primitive types. The derived types are references with
 the `static` lifetime, fixed-size arrays, tuples, enum variants, and structs.
 ```
-const BIT1: uint = 1 << 0;
+const BIT1: u32 = 1 << 0;
-const BIT2: uint = 1 << 1;
+const BIT2: u32 = 1 << 1;
-const BITS: [uint; 2] = [BIT1, BIT2];
+const BITS: [u32; 2] = [BIT1, BIT2];
 const STRING: &'static str = "bitstring";
 struct BitsNStrings<'a> {
-    mybits: [uint; 2],
+    mybits: [u32; 2],
    mystring: &'a str
 }
@ -1500,14 +1500,14 @@ Constants should in general be preferred over statics, unless large amounts of
 data are being stored, or single-address and mutability properties are required.
 ```
-use std::sync::atomic::{AtomicUint, Ordering, ATOMIC_UINT_INIT};;
+use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};
-// Note that ATOMIC_UINT_INIT is a *const*, but it may be used to initialize a
+// Note that ATOMIC_USIZE_INIT is a *const*, but it may be used to initialize a
 // static. This static can be modified, so it is not placed in read-only memory.
-static COUNTER: AtomicUint = ATOMIC_UINT_INIT;
+static COUNTER: AtomicUsize = ATOMIC_USIZE_INIT;
 // This table is a candidate to be placed in read-only memory.
-static TABLE: &'static [uint] = &[1, 2, 3, /* ... */];
+static TABLE: &'static [usize] = &[1, 2, 3, /* ... */];
 for slot in TABLE.iter() {
    println!("{}", slot);
@ -1529,13 +1529,13 @@ Mutable statics are still very useful, however. They can be used with C
 libraries and can also be bound from C libraries (in an `extern` block).
 ```
-# fn atomic_add(_: &mut uint, _: uint) -> uint { 2 }
+# fn atomic_add(_: &mut u32, _: u32) -> u32 { 2 }
-static mut LEVELS: uint = 0;
+static mut LEVELS: u32 = 0;
 // This violates the idea of no shared state, and this doesn't internally
 // protect against races, so this function is `unsafe`
-unsafe fn bump_levels_unsafe1() -> uint {
+unsafe fn bump_levels_unsafe1() -> u32 {
    let ret = LEVELS;
    LEVELS += 1;
    return ret;
@ -1544,7 +1544,7 @@ unsafe fn bump_levels_unsafe1() -> uint {
 // Assuming that we have an atomic_add function which returns the old value,
 // this function is "safe" but the meaning of the return value may not be what
 // callers expect, so it's still marked as `unsafe`
-unsafe fn bump_levels_unsafe2() -> uint {
+unsafe fn bump_levels_unsafe2() -> u32 {
    return atomic_add(&mut LEVELS, 1);
 }
 ```
@ -1564,8 +1564,8 @@ Traits are implemented for specific types through separate
 [implementations](#implementations).
 ```
-# type Surface = int;
+# type Surface = i32;
-# type BoundingBox = int;
+# type BoundingBox = i32;
 trait Shape {
    fn draw(&self, Surface);
    fn bounding_box(&self) -> BoundingBox;
@ -1583,8 +1583,8 @@ functions](#generic-functions).
 ```
 trait Seq<T> {
-   fn len(&self) -> uint;
+   fn len(&self) -> u32;
-   fn elt_at(&self, n: uint) -> T;
+   fn elt_at(&self, n: u32) -> T;
   fn iter<F>(&self, F) where F: Fn(T);
 }
 ```
@ -1595,7 +1595,7 @@ parameter, and within the generic function, the methods of the trait can be
 called on values that have the parameter's type. For example:
 ```
-# type Surface = int;
+# type Surface = i32;
 # trait Shape { fn draw(&self, Surface); }
 fn draw_twice<T: Shape>(surface: Surface, sh: T) {
    sh.draw(surface);
@ -1610,8 +1610,8 @@ trait is in scope) to pointers to the trait name, used as a type.
 ```
 # trait Shape { }
-# impl Shape for int { }
+# impl Shape for i32 { }
-# let mycircle = 0i;
+# let mycircle = 0i32;
 let myshape: Box<Shape> = Box::new(mycircle) as Box<Shape>;
 ```
@ -1629,12 +1629,12 @@ module. For example:
 ```
 trait Num {
-    fn from_int(n: int) -> Self;
+    fn from_i32(n: i32) -> Self;
 }
 impl Num for f64 {
-    fn from_int(n: int) -> f64 { n as f64 }
+    fn from_i32(n: i32) -> f64 { n as f64 }
 }
-let x: f64 = Num::from_int(42);
+let x: f64 = Num::from_i32(42);
 ```
 Traits may inherit from other traits. For example, in
@ -1669,9 +1669,9 @@ Likewise, supertrait methods may also be called on trait objects.
 ```{.ignore}
 # trait Shape { fn area(&self) -> f64; }
 # trait Circle : Shape { fn radius(&self) -> f64; }
-# impl Shape for int { fn area(&self) -> f64 { 0.0 } }
+# impl Shape for i32 { fn area(&self) -> f64 { 0.0 } }
-# impl Circle for int { fn radius(&self) -> f64 { 0.0 } }
+# impl Circle for i32 { fn radius(&self) -> f64 { 0.0 } }
-# let mycircle = 0;
+# let mycircle = 0i32;
 let mycircle = Box::new(mycircle) as Box<Circle>;
 let nonsense = mycircle.radius() * mycircle.area();
 ```
@ -1686,7 +1686,7 @@ Implementations are defined with the keyword `impl`.
 ```
 # struct Point {x: f64, y: f64};
 # impl Copy for Point {}
-# type Surface = int;
+# type Surface = i32;
 # struct BoundingBox {x: f64, y: f64, width: f64, height: f64};
 # trait Shape { fn draw(&self, Surface); fn bounding_box(&self) -> BoundingBox; }
 # fn do_draw_circle(s: Surface, c: Circle) { }
@ -1715,7 +1715,7 @@ limited to nominal types (enums, structs), and the implementation must appear
 in the same module or a sub-module as the `self` type:
 ```
-struct Point {x: int, y: int}
+struct Point {x: i32, y: i32}
 impl Point {
    fn log(&self) {
@ -1826,7 +1826,7 @@ struct Foo;
 // Declare a public struct with a private field
 pub struct Bar {
-    field: int
+    field: i32
 }
 // Declare a public enum with two public variants
@ -2226,15 +2226,15 @@ plugins](book/plugin.html#lint-plugins) can provide additional lint checks.
 mod m1 {
    // Missing documentation is ignored here
    #[allow(missing_docs)]
-    pub fn undocumented_one() -> int { 1 }
+    pub fn undocumented_one() -> i32 { 1 }
    // Missing documentation signals a warning here
    #[warn(missing_docs)]
-    pub fn undocumented_too() -> int { 2 }
+    pub fn undocumented_too() -> i32 { 2 }
    // Missing documentation signals an error here
    #[deny(missing_docs)]
-    pub fn undocumented_end() -> int { 3 }
+    pub fn undocumented_end() -> i32 { 3 }
 }
 ```
@ -2247,16 +2247,16 @@ mod m2{
    #[allow(missing_docs)]
    mod nested {
        // Missing documentation is ignored here
-        pub fn undocumented_one() -> int { 1 }
+        pub fn undocumented_one() -> i32 { 1 }
        // Missing documentation signals a warning here,
        // despite the allow above.
        #[warn(missing_docs)]
-        pub fn undocumented_two() -> int { 2 }
+        pub fn undocumented_two() -> i32 { 2 }
    }
    // Missing documentation signals a warning here
-    pub fn undocumented_too() -> int { 3 }
+    pub fn undocumented_too() -> i32 { 3 }
 }
 ```
@ -2269,7 +2269,7 @@ mod m3 {
    // Attempting to toggle warning signals an error here
    #[allow(missing_docs)]
    /// Returns 2.
-    pub fn undocumented_too() -> int { 2 }
+    pub fn undocumented_too() -> i32 { 2 }
 }
 ```
@ -2451,7 +2451,7 @@ There are three different types of inline attributes:
 * `#[inline(always)]` asks the compiler to always perform an inline expansion.
 * `#[inline(never)]` asks the compiler to never perform an inline expansion.
-### Derive
+### `derive`
 The `derive` attribute allows certain traits to be automatically implemented
 for data structures. For example, the following will create an `impl` for the
@ -2461,7 +2461,7 @@ the `PartialEq` or `Clone` constraints for the appropriate `impl`:
 ```
 #[derive(PartialEq, Clone)]
 struct Foo<T> {
-    a: int,
+    a: i32,
    b: T
 }
 ```
@ -2469,7 +2469,7 @@ struct Foo<T> {
 The generated `impl` for `PartialEq` is equivalent to
 ```
-# struct Foo<T> { a: int, b: T }
+# struct Foo<T> { a: i32, b: T }
 impl<T: PartialEq> PartialEq for Foo<T> {
    fn eq(&self, other: &Foo<T>) -> bool {
        self.a == other.a && self.b == other.b
@ -2821,7 +2821,7 @@ parentheses. They are used to create [tuple-typed](#tuple-types) values.
 ```{.tuple}
 (0,);
 (0.0, 4.5);
-("a", 4u, true);
+("a", 4us, true);
 ```
 ### Unit expressions
@ -2862,7 +2862,7 @@ The following are examples of structure expressions:
 ```
 # struct Point { x: f64, y: f64 }
 # struct TuplePoint(f64, f64);
-# mod game { pub struct User<'a> { pub name: &'a str, pub age: uint, pub score: uint } }
+# mod game { pub struct User<'a> { pub name: &'a str, pub age: u32, pub score: uint } }
 # struct Cookie; fn some_fn<T>(t: T) {}
 Point {x: 10.0, y: 20.0};
 TuplePoint(10.0, 20.0);
@ -2883,7 +2883,7 @@ were explicitly specified and the values in the base expression for all other
 fields.
 ```
-# struct Point3d { x: int, y: int, z: int }
+# struct Point3d { x: i32, y: i32, z: i32 }
 let base = Point3d {x: 1, y: 2, z: 3};
 Point3d {y: 0, z: 10, .. base};
 ```
@ -2958,9 +2958,9 @@ constant expression that can be evaluated at compile time, such as a
 [literal](#literals) or a [static item](#static-items).
 ```
-[1i, 2, 3, 4];
+[1is, 2, 3, 4];
 ["a", "b", "c", "d"];
-[0i; 128];             // array with 128 zeros
+[0is; 128];            // array with 128 zeros
 [0u8, 0u8, 0u8, 0u8];
 ```
@ -3113,7 +3113,7 @@ An example of an `as` expression:
 ```
 # fn sum(v: &[f64]) -> f64 { 0.0 }
-# fn len(v: &[f64]) -> int { 0 }
+# fn len(v: &[f64]) -> i32 { 0 }
 fn avg(v: &[f64]) -> f64 {
  let sum: f64 = sum(v);
@ -3133,7 +3133,7 @@ moves](#moved-and-copied-types) its right-hand operand to its left-hand
 operand.
 ```
-# let mut x = 0i;
+# let mut x = 0is;
 # let y = 0;
 x = y;
@ -3184,7 +3184,7 @@ paren_expr : '(' expr ')' ;
 An example of a parenthesized expression:
 ```
-let x: int = (2 + 3) * 4;
+let x: i32 = (2 + 3) * 4;
 ```
@ -3204,9 +3204,9 @@ then the expression completes.
 Some examples of call expressions:
 ```
-# fn add(x: int, y: int) -> int { 0 }
+# fn add(x: i32, y: i32) -> i32 { 0 }
-let x: int = add(1, 2);
+let x: i32 = add(1i32, 2i32);
 let pi: Option<f32> = "3.14".parse();
 ```
@ -3245,8 +3245,8 @@ In this example, we define a function `ten_times` that takes a higher-order
 function argument, and call it with a lambda expression as an argument:
 ```
-fn ten_times<F>(f: F) where F: Fn(int) {
+fn ten_times<F>(f: F) where F: Fn(i32) {
-    let mut i = 0;
+    let mut i = 0i32;
    while i < 10 {
        f(i);
        i += 1;
@ -3270,7 +3270,7 @@ conditional expression evaluates to `false`, the `while` expression completes.
 An example:
 ```
-let mut i = 0u;
+let mut i = 0us;
 while i < 10 {
    println!("hello");
@ -3333,7 +3333,7 @@ by an implementation of `std::iter::Iterator`.
 An example of a for loop over the contents of an array:
 ```
-# type Foo = int;
+# type Foo = i32;
 # fn bar(f: Foo) { }
 # let a = 0;
 # let b = 0;
@ -3349,8 +3349,8 @@ for e in v.iter() {
 An example of a for loop over a series of integers:
 ```
-# fn bar(b:uint) { }
+# fn bar(b:usize) { }
-for i in range(0u, 256) {
+for i in range(0us, 256) {
    bar(i);
 }
 ```
@ -3402,7 +3402,7 @@ fields of a particular variant. For example:
 enum List<X> { Nil, Cons(X, Box<List<X>>) }
 fn main() {
-    let x: List<int> = List::Cons(10, box List::Cons(11, box List::Nil));
+    let x: List<i32> = List::Cons(10, box List::Cons(11, box List::Nil));
    match x {
        List::Cons(_, box List::Nil) => panic!("singleton list"),
@ -3423,12 +3423,12 @@ Used inside an array pattern, `..` stands for any number of elements, when the
 `advanced_slice_patterns` feature gate is turned on. This wildcard can be used
 at most once for a given array, which implies that it cannot be used to
 specifically match elements that are at an unknown distance from both ends of a
-array, like `[.., 42, ..]`. If followed by a variable name, it will bind the
+array, like `[.., 42, ..]`. If preceded by a variable name, it will bind the
 corresponding slice to the variable. Example:
 ```
 # #![feature(advanced_slice_patterns)]
-fn is_symmetric(list: &[uint]) -> bool {
+fn is_symmetric(list: &[u32]) -> bool {
    match list {
        [] | [_]                   => true,
        [x, inside.., y] if x == y => is_symmetric(inside),
@ -3462,13 +3462,13 @@ An example of a `match` expression:
 ```
 #![feature(box_syntax)]
-# fn process_pair(a: int, b: int) { }
+# fn process_pair(a: i32, b: i32) { }
 # fn process_ten() { }
 enum List<X> { Nil, Cons(X, Box<List<X>>) }
 fn main() {
-    let x: List<int> = List::Cons(10, box List::Cons(11, box List::Nil));
+    let x: List<i32> = List::Cons(10, box List::Cons(11, box List::Nil));
    match x {
        List::Cons(a, box List::Cons(b, _)) => {
@ -3520,11 +3520,11 @@ fn main() {
 ```
 Patterns can also dereference pointers by using the `&`, `&mut` and `box`
-symbols, as appropriate. For example, these two matches on `x: &int` are
+symbols, as appropriate. For example, these two matches on `x: &isize` are
 equivalent:
 ```
-# let x = &3i;
+# let x = &3is;
 let y = match *x { 0 => "zero", _ => "some" };
 let z = match x { &0 => "zero", _ => "some" };
@ -3545,7 +3545,7 @@ Multiple match patterns may be joined with the `|` operator. A range of values
 may be specified with `...`. For example:
 ```
-# let x = 2i;
+# let x = 2is;
 let message = match x {
  0 | 1  => "not many",
@ -3565,8 +3565,8 @@ may refer to the variables bound within the pattern they follow.
 ```
 # let maybe_digit = Some(0);
-# fn process_digit(i: int) { }
+# fn process_digit(i: i32) { }
-# fn process_other(i: int) { }
+# fn process_other(i: i32) { }
 let message = match maybe_digit {
  Some(x) if x < 10 => process_digit(x),
@ -3614,7 +3614,7 @@ caller frame.
 An example of a `return` expression:
 ```
-fn max(a: int, b: int) -> int {
+fn max(a: i32, b: i32) -> i32 {
   if a > b {
      return a;
   }
@ -3666,12 +3666,12 @@ The machine types are the following:
 #### Machine-dependent integer types
-The `uint` type is an unsigned integer type with the same number of bits as the
+The `usize` type is an unsigned integer type with the same number of bits as the
 platform's pointer type. It can represent every memory address in the process.
-The `int` type is a signed integer type with the same number of bits as the
+The `isize` type is a signed integer type with the same number of bits as the
 platform's pointer type. The theoretical upper bound on object and array size
-is the maximum `int` value. This ensures that `int` can be used to calculate
+is the maximum `isize` value. This ensures that `isize` can be used to calculate
 differences between pointers into an object or array and can address every byte
 within an object along with one byte past the end.
@ -3707,7 +3707,7 @@ by the tuple type.
 An example of a tuple type and its use:
 ```
-type Pair<'a> = (int, &'a str);
+type Pair<'a> = (i32, &'a str);
 let p: Pair<'static> = (10, "hello");
 let (a, b) = p;
 assert!(b != "world");
@ -3858,13 +3858,13 @@ or `extern`), a sequence of input types and an output type.
 An example of a `fn` type:
 ```
-fn add(x: int, y: int) -> int {
+fn add(x: i32, y: i32) -> i32 {
  return x + y;
 }
 let mut x = add(5,7);
-type Binop = fn(int, int) -> int;
+type Binop = fn(i32, i32) -> i32;
 let bo: Binop = add;
 x = bo(5,7);
 ```
@ -3886,16 +3886,16 @@ The type of a closure mapping an input of type `A` to an output of type `B` is
 An example of creating and calling a closure:
 ```rust
-let captured_var = 10i;
+let captured_var = 10is;
 let closure_no_args = |&:| println!("captured_var={}", captured_var);
-let closure_args = |&: arg: int| -> int {
+let closure_args = |&: arg: isize| -> isize {
  println!("captured_var={}, arg={}", captured_var, arg);
  arg // Note lack of semicolon after 'arg'
 };
-fn call_closure<F: Fn(), G: Fn(int) -> int>(c1: F, c2: G) {
+fn call_closure<F: Fn(), G: Fn(isize) -> isize>(c1: F, c2: G) {
  c1();
  c2(2);
 }
@ -3927,7 +3927,7 @@ trait Printable {
  fn stringify(&self) -> String;
 }
-impl Printable for int {
+impl Printable for isize {
  fn stringify(&self) -> String { self.to_string() }
 }
@ -3936,7 +3936,7 @@ fn print(a: Box<Printable>) {
 }
 fn main() {
-   print(Box::new(10i) as Box<Printable>);
+   print(Box::new(10is) as Box<Printable>);
 }
 ```
@ -4102,7 +4102,7 @@ Local variables are immutable unless declared otherwise like: `let mut x = ...`.
 Function parameters are immutable unless declared with `mut`. The `mut` keyword
 applies only to the following parameter (so `|mut x, y|` and `fn f(mut x:
-Box<int>, y: Box<int>)` declare one mutable variable `x` and one immutable
+Box<i32>, y: Box<i32>)` declare one mutable variable `x` and one immutable
 variable `y`).
 Methods that take either `self` or `Box<Self>` can optionally place them in a
@ -4130,7 +4130,7 @@ the type of a box is `std::owned::Box<T>`.
 An example of a box type and value:
 ```
-let x: Box<int> = Box::new(10);
+let x: Box<i32> = Box::new(10);
 ```
 Box values exist in 1:1 correspondence with their heap allocation, copying a
@ -4139,7 +4139,7 @@ copy of a box to move ownership of the value. After a value has been moved,
 the source location cannot be used unless it is reinitialized.
 ```
-let x: Box<int> = Box::new(10);
+let x: Box<i32> = Box::new(10);
 let y = x;
 // attempting to use `x` will result in an error here
 ```
--- a/src/doc/trpl/compound-data-types.md
+++ b/src/doc/trpl/compound-data-types.md
@ -254,7 +254,7 @@ things from the standard library if you need them.
 Okay, let's talk about the actual code in the example. `cmp` is a function that
 compares two things, and returns an `Ordering`. We return either
 `Ordering::Less`, `Ordering::Greater`, or `Ordering::Equal`, depending on if
-the two values are greater, less, or equal. Note that each variant of the
+the two values are less, greater, or equal. Note that each variant of the
 `enum` is namespaced under the `enum` itself: it's `Ordering::Greater` not
 `Greater`.
--- a/src/doc/trpl/crates-and-modules.md
+++ b/src/doc/trpl/crates-and-modules.md
@ -208,9 +208,8 @@ Again, these declarations tell Rust to look for either
 these sub-modules don't have their own sub-modules, we've chosen to make them
 `src/english/greetings.rs` and `src/japanese/farewells.rs`. Whew!
-Right now, the contents of `src/english/greetings.rs` and
+The contents of `src/english/greetings.rs` and `src/japanese/farewells.rs` are
-`src/japanese/farewells.rs` are both empty at the moment. Let's add some
+both empty at the moment. Let's add some functions.
 functions.
 Put this in `src/english/greetings.rs`:
--- a/src/doc/trpl/generics.md
+++ b/src/doc/trpl/generics.md
@ -79,9 +79,9 @@ This type is generic over _two_ types: `T` and `E`. By the way, the capital lett
 can be any letter you'd like. We could define `Result<T, E>` as:
 ```{rust}
-enum Result<H, N> {
+enum Result<A, Z> {
-    Ok(H),
+    Ok(A),
-    Err(N),
+    Err(Z),
 }
 ```
--- a/src/doc/trpl/macros.md
+++ b/src/doc/trpl/macros.md
@ -101,6 +101,7 @@ So `($x:ident -> (($e:expr)))`, though excessively fancy, would designate a macr
 that could be invoked like: `my_macro!(i->(( 2+2 )))`.
 To avoid ambiguity, macro invocation syntax must conform to the following rules:
 * `expr` must be followed by `=>`, `,` or `;`.
 * `ty` and `path` must be followed by `=>`, `,`, `:`, `=`, `>` or `as`.
 * `pat` must be followed by `=>`, `,` or `=`.
--- a/src/doc/trpl/ownership.md
+++ b/src/doc/trpl/ownership.md
@ -395,7 +395,7 @@ static FOO: i32 = 5;
 let x: &'static i32 = &FOO;
 ```
-This adds an `i32` to the data segment of the binary, and `FOO` is a reference
+This adds an `i32` to the data segment of the binary, and `x` is a reference
 to it.
 # Shared Ownership
--- a/src/doc/trpl/unsafe.md
+++ b/src/doc/trpl/unsafe.md
@ -254,7 +254,7 @@ impl<T: Send> Drop for Unique<T> {
            // Copy the object out from the pointer onto the stack,
            // where it is covered by normal Rust destructor semantics
            // and cleans itself up, if necessary
-            ptr::read(self.ptr as *const T);
+            ptr::read(self.ptr);
            // clean-up our allocation
            free(self.ptr as *mut c_void)
@ -703,10 +703,10 @@ Other features provided by lang items include:
  `deref`, and `add` respectively.
 - stack unwinding and general failure; the `eh_personality`, `fail`
  and `fail_bounds_checks` lang items.
- the traits in `std::markers` used to indicate types of
+- the traits in `std::marker` used to indicate types of
  various kinds; lang items `send`, `sync` and `copy`.
 - the marker types and variance indicators found in
-  `std::markers`; lang items `covariant_type`,
+  `std::marker`; lang items `covariant_type`,
  `contravariant_lifetime`, `no_sync_bound`, etc.
 Lang items are loaded lazily by the compiler; e.g. if one never uses
--- a/src/etc/generate-deriving-span-tests.py
+++ b/src/etc/generate-deriving-span-tests.py
@ -12,8 +12,8 @@
 """
 This script creates a pile of compile-fail tests check that all the
-derivings have spans that point to the fields, rather than the
+derives have spans that point to the fields, rather than the
-#[deriving(...)] line.
+#[derive(...)] line.
 sample usage: src/etc/generate-deriving-span-tests.py
 """
@ -46,7 +46,7 @@ fn main() {{}}
 """
 ENUM_STRING = """
-#[deriving({traits})]
+#[derive({traits})]
 enum Enum {{
   A(
     Error {errors}
@ -54,7 +54,7 @@ enum Enum {{
 }}
 """
 ENUM_STRUCT_VARIANT_STRING = """
-#[deriving({traits})]
+#[derive({traits})]
 enum Enum {{
   A {{
     x: Error {errors}
@ -62,13 +62,13 @@ enum Enum {{
 }}
 """
 STRUCT_STRING = """
-#[deriving({traits})]
+#[derive({traits})]
 struct Struct {{
    x: Error {errors}
 }}
 """
 STRUCT_TUPLE_STRING = """
-#[deriving({traits})]
+#[derive({traits})]
 struct Struct(
    Error {errors}
 );
@ -80,14 +80,14 @@ def create_test_case(type, trait, super_traits, number_of_errors):
    string = [ENUM_STRING, ENUM_STRUCT_VARIANT_STRING, STRUCT_STRING, STRUCT_TUPLE_STRING][type]
    all_traits = ','.join([trait] + super_traits)
    super_traits = ','.join(super_traits)
-    error_deriving = '#[deriving(%s)]' % super_traits if super_traits else ''
+    error_deriving = '#[derive(%s)]' % super_traits if super_traits else ''
    errors = '\n'.join('//~%s ERROR' % ('^' * n) for n in range(error_count))
    code = string.format(traits = all_traits, errors = errors)
    return TEMPLATE.format(year = YEAR, error_deriving=error_deriving, code = code)
 def write_file(name, string):
-    test_file = os.path.join(TEST_DIR, 'deriving-span-%s.rs' % name)
+    test_file = os.path.join(TEST_DIR, 'derives-span-%s.rs' % name)
    # set write permission if file exists, so it can be changed
    if os.path.exists(test_file):
--- a/src/etc/kate/rust.xml
+++ b/src/etc/kate/rust.xml
@ -249,7 +249,7 @@
 			<DetectChar char="=" attribute="Normal Text" context="#pop"/>
 			<DetectChar char="&lt;" attribute="Normal Text" context="#pop"/>
 		</context>
-		<context attribute="String" lineEndContext="#stay" name="String">
+		<context attribute="String" lineEndContext="#pop" name="String">
 			<LineContinue attribute="String" context="#stay"/>
 			<DetectChar char="\" attribute="CharEscape" context="CharEscape"/>
 			<DetectChar attribute="String" context="#pop" char="&quot;"/>
--- a/src/etc/nano/rust.nanorc
+++ b/src/etc/nano/rust.nanorc
@ -0,0 +1,35 @@
 # Nano configuration for Rust
 # Copyright 2015 The Rust Project Developers.
 #
 # NOTE: Rules are applied in order: later rules re-colorize matching text.
 syntax "rust" "\.rs"
 # function definition
 color magenta "fn [a-z0-9_]+"
 # Reserved words
 color yellow "\<(abstract|alignof|as|be|box|break|const|continue|crate|do|else|enum|extern|false|final|fn|for|if|impl|in|let|loop|macro|match|mod|move|mut|offsetof|override|priv|pub|pure|ref|return|sizeof|static|self|struct|super|true|trait|type|typeof|unsafe|unsized|use|virtual|where|while|yield)\>"
 # macros
 color red "[a-z_]+!"
 # Constants
 color magenta "[A-Z][A-Z_]+"
 # Traits/Enums/Structs/Types/etc.
 color magenta "[A-Z][a-z]+"
 # Strings
 color green "\".*\""
 color green start="\".*\\$" end=".*\""
 # NOTE: This isn't accurate but matching "#{0,} for the end of the string is too liberal
 color green start="r#+\"" end="\"#+"
 # Comments
 color blue "//.*"
 # Attributes
 color magenta start="#!\[" end="\]"
 # Some common markers
 color brightcyan "(XXX|TODO|FIXME|\?\?\?)"
--- a/src/etc/tidy.py
+++ b/src/etc/tidy.py
@ -8,7 +8,7 @@
 # option. This file may not be copied, modified, or distributed
 # except according to those terms.
-import sys, fileinput, subprocess, re
+import sys, fileinput, subprocess, re, os
 from licenseck import *
 import snapshot
@ -58,20 +58,20 @@ try:
    for line in fileinput.input(file_names,
                                openhook=fileinput.hook_encoded("utf-8")):
-        if fileinput.filename().find("tidy.py") == -1:
+        if "tidy.py" not in fileinput.filename():
-            if line.find(cr_flag) != -1:
+            if cr_flag in line:
                check_cr = False
-            if line.find(tab_flag) != -1:
+            if tab_flag in line:
                check_tab = False
-            if line.find(linelength_flag) != -1:
+            if linelength_flag in line:
                check_linelength = False
-            if line.find("TODO") != -1:
+            if "TODO" in line:
                report_err("TODO is deprecated; use FIXME")
            match = re.match(r'^.*/(\*|/!?)\s*XXX', line)
            if match:
                report_err("XXX is no longer necessary, use FIXME")
            match = re.match(r'^.*//\s*(NOTE.*)$', line)
-            if match:
+            if match and "TRAVIS" not in os.environ:
                m = match.group(1)
                if "snap" in m.lower():
                    report_warn(match.group(1))
@ -86,10 +86,10 @@ try:
                if "SNAP" in line:
                    report_warn("unmatched SNAP line: " + line)
-        if check_tab and (line.find('\t') != -1 and
+        if check_tab and ('\t' in line and
-            fileinput.filename().find("Makefile") == -1):
+            "Makefile" not in fileinput.filename()):
            report_err("tab character")
-        if check_cr and not autocrlf and line.find('\r') != -1:
+        if check_cr and not autocrlf and '\r' in line:
            report_err("CR character")
        if line.endswith(" \n") or line.endswith("\t\n"):
            report_err("trailing whitespace")
--- a/src/etc/unicode.py
+++ b/src/etc/unicode.py
@ -392,7 +392,7 @@ def emit_grapheme_module(f, grapheme_table, grapheme_cats):
    use core::slice;
    #[allow(non_camel_case_types)]
-    #[deriving(Clone)]
+    #[derive(Clone)]
    pub enum GraphemeCat {
 """)
    for cat in grapheme_cats + ["Any"]:
--- a/src/liballoc/heap.rs
+++ b/src/liballoc/heap.rs
@ -298,7 +298,7 @@ mod imp {
            libc::realloc(ptr as *mut libc::c_void, size as libc::size_t) as *mut u8
        } else {
            let new_ptr = allocate(size, align);
-            ptr::copy_memory(new_ptr, ptr as *const u8, cmp::min(size, old_size));
+            ptr::copy_memory(new_ptr, ptr, cmp::min(size, old_size));
            deallocate(ptr, old_size, align);
            new_ptr
        }
--- a/src/libcollections/btree/node.rs
+++ b/src/libcollections/btree/node.rs
@ -344,11 +344,11 @@ impl<K, V> Node<K, V> {
    pub fn as_slices<'a>(&'a self) -> (&'a [K], &'a [V]) {
        unsafe {(
            mem::transmute(raw::Slice {
-                data: self.keys.0 as *const K,
+                data: self.keys.0,
                len: self.len()
            }),
            mem::transmute(raw::Slice {
-                data: self.vals.0 as *const V,
+                data: self.vals.0,
                len: self.len()
            })
        )}
@ -368,7 +368,7 @@ impl<K, V> Node<K, V> {
        } else {
            unsafe {
                mem::transmute(raw::Slice {
-                    data: self.edges.0 as *const Node<K, V>,
+                    data: self.edges.0,
                    len: self.len() + 1
                })
            }
--- a/src/libcollections/lib.rs
+++ b/src/libcollections/lib.rs
@ -102,10 +102,10 @@ pub fn fixme_14344_be_sure_to_link_to_collections() {}
 mod std {
    pub use core::fmt;      // necessary for panic!()
    pub use core::option;   // necessary for panic!()
-    pub use core::clone;    // deriving(Clone)
+    pub use core::clone;    // derive(Clone)
-    pub use core::cmp;      // deriving(Eq, Ord, etc.)
+    pub use core::cmp;      // derive(Eq, Ord, etc.)
-    pub use core::marker;  // deriving(Copy)
+    pub use core::marker;  // derive(Copy)
-    pub use core::hash;     // deriving(Hash)
+    pub use core::hash;     // derive(Hash)
 }
 #[cfg(test)]
--- a/src/libcollections/ring_buf.rs
+++ b/src/libcollections/ring_buf.rs
@ -88,19 +88,19 @@ impl<T> RingBuf<T> {
    /// Turn ptr into a slice
    #[inline]
    unsafe fn buffer_as_slice(&self) -> &[T] {
-        mem::transmute(RawSlice { data: self.ptr as *const T, len: self.cap })
+        mem::transmute(RawSlice { data: self.ptr, len: self.cap })
    }
    /// Turn ptr into a mut slice
    #[inline]
    unsafe fn buffer_as_mut_slice(&mut self) -> &mut [T] {
-        mem::transmute(RawSlice { data: self.ptr as *const T, len: self.cap })
+        mem::transmute(RawSlice { data: self.ptr, len: self.cap })
    }
    /// Moves an element out of the buffer
    #[inline]
    unsafe fn buffer_read(&mut self, off: uint) -> T {
-        ptr::read(self.ptr.offset(off as int) as *const T)
+        ptr::read(self.ptr.offset(off as int))
    }
    /// Writes an element into the buffer, moving it.
--- a/src/libcollections/slice.rs
+++ b/src/libcollections/slice.rs
@ -1222,7 +1222,7 @@ fn insertion_sort<T, F>(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> O
                                 &*buf_v.offset(j),
                                 (i - j) as uint);
                ptr::copy_nonoverlapping_memory(buf_v.offset(j),
-                                                &tmp as *const T,
+                                                &tmp,
                                                1);
                mem::forget(tmp);
            }
--- a/src/libcollections/vec.rs
+++ b/src/libcollections/vec.rs
@ -426,7 +426,7 @@ impl<T> Vec<T> {
    pub fn as_mut_slice<'a>(&'a mut self) -> &'a mut [T] {
        unsafe {
            mem::transmute(RawSlice {
-                data: *self.ptr as *const T,
+                data: *self.ptr,
                len: self.len,
            })
        }
@ -574,7 +574,7 @@ impl<T> Vec<T> {
                let ptr = self.as_mut_ptr().offset(index as int);
                // copy it out, unsafely having a copy of the value on
                // the stack and in the vector at the same time.
-                ret = ptr::read(ptr as *const T);
+                ret = ptr::read(ptr);
                // Shift everything down to fill in that spot.
                ptr::copy_memory(ptr, &*ptr.offset(1), len - index - 1);
@ -879,7 +879,7 @@ impl<T> Vec<T> {
                    //          |         |
                    //          end_u     end_t
-                    let t = ptr::read(pv.start_t as *const T);
+                    let t = ptr::read(pv.start_t);
                    //  start_u start_t
                    //  |       |
                    // +-+-+-+-+-+-+-+-+-+
@ -1443,7 +1443,7 @@ impl<T> AsSlice<T> for Vec<T> {
    fn as_slice<'a>(&'a self) -> &'a [T] {
        unsafe {
            mem::transmute(RawSlice {
-                data: *self.ptr as *const T,
+                data: *self.ptr,
                len: self.len
            })
        }
@ -1806,11 +1806,11 @@ impl<T,U> Drop for PartialVecNonZeroSized<T,U> {
            // We have instances of `U`s and `T`s in `vec`. Destruct them.
            while self.start_u != self.end_u {
-                let _ = ptr::read(self.start_u as *const U); // Run a `U` destructor.
+                let _ = ptr::read(self.start_u); // Run a `U` destructor.
                self.start_u = self.start_u.offset(1);
            }
            while self.start_t != self.end_t {
-                let _ = ptr::read(self.start_t as *const T); // Run a `T` destructor.
+                let _ = ptr::read(self.start_t); // Run a `T` destructor.
                self.start_t = self.start_t.offset(1);
            }
            // After this destructor ran, the destructor of `vec` will run,
--- a/src/libcollections/vec_map.rs
+++ b/src/libcollections/vec_map.rs
@ -186,7 +186,7 @@ impl<V> VecMap<V> {
        }
    }
-    /// Returns an iterator visiting all keys in ascending order by the keys.
+    /// Returns an iterator visiting all keys in ascending order of the keys.
    /// The iterator's element type is `uint`.
    #[stable]
    pub fn keys<'r>(&'r self) -> Keys<'r, V> {
@ -196,7 +196,7 @@ impl<V> VecMap<V> {
        Keys { iter: self.iter().map(first) }
    }
-    /// Returns an iterator visiting all values in ascending order by the keys.
+    /// Returns an iterator visiting all values in ascending order of the keys.
    /// The iterator's element type is `&'r V`.
    #[stable]
    pub fn values<'r>(&'r self) -> Values<'r, V> {
@ -206,7 +206,7 @@ impl<V> VecMap<V> {
        Values { iter: self.iter().map(second) }
    }
-    /// Returns an iterator visiting all key-value pairs in ascending order by the keys.
+    /// Returns an iterator visiting all key-value pairs in ascending order of the keys.
    /// The iterator's element type is `(uint, &'r V)`.
    ///
    /// # Examples
@ -233,7 +233,7 @@ impl<V> VecMap<V> {
        }
    }
-    /// Returns an iterator visiting all key-value pairs in ascending order by the keys,
+    /// Returns an iterator visiting all key-value pairs in ascending order of the keys,
    /// with mutable references to the values.
    /// The iterator's element type is `(uint, &'r mut V)`.
    ///
@ -264,8 +264,8 @@ impl<V> VecMap<V> {
        }
    }
-    /// Returns an iterator visiting all key-value pairs in ascending order by
+    /// Returns an iterator visiting all key-value pairs in ascending order of
-    /// the keys, emptying (but not consuming) the original `VecMap`.
+    /// the keys, consuming the original `VecMap`.
    /// The iterator's element type is `(uint, &'r V)`.
    ///
    /// # Examples
@ -278,20 +278,46 @@ impl<V> VecMap<V> {
    /// map.insert(3, "c");
    /// map.insert(2, "b");
    ///
    /// // Not possible with .iter()
    /// let vec: Vec<(uint, &str)> = map.into_iter().collect();
    ///
    /// assert_eq!(vec, vec![(1, "a"), (2, "b"), (3, "c")]);
    /// ```
    #[stable]
-    pub fn into_iter(&mut self) -> IntoIter<V> {
+    pub fn into_iter(self) -> IntoIter<V> {
        fn filter<A>((i, v): (uint, Option<A>)) -> Option<(uint, A)> {
            v.map(|v| (i, v))
        }
        let filter: fn((uint, Option<V>)) -> Option<(uint, V)> = filter; // coerce to fn ptr
-        let values = replace(&mut self.v, vec!());
+        IntoIter { iter: self.v.into_iter().enumerate().filter_map(filter) }
-        IntoIter { iter: values.into_iter().enumerate().filter_map(filter) }
+    }
    /// Returns an iterator visiting all key-value pairs in ascending order of
    /// the keys, emptying (but not consuming) the original `VecMap`.
    /// The iterator's element type is `(uint, &'r V)`. Keeps the allocated memory for reuse.
    ///
    /// # Examples
    ///
    /// ```
    /// use std::collections::VecMap;
    ///
    /// let mut map = VecMap::new();
    /// map.insert(1, "a");
    /// map.insert(3, "c");
    /// map.insert(2, "b");
    ///
    /// let vec: Vec<(uint, &str)> = map.drain().collect();
    ///
    /// assert_eq!(vec, vec![(1, "a"), (2, "b"), (3, "c")]);
    /// ```
    #[unstable = "matches collection reform specification, waiting for dust to settle"]
    pub fn drain<'a>(&'a mut self) -> Drain<'a, V> {
        fn filter<A>((i, v): (uint, Option<A>)) -> Option<(uint, A)> {
            v.map(|v| (i, v))
        }
        let filter: fn((uint, Option<V>)) -> Option<(uint, V)> = filter; // coerce to fn ptr
        Drain { iter: self.v.drain().enumerate().filter_map(filter) }
    }
    /// Return the number of elements in the map.
@ -673,6 +699,28 @@ pub struct IntoIter<V> {
    fn((uint, Option<V>)) -> Option<(uint, V)>>
 }
 #[unstable]
 pub struct Drain<'a, V> {
    iter: FilterMap<
    (uint, Option<V>),
    (uint, V),
    Enumerate<vec::Drain<'a, Option<V>>>,
    fn((uint, Option<V>)) -> Option<(uint, V)>>
 }
 #[unstable]
 impl<'a, V> Iterator for Drain<'a, V> {
    type Item = (uint, V);
    fn next(&mut self) -> Option<(uint, V)> { self.iter.next() }
    fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
 }
 #[unstable]
 impl<'a, V> DoubleEndedIterator for Drain<'a, V> {
    fn next_back(&mut self) -> Option<(uint, V)> { self.iter.next_back() }
 }
 #[stable]
 impl<'a, V> Iterator for Keys<'a, V> {
    type Item = uint;
@ -918,7 +966,19 @@ mod test_map {
            assert_eq!(v, box 2i);
        }
        assert!(called);
-        m.insert(2, box 1i);
+    }
    #[test]
    fn test_drain_iterator() {
        let mut map = VecMap::new();
        map.insert(1, "a");
        map.insert(3, "c");
        map.insert(2, "b");
        let vec: Vec<(usize, &str)> = map.drain().collect();
        assert_eq!(vec, vec![(1, "a"), (2, "b"), (3, "c")]);
        assert_eq!(map.len(), 0);
    }
    #[test]
--- a/src/libcore/array.rs
+++ b/src/libcore/array.rs
@ -17,6 +17,7 @@
 use clone::Clone;
 use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering};
 use fmt;
 use hash::{Hash, Hasher, self};
 use marker::Copy;
 use ops::{Deref, FullRange};
 use option::Option;
@ -32,6 +33,12 @@ macro_rules! array_impls {
                }
            }
            impl<S: hash::Writer + Hasher, T: Hash<S>> Hash<S> for [T; $N] {
                fn hash(&self, state: &mut S) {
                    Hash::hash(&self[], state)
                }
            }
            #[unstable = "waiting for Show to stabilize"]
            impl<T:fmt::Show> fmt::Show for [T; $N] {
                fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
--- a/src/libcore/atomic.rs
+++ b/src/libcore/atomic.rs
@ -199,7 +199,7 @@ impl AtomicBool {
    #[inline]
    #[stable]
    pub fn load(&self, order: Ordering) -> bool {
-        unsafe { atomic_load(self.v.get() as *const usize, order) > 0 }
+        unsafe { atomic_load(self.v.get(), order) > 0 }
    }
    /// Stores a value into the bool.
@ -438,7 +438,7 @@ impl AtomicIsize {
    /// ```
    #[inline]
    pub fn load(&self, order: Ordering) -> isize {
-        unsafe { atomic_load(self.v.get() as *const isize, order) }
+        unsafe { atomic_load(self.v.get(), order) }
    }
    /// Stores a value into the isize.
@ -615,7 +615,7 @@ impl AtomicUsize {
    /// ```
    #[inline]
    pub fn load(&self, order: Ordering) -> usize {
-        unsafe { atomic_load(self.v.get() as *const usize, order) }
+        unsafe { atomic_load(self.v.get(), order) }
    }
    /// Stores a value into the usize.
@ -796,7 +796,7 @@ impl<T> AtomicPtr<T> {
    #[stable]
    pub fn load(&self, order: Ordering) -> *mut T {
        unsafe {
-            atomic_load(self.p.get() as *const *mut T, order) as *mut T
+            atomic_load(self.p.get(), order) as *mut T
        }
    }
@ -1070,7 +1070,7 @@ impl AtomicInt {
    #[inline]
    pub fn load(&self, order: Ordering) -> int {
-        unsafe { atomic_load(self.v.get() as *const int, order) }
+        unsafe { atomic_load(self.v.get(), order) }
    }
    #[inline]
@ -1123,7 +1123,7 @@ impl AtomicUint {
    #[inline]
    pub fn load(&self, order: Ordering) -> uint {
-        unsafe { atomic_load(self.v.get() as *const uint, order) }
+        unsafe { atomic_load(self.v.get(), order) }
    }
    #[inline]
--- a/src/libcore/ops.rs
+++ b/src/libcore/ops.rs
@ -880,7 +880,7 @@ pub trait IndexMut<Index: ?Sized> {
 }
 /// An unbounded range.
-#[derive(Copy, PartialEq, Eq)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 #[lang="full_range"]
 #[unstable = "API still in development"]
 pub struct FullRange;
@ -893,7 +893,7 @@ impl fmt::Show for FullRange {
 }
 /// A (half-open) range which is bounded at both ends.
-#[derive(Copy, PartialEq, Eq)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 #[lang="range"]
 #[unstable = "API still in development"]
 pub struct Range<Idx> {
@ -952,7 +952,7 @@ impl<Idx: fmt::Show> fmt::Show for Range<Idx> {
 }
 /// A range which is only bounded below.
-#[derive(Copy, PartialEq, Eq)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 #[lang="range_from"]
 #[unstable = "API still in development"]
 pub struct RangeFrom<Idx> {
@ -981,7 +981,7 @@ impl<Idx: fmt::Show> fmt::Show for RangeFrom<Idx> {
 }
 /// A range which is only bounded above.
-#[derive(Copy, PartialEq, Eq)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 #[lang="range_to"]
 #[unstable = "API still in development"]
 pub struct RangeTo<Idx> {
--- a/src/libcore/ptr.rs
+++ b/src/libcore/ptr.rs
@ -329,7 +329,7 @@ impl<T> PtrExt for *mut T {
    #[inline]
    #[stable]
    unsafe fn offset(self, count: int) -> *mut T {
-        intrinsics::offset(self as *const T, count) as *mut T
+        intrinsics::offset(self, count) as *mut T
    }
    #[inline]
--- a/src/libcore/slice.rs
+++ b/src/libcore/slice.rs
@ -741,7 +741,7 @@ macro_rules! make_slice {
            diff / mem::size_of::<$t>()
        };
        unsafe {
-            transmute::<_, $result>(RawSlice { data: $start as *const T, len: len })
+            transmute::<_, $result>(RawSlice { data: $start, len: len })
        }
    }}
 }
@ -1409,7 +1409,7 @@ pub unsafe fn from_raw_buf<'a, T>(p: &'a *const T, len: uint) -> &'a [T] {
 #[inline]
 #[unstable = "should be renamed to from_raw_parts_mut"]
 pub unsafe fn from_raw_mut_buf<'a, T>(p: &'a *mut T, len: uint) -> &'a mut [T] {
-    transmute(RawSlice { data: *p as *const T, len: len })
+    transmute(RawSlice { data: *p, len: len })
 }
 //
--- a/src/libcore/str/mod.rs
+++ b/src/libcore/str/mod.rs
@ -678,18 +678,15 @@ struct TwoWaySearcher {
 */
 impl TwoWaySearcher {
    fn new(needle: &[u8]) -> TwoWaySearcher {
-        let (crit_pos1, period1) = TwoWaySearcher::maximal_suffix(needle, false);
+        let (crit_pos_false, period_false) = TwoWaySearcher::maximal_suffix(needle, false);
-        let (crit_pos2, period2) = TwoWaySearcher::maximal_suffix(needle, true);
+        let (crit_pos_true, period_true) = TwoWaySearcher::maximal_suffix(needle, true);
-        let crit_pos;
+        let (crit_pos, period) =
-        let period;
+            if crit_pos_false > crit_pos_true {
-        if crit_pos1 > crit_pos2 {
+                (crit_pos_false, period_false)
-            crit_pos = crit_pos1;
+            } else {
-            period = period1;
+                (crit_pos_true, period_true)
-        } else {
+            };
            crit_pos = crit_pos2;
            period = period2;
        }
        // This isn't in the original algorithm, as far as I'm aware.
        let byteset = needle.iter()
--- a/src/liblibc/lib.rs
+++ b/src/liblibc/lib.rs
@ -1541,7 +1541,8 @@ pub mod types {
                pub type DWORDLONG = c_ulonglong;
                pub type HANDLE = LPVOID;
-                pub type HMODULE = c_uint;
+                pub type HINSTANCE = HANDLE;
                pub type HMODULE = HINSTANCE;
                pub type LONG = c_long;
                pub type PLONG = *mut c_long;
--- a/src/librustc/middle/infer/coercion.rs
+++ b/src/librustc/middle/infer/coercion.rs
@ -213,7 +213,12 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
        let inner_ty = match a.sty {
            ty::ty_uniq(_) => return Err(ty::terr_mismatch),
-            ty::ty_rptr(_, mt_a) => mt_a.ty,
+            ty::ty_rptr(_, mt_a) => {
                if !can_coerce_mutbls(mt_a.mutbl, mutbl_b) {
                    return Err(ty::terr_mutability);
                }
                mt_a.ty
            }
            _ => {
                return self.subtype(a, b);
            }
--- a/src/librustc_back/svh.rs
+++ b/src/librustc_back/svh.rs
@ -156,7 +156,7 @@ mod svh_visitor {
        StrictVersionHashVisitor { st: st }
    }
-    // To off-load the bulk of the hash-computation on deriving(Hash),
+    // To off-load the bulk of the hash-computation on #[derive(Hash)],
    // we define a set of enums corresponding to the content that our
    // crate visitor will encounter as it traverses the ast.
    //
--- a/src/librustc_trans/trans/builder.rs
+++ b/src/librustc_trans/trans/builder.rs
@ -33,7 +33,7 @@ pub struct Builder<'a, 'tcx: 'a> {
 // lot more efficient) than doing str::as_c_str("", ...) every time.
 pub fn noname() -> *const c_char {
    static CNULL: c_char = 0;
-    &CNULL as *const c_char
+    &CNULL
 }
 impl<'a, 'tcx> Builder<'a, 'tcx> {
--- a/src/librustdoc/flock.rs
+++ b/src/librustdoc/flock.rs
@ -128,7 +128,7 @@ mod imp {
                l_sysid: 0,
            };
            let ret = unsafe {
-                libc::fcntl(fd, os::F_SETLKW, &flock as *const os::flock)
+                libc::fcntl(fd, os::F_SETLKW, &flock)
            };
            if ret == -1 {
                let errno = stdos::errno();
@ -151,7 +151,7 @@ mod imp {
                l_sysid: 0,
            };
            unsafe {
-                libc::fcntl(self.fd, os::F_SETLK, &flock as *const os::flock);
+                libc::fcntl(self.fd, os::F_SETLK, &flock);
                libc::close(self.fd);
            }
        }
--- a/src/librustdoc/html/static/main.js
+++ b/src/librustdoc/html/static/main.js
@ -635,7 +635,7 @@
            $('.do-search').on('click', search);
            $('.search-input').on('keyup', function() {
                clearTimeout(keyUpTimeout);
-                keyUpTimeout = setTimeout(search, 100);
+                keyUpTimeout = setTimeout(search, 500);
            });
            // Push and pop states are used to add search results to the browser
--- a/src/libserialize/json.rs
+++ b/src/libserialize/json.rs
@ -34,7 +34,7 @@
 //!
 //! An object is a series of string keys mapping to values, in `"key": value` format.
 //! Arrays are enclosed in square brackets ([ ... ]) and objects in curly brackets ({ ... }).
-//! A simple JSON document encoding a person, his/her age, address and phone numbers could look like
+//! A simple JSON document encoding a person, their age, address and phone numbers could look like
 //!
 //! ```ignore
 //! {
--- a/src/libstd/collections/hash/map.rs
+++ b/src/libstd/collections/hash/map.rs
@ -2112,23 +2112,6 @@ mod test_map {
        assert_eq!(m.remove(&0), Some(0));
    }
    #[test]
    fn test_find_equiv() {
        let mut m = HashMap::new();
        let (foo, bar, baz) = (1i,2i,3i);
        m.insert("foo".to_string(), foo);
        m.insert("bar".to_string(), bar);
        m.insert("baz".to_string(), baz);
        assert_eq!(m.get("foo"), Some(&foo));
        assert_eq!(m.get("bar"), Some(&bar));
        assert_eq!(m.get("baz"), Some(&baz));
        assert_eq!(m.get("qux"), None);
    }
    #[test]
    fn test_from_iter() {
        let xs = [(1i, 1i), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
--- a/src/libstd/collections/hash/table.rs
+++ b/src/libstd/collections/hash/table.rs
@ -395,9 +395,6 @@ impl<K, V, M: Deref<Target=RawTable<K, V>> + DerefMut> FullBucket<K, V, M> {
    /// This works similarly to `put`, building an `EmptyBucket` out of the
    /// taken bucket.
    pub fn take(mut self) -> (EmptyBucket<K, V, M>, K, V) {
        let key = self.raw.key as *const K;
        let val = self.raw.val as *const V;
        self.table.size -= 1;
        unsafe {
@ -408,8 +405,8 @@ impl<K, V, M: Deref<Target=RawTable<K, V>> + DerefMut> FullBucket<K, V, M> {
                    idx: self.idx,
                    table: self.table
                },
-                ptr::read(key),
+                ptr::read(self.raw.key),
-                ptr::read(val)
+                ptr::read(self.raw.val)
            )
        }
    }
@ -477,8 +474,8 @@ impl<K, V, M: Deref<Target=RawTable<K, V>>> GapThenFull<K, V, M> {
    pub fn shift(mut self) -> Option<GapThenFull<K, V, M>> {
        unsafe {
            *self.gap.raw.hash = mem::replace(&mut *self.full.raw.hash, EMPTY_BUCKET);
-            copy_nonoverlapping_memory(self.gap.raw.key, self.full.raw.key as *const K, 1);
+            copy_nonoverlapping_memory(self.gap.raw.key, self.full.raw.key, 1);
-            copy_nonoverlapping_memory(self.gap.raw.val, self.full.raw.val as *const V, 1);
+            copy_nonoverlapping_memory(self.gap.raw.val, self.full.raw.val, 1);
        }
        let FullBucket { raw: prev_raw, idx: prev_idx, .. } = self.full;
@ -781,8 +778,8 @@ impl<'a, K, V> Iterator for RevMoveBuckets<'a, K, V> {
                if *self.raw.hash != EMPTY_BUCKET {
                    self.elems_left -= 1;
                    return Some((
-                        ptr::read(self.raw.key as *const K),
+                        ptr::read(self.raw.key),
-                        ptr::read(self.raw.val as *const V)
+                        ptr::read(self.raw.val)
                    ));
                }
            }
@ -878,8 +875,8 @@ impl<K, V> Iterator for IntoIter<K, V> {
                    SafeHash {
                        hash: *bucket.hash,
                    },
-                    ptr::read(bucket.key as *const K),
+                    ptr::read(bucket.key),
-                    ptr::read(bucket.val as *const V)
+                    ptr::read(bucket.val)
                )
            }
        })
@ -906,8 +903,8 @@ impl<'a, K, V> Iterator for Drain<'a, K, V> {
                    SafeHash {
                        hash: ptr::replace(bucket.hash, EMPTY_BUCKET),
                    },
-                    ptr::read(bucket.key as *const K),
+                    ptr::read(bucket.key),
-                    ptr::read(bucket.val as *const V)
+                    ptr::read(bucket.val)
                )
            }
        })
--- a/src/libstd/error.rs
+++ b/src/libstd/error.rs
@ -18,7 +18,7 @@
 //! chain information:
 //!
 //! ```
-//! trait Error: Send {
+//! trait Error {
 //!     fn description(&self) -> &str;
 //!
 //!     fn detail(&self) -> Option<String> { None }
@ -87,7 +87,7 @@ use string::{FromUtf8Error, FromUtf16Error};
 /// Base functionality for all errors in Rust.
 #[unstable = "the exact API of this trait may change"]
-pub trait Error: Send {
+pub trait Error {
    /// A short description of the error; usually a static string.
    fn description(&self) -> &str;
--- a/src/libstd/fmt.rs
+++ b/src/libstd/fmt.rs
@ -221,7 +221,7 @@
 //! - `fmt::Show` implementations should be implemented for **all** public types.
 //!   Output will typically represent the internal state as faithfully as possible.
 //!   The purpose of the `Show` trait is to facilitate debugging Rust code. In
-//!   most cases, using `#[deriving(Show)]` is sufficient and recommended.
+//!   most cases, using `#[derive(Show)]` is sufficient and recommended.
 //!
 //! Some examples of the output from both traits:
 //!
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@ -234,7 +234,7 @@ use error::{FromError, Error};
 use fmt;
 use int;
 use iter::{Iterator, IteratorExt};
-use marker::Sized;
+use marker::{Sized, Send};
 use mem::transmute;
 use ops::FnOnce;
 use option::Option;
@ -363,8 +363,8 @@ impl Error for IoError {
    }
 }
-impl FromError<IoError> for Box<Error> {
+impl FromError<IoError> for Box<Error + Send> {
-    fn from_error(err: IoError) -> Box<Error> {
+    fn from_error(err: IoError) -> Box<Error + Send> {
        box err
    }
 }
--- a/src/libstd/lib.rs
+++ b/src/libstd/lib.rs
@ -18,7 +18,7 @@
 //!
 //! The [`ptr`](ptr/index.html) and [`mem`](mem/index.html)
 //! modules deal with unsafe pointers and memory manipulation.
-//! [`markers`](markers/index.html) defines the special built-in traits,
+//! [`marker`](marker/index.html) defines the special built-in traits,
 //! and [`raw`](raw/index.html) the runtime representation of Rust types.
 //! These are some of the lowest-level building blocks in Rust.
 //!
--- a/src/libstd/os.rs
+++ b/src/libstd/os.rs
@ -37,7 +37,7 @@ use error::{FromError, Error};
 use fmt;
 use io::{IoResult, IoError};
 use iter::{Iterator, IteratorExt};
-use marker::Copy;
+use marker::{Copy, Send};
 use libc::{c_void, c_int, c_char};
 use libc;
 use boxed::Box;
@ -937,8 +937,8 @@ impl Error for MapError {
    fn detail(&self) -> Option<String> { Some(format!("{:?}", self)) }
 }
-impl FromError<MapError> for Box<Error> {
+impl FromError<MapError> for Box<Error + Send> {
-    fn from_error(err: MapError) -> Box<Error> {
+    fn from_error(err: MapError) -> Box<Error + Send> {
        box err
    }
 }
--- a/src/libstd/sync/poison.rs
+++ b/src/libstd/sync/poison.rs
@ -11,7 +11,7 @@
 use prelude::v1::*;
 use cell::UnsafeCell;
-use error::FromError;
+use error::{Error, FromError};
 use fmt;
 use thread::Thread;
@ -92,7 +92,13 @@ pub type TryLockResult<Guard> = Result<Guard, TryLockError<Guard>>;
 impl<T> fmt::Show for PoisonError<T> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        "poisoned lock: another task failed inside".fmt(f)
+        self.description().fmt(f)
    }
 }
 impl<T> Error for PoisonError<T> {
    fn description(&self) -> &str {
        "poisoned lock: another task failed inside"
    }
 }
@ -126,11 +132,22 @@ impl<T> FromError<PoisonError<T>> for TryLockError<T> {
 impl<T> fmt::Show for TryLockError<T> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        self.description().fmt(f)
    }
 }
 impl<T> Error for TryLockError<T> {
    fn description(&self) -> &str {
        match *self {
-            TryLockError::Poisoned(ref p) => p.fmt(f),
+            TryLockError::Poisoned(ref p) => p.description(),
-            TryLockError::WouldBlock => {
+            TryLockError::WouldBlock => "try_lock failed because the operation would block"
-                "try_lock failed because the operation would block".fmt(f)
+        }
-            }
+    }
    fn cause(&self) -> Option<&Error> {
        match *self {
            TryLockError::Poisoned(ref p) => Some(p),
            _ => None
        }
    }
 }
--- a/src/libstd/sys/unix/backtrace.rs
+++ b/src/libstd/sys/unix/backtrace.rs
@ -229,7 +229,7 @@ fn print(w: &mut Writer, idx: int, addr: *mut libc::c_void) -> IoResult<()> {
    }
    let mut info: Dl_info = unsafe { intrinsics::init() };
-    if unsafe { dladdr(addr as *const libc::c_void, &mut info) == 0 } {
+    if unsafe { dladdr(addr, &mut info) == 0 } {
        output(w, idx,addr, None)
    } else {
        output(w, idx, addr, Some(unsafe {
--- a/src/libstd/sys/windows/os.rs
+++ b/src/libstd/sys/windows/os.rs
@ -281,7 +281,7 @@ pub fn join_paths<T: BytesContainer>(paths: &[T]) -> Result<Vec<u8>, &'static st
 pub fn load_self() -> Option<Vec<u8>> {
    unsafe {
        fill_utf16_buf_and_decode(|buf, sz| {
-            libc::GetModuleFileNameW(0u as libc::DWORD, buf, sz)
+            libc::GetModuleFileNameW(ptr::null_mut(), buf, sz)
        }).map(|s| s.to_string().into_bytes())
    }
 }
--- a/src/libstd/thread_local/mod.rs
+++ b/src/libstd/thread_local/mod.rs
@ -449,7 +449,7 @@ mod imp {
        // destructor as running for this thread so calls to `get` will return
        // `None`.
        *(*ptr).dtor_running.get() = true;
-        ptr::read((*ptr).inner.get() as *const T);
+        ptr::read((*ptr).inner.get());
    }
 }
--- a/src/libsyntax/ext/deriving/clone.rs
+++ b/src/libsyntax/ext/deriving/clone.rs
@ -80,11 +80,11 @@ fn cs_clone(
        EnumNonMatchingCollapsed (..) => {
            cx.span_bug(trait_span,
                        &format!("non-matching enum variants in \
-                                 `deriving({})`", name)[])
+                                 `derive({})`", name)[])
        }
        StaticEnum(..) | StaticStruct(..) => {
            cx.span_bug(trait_span,
-                        &format!("static method in `deriving({})`", name)[])
+                        &format!("static method in `derive({})`", name)[])
        }
    }
@ -101,7 +101,7 @@ fn cs_clone(
                None => {
                    cx.span_bug(trait_span,
                                &format!("unnamed field in normal struct in \
-                                         `deriving({})`", name)[])
+                                         `derive({})`", name)[])
                }
            };
            cx.field_imm(field.span, ident, subcall(field))
--- a/src/libsyntax/ext/deriving/cmp/eq.rs
+++ b/src/libsyntax/ext/deriving/cmp/eq.rs
@ -32,7 +32,7 @@ pub fn expand_deriving_eq<F>(cx: &mut ExtCtxt,
            |cx, span, subexpr, self_f, other_fs| {
                let other_f = match other_fs {
                    [ref o_f] => o_f,
-                    _ => cx.span_bug(span, "not exactly 2 arguments in `deriving(PartialEq)`")
+                    _ => cx.span_bug(span, "not exactly 2 arguments in `derive(PartialEq)`")
                };
                let eq = cx.expr_binary(span, ast::BiEq, self_f, other_f.clone());
@ -49,7 +49,7 @@ pub fn expand_deriving_eq<F>(cx: &mut ExtCtxt,
            |cx, span, subexpr, self_f, other_fs| {
                let other_f = match other_fs {
                    [ref o_f] => o_f,
-                    _ => cx.span_bug(span, "not exactly 2 arguments in `deriving(PartialEq)`")
+                    _ => cx.span_bug(span, "not exactly 2 arguments in `derive(PartialEq)`")
                };
                let eq = cx.expr_binary(span, ast::BiNe, self_f, other_f.clone());
--- a/src/libsyntax/ext/deriving/cmp/ord.rs
+++ b/src/libsyntax/ext/deriving/cmp/ord.rs
@ -152,7 +152,7 @@ pub fn cs_partial_cmp(cx: &mut ExtCtxt, span: Span,
            let new = {
                let other_f = match other_fs {
                    [ref o_f] => o_f,
-                    _ => cx.span_bug(span, "not exactly 2 arguments in `deriving(PartialOrd)`"),
+                    _ => cx.span_bug(span, "not exactly 2 arguments in `derive(PartialOrd)`"),
                };
                let args = vec![
@ -176,7 +176,7 @@ pub fn cs_partial_cmp(cx: &mut ExtCtxt, span: Span,
        equals_expr.clone(),
        box |cx, span, (self_args, tag_tuple), _non_self_args| {
            if self_args.len() != 2 {
-                cx.span_bug(span, "not exactly 2 arguments in `deriving(PartialOrd)`")
+                cx.span_bug(span, "not exactly 2 arguments in `derive(PartialOrd)`")
            } else {
                some_ordering_collapsed(cx, span, PartialCmpOp, tag_tuple)
            }
@ -210,7 +210,7 @@ fn cs_op(less: bool, equal: bool, cx: &mut ExtCtxt,
            */
            let other_f = match other_fs {
                [ref o_f] => o_f,
-                _ => cx.span_bug(span, "not exactly 2 arguments in `deriving(PartialOrd)`")
+                _ => cx.span_bug(span, "not exactly 2 arguments in `derive(PartialOrd)`")
            };
            let cmp = cx.expr_binary(span, op, self_f.clone(), other_f.clone());
@ -224,7 +224,7 @@ fn cs_op(less: bool, equal: bool, cx: &mut ExtCtxt,
        cx.expr_bool(span, equal),
        box |cx, span, (self_args, tag_tuple), _non_self_args| {
            if self_args.len() != 2 {
-                cx.span_bug(span, "not exactly 2 arguments in `deriving(PartialOrd)`")
+                cx.span_bug(span, "not exactly 2 arguments in `derive(PartialOrd)`")
            } else {
                let op = match (less, equal) {
                    (true,  true) => LeOp, (true,  false) => LtOp,
--- a/src/libsyntax/ext/deriving/cmp/totaleq.rs
+++ b/src/libsyntax/ext/deriving/cmp/totaleq.rs
@ -32,7 +32,7 @@ pub fn expand_deriving_totaleq<F>(cx: &mut ExtCtxt,
            let block = cx.block(span, stmts, None);
            cx.expr_block(block)
        },
-                       box |cx, sp, _, _| cx.span_bug(sp, "non matching enums in deriving(Eq)?"),
+                       box |cx, sp, _, _| cx.span_bug(sp, "non matching enums in derive(Eq)?"),
                       cx,
                       span,
                       substr)
--- a/src/libsyntax/ext/deriving/cmp/totalord.rs
+++ b/src/libsyntax/ext/deriving/cmp/totalord.rs
@ -108,7 +108,7 @@ pub fn cs_cmp(cx: &mut ExtCtxt, span: Span,
            let new = {
                let other_f = match other_fs {
                    [ref o_f] => o_f,
-                    _ => cx.span_bug(span, "not exactly 2 arguments in `deriving(PartialOrd)`"),
+                    _ => cx.span_bug(span, "not exactly 2 arguments in `derive(PartialOrd)`"),
                };
                let args = vec![
@ -132,7 +132,7 @@ pub fn cs_cmp(cx: &mut ExtCtxt, span: Span,
        cx.expr_path(equals_path.clone()),
        box |cx, span, (self_args, tag_tuple), _non_self_args| {
            if self_args.len() != 2 {
-                cx.span_bug(span, "not exactly 2 arguments in `deriving(Ord)`")
+                cx.span_bug(span, "not exactly 2 arguments in `derives(Ord)`")
            } else {
                ordering_collapsed(cx, span, tag_tuple)
            }
--- a/src/libsyntax/ext/deriving/decodable.rs
+++ b/src/libsyntax/ext/deriving/decodable.rs
@ -173,7 +173,7 @@ fn decodable_substructure(cx: &mut ExtCtxt, trait_span: Span,
                cx.lambda_expr_1(trait_span, result, blkarg)
            ))
        }
-        _ => cx.bug("expected StaticEnum or StaticStruct in deriving(Decodable)")
+        _ => cx.bug("expected StaticEnum or StaticStruct in derive(Decodable)")
    };
 }
--- a/src/libsyntax/ext/deriving/default.rs
+++ b/src/libsyntax/ext/deriving/default.rs
@ -81,6 +81,6 @@ fn default_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructur
            // let compilation continue
            cx.expr_uint(trait_span, 0)
        }
-        _ => cx.span_bug(trait_span, "Non-static method in `deriving(Default)`")
+        _ => cx.span_bug(trait_span, "Non-static method in `derive(Default)`")
    };
 }
--- a/src/libsyntax/ext/deriving/encodable.rs
+++ b/src/libsyntax/ext/deriving/encodable.rs
@ -276,6 +276,6 @@ fn encodable_substructure(cx: &mut ExtCtxt, trait_span: Span,
            cx.expr_block(cx.block(trait_span, vec!(me), Some(ret)))
        }
-        _ => cx.bug("expected Struct or EnumMatching in deriving(Encodable)")
+        _ => cx.bug("expected Struct or EnumMatching in derive(Encodable)")
    };
 }
--- a/src/libsyntax/ext/deriving/generic/mod.rs
+++ b/src/libsyntax/ext/deriving/generic/mod.rs
@ -1191,7 +1191,7 @@ impl<'a> TraitDef<'a> {
        to_set.expn_id = cx.codemap().record_expansion(codemap::ExpnInfo {
            call_site: to_set,
            callee: codemap::NameAndSpan {
-                name: format!("deriving({})", trait_name),
+                name: format!("derive({})", trait_name),
                format: codemap::MacroAttribute,
                span: Some(self.span)
            }
--- a/src/libsyntax/ext/deriving/generic/ty.rs
+++ b/src/libsyntax/ext/deriving/generic/ty.rs
@ -182,8 +182,8 @@ impl<'a> Ty<'a> {
            Literal(ref p) => {
                p.to_path(cx, span, self_ty, self_generics)
            }
-            Ptr(..) => { cx.span_bug(span, "pointer in a path in generic `deriving`") }
+            Ptr(..) => { cx.span_bug(span, "pointer in a path in generic `derive`") }
-            Tuple(..) => { cx.span_bug(span, "tuple in a path in generic `deriving`") }
+            Tuple(..) => { cx.span_bug(span, "tuple in a path in generic `derive`") }
        }
    }
 }
--- a/src/libsyntax/ext/deriving/primitive.rs
+++ b/src/libsyntax/ext/deriving/primitive.rs
@ -74,7 +74,7 @@ pub fn expand_deriving_from_primitive<F>(cx: &mut ExtCtxt,
 fn cs_from(name: &str, cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure) -> P<Expr> {
    let n = match substr.nonself_args {
        [ref n] => n,
-        _ => cx.span_bug(trait_span, "incorrect number of arguments in `deriving(FromPrimitive)`")
+        _ => cx.span_bug(trait_span, "incorrect number of arguments in `derive(FromPrimitive)`")
    };
    match *substr.fields {
@ -144,6 +144,6 @@ fn cs_from(name: &str, cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure
            cx.expr_match(trait_span, n.clone(), arms)
        }
-        _ => cx.span_bug(trait_span, "expected StaticEnum in deriving(FromPrimitive)")
+        _ => cx.span_bug(trait_span, "expected StaticEnum in derive(FromPrimitive)")
    }
 }
--- a/src/libsyntax/ext/deriving/rand.rs
+++ b/src/libsyntax/ext/deriving/rand.rs
@ -57,7 +57,7 @@ pub fn expand_deriving_rand<F>(cx: &mut ExtCtxt,
 fn rand_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure) -> P<Expr> {
    let rng = match substr.nonself_args {
        [ref rng] => rng,
-        _ => cx.bug("Incorrect number of arguments to `rand` in `deriving(Rand)`")
+        _ => cx.bug("Incorrect number of arguments to `rand` in `derive(Rand)`")
    };
    let rand_ident = vec!(
        cx.ident_of("std"),
@ -131,7 +131,7 @@ fn rand_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure)
            let block = cx.block(trait_span, vec!( let_statement ), Some(match_expr));
            cx.expr_block(block)
        }
-        _ => cx.bug("Non-static method in `deriving(Rand)`")
+        _ => cx.bug("Non-static method in `derive(Rand)`")
    };
    fn rand_thing<F>(cx: &mut ExtCtxt,
--- a/src/libsyntax/parse/mod.rs
+++ b/src/libsyntax/parse/mod.rs
@ -253,9 +253,8 @@ pub fn file_to_filemap(sess: &ParseSess, path: &Path, spanopt: Option<Span>)
    let bytes = match File::open(path).read_to_end() {
        Ok(bytes) => bytes,
        Err(e) => {
-            err(&format!("couldn't read {:?}: {:?}",
+            err(&format!("couldn't read {:?}: {}",
-                        path.display(),
+                        path.display(), e)[]);
                        e)[]);
            unreachable!()
        }
    };
--- a/src/libtest/lib.rs
+++ b/src/libtest/lib.rs
@ -187,7 +187,7 @@ impl fmt::Show for TestFn {
 /// Manager of the benchmarking runs.
 ///
-/// This is feed into functions marked with `#[bench]` to allow for
+/// This is fed into functions marked with `#[bench]` to allow for
 /// set-up & tear-down before running a piece of code repeatedly via a
 /// call to `iter`.
 #[derive(Copy)]
--- a/src/llvm
+++ b/src/llvm
@ -1 +1 @@
-Subproject commit ec1fdb3b9d3b1fb9e1dae97a65dd3a13db9bfb23
+Subproject commit b820135911e17c7a46b901db56baa48e5155bf46
--- a/src/rustllvm/llvm-auto-clean-trigger
+++ b/src/rustllvm/llvm-auto-clean-trigger
@ -1,4 +1,4 @@
 # If this file is modified, then llvm will be forcibly cleaned and then rebuilt.
 # The actual contents of this file do not matter, but to trigger a change on the
 # build bots then the contents should be changed so git updates the mtime.
-2015-01-13
+2015-01-18
--- a/src/test/compile-fail/coerce-mut.rs
+++ b/src/test/compile-fail/coerce-mut.rs
@ -0,0 +1,20 @@
 // Copyright 2015 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 fn f(x: &mut i32) {}
 fn main() {
    let x = 0;
    f(&x);
    //~^ ERROR mismatched types
    //~| expected `&mut i32`
    //~| found `&_`
    //~| values differ in mutability
 }
--- a/src/test/compile-fail/issue-12028.rs
+++ b/src/test/compile-fail/issue-12028.rs
@ -43,7 +43,7 @@ impl<H: StreamHasher> Hash<H> for u8 {
 impl<H: StreamHasher> StreamHash<H> for u8 {
    fn input_stream(&self, stream: &mut H::S) {
-        Stream::input(&*stream, &[*self]);
+        Stream::input(stream, &[*self]);
    }
 }
--- a/src/test/compile-fail/method-self-arg-2.rs
+++ b/src/test/compile-fail/method-self-arg-2.rs
@ -22,6 +22,7 @@ fn main() {
    let y = &mut x;
    Foo::bar(&x); //~ERROR cannot borrow `x`
-    let x = Foo;
+    let mut x = Foo;
-    Foo::baz(&x); //~ERROR cannot borrow immutable borrowed content as mutable
+    let y = &mut x;
    Foo::baz(&mut x); //~ERROR cannot borrow `x`
 }
--- a/src/test/compile-fail/slice-mut.rs
+++ b/src/test/compile-fail/slice-mut.rs
@ -13,5 +13,9 @@
 fn main() {
    let x: &[isize] = &[1, 2, 3, 4, 5];
    // Immutable slices are not mutable.
-    let y: &mut[_] = &x[2..4]; //~ ERROR cannot borrow immutable borrowed content as mutable
+    let y: &mut[_] = &x[2..4];
    //~^ ERROR mismatched types
    //~| expected `&mut [_]`
    //~| found `&_`
    //~| values differ in mutability
 }
--- a/src/test/run-pass/issue-21384.rs
+++ b/src/test/run-pass/issue-21384.rs
@ -0,0 +1,27 @@
 // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 fn test<T : Clone>(arg: T) -> T {
    arg.clone()
 }
 #[derive(PartialEq)]
 struct Test(int);
 fn main() {
    // Check that ranges implement clone
    assert!(test(1..5) == (1..5));
    assert!(test(..5) == (..5));
    assert!(test(1..) == (1..));
    assert!(test(FullRange) == (FullRange));
    // Check that ranges can still be used with non-clone limits
    assert!((Test(1)..Test(5)) == (Test(1)..Test(5)));
 }
--- a/src/test/run-pass/issue-21402.rs
+++ b/src/test/run-pass/issue-21402.rs
@ -0,0 +1,18 @@
 // Copyright 2015 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 #[derive(Hash)]
 struct Foo {
    a: Vec<bool>,
    b: (bool, bool),
    c: [bool; 2],
 }
 fn main() {}
		`@ -1 +1 @@`
			`Subproject commit ec1fdb3b9d3b1fb9e1dae97a65dd3a13db9bfb23`				`Subproject commit b820135911e17c7a46b901db56baa48e5155bf46`