---

yaml
---
r: 159259
b: refs/heads/snap-stage3
c: 215f693
h: refs/heads/master
i:
  159257: ffa09d0
  159255: 28eb564
v: v3

Author: jayelm

[refs]

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

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

@@ -7,7 +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.
-pub use self::Mode::*;
 
 use std::fmt;
 use std::str::FromStr;

branches/snap-stage3/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)]
 

branches/snap-stage3/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};

branches/snap-stage3/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

branches/snap-stage3/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;

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

@@ -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);
 }
 ```

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

@@ -1263,17 +1263,17 @@ enum OptionalInt {
 }
 
 fn main() {
-    let x = OptionalInt::Value(5);
-    let y = OptionalInt::Missing;
+    let x = Value(5);
+    let y = Missing;
 
     match x {
-        OptionalInt::Value(n) => println!("x is {}", n),
-        OptionalInt::Missing  => println!("x is missing!"),
+        Value(n) => println!("x is {}", n),
+        Missing  => println!("x is missing!"),
     }
 
     match y {
-        OptionalInt::Value(n) => println!("y is {}", n),
-        OptionalInt::Missing  => println!("y is missing!"),
+        Value(n) => println!("y is {}", n),
+        Missing  => println!("y is missing!"),
     }
 }
 ```
@@ -1702,17 +1702,17 @@ enum OptionalInt {
 }
 
 fn main() {
-    let x = OptionalInt::Value(5);
-    let y = OptionalInt::Missing;
+    let x = Value(5);
+    let y = Missing;
 
     match x {
-        OptionalInt::Value(n) => println!("x is {}", n),
-        OptionalInt::Missing  => println!("x is missing!"),
+        Value(n) => println!("x is {}", n),
+        Missing  => println!("x is missing!"),
     }
 
     match y {
-        OptionalInt::Value(n) => println!("y is {}", n),
-        OptionalInt::Missing  => println!("y is missing!"),
+        Value(n) => println!("y is {}", n),
+        Missing  => println!("y is missing!"),
     }
 }
 ```
@@ -3709,7 +3709,7 @@ enum List {
 }
 
 fn main() {
-    let list = List::Node(0, box List::Node(1, box List::Nil));
+    let list = Node(0, box Node(1, box Nil));
 }
 ```
 
@@ -3895,11 +3895,11 @@ enum OptionalInt {
     Missing,
 }
 
-let x = OptionalInt::Value(5i);
+let x = Value(5i);
 
 match x {
-    OptionalInt::Value(..) => println!("Got an int!"),
-    OptionalInt::Missing   => println!("No such luck."),
+    Value(..) => println!("Got an int!"),
+    Missing   => println!("No such luck."),
 }
 ```
 
@@ -3911,12 +3911,12 @@ enum OptionalInt {
     Missing,
 }
 
-let x = OptionalInt::Value(5i);
+let x = Value(5i);
 
 match x {
-    OptionalInt::Value(i) if i > 5 => println!("Got an int bigger than five!"),
-    OptionalInt::Value(..) => println!("Got an int!"),
-    OptionalInt::Missing   => println!("No such luck."),
+    Value(i) if i > 5 => println!("Got an int bigger than five!"),
+    Value(..) => println!("Got an int!"),
+    Missing   => println!("No such luck."),
 }
 ```
 

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

@@ -304,8 +304,8 @@ r##"foo #"# bar"##;                // foo #"# bar
 #### Byte and byte string literals
 
 ```{.ebnf .gram}
-byte_lit : "b\x27" byte_body '\x27' ;
-byte_string_lit : "b\x22" string_body * '\x22' | "br" raw_byte_string ;
+byte_lit : 'b' '\x27' byte_body '\x27' ;
+byte_string_lit : 'b' '"' string_body * '"' | 'b' 'r' raw_byte_string ;
 
 byte_body : ascii_non_single_quote
           | '\x5c' [ '\x27' | common_escape ] ;
@@ -381,10 +381,10 @@ num_suffix : int_suffix | float_suffix ;
 
 int_suffix : 'u' int_suffix_size ?
            | 'i' int_suffix_size ? ;
-int_suffix_size : [ '8' | "16" | "32" | "64" ] ;
+int_suffix_size : [ '8' | '1' '6' | '3' '2' | '6' '4' ] ;
 
 float_suffix : [ exponent | '.' dec_lit exponent ? ] ? float_suffix_ty ? ;
-float_suffix_ty : 'f' [ "32" | "64" ] ;
+float_suffix_ty : 'f' [ '3' '2' | '6' '4' ] ;
 exponent : ['E' | 'e'] ['-' | '+' ] ? dec_lit ;
 dec_lit : [ dec_digit | '_' ] + ;
 ```
@@ -1331,8 +1331,8 @@ enum Animal {
   Cat
 }
 
-let mut a: Animal = Animal::Dog;
-a = Animal::Cat;
+let mut a: Animal = Dog;
+a = Cat;
 ```
 
 Enumeration constructors can have either named or unnamed fields:
@@ -1345,8 +1345,8 @@ enum Animal {
     Cat { name: String, weight: f64 }
 }
 
-let mut a: Animal = Animal::Dog("Cocoa".to_string(), 37.2);
-a = Animal::Cat { name: "Spotty".to_string(), weight: 2.7 };
+let mut a: Animal = Dog("Cocoa".to_string(), 37.2);
+a = Cat { name: "Spotty".to_string(), weight: 2.7 };
 # }
 ```
 
@@ -1862,7 +1862,7 @@ the namespace hierarchy as it normally would.
 ## Attributes
 
 ```{.ebnf .gram}
-attribute : "#!" ? '[' meta_item ']' ;
+attribute : '#' '!' ? '[' meta_item ']' ;
 meta_item : ident [ '=' literal
                   | '(' meta_seq ')' ] ? ;
 meta_seq : meta_item [ ',' meta_seq ] ? ;
@@ -3308,12 +3308,12 @@ fields of a particular variant. For example:
 ```
 enum List<X> { Nil, Cons(X, Box<List<X>>) }
 
-let x: List<int> = List::Cons(10, box List::Cons(11, box List::Nil));
+let x: List<int> = Cons(10, box Cons(11, box Nil));
 
 match x {
-    List::Cons(_, box List::Nil) => panic!("singleton list"),
-    List::Cons(..)               => return,
-    List::Nil                    => panic!("empty list")
+    Cons(_, box Nil) => panic!("singleton list"),
+    Cons(..)         => return,
+    Nil              => panic!("empty list")
 }
 ```
 
@@ -3371,16 +3371,16 @@ An example of a `match` expression:
 
 enum List<X> { Nil, Cons(X, Box<List<X>>) }
 
-let x: List<int> = List::Cons(10, box List::Cons(11, box List::Nil));
+let x: List<int> = Cons(10, box Cons(11, box Nil));
 
 match x {
-    List::Cons(a, box List::Cons(b, _)) => {
+    Cons(a, box Cons(b, _)) => {
         process_pair(a, b);
     }
-    List::Cons(10, _) => {
+    Cons(10, _) => {
         process_ten();
     }
-    List::Nil => {
+    Nil => {
         return;
     }
     _ => {
@@ -3402,18 +3402,18 @@ enum List { Nil, Cons(uint, Box<List>) }
 
 fn is_sorted(list: &List) -> bool {
     match *list {
-        List::Nil | List::Cons(_, box List::Nil) => true,
-        List::Cons(x, ref r @ box List::Cons(_, _)) => {
+        Nil | Cons(_, box Nil) => true,
+        Cons(x, ref r @ box Cons(_, _)) => {
             match *r {
-                box List::Cons(y, _) => (x <= y) && is_sorted(&**r),
+                box Cons(y, _) => (x <= y) && is_sorted(&**r),
                 _ => panic!()
             }
         }
     }
 }
 
 fn main() {
-    let a = List::Cons(6, box List::Cons(7, box List::Cons(42, box List::Nil)));
+    let a = Cons(6, box Cons(7, box Cons(42, box Nil)));
     assert!(is_sorted(&a));
 }
 
@@ -3718,7 +3718,7 @@ enum List<T> {
   Cons(T, Box<List<T>>)
 }
 
-let a: List<int> = List::Cons(7, box List::Cons(13, box List::Nil));
+let a: List<int> = Cons(7, box Cons(13, box Nil));
 ```
 
 ### Pointer types