---

yaml
---
r: 159210
b: refs/heads/snap-stage3
c: 88c743d
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 40fb87d40f681f5356af42175fc7b85da387f037
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: f97524387d0cabc146f6e2944eb6c820256493ef
+refs/heads/snap-stage3: 88c743def3cf42ee943ca09dda1e6dccf4894db9
 refs/heads/try: f58aad6dce273570fb130b4df008ef9acd5a5be2
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

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

@@ -8,8 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::from_str::FromStr;
 use std::fmt;
+use std::str::FromStr;
 use regex::Regex;
 
 #[deriving(Clone, PartialEq)]

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

@@ -22,7 +22,7 @@ extern crate regex;
 use std::os;
 use std::io;
 use std::io::fs;
-use std::from_str::FromStr;
+use std::str::FromStr;
 use getopts::{optopt, optflag, reqopt};
 use common::Config;
 use common::{Pretty, DebugInfoGdb, DebugInfoLldb, Codegen};

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

@@ -12,8 +12,6 @@ use common::Config;
 use common;
 use util;
 
-use std::from_str::FromStr;
-
 pub struct TestProps {
     // Lines that should be expected, in order, on standard out
     pub error_patterns: Vec<String> ,
@@ -353,8 +351,8 @@ pub fn gdb_version_to_int(version_string: &str) -> int {
         panic!("{}", error_string);
     }
 
-    let major: int = FromStr::from_str(components[0]).expect(error_string);
-    let minor: int = FromStr::from_str(components[1]).expect(error_string);
+    let major: int = from_str(components[0]).expect(error_string);
+    let minor: int = from_str(components[1]).expect(error_string);
 
     return major * 1000 + minor;
 }
@@ -364,6 +362,6 @@ pub fn lldb_version_to_int(version_string: &str) -> int {
         "Encountered LLDB version string with unexpected format: {}",
         version_string);
     let error_string = error_string.as_slice();
-    let major: int = FromStr::from_str(version_string).expect(error_string);
+    let major: int = from_str(version_string).expect(error_string);
     return major;
 }

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

@@ -399,7 +399,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
             procsrv::run("",
                          config.adb_path.as_slice(),
                          None,
-                         [
+                         &[
                             "push".to_string(),
                             exe_file.as_str().unwrap().to_string(),
                             config.adb_test_dir.clone()
@@ -411,7 +411,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
             procsrv::run("",
                          config.adb_path.as_slice(),
                          None,
-                         [
+                         &[
                             "forward".to_string(),
                             "tcp:5039".to_string(),
                             "tcp:5039".to_string()
@@ -432,7 +432,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
                                                       config.adb_path
                                                             .as_slice(),
                                                       None,
-                                                      [
+                                                      &[
                                                         "shell".to_string(),
                                                         adb_arg.clone()
                                                       ],
@@ -746,7 +746,7 @@ fn run_debuginfo_lldb_test(config: &Config, props: &TestProps, testfile: &Path)
         cmd.arg(lldb_script_path)
            .arg(test_executable)
            .arg(debugger_script)
-           .env_set_all([("PYTHONPATH", config.lldb_python_dir.clone().unwrap().as_slice())]);
+           .env_set_all(&[("PYTHONPATH", config.lldb_python_dir.clone().unwrap().as_slice())]);
 
         let (status, out, err) = match cmd.spawn() {
             Ok(process) => {
@@ -1142,11 +1142,11 @@ struct ProcRes {
 
 fn compile_test(config: &Config, props: &TestProps,
                 testfile: &Path) -> ProcRes {
-    compile_test_(config, props, testfile, [])
+    compile_test_(config, props, testfile, &[])
 }
 
 fn jit_test(config: &Config, props: &TestProps, testfile: &Path) -> ProcRes {
-    compile_test_(config, props, testfile, ["--jit".to_string()])
+    compile_test_(config, props, testfile, &["--jit".to_string()])
 }
 
 fn compile_test_(config: &Config, props: &TestProps,
@@ -1507,7 +1507,7 @@ fn _arm_exec_compiled_test(config: &Config,
     let copy_result = procsrv::run("",
                                    config.adb_path.as_slice(),
                                    None,
-                                   [
+                                   &[
                                     "push".to_string(),
                                     args.prog.clone(),
                                     config.adb_test_dir.clone()
@@ -1624,7 +1624,7 @@ fn _arm_push_aux_shared_library(config: &Config, testfile: &Path) {
             let copy_result = procsrv::run("",
                                            config.adb_path.as_slice(),
                                            None,
-                                           [
+                                           &[
                                             "push".to_string(),
                                             file.as_str()
                                                 .unwrap()

branches/snap-stage3/src/doc/complement-design-faq.md

@@ -95,7 +95,7 @@ code should need to run is a stack.
 `match` being exhaustive has some useful properties. First, if every
 possibility is covered by the `match`, adding further variants to the `enum`
 in the future will prompt a compilation failure, rather than runtime panic.
-Second, it makes cost explicit. In general, only safe way to have a
+Second, it makes cost explicit. In general, the only safe way to have a
 non-exhaustive match would be to panic the task if nothing is matched, though
 it could fall through if the type of the `match` expression is `()`. This sort
 of hidden cost and special casing is against the language's philosophy. It's

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

@@ -133,11 +133,11 @@ pass-by-reference. Basically, languages can make two choices (this is made
 up syntax, it's not Rust):
 
 ```{notrust,ignore}
-fn foo(x) {
+func foo(x) {
     x = 5
 }
 
-fn main() {
+func main() {
     i = 1
     foo(i)
     // what is the value of i here?
@@ -153,11 +153,11 @@ So what do pointers have to do with this? Well, since pointers point to a
 location in memory...
 
 ```{notrust,ignore}
-fn foo(&int x) {
+func foo(&int x) {
     *x = 5
 }
 
-fn main() {
+func main() {
     i = 1
     foo(&i)
     // what is the value of i here?
@@ -192,13 +192,13 @@ When you combine pointers and functions, it's easy to accidentally invalidate
 the memory the pointer is pointing to. For example:
 
 ```{notrust,ignore}
-fn make_pointer(): &int {
+func make_pointer(): &int {
     x = 5;
 
     return &x;
 }
 
-fn main() {
+func main() {
     &int i = make_pointer();
     *i = 5; // uh oh!
 }
@@ -214,11 +214,11 @@ issue. Two pointers are said to alias when they point at the same location
 in memory. Like this:
 
 ```{notrust,ignore}
-fn mutate(&int i, int j) {
+func mutate(&int i, int j) {
     *i = j;
 }
 
-fn main() {
+func main() {
   x = 5;
   y = &x;
   z = &x; //y and z are aliased

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

@@ -155,7 +155,7 @@ println!("{}", s[0]);
 This does not compile. This is on purpose. In the world of UTF-8, direct
 indexing is basically never what you want to do. The reason is that each
 character can be a variable number of bytes. This means that you have to iterate
-through the characters anyway, which is a O(n) operation. 
+through the characters anyway, which is an O(n) operation.
 
 There's 3 basic levels of unicode (and its encodings):
 

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

@@ -84,7 +84,7 @@ will be counted as a failure. For example:
 #[test]
 #[should_fail]
 fn test_out_of_bounds_failure() {
-    let v: &[int] = [];
+    let v: &[int] = &[];
     v[0];
 }
 ~~~

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

@@ -133,7 +133,7 @@ Some productions are defined by exclusion of particular Unicode characters:
 
 ```{.ebnf .gram}
 comment : block_comment | line_comment ;
-block_comment : "/*" block_comment_body * '*' + '/' ;
+block_comment : "/*" block_comment_body * "*/" ;
 block_comment_body : [block_comment | character] * ;
 line_comment : "//" non_eol * ;
 ```
@@ -458,10 +458,9 @@ Examples of floating-point literals of various forms:
 12E+99_f64;                        // type f64
 ```
 
-##### Unit and boolean literals
+##### Boolean literals
 
-The _unit value_, the only value of the type that has the same name, is written
-as `()`. The two values of the boolean type are written `true` and `false`.
+The two values of the boolean type are written `true` and `false`.
 
 ### Symbols
 
@@ -2526,7 +2525,7 @@ The currently implemented features of the reference compiler are:
 
 * `plugin_registrar` - Indicates that a crate has [compiler plugins][plugin] that it
                        wants to load. As with `phase`, the implementation is
-                       in need of a overhaul, and it is not clear that plugins
+                       in need of an overhaul, and it is not clear that plugins
                        defined using this will continue to work.
 
 * `quote` - Allows use of the `quote_*!` family of macros, which are
@@ -2583,7 +2582,7 @@ there isn't a parser error first). The directive in this case is no longer
 necessary, and it's likely that existing code will break if the feature isn't
 removed.
 
-If a unknown feature is found in a directive, it results in a compiler error.
+If an unknown feature is found in a directive, it results in a compiler error.
 An unknown feature is one which has never been recognized by the compiler.
 
 # Statements and expressions
@@ -2685,7 +2684,7 @@ When an lvalue is evaluated in an _lvalue context_, it denotes a memory
 location; when evaluated in an _rvalue context_, it denotes the value held _in_
 that memory location.
 
-When an rvalue is used in lvalue context, a temporary un-named lvalue is
+When an rvalue is used in an lvalue context, a temporary un-named lvalue is
 created and used instead. A temporary's lifetime equals the largest lifetime
 of any reference that points to it.
 
@@ -2717,7 +2716,7 @@ or an item. Path expressions are [lvalues](#lvalues,-rvalues-and-temporaries).
 
 ### Tuple expressions
 
-Tuples are written by enclosing one or more comma-separated expressions in
+Tuples are written by enclosing zero or more comma-separated expressions in
 parentheses. They are used to create [tuple-typed](#tuple-types) values.
 
 ```{.tuple}
@@ -2726,6 +2725,11 @@ parentheses. They are used to create [tuple-typed](#tuple-types) values.
 ("a", 4u, true);
 ```
 
+### Unit expressions
+
+The expression `()` denotes the _unit value_, the only value of the type with
+the same name.
+
 ### Structure expressions
 
 ```{.ebnf .gram}
@@ -2833,7 +2837,7 @@ foo().x;
 ```
 
 A field access is an [lvalue](#lvalues,-rvalues-and-temporaries) referring to
-the value of that field. When the type providing the field inherits mutabilty,
+the value of that field. When the type providing the field inherits mutability,
 it can be [assigned](#assignment-expressions) to.
 
 Also, if the type of the expression to the left of the dot is a pointer, it is
@@ -3108,11 +3112,10 @@ then the expression completes.
 Some examples of call expressions:
 
 ```
-# use std::from_str::FromStr;
 # fn add(x: int, y: int) -> int { 0 }
 
 let x: int = add(1, 2);
-let pi: Option<f32> = FromStr::from_str("3.14");
+let pi: Option<f32> = from_str("3.14");
 ```
 
 ### Lambda expressions
@@ -3321,7 +3324,7 @@ between `_` and `..` is that the pattern `C(_)` is only type-correct if `C` has
 exactly one argument, while the pattern `C(..)` is type-correct for any enum
 variant `C`, regardless of how many arguments `C` has.
 
-Used inside a array pattern, `..` stands for any number of elements, when the
+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
@@ -3584,7 +3587,7 @@ is not a surrogate), represented as a 32-bit unsigned word in the 0x0000 to
 0xD7FF or 0xE000 to 0x10FFFF range. A `[char]` array is effectively an UCS-4 /
 UTF-32 string.
 
-A value of type `str` is a Unicode string, represented as a array of 8-bit
+A value of type `str` is a Unicode string, represented as an array of 8-bit
 unsigned bytes holding a sequence of UTF-8 codepoints. Since `str` is of
 unknown size, it is not a _first class_ type, but can only be instantiated
 through a pointer type, such as `&str` or `String`.

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

@@ -37,7 +37,6 @@
 
 // This file was auto-generated using 'src/etc/generate-deriving-span-tests.py'
 
-#![feature(struct_variant)]
 extern crate rand;
 
 {error_deriving}

branches/snap-stage3/src/etc/snapshot.py

@@ -75,7 +75,11 @@ def full_snapshot_name(date, rev, platform, hsh):
 
 
 def get_kernel(triple):
-    os_name = triple.split('-')[2]
+    t = triple.split('-')
+    if len(t) == 2:
+      os_name = t[1]
+    else:
+      os_name = t[2]
     if os_name == "windows":
         return "winnt"
     if os_name == "darwin":

branches/snap-stage3/src/etc/vim/syntax/rust.vim

@@ -105,7 +105,7 @@ syn keyword rustTrait RawPtr
 syn keyword rustTrait Buffer Writer Reader Seek
 syn keyword rustTrait Str StrVector StrSlice
 syn keyword rustTrait IntoMaybeOwned StrAllocating UnicodeStrSlice
-syn keyword rustTrait ToString IntoStr
+syn keyword rustTrait ToString IntoString
 syn keyword rustTrait Tuple1 Tuple2 Tuple3 Tuple4
 syn keyword rustTrait Tuple5 Tuple6 Tuple7 Tuple8
 syn keyword rustTrait Tuple9 Tuple10 Tuple11 Tuple12

branches/snap-stage3/src/liballoc/rc.rs

@@ -179,9 +179,9 @@ pub struct Rc<T> {
     _noshare: marker::NoSync
 }
 
-#[stable]
 impl<T> Rc<T> {
     /// Constructs a new reference-counted pointer.
+    #[stable]
     pub fn new(value: T) -> Rc<T> {
         unsafe {
             Rc {
@@ -200,9 +200,7 @@ impl<T> Rc<T> {
             }
         }
     }
-}
 
-impl<T> Rc<T> {
     /// Downgrades the reference-counted pointer to a weak reference.
     #[experimental = "Weak pointers may not belong in this module"]
     pub fn downgrade(&self) -> Weak<T> {