---

yaml
---
r: 194615
b: refs/heads/snap-stage3
c: 9754b06
h: refs/heads/master
i:
  194613: 8cc586f
  194611: 18fd6a9
  194607: 996d8d6
v: v3

Author: alexcrichton

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 242ed0b7c0f6a21096f2cc3e1ad1bdb176d02545
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 28a6b16130388b126635773694d450ddbc9120d4
+refs/heads/snap-stage3: 9754b06cd80cfcc523573535090519bec935fec3
 refs/heads/try: 961e0358e1a5c0faaef606e31e9965742c1643bf
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

branches/snap-stage3/src/compiletest/compiletest.rs

@@ -12,6 +12,7 @@
 
 #![feature(box_syntax)]
 #![feature(collections)]
+#![feature(int_uint)]
 #![feature(old_io)]
 #![feature(old_path)]
 #![feature(rustc_private)]

branches/snap-stage3/src/compiletest/errors.rs

@@ -15,13 +15,13 @@ use std::io::prelude::*;
 use std::path::Path;
 
 pub struct ExpectedError {
-    pub line: usize,
+    pub line: uint,
     pub kind: String,
     pub msg: String,
 }
 
 #[derive(PartialEq, Debug)]
-enum WhichLine { ThisLine, FollowPrevious(usize), AdjustBackward(usize) }
+enum WhichLine { ThisLine, FollowPrevious(uint), AdjustBackward(uint) }
 
 /// Looks for either "//~| KIND MESSAGE" or "//~^^... KIND MESSAGE"
 /// The former is a "follow" that inherits its target from the preceding line;
@@ -58,8 +58,8 @@ pub fn load_errors(testfile: &Path) -> Vec<ExpectedError> {
     }).collect()
 }
 
-fn parse_expected(last_nonfollow_error: Option<usize>,
-                  line_num: usize,
+fn parse_expected(last_nonfollow_error: Option<uint>,
+                  line_num: uint,
                   line: &str) -> Option<(WhichLine, ExpectedError)> {
     let start = match line.find("//~") { Some(i) => i, None => return None };
     let (follow, adjusts) = if line.char_at(start + 3) == '|' {

branches/snap-stage3/src/compiletest/header.rs

@@ -357,7 +357,7 @@ pub fn parse_name_value_directive(line: &str, directive: &str)
     }
 }
 
-pub fn gdb_version_to_int(version_string: &str) -> isize {
+pub fn gdb_version_to_int(version_string: &str) -> int {
     let error_string = format!(
         "Encountered GDB version string with unexpected format: {}",
         version_string);
@@ -369,17 +369,17 @@ pub fn gdb_version_to_int(version_string: &str) -> isize {
         panic!("{}", error_string);
     }
 
-    let major: isize = components[0].parse().ok().expect(&error_string);
-    let minor: isize = components[1].parse().ok().expect(&error_string);
+    let major: int = components[0].parse().ok().expect(&error_string);
+    let minor: int = components[1].parse().ok().expect(&error_string);
 
     return major * 1000 + minor;
 }
 
-pub fn lldb_version_to_int(version_string: &str) -> isize {
+pub fn lldb_version_to_int(version_string: &str) -> int {
     let error_string = format!(
         "Encountered LLDB version string with unexpected format: {}",
         version_string);
     let error_string = error_string;
-    let major: isize = version_string.parse().ok().expect(&error_string);
+    let major: int = version_string.parse().ok().expect(&error_string);
     return major;
 }

branches/snap-stage3/src/compiletest/runtest.rs

@@ -758,7 +758,7 @@ fn run_debuginfo_lldb_test(config: &Config, props: &TestProps, testfile: &Path)
 struct DebuggerCommands {
     commands: Vec<String>,
     check_lines: Vec<String>,
-    breakpoint_lines: Vec<usize>,
+    breakpoint_lines: Vec<uint>,
 }
 
 fn parse_debugger_commands(file_path: &Path, debugger_prefix: &str)
@@ -1036,7 +1036,7 @@ fn is_compiler_error_or_warning(line: &str) -> bool {
          scan_string(line, "warning", &mut i));
 }
 
-fn scan_until_char(haystack: &str, needle: char, idx: &mut usize) -> bool {
+fn scan_until_char(haystack: &str, needle: char, idx: &mut uint) -> bool {
     if *idx >= haystack.len() {
         return false;
     }
@@ -1048,7 +1048,7 @@ fn scan_until_char(haystack: &str, needle: char, idx: &mut usize) -> bool {
     return true;
 }
 
-fn scan_char(haystack: &str, needle: char, idx: &mut usize) -> bool {
+fn scan_char(haystack: &str, needle: char, idx: &mut uint) -> bool {
     if *idx >= haystack.len() {
         return false;
     }
@@ -1060,7 +1060,7 @@ fn scan_char(haystack: &str, needle: char, idx: &mut usize) -> bool {
     return true;
 }
 
-fn scan_integer(haystack: &str, idx: &mut usize) -> bool {
+fn scan_integer(haystack: &str, idx: &mut uint) -> bool {
     let mut i = *idx;
     while i < haystack.len() {
         let ch = haystack.char_at(i);
@@ -1076,7 +1076,7 @@ fn scan_integer(haystack: &str, idx: &mut usize) -> bool {
     return true;
 }
 
-fn scan_string(haystack: &str, needle: &str, idx: &mut usize) -> bool {
+fn scan_string(haystack: &str, needle: &str, idx: &mut uint) -> bool {
     let mut haystack_i = *idx;
     let mut needle_i = 0;
     while needle_i < needle.len() {
@@ -1725,7 +1725,7 @@ fn disassemble_extract(config: &Config, _props: &TestProps,
 }
 
 
-fn count_extracted_lines(p: &Path) -> usize {
+fn count_extracted_lines(p: &Path) -> uint {
     let mut x = Vec::new();
     File::open(&p.with_extension("ll")).unwrap().read_to_end(&mut x).unwrap();
     let x = str::from_utf8(&x).unwrap();

branches/snap-stage3/src/compiletest/util.rs

@@ -13,34 +13,33 @@ use common::Config;
 
 /// Conversion table from triple OS name to Rust SYSNAME
 const OS_TABLE: &'static [(&'static str, &'static str)] = &[
-    ("android", "android"),
-    ("bitrig", "bitrig"),
-    ("darwin", "macos"),
-    ("dragonfly", "dragonfly"),
-    ("freebsd", "freebsd"),
-    ("ios", "ios"),
-    ("linux", "linux"),
     ("mingw32", "windows"),
-    ("openbsd", "openbsd"),
     ("win32", "windows"),
     ("windows", "windows"),
+    ("darwin", "macos"),
+    ("android", "android"),
+    ("linux", "linux"),
+    ("freebsd", "freebsd"),
+    ("dragonfly", "dragonfly"),
+    ("bitrig", "bitrig"),
+    ("openbsd", "openbsd"),
 ];
 
 const ARCH_TABLE: &'static [(&'static str, &'static str)] = &[
-    ("aarch64", "aarch64"),
-    ("amd64", "x86_64"),
-    ("arm", "arm"),
-    ("arm64", "aarch64"),
-    ("hexagon", "hexagon"),
     ("i386", "x86"),
     ("i686", "x86"),
+    ("amd64", "x86_64"),
+    ("x86_64", "x86_64"),
+    ("sparc", "sparc"),
+    ("powerpc", "powerpc"),
+    ("arm64", "aarch64"),
+    ("arm", "arm"),
+    ("aarch64", "aarch64"),
     ("mips", "mips"),
+    ("xcore", "xcore"),
     ("msp430", "msp430"),
-    ("powerpc", "powerpc"),
+    ("hexagon", "hexagon"),
     ("s390x", "systemz"),
-    ("sparc", "sparc"),
-    ("x86_64", "x86_64"),
-    ("xcore", "xcore"),
 ];
 
 pub fn get_os(triple: &str) -> &'static str {

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

@@ -2440,6 +2440,9 @@ The currently implemented features of the reference compiler are:
 * `intrinsics` - Allows use of the "rust-intrinsics" ABI. Compiler intrinsics
                  are inherently unstable and no promise about them is made.
 
+* `int_uint` - Allows the use of the `int` and `uint` types, which are deprecated.
+               Use `isize` and `usize` instead.
+
 * `lang_items` - Allows use of the `#[lang]` attribute. Like `intrinsics`,
                  lang items are inherently unstable and no promise about them
                  is made.
@@ -2756,7 +2759,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: u32, pub score: usize } }
+# 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);
@@ -3399,7 +3402,7 @@ subpattern`. For example:
 #![feature(box_patterns)]
 #![feature(box_syntax)]
 
-enum List { Nil, Cons(u32, Box<List>) }
+enum List { Nil, Cons(uint, Box<List>) }
 
 fn is_sorted(list: &List) -> bool {
     match *list {

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

@@ -11,7 +11,8 @@ navigate through the menu on the left.
 <h2 class="section-header"><a href="basic.html">Basics</a></h2>
 
 This section is a linear introduction to the basic syntax and semantics of
-Rust. It has individual sections on each part of Rust's syntax.
+Rust. It has individual sections on each part of Rust's syntax, and culminates
+in a small project: a guessing game.
 
 After reading "Basics," you will have a good foundation to learn more about
 Rust, and can write very simple programs.
@@ -28,12 +29,7 @@ and will be able to understand most Rust code and write more complex programs.
 
 In a similar fashion to "Intermediate," this section is full of individual,
 deep-dive chapters, which stand alone and can be read in any order. These
-chapters focus on the most complex features,
+chapters focus on the most complex features, as well as some things that
+are only available in upcoming versions of Rust.
 
-<h2 class="section-header"><a href="unstable.html">Unstable</a></h2>
-
-In a similar fashion to "Intermediate," this section is full of individual,
-deep-dive chapters, which stand alone and can be read in any order.
-
-This chapter contains things that are only available on the nightly channel of
-Rust.
+After reading "Advanced," you'll be a Rust expert!

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

@@ -36,12 +36,6 @@
     * [FFI](ffi.md)
     * [Unsafe Code](unsafe.md)
     * [Advanced Macros](advanced-macros.md)
-* [Unstable Rust](unstable.md)
     * [Compiler Plugins](plugins.md)
-    * [Inline Assembly](inline-assembly.md)
-    * [No stdlib](no-stdlib.md)
-    * [Intrinsics](intrinsics.md)
-    * [Lang items](lang-items.md)
-    * [Link args](link-args.md)
 * [Conclusion](conclusion.md)
 * [Glossary](glossary.md)

branches/snap-stage3/src/doc/trpl/advanced-macros.md

@@ -206,6 +206,8 @@ the [Bitwise Cyclic Tag](http://esolangs.org/wiki/Bitwise_Cyclic_Tag) automaton
 within Rust's macro system.
 
 ```rust
+#![feature(trace_macros)]
+
 macro_rules! bct {
     // cmd 0:  d ... => ...
     (0, $($ps:tt),* ; $_d:tt)
@@ -227,6 +229,13 @@ macro_rules! bct {
     ( $($ps:tt),* ; )
         => (());
 }
+
+fn main() {
+    trace_macros!(true);
+# /* just check the definition
+    bct!(0, 0, 1, 1, 1 ; 1, 0, 1);
+# */
+}
 ```
 
 Exercise: use macros to reduce duplication in the above definition of the

branches/snap-stage3/src/doc/trpl/arrays-vectors-and-slices.md

@@ -99,5 +99,7 @@ You can also take a slice of a vector, `String`, or `&str`, because they are
 backed by arrays. Slices have type `&[T]`, which we'll talk about when we cover
 generics.
 
-We have now learned all of the most basic Rust concepts. Next, we learn how to
-get input from the keyboard.
+We have now learned all of the most basic Rust concepts. We're ready to start
+building ourselves a guessing game, we just need to know one last thing: how to
+get input from the keyboard. You can't have a guessing game without the ability
+to guess!

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

@@ -1,7 +1,8 @@
 % Basics
 
 This section is a linear introduction to the basic syntax and semantics of
-Rust. It has individual sections on each part of Rust's syntax.
+Rust. It has individual sections on each part of Rust's syntax, and cumulates
+in a small project: a guessing game.
 
 After reading "Basics," you will have a good foundation to learn more about
 Rust, and can write very simple programs.

branches/snap-stage3/src/doc/trpl/compound-data-types.md

@@ -361,4 +361,5 @@ and brittle `if`/`else`s.
 
 [arity]: ./glossary.html#arity
 [match]: ./match.html
+[game]: ./guessing-game.html#comparing-guesses
 [generics]: ./generics.html

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

@@ -352,7 +352,7 @@ Here’s an example of documenting a macro:
 /// # }
 /// ```
 ///
-/// ```should_panic
+/// ```should_fail
 /// # #[macro_use] extern crate foo;
 /// # fn main() {
 /// panic_unless!(true == false, “I’m broken.”);

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

@@ -366,6 +366,31 @@ A few examples of how this model can be used are:
 
 On OSX, frameworks behave with the same semantics as a dynamic library.
 
+## The `link_args` attribute
+
+There is one other way to tell rustc how to customize linking, and that is via
+the `link_args` attribute. This attribute is applied to `extern` blocks and
+specifies raw flags which need to get passed to the linker when producing an
+artifact. An example usage would be:
+
+``` no_run
+#![feature(link_args)]
+
+#[link_args = "-foo -bar -baz"]
+extern {}
+# fn main() {}
+```
+
+Note that this feature is currently hidden behind the `feature(link_args)` gate
+because this is not a sanctioned way of performing linking. Right now rustc
+shells out to the system linker, so it makes sense to provide extra command line
+arguments, but this will not always be the case. In the future rustc may use
+LLVM directly to link native libraries in which case `link_args` will have no
+meaning.
+
+It is highly recommended to *not* use this attribute, and rather use the more
+formal `#[link(...)]` attribute on `extern` blocks instead.
+
 # Unsafe blocks
 
 Some operations, like dereferencing unsafe pointers or calling functions that have been marked
@@ -376,7 +401,7 @@ Unsafe functions, on the other hand, advertise it to the world. An unsafe functi
 this:
 
 ```
-unsafe fn kaboom(ptr: *const i32) -> i32 { *ptr }
+unsafe fn kaboom(ptr: *const int) -> int { *ptr }
 ```
 
 This function can only be called from an `unsafe` block or another `unsafe` function.
@@ -398,7 +423,7 @@ extern {
 
 fn main() {
     println!("You have readline version {} installed.",
-             rl_readline_version as i32);
+             rl_readline_version as int);
 }
 ```