---

yaml
---
r: 159452
b: refs/heads/master
c: eb9684e
h: refs/heads/master
v: v3

Author: tbu-

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 76daa0c77c14d482228af6bf5dd20d9c96a3cdb8
+refs/heads/master: eb9684ee19e1d79999b9809704fbffe072332e7b
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 9c96a79a74f10bed18b031ce0ac4126c56d6cfb3
 refs/heads/try: f58aad6dce273570fb130b4df008ef9acd5a5be2

trunk/src/compiletest/common.rs

@@ -7,10 +7,9 @@
 // <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.
-pub use self::Mode::*;
 
+use std::from_str::FromStr;
 use std::fmt;
-use std::str::FromStr;
 use regex::Regex;
 
 #[deriving(Clone, PartialEq)]

trunk/src/compiletest/compiletest.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 #![crate_type = "bin"]
-#![feature(phase, slicing_syntax, globs)]
+#![feature(phase, slicing_syntax)]
 
 #![deny(warnings)]
 
@@ -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};

trunk/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;
 }

trunk/src/compiletest/runtest.rs

@@ -7,8 +7,6 @@
 // <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.
-#[cfg(not(stage0))]
-use self::TargetLocation::*;
 
 use common::Config;
 use common::{CompileFail, Pretty, RunFail, RunPass, RunPassValgrind, DebugInfoGdb};
@@ -401,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()
@@ -413,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()
@@ -434,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()
                                                       ],
@@ -748,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) => {
@@ -1144,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,
@@ -1509,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()
@@ -1626,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()

trunk/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

trunk/src/doc/guide-lifetimes.md

@@ -308,8 +308,8 @@ copying.
 # }
 fn compute_area(shape: &Shape) -> f64 {
     match *shape {
-        Shape::Circle(_, radius) => std::f64::consts::PI * radius * radius,
-        Shape::Rectangle(_, ref size) => size.w * size.h
+        Circle(_, radius) => std::f64::consts::PI * radius * radius,
+        Rectangle(_, ref size) => size.w * size.h
     }
 }
 ~~~
@@ -478,14 +478,14 @@ example:
 #                  a: &'r T, b: &'r T) -> &'r T {
 #     if compute_area(shape) > threshold {a} else {b}
 # }
-                                                            // -+ r
-fn select_based_on_unit_circle<'r, T>(                      //  |-+ B
-    threshold: f64, a: &'r T, b: &'r T) -> &'r T {          //  | |
-                                                            //  | |
-    let shape = Shape::Circle(Point {x: 0., y: 0.}, 1.);    //  | |
-    select(&shape, threshold, a, b)                         //  | |
-}                                                           //  |-+
-                                                            // -+
+                                                     // -+ r
+fn select_based_on_unit_circle<'r, T>(               //  |-+ B
+    threshold: f64, a: &'r T, b: &'r T) -> &'r T {   //  | |
+                                                     //  | |
+    let shape = Circle(Point {x: 0., y: 0.}, 1.);    //  | |
+    select(&shape, threshold, a, b)                  //  | |
+}                                                    //  |-+
+                                                     // -+
 ~~~
 
 In this call to `select()`, the lifetime of the first parameter shape

trunk/src/doc/guide-macros.md

@@ -22,15 +22,15 @@ doing nothing otherwise:
 ~~~~
 # enum T { SpecialA(uint), SpecialB(uint) }
 # fn f() -> uint {
-# let input_1 = T::SpecialA(0);
-# let input_2 = T::SpecialA(0);
+# let input_1 = SpecialA(0);
+# let input_2 = SpecialA(0);
 match input_1 {
-    T::SpecialA(x) => { return x; }
+    SpecialA(x) => { return x; }
     _ => {}
 }
 // ...
 match input_2 {
-    T::SpecialB(x) => { return x; }
+    SpecialB(x) => { return x; }
     _ => {}
 }
 # return 0u;
@@ -49,20 +49,20 @@ the pattern in the above code:
 # #![feature(macro_rules)]
 # enum T { SpecialA(uint), SpecialB(uint) }
 # fn f() -> uint {
-# let input_1 = T::SpecialA(0);
-# let input_2 = T::SpecialA(0);
+# let input_1 = SpecialA(0);
+# let input_2 = SpecialA(0);
 macro_rules! early_return(
-    ($inp:expr $sp:path) => ( // invoke it like `(input_5 SpecialE)`
+    ($inp:expr $sp:ident) => ( // invoke it like `(input_5 SpecialE)`
         match $inp {
             $sp(x) => { return x; }
             _ => {}
         }
     );
 )
 // ...
-early_return!(input_1 T::SpecialA);
+early_return!(input_1 SpecialA);
 // ...
-early_return!(input_2 T::SpecialB);
+early_return!(input_2 SpecialB);
 # return 0;
 # }
 # fn main() {}
@@ -169,10 +169,10 @@ instead of `*` to mean "at least one".
 # #![feature(macro_rules)]
 # enum T { SpecialA(uint),SpecialB(uint),SpecialC(uint),SpecialD(uint)}
 # fn f() -> uint {
-# let input_1 = T::SpecialA(0);
-# let input_2 = T::SpecialA(0);
+# let input_1 = SpecialA(0);
+# let input_2 = SpecialA(0);
 macro_rules! early_return(
-    ($inp:expr, [ $($sp:path)|+ ]) => (
+    ($inp:expr, [ $($sp:ident)|+ ]) => (
         match $inp {
             $(
                 $sp(x) => { return x; }
@@ -182,9 +182,9 @@ macro_rules! early_return(
     );
 )
 // ...
-early_return!(input_1, [T::SpecialA|T::SpecialC|T::SpecialD]);
+early_return!(input_1, [SpecialA|SpecialC|SpecialD]);
 // ...
-early_return!(input_2, [T::SpecialB]);
+early_return!(input_2, [SpecialB]);
 # return 0;
 # }
 # fn main() {}
@@ -234,9 +234,9 @@ Now consider code like the following:
 # enum T3 { Good2(uint), Bad2}
 # fn f(x: T1) -> uint {
 match x {
-    T1::Good1(g1, val) => {
+    Good1(g1, val) => {
         match g1.body {
-            T3::Good2(result) => {
+            Good2(result) => {
                 // complicated stuff goes here
                 return result + val;
             },
@@ -281,9 +281,9 @@ macro_rules! biased_match (
 # struct T2 { body: T3 }
 # enum T3 { Good2(uint), Bad2}
 # fn f(x: T1) -> uint {
-biased_match!((x)       ~ (T1::Good1(g1, val)) else { return 0 };
+biased_match!((x)       ~ (Good1(g1, val)) else { return 0 };
               binds g1, val )
-biased_match!((g1.body) ~ (T3::Good2(result) )
+biased_match!((g1.body) ~ (Good2(result) )
                   else { panic!("Didn't get good_2") };
               binds result )
 // complicated stuff goes here
@@ -396,8 +396,8 @@ macro_rules! biased_match (
 # enum T3 { Good2(uint), Bad2}
 # fn f(x: T1) -> uint {
 biased_match!(
-    (x)       ~ (T1::Good1(g1, val)) else { return 0 };
-    (g1.body) ~ (T3::Good2(result) ) else { panic!("Didn't get Good2") };
+    (x)       ~ (Good1(g1, val)) else { return 0 };
+    (g1.body) ~ (Good2(result) ) else { panic!("Didn't get Good2") };
     binds val, result )
 // complicated stuff goes here
 return result + val;

trunk/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
@@ -598,7 +598,7 @@ enum List<T> {
 }
 
 fn main() {
-    let list: List<int> = List::Cons(1, box List::Cons(2, box List::Cons(3, box List::Nil)));
+    let list: List<int> = Cons(1, box Cons(2, box Cons(3, box Nil)));
     println!("{}", list);
 }
 ```

trunk/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):
 

trunk/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];
 }
 ~~~