---

yaml
---
r: 159666
b: refs/heads/auto
c: 4aa2040
h: refs/heads/master
v: v3

Author: areski

[refs]

@@ -10,7 +10,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 0b7b4f075a531eb160becf2818c1e9a63fa10cd3
+refs/heads/auto: 4aa2040cc71d1a0394a2845e5b0959655e2a3ecb
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/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/auto/src/compiletest/compiletest.rs

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

branches/auto/src/compiletest/header.rs

@@ -12,6 +12,8 @@ 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> ,
@@ -351,8 +353,8 @@ pub fn gdb_version_to_int(version_string: &str) -> int {
         panic!("{}", error_string);
     }
 
-    let major: int = from_str(components[0]).expect(error_string);
-    let minor: int = from_str(components[1]).expect(error_string);
+    let major: int = FromStr::from_str(components[0]).expect(error_string);
+    let minor: int = FromStr::from_str(components[1]).expect(error_string);
 
     return major * 1000 + minor;
 }
@@ -362,6 +364,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 = from_str(version_string).expect(error_string);
+    let major: int = FromStr::from_str(version_string).expect(error_string);
     return major;
 }

branches/auto/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, the only safe way to have a
+Second, it makes cost explicit. In general, 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/auto/src/doc/guide-lifetimes.md

@@ -51,7 +51,6 @@ expensive. So we'd like to define a function that takes the points just as
 a reference.
 
 ~~~
-# use std::num::Float;
 # struct Point {x: f64, y: f64}
 # fn sqrt(f: f64) -> f64 { 0.0 }
 fn compute_distance(p1: &Point, p2: &Point) -> f64 {

branches/auto/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}
-func foo(x) {
+fn foo(x) {
     x = 5
 }
 
-func main() {
+fn 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}
-func foo(&int x) {
+fn foo(&int x) {
     *x = 5
 }
 
-func main() {
+fn 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}
-func make_pointer(): &int {
+fn make_pointer(): &int {
     x = 5;
 
     return &x;
 }
 
-func main() {
+fn 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}
-func mutate(&int i, int j) {
+fn mutate(&int i, int j) {
     *i = j;
 }
 
-func main() {
+fn main() {
   x = 5;
   y = &x;
   z = &x; //y and z are aliased

branches/auto/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 an O(n) operation.
+through the characters anyway, which is a O(n) operation. 
 
 There's 3 basic levels of unicode (and its encodings):
 

branches/auto/src/doc/guide-tasks.md

@@ -225,7 +225,6 @@ Here is another example showing how futures allow you to background
 computations. The workload will be distributed on the available cores.
 
 ```{rust}
-# use std::num::Float;
 # use std::sync::Future;
 fn partial_sum(start: uint) -> f64 {
     let mut local_sum = 0f64;
@@ -263,7 +262,6 @@ several computations on a single large vector of floats. Each task needs the
 full vector to perform its duty.
 
 ```{rust}
-use std::num::Float;
 use std::rand;
 use std::sync::Arc;
 

branches/auto/src/doc/po4a.conf

@@ -19,7 +19,7 @@
 [type: text] src/doc/guide-tasks.md $lang:doc/l10n/$lang/guide-tasks.md
 [type: text] src/doc/guide-testing.md $lang:doc/l10n/$lang/guide-testing.md
 [type: text] src/doc/guide-unsafe.md $lang:doc/l10n/$lang/guide-unsafe.md
-[type: text] src/doc/guide-crates.md $lang:doc/l10n/$lang/guide-crates.md
+[type: text] src/doc/guide-unsafe.md $lang:doc/l10n/$lang/guide-crates.md
 [type: text] src/doc/guide.md $lang:doc/l10n/$lang/guide.md
 [type: text] src/doc/index.md $lang:doc/l10n/$lang/index.md
 [type: text] src/doc/intro.md $lang:doc/l10n/$lang/intro.md

branches/auto/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,9 +458,10 @@ Examples of floating-point literals of various forms:
 12E+99_f64;                        // type f64
 ```
 
-##### Boolean literals
+##### Unit and boolean literals
 
-The two values of the boolean type are written `true` and `false`.
+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`.
 
 ### Symbols
 
@@ -2525,7 +2526,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 an overhaul, and it is not clear that plugins
+                       in need of a 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
@@ -2582,7 +2583,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 an unknown feature is found in a directive, it results in a compiler error.
+If a 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
@@ -2652,10 +2653,9 @@ An expression may have two roles: it always produces a *value*, and it may have
 value, and has effects during *evaluation*. Many expressions contain
 sub-expressions (operands). The meaning of each kind of expression dictates
 several things:
-
-* Whether or not to evaluate the sub-expressions when evaluating the expression
-* The order in which to evaluate the sub-expressions
-* How to combine the sub-expressions' values to obtain the value of the expression
+  * Whether or not to evaluate the sub-expressions when evaluating the
+  * expression The order in which to evaluate the sub-expressions How to
+  * combine the sub-expressions' values to obtain the value of the expression.
 
 In this way, the structure of expressions dictates the structure of execution.
 Blocks are just another kind of expression, so blocks, statements, expressions,
@@ -2684,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 an lvalue context, a temporary un-named lvalue is
+When an rvalue is used in 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.
 
@@ -2716,7 +2716,7 @@ or an item. Path expressions are [lvalues](#lvalues,-rvalues-and-temporaries).
 
 ### Tuple expressions
 
-Tuples are written by enclosing zero or more comma-separated expressions in
+Tuples are written by enclosing one or more comma-separated expressions in
 parentheses. They are used to create [tuple-typed](#tuple-types) values.
 
 ```{.tuple}
@@ -2725,11 +2725,6 @@ 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}
@@ -2837,7 +2832,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 mutability,
+the value of that field. When the type providing the field inherits mutabilty,
 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
@@ -3112,10 +3107,11 @@ 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> = from_str("3.14");
+let pi: Option<f32> = FromStr::from_str("3.14");
 ```
 
 ### Lambda expressions
@@ -3324,7 +3320,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 an array pattern, `..` stands for any number of elements, when the
+Used inside a 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
@@ -3587,7 +3583,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 an array of 8-bit
+A value of type `str` is a Unicode string, represented as a 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/auto/src/etc/generate-deriving-span-tests.py

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

branches/auto/src/etc/make-win-dist.py

@@ -62,6 +62,7 @@ def make_win_dist(dist_root, target_triple):
                     "libcomctl32.a",
                     "libcomdlg32.a",
                     "libcrypt32.a",
+                    "libctl3d32.a",
                     "libgdi32.a",
                     "libimagehlp.a",
                     "libiphlpapi.a",

branches/auto/src/etc/snapshot.py

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

branches/auto/src/etc/vim/syntax/rust.vim

@@ -97,15 +97,16 @@ syn keyword rustTrait FromIterator IntoIterator Extend ExactSize
 syn keyword rustTrait Iterator DoubleEndedIterator
 syn keyword rustTrait RandomAccessIterator CloneableIterator
 syn keyword rustTrait OrdIterator MutableDoubleEndedIterator
-syn keyword rustTrait NumCast Int SignedInt UnsignedInt Float
+syn keyword rustTrait Num NumCast CheckedAdd CheckedSub CheckedMul CheckedDiv
+syn keyword rustTrait Signed Unsigned Primitive Int Float
 syn keyword rustTrait FloatMath ToPrimitive FromPrimitive
 syn keyword rustTrait Box
 syn keyword rustTrait GenericPath Path PosixPath WindowsPath
 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 IntoString
+syn keyword rustTrait ToString IntoStr
 syn keyword rustTrait Tuple1 Tuple2 Tuple3 Tuple4
 syn keyword rustTrait Tuple5 Tuple6 Tuple7 Tuple8
 syn keyword rustTrait Tuple9 Tuple10 Tuple11 Tuple12

branches/auto/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,7 +200,9 @@ 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> {