Remove 'with'

Author: brson

doc/rust.md

@@ -1595,9 +1595,9 @@ The order of the fields in a record expression is significant, and
 determines the type of the resulting value. `{a: u8, b: u8}` and `{b:
 u8, a: u8}` are two different fields.
 
-A record expression can terminate with the word `with` followed by an
+A record expression can terminate with the syntax `..` followed by an
 expression to denote a functional update. The expression following
-`with` (the base) must be of a record type that includes at least all the
+`..` (the base) must be of a record type that includes at least all the
 fields mentioned in the record expression. A new record will be
 created, of the same type as the base expression, with the given
 values for the fields that were explicitly specified, and the values
@@ -1606,7 +1606,7 @@ such a record expression is not significant.
 
 ~~~~
 let base = {x: 1, y: 2, z: 3};
-{y: 0, z: 10 with base};
+{y: 0, z: 10, .. base};
 ~~~~
 
 ### Field expressions

src/cargo/cargo.rs

@@ -362,7 +362,7 @@ fn load_crate(filename: &Path) -> Option<crate> {
     let v = visit::mk_simple_visitor(@{
         visit_view_item: |a| goto_view_item(sess, e, a),
         visit_item: |a| goto_item(e, a),
-        with *visit::default_simple_visitor()
+        .. *visit::default_simple_visitor()
     });
 
     visit::visit_crate(*c, (), v);

src/fuzzer/fuzzer.rs

@@ -132,8 +132,8 @@ fn steal(crate: ast::crate, tm: test_mode) -> stolen_stuff {
     let tys = @mut ~[];
     let v = visit::mk_simple_visitor(@{
         visit_expr: |a| stash_expr_if(safe_to_steal_expr, exprs, a, tm),
-        visit_ty: |a| stash_ty_if(safe_to_steal_ty, tys, a, tm)
-        with *visit::default_simple_visitor()
+        visit_ty: |a| stash_ty_if(safe_to_steal_ty, tys, a, tm),
+        .. *visit::default_simple_visitor()
     });
     visit::visit_crate(crate, (), v);
     {exprs: *exprs, tys: *tys}
@@ -182,8 +182,8 @@ fn replace_expr_in_crate(crate: ast::crate, i: uint,
     let afp = @{
         fold_expr: fold::wrap(|a,b| {
             fold_expr_rep(j, i, newexpr.node, a, b, tm)
-        })
-        with *fold::default_ast_fold()
+        }),
+        .. *fold::default_ast_fold()
     };
     let af = fold::make_fold(afp);
     let crate2: @ast::crate = @af.fold_crate(crate);
@@ -205,8 +205,8 @@ fn replace_ty_in_crate(crate: ast::crate, i: uint, newty: ast::ty,
         } else { fold::noop_fold_ty(original, fld) }
     }
     let afp = @{
-        fold_ty: fold::wrap(|a,b| fold_ty_rep(j, i, newty.node, a, b, tm) )
-        with *fold::default_ast_fold()
+        fold_ty: fold::wrap(|a,b| fold_ty_rep(j, i, newty.node, a, b, tm) ),
+        .. *fold::default_ast_fold()
     };
     let af = fold::make_fold(afp);
     let crate2: @ast::crate = @af.fold_crate(crate);
@@ -452,8 +452,8 @@ fn has_raw_pointers(c: ast::crate) -> bool {
         }
     }
     let v =
-        visit::mk_simple_visitor(@{visit_ty: |a| visit_ty(has_rp, a)
-                                      with *visit::default_simple_visitor()});
+        visit::mk_simple_visitor(@{visit_ty: |a| visit_ty(has_rp, a),
+                                      .. *visit::default_simple_visitor()});
     visit::visit_crate(c, (), v);
     return *has_rp;
 }

src/libcore/task.rs

@@ -247,7 +247,7 @@ priv impl TaskBuilder {
             fail ~"Cannot copy a task_builder"; // Fake move mode on self
         }
         self.consumed = true;
-        TaskBuilder({ can_not_copy: None, mut consumed: false, with *self })
+        TaskBuilder({ can_not_copy: None, mut consumed: false,.. *self })
     }
 }
 
@@ -258,9 +258,9 @@ impl TaskBuilder {
      */
     fn unlinked() -> TaskBuilder {
         TaskBuilder({
-            opts: { linked: false with self.opts },
+            opts: { linked: false,.. self.opts },
             can_not_copy: None,
-            with *self.consume()
+            .. *self.consume()
         })
     }
     /**
@@ -270,9 +270,9 @@ impl TaskBuilder {
      */
     fn supervised() -> TaskBuilder {
         TaskBuilder({
-            opts: { linked: false, supervised: true with self.opts },
+            opts: { linked: false, supervised: true,.. self.opts },
             can_not_copy: None,
-            with *self.consume()
+            .. *self.consume()
         })
     }
     /**
@@ -281,9 +281,9 @@ impl TaskBuilder {
      */
     fn linked() -> TaskBuilder {
         TaskBuilder({
-            opts: { linked: true, supervised: false with self.opts },
+            opts: { linked: true, supervised: false,.. self.opts },
             can_not_copy: None,
-            with *self.consume()
+            .. *self.consume()
         })
     }
 
@@ -326,18 +326,18 @@ impl TaskBuilder {
 
         // Reconfigure self to use a notify channel.
         TaskBuilder({
-            opts: { notify_chan: Some(ch) with self.opts },
+            opts: { notify_chan: Some(ch),.. self.opts },
             can_not_copy: None,
-            with *self.consume()
+            .. *self.consume()
         })
     }
     /// Configure a custom scheduler mode for the task.
     fn sched_mode(mode: SchedMode) -> TaskBuilder {
         TaskBuilder({
-            opts: { sched: Some({ mode: mode, foreign_stack_size: None})
-                    with self.opts },
+            opts: { sched: Some({ mode: mode, foreign_stack_size: None}),
+                    .. self.opts },
             can_not_copy: None,
-            with *self.consume()
+            .. *self.consume()
         })
     }
 
@@ -358,7 +358,7 @@ impl TaskBuilder {
         TaskBuilder({
             gen_body: |body| { wrapper(prev_gen_body(body)) },
             can_not_copy: None,
-            with *self.consume()
+            .. *self.consume()
         })
     }
 
@@ -1560,8 +1560,8 @@ fn test_spawn_raw_simple() {
 #[ignore(cfg(windows))]
 fn test_spawn_raw_unsupervise() {
     let opts = {
-        linked: false
-        with default_task_opts()
+        linked: false,
+        .. default_task_opts()
     };
     do spawn_raw(opts) {
         fail;
@@ -1623,9 +1623,9 @@ fn test_spawn_linked_sup_fail_up() { // child fails; parent fails
     // they don't make sense (redundant with task().supervised()).
     let b0 = task();
     let b1 = TaskBuilder({
-        opts: { linked: true, supervised: true with b0.opts },
+        opts: { linked: true, supervised: true,.. b0.opts },
         can_not_copy: None,
-        with *b0
+        .. *b0
     });
     do b1.spawn { fail; }
     comm::recv(po); // We should get punted awake
@@ -1636,9 +1636,9 @@ fn test_spawn_linked_sup_fail_down() { // parent fails; child fails
     // they don't make sense (redundant with task().supervised()).
     let b0 = task();
     let b1 = TaskBuilder({
-        opts: { linked: true, supervised: true with b0.opts },
+        opts: { linked: true, supervised: true,.. b0.opts },
         can_not_copy: None,
-        with *b0
+        .. *b0
     });
     do b1.spawn { loop { task::yield(); } }
     fail; // *both* mechanisms would be wrong if this didn't kill the child...
@@ -1724,8 +1724,8 @@ fn test_spawn_raw_notify() {
     let notify_ch = comm::Chan(notify_po);
 
     let opts = {
-        notify_chan: Some(notify_ch)
-        with default_task_opts()
+        notify_chan: Some(notify_ch),
+        .. default_task_opts()
     };
     do spawn_raw(opts) {
         comm::send(task_ch, get_task());
@@ -1735,8 +1735,8 @@ fn test_spawn_raw_notify() {
 
     let opts = {
         linked: false,
-        notify_chan: Some(notify_ch)
-        with default_task_opts()
+        notify_chan: Some(notify_ch),
+        .. default_task_opts()
     };
     do spawn_raw(opts) {
         comm::send(task_ch, get_task());
@@ -2042,7 +2042,7 @@ fn test_unkillable() {
     let ch = po.chan();
 
     // We want to do this after failing
-    do spawn_raw({ linked: false with default_task_opts() }) {
+    do spawn_raw({ linked: false,.. default_task_opts() }) {
         for iter::repeat(10u) { yield() }
         ch.send(());
     }
@@ -2078,7 +2078,7 @@ fn test_unkillable_nested() {
     let ch = po.chan();
 
     // We want to do this after failing
-    do spawn_raw({ linked: false with default_task_opts() }) {
+    do spawn_raw({ linked: false,.. default_task_opts() }) {
         for iter::repeat(10u) { yield() }
         ch.send(());
     }

src/libsyntax/ast_map.rs

@@ -96,8 +96,8 @@ fn mk_ast_map_visitor() -> vt {
         visit_local: map_local,
         visit_arm: map_arm,
         visit_view_item: map_view_item,
-        visit_block: map_block
-        with *visit::default_visitor()
+        visit_block: map_block,
+        .. *visit::default_visitor()
     });
 }
 

src/libsyntax/ext/auto_serialize.rs

@@ -96,8 +96,8 @@ fn expand(cx: ext_ctxt,
     }
 
     fn filter_attrs(item: @ast::item) -> @ast::item {
-        @{attrs: vec::filter(item.attrs, not_auto_serialize)
-          with *item}
+        @{attrs: vec::filter(item.attrs, not_auto_serialize),
+          .. *item}
     }
 
     do vec::flat_map(in_items) |in_item| {
@@ -281,8 +281,8 @@ impl ext_ctxt: ext_ctxt_helpers {
 
     fn clone_folder() -> fold::ast_fold {
         fold::make_fold(@{
-            new_id: |_id| self.next_id()
-            with *fold::default_ast_fold()
+            new_id: |_id| self.next_id(),
+            .. *fold::default_ast_fold()
         })
     }
 
@@ -311,8 +311,8 @@ impl ext_ctxt: ext_ctxt_helpers {
         }
 
         let fld = fold::make_fold(@{
-            new_span: |a| repl_sp(a, ast_util::dummy_sp(), span)
-            with *fold::default_ast_fold()
+            new_span: |a| repl_sp(a, ast_util::dummy_sp(), span),
+            .. *fold::default_ast_fold()
         });
 
         fld.fold_expr(expr)
@@ -799,8 +799,8 @@ fn mk_deser_fn(cx: ext_ctxt, span: span,
                     vec::map(tps, |tp| {
                         let cloned = cx.clone_ty_param(tp);
                         {bounds: @(vec::append(*cloned.bounds,
-                                               ~[ast::bound_copy]))
-                         with cloned}
+                                               ~[ast::bound_copy])),
+                         .. cloned}
                     }));
 
     let deser_blk = cx.expr_blk(f(cx, tps_map, #ast[expr]{__d}));

src/libsyntax/ext/expand.rs

@@ -160,7 +160,7 @@ fn expand_mod_items(exts: hashmap<~str, syntax_extension>, cx: ext_ctxt,
         }
     };
 
-    return {items: new_items with module_};
+    return {items: new_items,.. module_};
 }
 
 
@@ -259,8 +259,8 @@ fn expand_crate(parse_sess: parse::parse_sess,
         @{fold_expr: |a,b,c| expand_expr(exts, cx, a, b, c, afp.fold_expr),
           fold_mod: |a,b| expand_mod_items(exts, cx, a, b, afp.fold_mod),
           fold_item: |a,b| expand_item(exts, cx, a, b, afp.fold_item),
-          new_span: |a|new_span(cx, a)
-          with *afp};
+          new_span: |a|new_span(cx, a),
+          .. *afp};
     let f = make_fold(f_pre);
     let cm = parse_expr_from_source_str(~"<core-macros>",
                                         @core_macros(),

src/libsyntax/ext/pipes/ast_builder.rs

@@ -35,13 +35,13 @@ trait append_types {
 
 impl @ast::path: append_types {
     fn add_ty(ty: @ast::ty) -> @ast::path {
-        @{types: vec::append_one(self.types, ty)
-          with *self}
+        @{types: vec::append_one(self.types, ty),
+          .. *self}
     }
 
     fn add_tys(+tys: ~[@ast::ty]) -> @ast::path {
-        @{types: vec::append(self.types, tys)
-          with *self}
+        @{types: vec::append(self.types, tys),
+          .. *self}
     }
 }
 

src/libsyntax/ext/qquote.rs

@@ -117,8 +117,8 @@ impl @ast::pat: qq_helper {
 fn gather_anti_quotes<N: qq_helper>(lo: uint, node: N) -> aq_ctxt
 {
     let v = @{visit_expr: |node, &&cx, v| visit_aq(node, ~"from_expr", cx, v),
-              visit_ty: |node, &&cx, v| visit_aq(node, ~"from_ty", cx, v)
-              with *default_visitor()};
+              visit_ty: |node, &&cx, v| visit_aq(node, ~"from_ty", cx, v),
+              .. *default_visitor()};
     let cx = @{lo:lo, gather: DVec()};
     node.visit(cx, mk_vt(v));
     // FIXME (#2250): Maybe this is an overkill (merge_sort), it might
@@ -301,8 +301,8 @@ fn replace<T>(node: T, repls: ~[fragment], ff: fn (ast_fold, T) -> T)
     let f_pre = @{fold_expr: |a,b,c|replace_expr(repls, a, b, c,
                                                   aft.fold_expr),
                   fold_ty: |a,b,c|replace_ty(repls, a, b, c,
-                                              aft.fold_ty)
-                  with *aft};
+                                              aft.fold_ty),
+                  .. *aft};
     return ff(make_fold(f_pre), node);
 }
 fn fold_crate(f: ast_fold, &&n: @ast::crate) -> @ast::crate {

src/libsyntax/ext/simplext.rs

@@ -196,8 +196,8 @@ fn transcribe(cx: ext_ctxt, b: bindings, body: @expr) -> @expr {
           map_exprs: |x,y|
               transcribe_exprs(cx, b, idx_path, x, y)
           ,
-          new_id: |x|new_id(x, cx)
-          with *afp};
+          new_id: |x|new_id(x, cx),
+          .. *afp};
     let f = make_fold(f_pre);
     let result = f.fold_expr(body);
     return result;
@@ -246,8 +246,8 @@ fn free_vars(b: bindings, e: @expr, it: fn(ident)) {
     // using fold is a hack: we want visit, but it doesn't hit idents ) :
     // solve this with macros
     let f_pre =
-        @{fold_ident: |x,y|mark_ident(x, y, b, idents)
-          with *default_ast_fold()};
+        @{fold_ident: |x,y|mark_ident(x, y, b, idents),
+          .. *default_ast_fold()};
     let f = make_fold(f_pre);
     f.fold_expr(e); // ignore result
     for idents.each_key |x| { it(x); };