---

yaml
---
r: 53069
b: refs/heads/dist-snap
c: 7a6db3f
h: refs/heads/master
i:
  53067: fb3c300
v: v3

Author: sanxiyn

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
 refs/heads/incoming: 44d4d6de762f3f9aae1fedcf454c66b79b3ad58d
-refs/heads/dist-snap: 5a4695d407b63faae33c37499dc3c9bac43dfaf8
+refs/heads/dist-snap: 7a6db3f982cea9c5c1ed9921358988c1180851dc
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/doc/rust.md

@@ -1209,7 +1209,7 @@ to pointers to the trait name, used as a type.
 
 ~~~~
 # trait Shape { }
-# impl Shape for int { }
+# impl int: Shape { }
 # let mycircle = 0;
 
 let myshape: Shape = @mycircle as @Shape;
@@ -1233,7 +1233,7 @@ For example:
 trait Num {
     static pure fn from_int(n: int) -> Self;
 }
-impl Num for float {
+impl float: Num {
     static pure fn from_int(n: int) -> float { n as float }
 }
 let x: float = Num::from_int(42);
@@ -1269,8 +1269,8 @@ Likewise, supertrait methods may also be called on trait objects.
 ~~~ {.xfail-test}
 # trait Shape { fn area() -> float; }
 # trait Circle : Shape { fn radius() -> float; }
-# impl Shape for int { fn area() -> float { 0.0 } }
-# impl Circle for int { fn radius() -> float { 0.0 } }
+# impl int: Shape { fn area() -> float { 0.0 } }
+# impl int: Circle { fn radius() -> float { 0.0 } }
 # let mycircle = 0;
 
 let mycircle: Circle = @mycircle as @Circle;
@@ -1292,7 +1292,7 @@ Implementations are defined with the keyword `impl`.
 
 type Circle = {radius: float, center: Point};
 
-impl Shape for Circle {
+impl Circle: Shape {
     fn draw(s: Surface) { do_draw_circle(s, self); }
     fn bounding_box() -> BoundingBox {
         let r = self.radius;
@@ -1303,9 +1303,9 @@ impl Shape for Circle {
 ~~~~
 
 It is possible to define an implementation without referring to a trait.
-The methods in such an implementation can only be used
-as direct calls on the values of the type that the implementation targets.
-In such an implementation, the trait type and `for` after `impl` are omitted.
+The methods in such an implementation can only be used statically
+(as direct calls on the values of the type that the implementation targets).
+In such an implementation, the type after the colon is omitted.
 Such implementations are limited to nominal types (enums, structs),
 and the implementation must appear in the same module or a sub-module as the `self` type.
 
@@ -1320,10 +1320,10 @@ Implementation parameters are written after after the `impl` keyword.
 ~~~~
 # trait Seq<T> { }
 
-impl<T> Seq<T> for ~[T] {
+impl<T> ~[T]: Seq<T> {
    ...
 }
-impl Seq<bool> for u32 {
+impl u32: Seq<bool> {
    /* Treat the integer as a sequence of bits */
 }
 ~~~~
@@ -2801,7 +2801,7 @@ trait Printable {
   fn to_str() -> ~str;
 }
 
-impl Printable for int {
+impl int: Printable {
   fn to_str() -> ~str { int::to_str(self) }
 }
 
@@ -2844,7 +2844,7 @@ trait Printable {
   fn make_string() -> ~str;
 }
 
-impl Printable for ~str {
+impl ~str: Printable {
   fn make_string() -> ~str { copy self }
 }
 ~~~~~~~~

branches/dist-snap/doc/tutorial.md

@@ -1909,7 +1909,7 @@ struct TimeBomb {
     explosivity: uint
 }
 
-impl Drop for TimeBomb {
+impl TimeBomb : Drop {
     fn finalize(&self) {
         for iter::repeat(self.explosivity) {
             io::println("blam!");
@@ -1943,11 +1943,11 @@ and `&str`.
 
 ~~~~
 # trait Printable { fn print(&self); }
-impl Printable for int {
+impl int: Printable {
     fn print(&self) { io::println(fmt!("%d", *self)) }
 }
 
-impl Printable for &str {
+impl &str: Printable {
     fn print(&self) { io::println(*self) }
 }
 
@@ -1966,7 +1966,7 @@ trait Seq<T> {
     fn iter(&self, b: fn(v: &T));
 }
 
-impl<T> Seq<T> for ~[T] {
+impl<T> ~[T]: Seq<T> {
     fn len(&self) -> uint { vec::len(*self) }
     fn iter(&self, b: fn(v: &T)) {
         for vec::each(*self) |elt| { b(elt); }
@@ -1978,7 +1978,7 @@ The implementation has to explicitly declare the type parameter that
 it binds, `T`, before using it to specify its trait type. Rust
 requires this declaration because the `impl` could also, for example,
 specify an implementation of `Seq<int>`. The trait type (appearing
-between `impl` and `for`) *refers* to a type, rather than
+after the colon in the `impl`) *refers* to a type, rather than
 defining one.
 
 The type parameters bound by a trait are in scope in each of the
@@ -2000,7 +2000,7 @@ trait Eq {
 }
 
 // In an impl, `self` refers just to the value of the receiver
-impl Eq for int {
+impl int: Eq {
     fn equals(&self, other: &int) -> bool { *other == *self }
 }
 ~~~~
@@ -2021,10 +2021,10 @@ trait Shape { static fn new(area: float) -> Self; }
 struct Circle { radius: float }
 struct Square { length: float }
 
-impl Shape for Circle {
+impl Circle: Shape {
     static fn new(area: float) -> Circle { Circle { radius: sqrt(area / pi) } }
 }
-impl Shape for Square {
+impl Square: Shape {
     static fn new(area: float) -> Square { Square { length: sqrt(area) } }
 }
 
@@ -2084,7 +2084,7 @@ However, consider this function:
 
 ~~~~
 # type Circle = int; type Rectangle = int;
-# impl Drawable for int { fn draw(&self) {} }
+# impl int: Drawable { fn draw(&self) {} }
 # fn new_circle() -> int { 1 }
 trait Drawable { fn draw(&self); }
 
@@ -2120,8 +2120,9 @@ value to an object:
 # fn new_rectangle() -> Rectangle { true }
 # fn draw_all(shapes: &[@Drawable]) {}
 
-impl Drawable for Circle { fn draw(&self) { ... } }
-impl Drawable for Rectangle { fn draw(&self) { ... } }
+impl Circle: Drawable { fn draw(&self) { ... } }
+
+impl Rectangle: Drawable { fn draw(&self) { ... } }
 
 let c: @Circle = @new_circle();
 let r: @Rectangle = @new_rectangle();
@@ -2139,7 +2140,7 @@ for example, an `@Circle` may not be cast to an `~Drawable`.
 ~~~
 # type Circle = int; type Rectangle = int;
 # trait Drawable { fn draw(&self); }
-# impl Drawable for int { fn draw(&self) {} }
+# impl int: Drawable { fn draw(&self) {} }
 # fn new_circle() -> int { 1 }
 # fn new_rectangle() -> int { 2 }
 // A managed object
@@ -2179,10 +2180,10 @@ Now, we can implement `Circle` on a type only if we also implement `Shape`.
 # use float::sqrt;
 # fn square(x: float) -> float { x * x }
 struct CircleStruct { center: Point, radius: float }
-impl Circle for CircleStruct {
+impl CircleStruct: Circle {
     fn radius(&self) -> float { sqrt(self.area() / pi) }
 }
-impl Shape for CircleStruct {
+impl CircleStruct: Shape {
     fn area(&self) -> float { pi * square(self.radius) }
 }   
 ~~~~
@@ -2214,8 +2215,8 @@ Likewise, supertrait methods may also be called on trait objects.
 # use float::sqrt;
 # struct Point { x: float, y: float }
 # struct CircleStruct { center: Point, radius: float }
-# impl Circle for CircleStruct { fn radius(&self) -> float { sqrt(self.area() / pi) } }
-# impl Shape for CircleStruct { fn area(&self) -> float { pi * square(self.radius) } }
+# impl CircleStruct: Circle { fn radius(&self) -> float { sqrt(self.area() / pi) } }
+# impl CircleStruct: Shape { fn area(&self) -> float { pi * square(self.radius) } }
 
 let concrete = @CircleStruct{center:Point{x:3f,y:4f},radius:5f};
 let mycircle: Circle = concrete as @Circle;

branches/dist-snap/src/libsyntax/parse/mod.rs

@@ -227,12 +227,11 @@ mod test {
     use super::*;
     use std::serialize::Encodable;
     use std;
-    use core::dvec;
     use core::str;
     use util::testing::*;
 
     #[test] fn to_json_str (val: Encodable<std::json::Encoder>) -> ~str {
-        let bw = @io::BytesWriter {bytes: dvec::DVec(), pos: 0};
+        let bw = @io::BytesWriter();
         val.encode(~std::json::Encoder(bw as io::Writer));
         str::from_bytes(bw.bytes.data)
     }

branches/dist-snap/src/libsyntax/parse/parser.rs

@@ -84,8 +84,6 @@ use print::pprust::expr_to_str;
 use util::interner::Interner;
 
 use core::cmp;
-use core::dvec::DVec;
-use core::dvec;
 use core::either::{Either, Left, Right};
 use core::either;
 use core::result::Result;
@@ -1323,11 +1321,11 @@ pub impl Parser {
     }
 
     fn parse_all_token_trees() -> ~[token_tree] {
-        let tts = DVec();
+        let mut tts = ~[];
         while self.token != token::EOF {
             tts.push(self.parse_token_tree());
         }
-        tts.get()
+        tts
     }
 
     fn parse_matchers() -> ~[matcher] {
@@ -3954,7 +3952,7 @@ pub impl Parser {
             VIEW_ITEMS_AND_ITEMS_ALLOWED | IMPORTS_AND_ITEMS_ALLOWED => false
         };
 
-        let (view_items, items, foreign_items) = (DVec(), DVec(), DVec());
+        let mut (view_items, items, foreign_items) = (~[], ~[], ~[]);
         loop {
             match self.parse_item_or_view_item(attrs, items_allowed,
                                                foreign_items_allowed,
@@ -3986,9 +3984,9 @@ pub impl Parser {
         }
 
         {attrs_remaining: attrs,
-         view_items: dvec::unwrap(move view_items),
-         items: dvec::unwrap(move items),
-         foreign_items: dvec::unwrap(move foreign_items)}
+         view_items: view_items,
+         items: items,
+         foreign_items: foreign_items}
     }
 
     // Parses a source module as a crate