---

yaml
---
r: 47066
b: refs/heads/try
c: 6956e81
h: refs/heads/master
v: v3

Author: thestinger

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 3bbcac322669cff3abde5be937cc4ec3860f3985
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d9689399d091c3265f00434a69c551a61c28dc
-refs/heads/try: baeac2f9ac0e64eefe22779d28a421c5f5eadb58
+refs/heads/try: 6956e81c9bda11ec480e63b217efd44b83974fd3
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/libcore/vec.rs

@@ -1865,6 +1865,7 @@ pub trait OwnedVector<T> {
     fn consume(self, f: fn(uint, v: T));
     fn filter(self, f: fn(t: &T) -> bool) -> ~[T];
     fn partition(self, f: pure fn(&T) -> bool) -> (~[T], ~[T]);
+    fn grow_fn(&mut self, n: uint, op: iter::InitOp<T>);
 }
 
 impl<T> OwnedVector<T> for ~[T] {
@@ -1936,6 +1937,11 @@ impl<T> OwnedVector<T> for ~[T] {
     fn partition(self, f: fn(&T) -> bool) -> (~[T], ~[T]) {
         partition(self, f)
     }
+
+    #[inline]
+    fn grow_fn(&mut self, n: uint, op: iter::InitOp<T>) {
+        grow_fn(self, n, op);
+    }
 }
 
 impl<T> Mutable for ~[T] {
@@ -1946,7 +1952,6 @@ impl<T> Mutable for ~[T] {
 pub trait OwnedCopyableVector<T: Copy> {
     fn push_all(&mut self, rhs: &[const T]);
     fn grow(&mut self, n: uint, initval: &T);
-    fn grow_fn(&mut self, n: uint, op: iter::InitOp<T>);
     fn grow_set(&mut self, index: uint, initval: &T, val: T);
 }
 
@@ -1961,11 +1966,6 @@ impl<T: Copy> OwnedCopyableVector<T> for ~[T] {
         grow(self, n, initval);
     }
 
-    #[inline]
-    fn grow_fn(&mut self, n: uint, op: iter::InitOp<T>) {
-        grow_fn(self, n, op);
-    }
-
     #[inline]
     fn grow_set(&mut self, index: uint, initval: &T, val: T) {
         grow_set(self, index, initval, val);

branches/try/src/libstd/deque.rs

@@ -100,7 +100,7 @@ fn grow<T>(nelts: uint, lo: uint, elts: &mut [Option<T>]) -> ~[Option<T>] {
     assert nelts == elts.len();
     let mut rv = ~[];
 
-    do vec::grow_fn(&mut rv, nelts + 1) |i| {
+    do rv.grow_fn(nelts + 1) |i| {
         let mut element = None;
         element <-> elts[(lo + i) % nelts];
         element

branches/try/src/libsyntax/ext/pipes/ast_builder.rs

@@ -67,68 +67,61 @@ pub impl append_types for @ast::path {
 }
 
 pub trait ext_ctxt_ast_builder {
-    fn ty_param(&self, id: ast::ident, +bounds: ~[ast::ty_param_bound])
+    fn ty_param(id: ast::ident, +bounds: ~[ast::ty_param_bound])
         -> ast::ty_param;
-    fn arg(&self, name: ident, ty: @ast::Ty) -> ast::arg;
-    fn expr_block(&self, e: @ast::expr) -> ast::blk;
-    fn fn_decl(&self, +inputs: ~[ast::arg], output: @ast::Ty) -> ast::fn_decl;
-    fn item(&self, name: ident, span: span, +node: ast::item_) -> @ast::item;
-    fn item_fn_poly(&self, name: ident,
+    fn arg(name: ident, ty: @ast::Ty) -> ast::arg;
+    fn expr_block(e: @ast::expr) -> ast::blk;
+    fn fn_decl(+inputs: ~[ast::arg], output: @ast::Ty) -> ast::fn_decl;
+    fn item(name: ident, span: span, +node: ast::item_) -> @ast::item;
+    fn item_fn_poly(name: ident,
                     +inputs: ~[ast::arg],
                     output: @ast::Ty,
                     +ty_params: ~[ast::ty_param],
                     +body: ast::blk) -> @ast::item;
-    fn item_fn(&self, name: ident,
+    fn item_fn(name: ident,
                +inputs: ~[ast::arg],
                output: @ast::Ty,
                +body: ast::blk) -> @ast::item;
-    fn item_enum_poly(&self, name: ident,
+    fn item_enum_poly(name: ident,
                       span: span,
                       +enum_definition: ast::enum_def,
                       +ty_params: ~[ast::ty_param]) -> @ast::item;
-    fn item_enum(&self, name: ident, span: span,
+    fn item_enum(name: ident, span: span,
                  +enum_definition: ast::enum_def) -> @ast::item;
-    fn item_struct_poly(&self, name: ident, span: span,
-                        struct_def: ast::struct_def,
-                        ty_params: ~[ast::ty_param]) -> @ast::item;
-    fn item_struct(&self, name: ident, span: span,
-                   struct_def: ast::struct_def) -> @ast::item;
-    fn struct_expr(&self, path: @ast::path,
-                   fields: ~[ast::field]) -> @ast::expr;
-    fn variant(&self, name: ident, span: span,
-               +tys: ~[@ast::Ty]) -> ast::variant;
-    fn item_mod(&self, name: ident, span: span,
-                +items: ~[@ast::item]) -> @ast::item;
-    fn ty_path_ast_builder(&self, path: @ast::path) -> @ast::Ty;
-    fn item_ty_poly(&self, name: ident,
+    fn variant(name: ident, span: span, +tys: ~[@ast::Ty]) -> ast::variant;
+    fn item_mod(name: ident, span: span, +items: ~[@ast::item]) -> @ast::item;
+    fn ty_path_ast_builder(path: @ast::path) -> @ast::Ty;
+    fn item_ty_poly(name: ident,
                     span: span,
                     ty: @ast::Ty,
                     +params: ~[ast::ty_param]) -> @ast::item;
-    fn item_ty(&self, name: ident, span: span, ty: @ast::Ty) -> @ast::item;
-    fn ty_vars(&self, +ty_params: ~[ast::ty_param]) -> ~[@ast::Ty];
-    fn ty_vars_global(&self, +ty_params: ~[ast::ty_param]) -> ~[@ast::Ty];
-    fn ty_field_imm(&self, name: ident, ty: @ast::Ty) -> ast::ty_field;
-    fn field_imm(&self, name: ident, e: @ast::expr) -> ast::field;
-    fn block(&self, +stmts: ~[@ast::stmt], e: @ast::expr) -> ast::blk;
-    fn stmt_let(&self, ident: ident, e: @ast::expr) -> @ast::stmt;
-    fn stmt_expr(&self, e: @ast::expr) -> @ast::stmt;
-    fn block_expr(&self, b: ast::blk) -> @ast::expr;
-    fn ty_option(&self, ty: @ast::Ty) -> @ast::Ty;
-    fn ty_infer(&self) -> @ast::Ty;
-    fn ty_nil_ast_builder(&self) -> @ast::Ty;
-    fn strip_bounds(&self, bounds: &[ast::ty_param]) -> ~[ast::ty_param];
+    fn item_ty(name: ident, span: span, ty: @ast::Ty) -> @ast::item;
+    fn ty_vars(+ty_params: ~[ast::ty_param]) -> ~[@ast::Ty];
+    fn ty_vars_global(+ty_params: ~[ast::ty_param]) -> ~[@ast::Ty];
+    fn ty_field_imm(name: ident, ty: @ast::Ty) -> ast::ty_field;
+    fn ty_rec(+v: ~[ast::ty_field]) -> @ast::Ty;
+    fn field_imm(name: ident, e: @ast::expr) -> ast::field;
+    fn rec(+v: ~[ast::field]) -> @ast::expr;
+    fn block(+stmts: ~[@ast::stmt], e: @ast::expr) -> ast::blk;
+    fn stmt_let(ident: ident, e: @ast::expr) -> @ast::stmt;
+    fn stmt_expr(e: @ast::expr) -> @ast::stmt;
+    fn block_expr(b: ast::blk) -> @ast::expr;
+    fn ty_option(ty: @ast::Ty) -> @ast::Ty;
+    fn ty_infer() -> @ast::Ty;
+    fn ty_nil_ast_builder() -> @ast::Ty;
+    fn strip_bounds(bounds: &[ast::ty_param]) -> ~[ast::ty_param];
 }
 
 pub impl ext_ctxt_ast_builder for ext_ctxt {
-    fn ty_option(&self, ty: @ast::Ty) -> @ast::Ty {
+    fn ty_option(ty: @ast::Ty) -> @ast::Ty {
         self.ty_path_ast_builder(path_global(~[
             self.ident_of(~"core"),
             self.ident_of(~"option"),
             self.ident_of(~"Option")
         ], dummy_sp()).add_ty(ty))
     }
 
-    fn block_expr(&self, b: ast::blk) -> @ast::expr {
+    fn block_expr(b: ast::blk) -> @ast::expr {
         @expr {
             id: self.next_id(),
             callee_id: self.next_id(),
@@ -137,24 +130,33 @@ pub impl ext_ctxt_ast_builder for ext_ctxt {
         }
     }
 
-    fn stmt_expr(&self, e: @ast::expr) -> @ast::stmt {
+    fn stmt_expr(e: @ast::expr) -> @ast::stmt {
         @spanned { node: ast::stmt_expr(e, self.next_id()),
                    span: dummy_sp()}
     }
 
-    fn stmt_let(&self, ident: ident, e: @ast::expr) -> @ast::stmt {
-        let ext_cx = *self;
+    fn stmt_let(ident: ident, e: @ast::expr) -> @ast::stmt {
+        let ext_cx = self;
         quote_stmt!( let $ident = $e; )
     }
 
-    fn field_imm(&self, name: ident, e: @ast::expr) -> ast::field {
+    fn field_imm(name: ident, e: @ast::expr) -> ast::field {
         spanned {
             node: ast::field_ { mutbl: ast::m_imm, ident: name, expr: e },
             span: dummy_sp(),
         }
     }
 
-    fn ty_field_imm(&self, name: ident, ty: @ast::Ty) -> ast::ty_field {
+    fn rec(+fields: ~[ast::field]) -> @ast::expr {
+        @expr {
+            id: self.next_id(),
+            callee_id: self.next_id(),
+            node: ast::expr_rec(fields, None),
+            span: dummy_sp(),
+        }
+    }
+
+    fn ty_field_imm(name: ident, ty: @ast::Ty) -> ast::ty_field {
         spanned {
             node: ast::ty_field_ {
                 ident: name,
@@ -164,21 +166,29 @@ pub impl ext_ctxt_ast_builder for ext_ctxt {
         }
     }
 
-    fn ty_infer(&self) -> @ast::Ty {
+    fn ty_rec(+fields: ~[ast::ty_field]) -> @ast::Ty {
+        @ast::Ty {
+            id: self.next_id(),
+            node: ast::ty_rec(fields),
+            span: dummy_sp(),
+        }
+    }
+
+    fn ty_infer() -> @ast::Ty {
         @ast::Ty {
             id: self.next_id(),
             node: ast::ty_infer,
             span: dummy_sp(),
         }
     }
 
-    fn ty_param(&self, id: ast::ident, +bounds: ~[ast::ty_param_bound])
+    fn ty_param(id: ast::ident, +bounds: ~[ast::ty_param_bound])
         -> ast::ty_param
     {
         ast::ty_param { ident: id, id: self.next_id(), bounds: @bounds }
     }
 
-    fn arg(&self, name: ident, ty: @ast::Ty) -> ast::arg {
+    fn arg(name: ident, ty: @ast::Ty) -> ast::arg {
         ast::arg {
             mode: ast::infer(self.next_id()),
             is_mutbl: false,
@@ -195,7 +205,7 @@ pub impl ext_ctxt_ast_builder for ext_ctxt {
         }
     }
 
-    fn block(&self, +stmts: ~[@ast::stmt], e: @ast::expr) -> ast::blk {
+    fn block(+stmts: ~[@ast::stmt], e: @ast::expr) -> ast::blk {
         let blk = ast::blk_ {
             view_items: ~[],
             stmts: stmts,
@@ -207,11 +217,11 @@ pub impl ext_ctxt_ast_builder for ext_ctxt {
         spanned { node: blk, span: dummy_sp() }
     }
 
-    fn expr_block(&self, e: @ast::expr) -> ast::blk {
+    fn expr_block(e: @ast::expr) -> ast::blk {
         self.block(~[], e)
     }
 
-    fn fn_decl(&self, +inputs: ~[ast::arg],
+    fn fn_decl(+inputs: ~[ast::arg],
                output: @ast::Ty) -> ast::fn_decl {
         ast::fn_decl {
             inputs: inputs,
@@ -220,7 +230,8 @@ pub impl ext_ctxt_ast_builder for ext_ctxt {
         }
     }
 
-    fn item(&self, name: ident, span: span,
+    fn item(name: ident,
+            span: span,
             +node: ast::item_) -> @ast::item {
 
         // XXX: Would be nice if our generated code didn't violate
@@ -243,7 +254,7 @@ pub impl ext_ctxt_ast_builder for ext_ctxt {
                      span: span }
     }
 
-    fn item_fn_poly(&self, name: ident,
+    fn item_fn_poly(name: ident,
                     +inputs: ~[ast::arg],
                     output: @ast::Ty,
                     +ty_params: ~[ast::ty_param],
@@ -256,46 +267,27 @@ pub impl ext_ctxt_ast_builder for ext_ctxt {
                                body))
     }
 
-    fn item_fn(&self, name: ident,
+    fn item_fn(name: ident,
                +inputs: ~[ast::arg],
                output: @ast::Ty,
                +body: ast::blk) -> @ast::item {
         self.item_fn_poly(name, inputs, output, ~[], body)
     }
 
-    fn item_enum_poly(&self, name: ident, span: span,
+    fn item_enum_poly(name: ident,
+                      span: span,
                       +enum_definition: ast::enum_def,
                       +ty_params: ~[ast::ty_param]) -> @ast::item {
         self.item(name, span, ast::item_enum(enum_definition, ty_params))
     }
 
-    fn item_enum(&self, name: ident, span: span,
+    fn item_enum(name: ident, span: span,
                  +enum_definition: ast::enum_def) -> @ast::item {
         self.item_enum_poly(name, span, enum_definition, ~[])
     }
 
-    fn item_struct(&self, name: ident, span: span,
-                   struct_def: ast::struct_def) -> @ast::item {
-        self.item_struct_poly(name, span, struct_def, ~[])
-    }
-
-    fn item_struct_poly(&self, name: ident, span: span,
-                        struct_def: ast::struct_def,
-                        ty_params: ~[ast::ty_param]) -> @ast::item {
-        self.item(name, span, ast::item_struct(@struct_def, ty_params))
-    }
-
-    fn struct_expr(&self, path: @ast::path,
-                   fields: ~[ast::field]) -> @ast::expr {
-        @ast::expr {
-            id: self.next_id(),
-            callee_id: self.next_id(),
-            node: ast::expr_struct(path, fields, None),
-            span: dummy_sp()
-        }
-    }
-
-    fn variant(&self, name: ident, span: span,
+    fn variant(name: ident,
+               span: span,
                +tys: ~[@ast::Ty]) -> ast::variant {
         let args = do tys.map |ty| {
             ast::variant_arg { ty: *ty, id: self.next_id() }
@@ -308,15 +300,14 @@ pub impl ext_ctxt_ast_builder for ext_ctxt {
                 kind: ast::tuple_variant_kind(args),
                 id: self.next_id(),
                 disr_expr: None,
-                vis: ast::public
-            },
+                vis: ast::public},
             span: span,
         }
     }
 
-    fn item_mod(&self, name: ident, span: span,
+    fn item_mod(name: ident,
+                span: span,
                 +items: ~[@ast::item]) -> @ast::item {
-
         // XXX: Total hack: import `core::kinds::Owned` to work around a
         // parser bug whereby `fn f<T: ::kinds::Owned>` doesn't parse.
         let vi = ast::view_item_import(~[
@@ -354,43 +345,45 @@ pub impl ext_ctxt_ast_builder for ext_ctxt {
         )
     }
 
-    fn ty_path_ast_builder(&self, path: @ast::path) -> @ast::Ty {
+    fn ty_path_ast_builder(path: @ast::path) -> @ast::Ty {
         @ast::Ty {
             id: self.next_id(),
             node: ast::ty_path(path, self.next_id()),
             span: path.span,
         }
     }
 
-    fn ty_nil_ast_builder(&self) -> @ast::Ty {
+    fn ty_nil_ast_builder() -> @ast::Ty {
         @ast::Ty {
             id: self.next_id(),
             node: ast::ty_nil,
             span: dummy_sp(),
         }
     }
 
-    fn strip_bounds(&self, bounds: &[ast::ty_param]) -> ~[ast::ty_param] {
+    fn strip_bounds(bounds: &[ast::ty_param]) -> ~[ast::ty_param] {
         do bounds.map |ty_param| {
             ast::ty_param { bounds: @~[], ..copy *ty_param }
         }
     }
 
-    fn item_ty_poly(&self, name: ident, span: span, ty: @ast::Ty,
+    fn item_ty_poly(name: ident,
+                    span: span,
+                    ty: @ast::Ty,
                     +params: ~[ast::ty_param]) -> @ast::item {
         self.item(name, span, ast::item_ty(ty, params))
     }
 
-    fn item_ty(&self, name: ident, span: span, ty: @ast::Ty) -> @ast::item {
+    fn item_ty(name: ident, span: span, ty: @ast::Ty) -> @ast::item {
         self.item_ty_poly(name, span, ty, ~[])
     }
 
-    fn ty_vars(&self, +ty_params: ~[ast::ty_param]) -> ~[@ast::Ty] {
+    fn ty_vars(+ty_params: ~[ast::ty_param]) -> ~[@ast::Ty] {
         ty_params.map(|p| self.ty_path_ast_builder(
             path(~[p.ident], dummy_sp())))
     }
 
-    fn ty_vars_global(&self, +ty_params: ~[ast::ty_param]) -> ~[@ast::Ty] {
+    fn ty_vars_global(+ty_params: ~[ast::ty_param]) -> ~[@ast::Ty] {
         ty_params.map(|p| self.ty_path_ast_builder(
             path(~[p.ident], dummy_sp())))
     }