---

yaml
---
r: 174630
b: refs/heads/snap-stage3
c: 66003c0
h: refs/heads/master
v: v3

Author: Alfie John

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: a0f86de49748b472d4d189d9688b0d856c000914
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 9db869b348689797f3e1022b0b7d85f2067ee424
+refs/heads/snap-stage3: 66003c06a19836f049996a629e8db4b6a118d5fa
 refs/heads/try: 08f6380a9f0b866796080094f44fe25ea5636547
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

branches/snap-stage3/mk/tests.mk

@@ -1011,8 +1011,7 @@ $(3)/test/run-make/%-$(1)-T-$(2)-H-$(3).ok: \
 	    $$(LD_LIBRARY_PATH_ENV_NAME$(1)_T_$(2)_H_$(3)) \
 	    "$$(LD_LIBRARY_PATH_ENV_HOSTDIR$(1)_T_$(2)_H_$(3))" \
 	    "$$(LD_LIBRARY_PATH_ENV_TARGETDIR$(1)_T_$(2)_H_$(3))" \
-	    $(1) \
-	    $$(S)
+	    $(1)
 	@touch $$@
 else
 # FIXME #11094 - The above rule doesn't work right for multiple targets

branches/snap-stage3/src/doc/guide-crates.md

@@ -1,4 +1,4 @@
 % The (old) Rust Crates and Modules Guide
 
-This content has moved into
+This content has moved into the
 [the Rust Programming Language book](book/crates-and-modules.html).

branches/snap-stage3/src/doc/guide-error-handling.md

@@ -1,4 +1,4 @@
 % Error Handling in Rust
 
-This content has moved into
+This content has moved into the
 [the Rust Programming Language book](book/error-handling.html).

branches/snap-stage3/src/doc/guide-ffi.md

@@ -1,4 +1,4 @@
 % The (old) Rust Foreign Function Interface Guide
 
-This content has moved into
+This content has moved into the
 [the Rust Programming Language book](book/ffi.html).

branches/snap-stage3/src/doc/guide-macros.md

@@ -1,4 +1,4 @@
 % The (old) Rust Macros Guide
 
-This content has moved into
+This content has moved into the
 [the Rust Programming Language book](book/macros.html).

branches/snap-stage3/src/doc/guide-ownership.md

@@ -1,4 +1,4 @@
 % The (old) Rust Ownership Guide
 
-This content has moved into
+This content has moved into the
 [the Rust Programming Language book](book/ownership.html).

branches/snap-stage3/src/doc/guide-plugins.md

@@ -1,4 +1,4 @@
 % The (old) Rust Compiler Plugins Guide
 
-This content has moved into
+This content has moved into the
 [the Rust Programming Language book](book/plugins.html).

branches/snap-stage3/src/doc/guide-pointers.md

@@ -1,4 +1,4 @@
 % The (old) Rust Pointer Guide
 
-This content has moved into
+This content has moved into the
 [the Rust Programming Language book](book/pointers.html).

branches/snap-stage3/src/doc/guide-strings.md

@@ -1,4 +1,4 @@
 % The (old) Guide to Rust Strings
 
-This content has moved into
+This content has moved into the
 [the Rust Programming Language book](book/strings.html).

branches/snap-stage3/src/doc/guide-tasks.md

@@ -1,4 +1,4 @@
 % The (old) Rust Threads and Communication Guide
 
-This content has moved into
+This content has moved into the
 [the Rust Programming Language book](book/tasks.html).

branches/snap-stage3/src/doc/guide-testing.md

@@ -1,4 +1,4 @@
 % The (old) Rust Testing Guide
 
-This content has moved into
+This content has moved into the
 [the Rust Programming Language book](book/testing.html).

branches/snap-stage3/src/doc/guide-unsafe.md

@@ -1,4 +1,4 @@
 % Writing Safe Low-level and Unsafe Code in Rust
 
-This content has moved into
+This content has moved into the
 [the Rust Programming Language book](book/unsafe.html).

branches/snap-stage3/src/doc/guide.md

@@ -1,4 +1,4 @@
 % The (old) Rust Guide
 
-This content has moved into
+This content has moved into the
 [the Rust Programming Language book](book/README.html).

branches/snap-stage3/src/doc/reference.md

@@ -257,18 +257,18 @@ cases mentioned in [Number literals](#number-literals) below.
 
 | [Number literals](#number-literals)`*` | Example | Exponentiation | Suffixes |
 |----------------------------------------|---------|----------------|----------|
-| Decimal integer | `98_222i` | `N/A` | Integer suffixes |
-| Hex integer | `0xffi` | `N/A` | Integer suffixes |
-| Octal integer | `0o77i` | `N/A` | Integer suffixes |
-| Binary integer | `0b1111_0000i` | `N/A` | Integer suffixes |
+| Decimal integer | `98_222is` | `N/A` | Integer suffixes |
+| Hex integer | `0xffis` | `N/A` | Integer suffixes |
+| Octal integer | `0o77is` | `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`
 
 ##### 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
-123u;                              // type uint
-123_u;                             // type uint
+123is;                             // type isize
+123us;                             // type usize
+123_us                             // type usize
 0xff_u8;                           // type u8
 0o70_i16;                          // type i16
 0b1111_1111_1001_0000_i32;         // type i32
@@ -1002,11 +1002,11 @@ use std::option::Option::{Some, None};
 use std::collections::hash_map::{mod, 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);'
-    range_step(0u, 10u, 2u);
+    // Equivalent to 'std::iter::range_step(0us, 10, 2);'
+    range_step(0us, 10, 2);
 
     // Equivalent to 'foo(vec![std::option::Option::Some(1.0f64),
     // std::option::Option::None]);'
@@ -1611,7 +1611,7 @@ trait is in scope) to pointers to the trait name, used as a type.
 ```
 # trait Shape { }
 # impl Shape for int { }
-# let mycircle = 0i;
+# let mycircle = 0is;
 let myshape: Box<Shape> = Box::new(mycircle) as Box<Shape>;
 ```
 
@@ -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
@@ -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
@@ -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];
 ```
 
@@ -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;
@@ -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");
@@ -3349,8 +3349,8 @@ for e in v.iter() {
 An example of a for loop over a series of integers:
 
 ```
-# fn bar(b:uint) { }
-for i in range(0u, 256) {
+# fn bar(b:usize) { }
+for i in range(0us, 256) {
     bar(i);
 }
 ```
@@ -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",
@@ -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>);
 }
 ```
 

branches/snap-stage3/src/doc/trpl/unsafe.md

@@ -447,7 +447,7 @@ in the same format as C:
 
 ```
 #![no_std]
-#![feature(lang_items, start)]
+#![feature(lang_items)]
 
 // Pull in the system libc library for what crt0.o likely requires
 extern crate libc;
@@ -475,7 +475,7 @@ compiler's name mangling too:
 ```ignore
 #![no_std]
 #![no_main]
-#![feature(lang_items, start)]
+#![feature(lang_items)]
 
 extern crate libc;
 
@@ -529,7 +529,7 @@ vectors provided from C, using idiomatic Rust practices.
 
 ```
 #![no_std]
-#![feature(lang_items, start)]
+#![feature(lang_items)]
 
 # extern crate libc;
 extern crate core;
@@ -653,7 +653,7 @@ sugar for dynamic allocations via `malloc` and `free`:
 
 ```
 #![no_std]
-#![feature(lang_items, box_syntax, start)]
+#![feature(lang_items, box_syntax)]
 
 extern crate libc;
 

branches/snap-stage3/src/etc/generate-deriving-span-tests.py

@@ -12,8 +12,8 @@
 
 """
 This script creates a pile of compile-fail tests check that all the
-derives have spans that point to the fields, rather than the
-#[derive(...)] line.
+derivings have spans that point to the fields, rather than the
+#[deriving(...)] line.
 
 sample usage: src/etc/generate-deriving-span-tests.py
 """
@@ -46,29 +46,29 @@
 """
 
 ENUM_STRING = """
-#[derive({traits})]
+#[deriving({traits})]
 enum Enum {{
    A(
      Error {errors}
      )
 }}
 """
 ENUM_STRUCT_VARIANT_STRING = """
-#[derive({traits})]
+#[deriving({traits})]
 enum Enum {{
    A {{
      x: Error {errors}
    }}
 }}
 """
 STRUCT_STRING = """
-#[derive({traits})]
+#[deriving({traits})]
 struct Struct {{
     x: Error {errors}
 }}
 """
 STRUCT_TUPLE_STRING = """
-#[derive({traits})]
+#[deriving({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 = '#[derive(%s)]' % super_traits if super_traits else ''
+    error_deriving = '#[deriving(%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, 'derives-span-%s.rs' % name)
+    test_file = os.path.join(TEST_DIR, 'deriving-span-%s.rs' % name)
 
     # set write permission if file exists, so it can be changed
     if os.path.exists(test_file):