mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove 'with'

Browse Source
This commit is contained in:
Brian Anderson 2012-09-04 13:29:32 -07:00
parent ef880f2245
commit 200959d7ce
77 changed files with 404 additions and 419 deletions

6
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

2
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);

16
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;
}

50
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(());
}

4
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()
});
}

16
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}));

6
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(),

8
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}
}
}

8
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 {

8
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); };

24
src/libsyntax/fold.rs

@ -278,10 +278,10 @@ fn fold_struct_def(struct_def: @ast::struct_def, fld: ast_fold)
node: {
body: fld.fold_block(constructor.node.body),
dec: fold_fn_decl(constructor.node.dec, fld),
id: fld.new_id(constructor.node.id)
with constructor.node
}
with constructor
id: fld.new_id(constructor.node.id),
.. constructor.node
},
.. constructor
});
}
}
@ -289,8 +289,8 @@ fn fold_struct_def(struct_def: @ast::struct_def, fld: ast_fold)
let dtor_body = fld.fold_block(dtor.node.body);
let dtor_id = fld.new_id(dtor.node.id);
{node: {body: dtor_body,
id: dtor_id with dtor.node}
with dtor}};
id: dtor_id,.. dtor.node},
.. dtor}};
return @{
traits: vec::map(struct_def.traits, |p| fold_trait_ref(p, fld)),
fields: vec::map(struct_def.fields, |f| fold_struct_field(f, fld)),
@ -467,14 +467,14 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
expr_fn(proto, fold_fn_decl(decl, fld),
fld.fold_block(body),
@((*captures).map(|cap_item| {
@({id: fld.new_id((*cap_item).id)
with *cap_item})})))
@({id: fld.new_id((*cap_item).id),
.. *cap_item})})))
}
expr_fn_block(decl, body, captures) => {
expr_fn_block(fold_fn_decl(decl, fld), fld.fold_block(body),
@((*captures).map(|cap_item| {
@({id: fld.new_id((*cap_item).id)
with *cap_item})})))
@({id: fld.new_id((*cap_item).id),
.. *cap_item})})))
}
expr_block(blk) => expr_block(fld.fold_block(blk)),
expr_move(el, er) => {
@ -575,8 +575,8 @@ fn noop_fold_variant(v: variant_, fld: ast_fold) -> variant_ {
let dtor_body = fld.fold_block(dtor.node.body);
let dtor_id = fld.new_id(dtor.node.id);
{node: {body: dtor_body,
id: dtor_id with dtor.node}
with dtor}};
id: dtor_id,.. dtor.node},
.. dtor}};
kind = struct_variant_kind(@{
traits: ~[],
fields: vec::map(struct_def.fields,

30
src/libsyntax/parse/parser.rs

@ -776,7 +776,7 @@ struct parser {
return @{span: mk_sp(lo, tps.span.hi),
rp: rp,
types: tps.node with *path};
types: tps.node,.. *path};
}
fn parse_mutability() -> mutability {
@ -1000,11 +1000,9 @@ struct parser {
self.bump();
let mut fields = ~[];
vec::push(fields, self.parse_field(token::COLON));
while self.token != token::RBRACE &&
!self.is_keyword(~"with") {
while self.token != token::RBRACE {
self.expect(token::COMMA);
if self.token == token::RBRACE ||
self.is_keyword(~"with") ||
self.token == token::DOTDOT {
// Accept an optional trailing comma.
break;
@ -1013,7 +1011,7 @@ struct parser {
}
let base;
if self.eat_keyword(~"with") || self.eat(token::DOTDOT) {
if self.eat(token::DOTDOT) {
base = Some(self.parse_expr());
} else {
base = None;
@ -1572,8 +1570,8 @@ struct parser {
let last_arg = self.mk_expr(block.span.lo, block.span.hi,
ctor(block));
let args = vec::append(args, ~[last_arg]);
@{node: expr_call(f, args, true)
with *e}
@{node: expr_call(f, args, true),
.. *e}
}
expr_path(*) | expr_field(*) | expr_call(*) => {
let block = self.parse_lambda_block_expr();
@ -1661,18 +1659,6 @@ struct parser {
base = Some(self.parse_expr()); break;
}
// XXX: Remove "with" after all code is converted over and there's
// a snapshot.
// optional comma before "with"
if self.token == token::COMMA
&& self.token_is_keyword(~"with",
self.look_ahead(1u)) {
self.bump();
}
if self.eat_keyword(~"with") {
base = Some(self.parse_expr()); break;
}
self.expect(token::COMMA);
if self.token == token::RBRACE {
// record ends by an optional trailing comma
@ -2230,7 +2216,7 @@ struct parser {
token::SEMI => {
self.bump();
push(stmts,
@{node: stmt_semi(e, stmt_id) with *stmt});
@{node: stmt_semi(e, stmt_id),.. *stmt});
}
token::RBRACE => {
expr = Some(e);
@ -2741,8 +2727,8 @@ struct parser {
let lo = self.last_span.lo;
let (decl_, _) = self.parse_fn_decl(|p| p.parse_arg());
let decl = {output: @{id: self.get_id(),
node: result_ty, span: decl_.output.span}
with decl_};
node: result_ty, span: decl_.output.span},
.. decl_};
let body = self.parse_block();
ctor_decl(decl, attrs, body, mk_sp(lo, self.last_span.hi))
}

3
src/libsyntax/parse/token.rs

@ -388,8 +388,7 @@ fn contextual_keyword_table() -> hashmap<~str, ()> {
~"move",
~"priv", ~"pub",
~"self", ~"send", ~"static",
~"use",
~"with"
~"use"
];
for keys.each |word| {
words.insert(word, ());

4
src/rustc/front/config.rs

@ -26,8 +26,8 @@ fn strip_items(crate: @ast::crate, in_cfg: in_cfg_pred)
let precursor =
@{fold_mod: |a,b| fold_mod(ctxt, a, b),
fold_block: fold::wrap(|a,b| fold_block(ctxt, a, b) ),
fold_foreign_mod: |a,b| fold_foreign_mod(ctxt, a, b)
with *fold::default_ast_fold()};
fold_foreign_mod: |a,b| fold_foreign_mod(ctxt, a, b),
.. *fold::default_ast_fold()};
let fold = fold::make_fold(precursor);
let res = @fold.fold_crate(*crate);

4
src/rustc/front/core_inject.rs

@ -44,6 +44,6 @@ fn inject_libcore_ref(sess: session,
let vis = vec::append(~[vi1, vi2], crate.node.module.view_items);
return @{node: {module: { view_items: vis with crate.node.module }
with crate.node} with *crate }
return @{node: {module: { view_items: vis,.. crate.node.module },
.. crate.node},.. *crate }
}

4
src/rustc/front/intrinsic_inject.rs

@ -24,6 +24,6 @@ fn inject_intrinsic(sess: session,
let items = vec::append(~[item], crate.node.module.items);
return @{node: {module: { items: items with crate.node.module }
with crate.node} with *crate }
return @{node: {module: { items: items ,.. crate.node.module }
,.. crate.node} ,.. *crate }
}

6
src/rustc/front/test.rs

@ -47,7 +47,7 @@ fn generate_test_harness(sess: session::session,
let precursor =
@{fold_crate: fold::wrap(|a,b| fold_crate(cx, a, b) ),
fold_item: |a,b| fold_item(cx, a, b),
fold_mod: |a,b| fold_mod(cx, a, b) with *fold::default_ast_fold()};
fold_mod: |a,b| fold_mod(cx, a, b),.. *fold::default_ast_fold()};
let fold = fold::make_fold(precursor);
let res = @fold.fold_crate(*crate);
@ -92,7 +92,7 @@ fn fold_crate(cx: test_ctxt, c: ast::crate_, fld: fold::ast_fold) ->
// Add a special __test module to the crate that will contain code
// generated for the test harness
return {module: add_test_module(cx, folded.module) with folded};
return {module: add_test_module(cx, folded.module),.. folded};
}
@ -166,7 +166,7 @@ fn should_fail(i: @ast::item) -> bool {
fn add_test_module(cx: test_ctxt, m: ast::_mod) -> ast::_mod {
let testmod = mk_test_module(cx);
return {items: vec::append_one(m.items, testmod) with m};
return {items: vec::append_one(m.items, testmod),.. m};
}
/*

2
src/rustc/metadata/creader.rs

@ -31,7 +31,7 @@ fn read_crates(diag: span_handler, crate: ast::crate,
visit::mk_simple_visitor(@{visit_view_item:
|a| visit_view_item(e, a),
visit_item: |a| visit_item(e, a)
with *visit::default_simple_visitor()});
,.. *visit::default_simple_visitor()});
visit::visit_crate(crate, (), v);
dump_crates(e.crate_cache);
warn_if_multiple_versions(e, diag, e.crate_cache.get());

2
src/rustc/metadata/encoder.rs

@ -858,7 +858,7 @@ fn encode_info_for_items(ecx: @encode_ctxt, ebml_w: ebml::Writer,
_ => fail ~"bad foreign item"
}
}
with *visit::default_visitor()
,.. *visit::default_visitor()
}));
ebml_w.end_tag();
return *index;

2
src/rustc/metadata/tydecode.rs

@ -294,7 +294,7 @@ fn parse_ty(st: @pstate, conv: conv_did) -> ty::t {
match st.tcx.rcache.find({cnum: st.crate, pos: pos, len: len}) {
Some(tt) => return tt,
None => {
let ps = @{pos: pos with *st};
let ps = @{pos: pos ,.. *st};
let tt = parse_ty(ps, conv);
st.tcx.rcache.insert({cnum: st.crate, pos: pos, len: len}, tt);
return tt;

34
src/rustc/middle/astencode.rs

@ -247,13 +247,13 @@ fn simplify_ast(ii: ast::inlined_item) -> ast::inlined_item {
ast::stmt_decl(@{node: ast::decl_item(_), span: _}, _) => false
}
};
let blk_sans_items = { stmts: stmts_sans_items with blk };
let blk_sans_items = { stmts: stmts_sans_items,.. blk };
fold::noop_fold_block(blk_sans_items, fld)
}
let fld = fold::make_fold(@{
fold_block: fold::wrap(drop_nested_items)
with *fold::default_ast_fold()
fold_block: fold::wrap(drop_nested_items),
.. *fold::default_ast_fold()
});
match ii {
@ -269,15 +269,15 @@ fn simplify_ast(ii: ast::inlined_item) -> ast::inlined_item {
ast::ii_ctor(ctor, nm, tps, parent_id) => {
let ctor_body = fld.fold_block(ctor.node.body);
let ctor_decl = fold::fold_fn_decl(ctor.node.dec, fld);
ast::ii_ctor({node: {body: ctor_body, dec: ctor_decl
with ctor.node}
with ctor}, nm, tps, parent_id)
ast::ii_ctor({node: {body: ctor_body, dec: ctor_decl,
.. ctor.node},
.. ctor}, nm, tps, parent_id)
}
ast::ii_dtor(dtor, nm, tps, parent_id) => {
let dtor_body = fld.fold_block(dtor.node.body);
ast::ii_dtor({node: {body: dtor_body
with dtor.node}
with dtor}, nm, tps, parent_id)
ast::ii_dtor({node: {body: dtor_body,
.. dtor.node},
.. dtor}, nm, tps, parent_id)
}
}
}
@ -292,8 +292,8 @@ fn renumber_ast(xcx: extended_decode_ctxt, ii: ast::inlined_item)
-> ast::inlined_item {
let fld = fold::make_fold(@{
new_id: |a| xcx.tr_id(a),
new_span: |a| xcx.tr_span(a)
with *fold::default_ast_fold()
new_span: |a| xcx.tr_span(a),
.. *fold::default_ast_fold()
});
match ii {
@ -314,9 +314,9 @@ fn renumber_ast(xcx: extended_decode_ctxt, ii: ast::inlined_item)
let ctor_id = fld.new_id(ctor.node.id);
let new_parent = xcx.tr_def_id(parent_id);
ast::ii_ctor({node: {body: ctor_body, attrs: ctor_attrs,
dec: ctor_decl, id: ctor_id
with ctor.node}
with ctor}, nm, new_params, new_parent)
dec: ctor_decl, id: ctor_id,
.. ctor.node},
.. ctor}, nm, new_params, new_parent)
}
ast::ii_dtor(dtor, nm, tps, parent_id) => {
let dtor_body = fld.fold_block(dtor.node.body);
@ -326,8 +326,8 @@ fn renumber_ast(xcx: extended_decode_ctxt, ii: ast::inlined_item)
let new_parent = xcx.tr_def_id(parent_id);
let new_self = fld.new_id(dtor.node.self_id);
ast::ii_dtor({node: {id: dtor_id, attrs: dtor_attrs,
self_id: new_self, body: dtor_body}
with dtor},
self_id: new_self, body: dtor_body},
.. dtor},
nm, new_params, new_parent)
}
}
@ -432,7 +432,7 @@ impl method_origin: tr {
typeck::method_static(did.tr(xcx))
}
typeck::method_param(mp) => {
typeck::method_param({trait_id:mp.trait_id.tr(xcx) with mp})
typeck::method_param({trait_id:mp.trait_id.tr(xcx),.. mp})
}
typeck::method_trait(did, m) => {
typeck::method_trait(did.tr(xcx), m)

2
src/rustc/middle/borrowck.rs

@ -443,7 +443,7 @@ impl borrowck_ctxt {
}
fn cat_discr(cmt: cmt, alt_id: ast::node_id) -> cmt {
return @{cat:cat_discr(cmt, alt_id) with *cmt};
return @{cat:cat_discr(cmt, alt_id),.. *cmt};
}
fn cat_pattern(cmt: cmt, pat: @ast::pat, op: fn(cmt, @ast::pat)) {

4
src/rustc/middle/borrowck/check_loans.rs

@ -67,8 +67,8 @@ fn check_loans(bccx: borrowck_ctxt,
let vt = visit::mk_vt(@{visit_expr: check_loans_in_expr,
visit_local: check_loans_in_local,
visit_block: check_loans_in_block,
visit_fn: check_loans_in_fn
with *visit::default_visitor()});
visit_fn: check_loans_in_fn,
.. *visit::default_visitor()});
visit::visit_crate(*crate, clcx, vt);
}

2
src/rustc/middle/borrowck/gather_loans.rs

@ -53,7 +53,7 @@ fn gather_loans(bccx: borrowck_ctxt, crate: @ast::crate) -> req_maps {
mut root_ub: 0});
let v = visit::mk_vt(@{visit_expr: req_loans_in_expr,
visit_fn: req_loans_in_fn,
with *visit::default_visitor()});
.. *visit::default_visitor()});
visit::visit_crate(*crate, glcx, v);
return glcx.req_maps;
}

6
src/rustc/middle/borrowck/preserve.rs

@ -158,7 +158,7 @@ priv impl &preserve_ctxt {
debug!("base.mutbl = %?", self.bccx.mut_to_str(base.mutbl));
if base.mutbl == m_imm {
let non_rooting_ctxt =
preserve_ctxt({root_managed_data: false with **self});
preserve_ctxt({root_managed_data: false,.. **self});
match (&non_rooting_ctxt).preserve(base) {
Ok(pc_ok) => {
Ok(pc_ok)
@ -232,8 +232,8 @@ priv impl &preserve_ctxt {
// in the *arm* vs the *alt*.
let alt_rooting_ctxt =
preserve_ctxt({scope_region: ty::re_scope(alt_id)
with **self});
preserve_ctxt({scope_region: ty::re_scope(alt_id),
.. **self});
(&alt_rooting_ctxt).preserve(base)
}
}

4
src/rustc/middle/check_alt.rs

@ -15,8 +15,8 @@ use std::map::hashmap;
fn check_crate(tcx: ty::ctxt, crate: @crate) {
visit::visit_crate(*crate, (), visit::mk_vt(@{
visit_expr: |a,b,c| check_expr(tcx, a, b, c),
visit_local: |a,b,c| check_local(tcx, a, b, c)
with *visit::default_visitor::<()>()
visit_local: |a,b,c| check_local(tcx, a, b, c),
.. *visit::default_visitor::<()>()
}));
tcx.sess.abort_if_errors();
}

8
src/rustc/middle/check_const.rs

@ -11,8 +11,8 @@ fn check_crate(sess: session, crate: @crate, ast_map: ast_map::map,
visit_item: |a,b,c| check_item(sess, ast_map, def_map, a, b, c),
visit_pat: check_pat,
visit_expr: |a,b,c|
check_expr(sess, def_map, method_map, tcx, a, b, c)
with *visit::default_visitor()
check_expr(sess, def_map, method_map, tcx, a, b, c),
.. *visit::default_visitor()
}));
sess.abort_if_errors();
}
@ -163,8 +163,8 @@ fn check_item_recursion(sess: session, ast_map: ast_map::map,
let visitor = visit::mk_vt(@{
visit_item: visit_item,
visit_expr: visit_expr
with *visit::default_visitor()
visit_expr: visit_expr,
.. *visit::default_visitor()
});
visitor.visit_item(it, env, visitor);

8
src/rustc/middle/check_loop.rs

@ -13,10 +13,10 @@ fn check_crate(tcx: ty::ctxt, crate: @crate) {
match e.node {
expr_while(e, b) => {
v.visit_expr(e, cx, v);
v.visit_block(b, {in_loop: true with cx}, v);
v.visit_block(b, {in_loop: true,.. cx}, v);
}
expr_loop(b, _) => {
v.visit_block(b, {in_loop: true with cx}, v);
v.visit_block(b, {in_loop: true,.. cx}, v);
}
expr_fn(_, _, _, _) => {
visit::visit_expr(e, {in_loop: false, can_ret: true}, v);
@ -47,7 +47,7 @@ fn check_crate(tcx: ty::ctxt, crate: @crate) {
}
_ => visit::visit_expr(e, cx, v)
}
}
with *visit::default_visitor()
},
.. *visit::default_visitor()
}));
}

4
src/rustc/middle/const_eval.rs

@ -171,8 +171,8 @@ fn process_crate(crate: @ast::crate,
def_map: resolve::DefMap,
tcx: ty::ctxt) {
let v = visit::mk_simple_visitor(@{
visit_expr_post: |e| { classify(e, def_map, tcx); }
with *visit::default_simple_visitor()
visit_expr_post: |e| { classify(e, def_map, tcx); },
.. *visit::default_simple_visitor()
});
visit::visit_crate(*crate, (), v);
tcx.sess.abort_if_errors();

8
src/rustc/middle/freevars.rs

@ -74,8 +74,8 @@ fn collect_freevars(def_map: resolve::DefMap, blk: ast::blk)
}
};
let v = visit::mk_vt(@{visit_item: ignore_item, visit_expr: walk_expr
with *visit::default_visitor()});
let v = visit::mk_vt(@{visit_item: ignore_item, visit_expr: walk_expr,
.. *visit::default_visitor()});
v.visit_block(blk, 1, v);
return @*refs;
}
@ -96,8 +96,8 @@ fn annotate_freevars(def_map: resolve::DefMap, crate: @ast::crate) ->
};
let visitor =
visit::mk_simple_visitor(@{visit_fn: walk_fn
with *visit::default_simple_visitor()});
visit::mk_simple_visitor(@{visit_fn: walk_fn,
.. *visit::default_simple_visitor()});
visit::visit_crate(*crate, (), visitor);
return freevars;

6
src/rustc/middle/kind.rs

@ -81,9 +81,9 @@ fn check_crate(tcx: ty::ctxt,
visit_fn: check_fn,
visit_ty: check_ty,
visit_item: fn@(i: @item, cx: ctx, v: visit::vt<ctx>) {
visit::visit_item(i, {current_item: i.id with cx}, v);
}
with *visit::default_visitor()
visit::visit_item(i, {current_item: i.id,.. cx}, v);
},
.. *visit::default_visitor()
});
visit::visit_crate(*crate, ctx, visit);
tcx.sess.abort_if_errors();

4
src/rustc/middle/lang_items.rs

@ -165,8 +165,8 @@ struct LanguageItemCollector {
.value);
}
}
}
with *default_simple_visitor()
},
.. *default_simple_visitor()
}));
}

24
src/rustc/middle/lint.rs

@ -321,7 +321,7 @@ impl ctxt {
new_ctxt =
ctxt_({is_default: false,
curr: c,
with *new_ctxt});
.. *new_ctxt});
new_ctxt.set_level(lint.lint, level);
}
}
@ -362,11 +362,11 @@ fn build_settings_crate(sess: session::session, crate: @ast::crate) {
sess.lint_settings.default_settings.insert(k, v);
}
let cx = ctxt_({is_default: true with *cx});
let cx = ctxt_({is_default: true,.. *cx});
let visit = visit::mk_vt(@{
visit_item: build_settings_item
with *visit::default_visitor()
visit_item: build_settings_item,
.. *visit::default_visitor()
});
visit::visit_crate(*crate, cx, visit);
}
@ -387,7 +387,7 @@ fn check_item(i: @ast::item, cx: ty::ctxt) {
// not traverse into subitems, since that is handled by the outer
// lint visitor.
fn item_stopping_visitor<E>(v: visit::vt<E>) -> visit::vt<E> {
visit::mk_vt(@{visit_item: |_i, _e, _v| { } with **v})
visit::mk_vt(@{visit_item: |_i, _e, _v| { },.. **v})
}
fn check_item_while_true(cx: ty::ctxt, it: @ast::item) {
@ -407,8 +407,8 @@ fn check_item_while_true(cx: ty::ctxt, it: @ast::item) {
}
_ => ()
}
}
with *visit::default_simple_visitor()
},
.. *visit::default_simple_visitor()
}));
visit::visit_item(it, (), visit);
}
@ -519,8 +519,8 @@ fn check_item_heap(cx: ty::ctxt, it: @ast::item) {
visit_expr: fn@(e: @ast::expr) {
let ty = ty::expr_ty(cx, e);
check_type(cx, e.id, it.id, e.span, ty);
}
with *visit::default_simple_visitor()
},
.. *visit::default_simple_visitor()
}));
visit::visit_item(it, (), visit);
}
@ -540,8 +540,8 @@ fn check_item_path_statement(cx: ty::ctxt, it: @ast::item) {
}
_ => ()
}
}
with *visit::default_simple_visitor()
},
.. *visit::default_simple_visitor()
}));
visit::visit_item(it, (), visit);
}
@ -681,7 +681,7 @@ fn check_crate(tcx: ty::ctxt, crate: @ast::crate) {
check_fn(tcx, fk, decl, body, span, id),
visit_pat: |pat|
check_pat(tcx, pat),
with *visit::default_simple_visitor()
.. *visit::default_simple_visitor()
});
visit::visit_crate(*crate, (), v);

4
src/rustc/middle/liveness.rs

@ -185,7 +185,7 @@ fn check_crate(tcx: ty::ctxt,
visit_local: visit_local,
visit_expr: visit_expr,
visit_arm: visit_arm,
with *visit::default_visitor()
.. *visit::default_visitor()
});
let last_use_map = int_hash();
@ -457,7 +457,7 @@ fn visit_fn(fk: visit::fn_kind, decl: fn_decl, body: blk,
visit_local: check_local,
visit_expr: check_expr,
visit_arm: check_arm,
with *visit::default_visitor()
.. *visit::default_visitor()
});
check_vt.visit_block(body, lsets, check_vt);
lsets.check_ret(id, sp, fk, entry_ln);

4
src/rustc/middle/privacy.rs

@ -67,8 +67,8 @@ fn check_crate(tcx: ty::ctxt, crate: @ast::crate) {
}
visit::visit_expr(expr, env, visitor);
}
with *visit::default_visitor()
},
.. *visit::default_visitor()
});
visit::visit_crate(*crate, (), visitor);
}

12
src/rustc/middle/region.rs

@ -206,7 +206,7 @@ fn resolve_block(blk: ast::blk, cx: ctxt, visitor: visit::vt<ctxt>) {
record_parent(cx, blk.node.id);
// Descend.
let new_cx: ctxt = ctxt {parent: Some(blk.node.id) with cx};
let new_cx: ctxt = ctxt {parent: Some(blk.node.id),.. cx};
visit::visit_block(blk, new_cx, visitor);
}
@ -293,7 +293,7 @@ fn resolve_local(local: @ast::local, cx: ctxt, visitor: visit::vt<ctxt>) {
fn resolve_item(item: @ast::item, cx: ctxt, visitor: visit::vt<ctxt>) {
// Items create a new outer block scope as far as we're concerned.
let new_cx: ctxt = ctxt {parent: None with cx};
let new_cx: ctxt = ctxt {parent: None,.. cx};
visit::visit_item(item, new_cx, visitor);
}
@ -305,7 +305,7 @@ fn resolve_fn(fk: visit::fn_kind, decl: ast::fn_decl, body: ast::blk,
visit::fk_item_fn(*) | visit::fk_method(*) |
visit::fk_ctor(*) | visit::fk_dtor(*) => {
// Top-level functions are a root scope.
ctxt {parent: Some(id) with cx}
ctxt {parent: Some(id),.. cx}
}
visit::fk_anon(*) | visit::fk_fn_block(*) => {
@ -340,8 +340,8 @@ fn resolve_crate(sess: session, def_map: resolve::DefMap,
visit_pat: resolve_pat,
visit_stmt: resolve_stmt,
visit_expr: resolve_expr,
visit_local: resolve_local
with *visit::default_visitor()
visit_local: resolve_local,
.. *visit::default_visitor()
});
visit::visit_crate(*crate, cx, visitor);
return cx.region_map;
@ -771,7 +771,7 @@ fn determine_rp_in_crate(sess: session,
visit_ty: determine_rp_in_ty,
visit_ty_method: determine_rp_in_ty_method,
visit_struct_field: determine_rp_in_struct_field,
with *visit::default_visitor()
.. *visit::default_visitor()
});
visit::visit_crate(*crate, cx, visitor);

8
src/rustc/middle/resolve.rs

@ -777,9 +777,9 @@ struct Resolver {
visit_block: |block, context, visitor|
(*this).build_reduced_graph_for_block(block,
context,
visitor)
visitor),
with *default_visitor()
.. *default_visitor()
}));
}
@ -3025,8 +3025,8 @@ struct Resolver {
visit_local: |local, _context, visitor|
self.resolve_local(local, visitor),
visit_ty: |ty, _context, visitor|
self.resolve_type(ty, visitor)
with *default_visitor()
self.resolve_type(ty, visitor),
.. *default_visitor()
}));
}

6
src/rustc/middle/trans/alt.rs

@ -140,8 +140,8 @@ fn expand_nested_bindings(bcx: block, m: match_, col: uint, val: ValueRef)
mode: mode,
ty: node_id_type(bcx,
br.pats[col].id)
}}])
with *br});
}}]),
.. *br});
}
_ => vec::push(result, br)
}
@ -174,7 +174,7 @@ fn enter_match(bcx: block, dm: DefMap, m: match_, col: uint, val: ValueRef,
}
_ => br.bound
};
vec::push(result, @{pats: pats, bound: bound with *br});
vec::push(result, @{pats: pats, bound: bound,.. *br});
}
None => ()
}

14
src/rustc/middle/trans/base.rs

@ -2841,7 +2841,7 @@ fn trans_lval(cx: block, e: @ast::expr) -> lval_result {
let root_loc = alloca_zeroed(lv.bcx, type_of(cx.ccx(), ty));
let bcx = store_temp_expr(lv.bcx, INIT, root_loc, lv, ty, false);
add_root_cleanup(bcx, scope_id, root_loc, ty);
{bcx: bcx with lv}
{bcx: bcx,.. lv}
}
};
@ -3335,7 +3335,7 @@ fn body_contains_ret(body: ast::blk) -> bool {
_ => visit::visit_expr(e, cx, v),
}
}
} with *visit::default_visitor()
} ,.. *visit::default_visitor()
}));
cx.found
}
@ -4883,7 +4883,7 @@ fn copy_args_to_allocas(fcx: fn_ctxt, bcx: block, args: ~[ast::arg],
if slf.is_owned {
let self_val = PointerCast(bcx, slf.v,
T_ptr(type_of(bcx.ccx(), slf.t)));
fcx.llself = Some({v: self_val with slf});
fcx.llself = Some({v: self_val,.. slf});
add_clean(bcx, self_val, slf.t);
}
}
@ -5667,8 +5667,8 @@ fn trans_constant(ccx: @crate_ctxt, it: @ast::item) {
fn trans_constants(ccx: @crate_ctxt, crate: @ast::crate) {
visit::visit_crate(*crate, (), visit::mk_simple_visitor(@{
visit_item: |a| trans_constant(ccx, a)
with *visit::default_simple_visitor()
visit_item: |a| trans_constant(ccx, a),
.. *visit::default_simple_visitor()
}));
}
@ -5775,8 +5775,8 @@ fn gather_local_rtcalls(ccx: @crate_ctxt, crate: @ast::crate) {
}
}
_ => ()
}
with *visit::default_simple_visitor()
},
.. *visit::default_simple_visitor()
}));
}

12
src/rustc/middle/trans/impl.rs

@ -120,8 +120,8 @@ fn trans_method_callee(bcx: block, callee_id: ast::node_id,
let {bcx, val} = trans_self_arg(bcx, self, mentry);
{env: self_env(val, node_id_type(bcx, self.id), None,
mentry.self_mode)
with lval_static_fn(bcx, did, callee_id)}
mentry.self_mode),
.. lval_static_fn(bcx, did, callee_id)}
}
typeck::method_param({trait_id:trait_id, method_num:off,
param_num:p, bound_num:b}) => {
@ -186,8 +186,8 @@ fn trans_static_method_callee(bcx: block, method_id: ast::def_id,
Some(sub_origins));
{env: null_env,
val: PointerCast(bcx, lval.val, T_ptr(type_of_fn_from_ty(
ccx, node_id_type(bcx, callee_id))))
with lval}
ccx, node_id_type(bcx, callee_id)))),
.. lval}
}
_ => {
fail ~"vtable_param left in monomorphized function's vtable substs";
@ -255,8 +255,8 @@ fn trans_monomorphized_callee(bcx: block, callee_id: ast::node_id,
{env: self_env(val, node_id_type(bcx, base.id),
None, mentry.self_mode),
val: PointerCast(bcx, lval.val, T_ptr(type_of_fn_from_ty(
ccx, node_id_type(bcx, callee_id))))
with lval}
ccx, node_id_type(bcx, callee_id)))),
.. lval}
}
typeck::vtable_trait(*) => {
let {bcx, val} = trans_temp_expr(bcx, base);

10
src/rustc/middle/trans/reachable.rs

@ -144,7 +144,7 @@ fn traverse_public_item(cx: ctx, item: @item) {
}
fn mk_ty_visitor() -> visit::vt<ctx> {
visit::mk_vt(@{visit_ty: traverse_ty with *visit::default_visitor()})
visit::mk_vt(@{visit_ty: traverse_ty,.. *visit::default_visitor()})
}
fn traverse_ty(ty: @ty, cx: ctx, v: visit::vt<ctx>) {
@ -199,8 +199,8 @@ fn traverse_inline_body(cx: ctx, body: blk) {
}
visit::visit_block(body, cx, visit::mk_vt(@{
visit_expr: traverse_expr,
visit_item: traverse_item
with *visit::default_visitor()
visit_item: traverse_item,
.. *visit::default_visitor()
}));
}
@ -218,8 +218,8 @@ fn traverse_all_resources_and_impls(cx: ctx, crate_mod: _mod) {
}
_ => ()
}
}
with *visit::default_visitor()
},
.. *visit::default_visitor()
}));
}

4
src/rustc/middle/trans/type_use.rs

@ -287,8 +287,8 @@ fn handle_body(cx: ctx, body: blk) {
node_type_needs(cx, use_repr, e.id);
}
},
visit_item: |_i, _cx, _v| { }
with *visit::default_visitor()
visit_item: |_i, _cx, _v| { },
.. *visit::default_visitor()
});
v.visit_block(body, cx, v);
}

6
src/rustc/middle/ty.rs

@ -1011,7 +1011,7 @@ fn fold_sty(sty: &sty, fldop: fn(t) -> t) -> sty {
{mode: a.mode, ty: new_ty}
});
let new_output = fldop(f.output);
ty_fn({inputs: new_args, output: new_output with *f})
ty_fn({inputs: new_args, output: new_output,.. *f})
}
ty_rptr(r, tm) => {
ty_rptr(r, {ty: fldop(tm.ty), mutbl: tm.mutbl})
@ -1110,7 +1110,7 @@ fn fold_regions_and_ty(
ty::mk_fn(cx, {
inputs: new_args,
output: new_output,
proto: new_proto with f
proto: new_proto,.. f
})
}
ref sty => {
@ -2915,7 +2915,7 @@ fn substd_enum_variants(cx: ctxt,
let substd_ctor_ty = subst(cx, substs, variant_info.ctor_ty);
@{args: substd_args, ctor_ty: substd_ctor_ty with *variant_info}
@{args: substd_args, ctor_ty: substd_ctor_ty,.. *variant_info}
}
}

20
src/rustc/middle/typeck/check.rs

@ -188,8 +188,8 @@ impl isr_alist: get_and_find_region {
fn check_item_types(ccx: @crate_ctxt, crate: @ast::crate) {
let visit = visit::mk_simple_visitor(@{
visit_item: |a| check_item(ccx, a)
with *visit::default_simple_visitor()
visit_item: |a| check_item(ccx, a),
.. *visit::default_simple_visitor()
});
visit::visit_crate(*crate, (), visit);
}
@ -286,7 +286,7 @@ fn check_fn(ccx: @crate_ctxt,
let ty = method::transform_self_type_for_method(
fcx.tcx(), self_region,
info.self_ty, info.explicit_self.node);
Some({self_ty: ty with info})
Some({self_ty: ty,.. info})
}
};
@ -405,8 +405,8 @@ fn check_fn(ccx: @crate_ctxt,
visit_pat: visit_pat,
visit_fn: visit_fn,
visit_item: visit_item,
visit_block: visit_block
with *visit::default_visitor()});
visit_block: visit_block,
.. *visit::default_visitor()});
visit.visit_block(body, (), visit);
}
@ -1649,7 +1649,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
fcx.infcx().ty_to_str(fty.output)));
}
}
ty::mk_fn(tcx, {output: ty::mk_nil(tcx) with fty})
ty::mk_fn(tcx, {output: ty::mk_nil(tcx),.. fty})
}
_ => {
tcx.sess.span_fatal(expr.span, ~"a `loop` function's last \
@ -1672,8 +1672,8 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
fcx, expr.span, fcx.node_ty(b.id));
match ty::get(block_ty).struct {
ty::ty_fn(fty) => {
fcx.write_ty(expr.id, ty::mk_fn(tcx, {output: ty::mk_bool(tcx)
with fty}));
fcx.write_ty(expr.id, ty::mk_fn(tcx, {output: ty::mk_bool(tcx),
.. fty}));
}
_ => fail ~"expected fn type"
}
@ -2113,8 +2113,8 @@ fn check_block_no_value(fcx: @fn_ctxt, blk: ast::blk) -> bool {
fn check_block(fcx0: @fn_ctxt, blk: ast::blk) -> bool {
let fcx = match blk.node.rules {
ast::unchecked_blk => @fn_ctxt {purity: ast::impure_fn with *fcx0},
ast::unsafe_blk => @fn_ctxt {purity: ast::unsafe_fn with *fcx0},
ast::unchecked_blk => @fn_ctxt {purity: ast::impure_fn,.. *fcx0},
ast::unsafe_blk => @fn_ctxt {purity: ast::unsafe_fn,.. *fcx0},
ast::default_blk => fcx0
};
do fcx.with_region_lb(blk.node.id) {

20
src/rustc/middle/typeck/check/method.rs

@ -324,8 +324,8 @@ struct lookup {
// (where the self type is not permitted), or from a trait
// type (in which case methods that refer to self are not
// permitted).
let substs = {self_ty: Some(self.self_ty)
with bound_substs};
let substs = {self_ty: Some(self.self_ty),
.. bound_substs};
self.add_candidates_from_m(
inner_ty,
@ -371,8 +371,8 @@ struct lookup {
// Note: although it is illegal to invoke a method that uses self
// through a trait instance, we use a dummy subst here so that we
// can soldier on with the compilation.
let substs = {self_ty: Some(self.self_ty)
with trait_substs};
let substs = {self_ty: Some(self.self_ty),
.. trait_substs};
self.add_candidates_from_m(
inner_ty, mode, substs, m, method_trait(did, i));
@ -411,7 +411,7 @@ struct lookup {
match ty::get(ty::lookup_item_type(self.tcx(), did).ty).struct {
ty::ty_fn(fty) => {
ty::mk_fn(self.tcx(),
{proto: ty::proto_vstore(ty::vstore_box) with fty})
{proto: ty::proto_vstore(ty::vstore_box),.. fty})
}
_ => fail ~"ty_from_did: not function ty"
}
@ -534,7 +534,7 @@ struct lookup {
}
Some(_) => self_substs.self_r
};
let self_substs = {self_r: self_r with self_substs};
let self_substs = {self_r: self_r,.. self_substs};
// Before we can be sure we succeeded we need to match the
// self type against the impl type that we get when we apply
@ -551,8 +551,8 @@ struct lookup {
// a bit hokey, but the method unbound has a bare protocol, whereas
// a.b has a protocol like fn@() (perhaps eventually fn&()):
let fty = ty::mk_fn(tcx, {proto: ty::proto_vstore(ty::vstore_box)
with m.fty});
let fty = ty::mk_fn(tcx, {proto: ty::proto_vstore(ty::vstore_box),
.. m.fty});
self.candidates.push(
{self_ty: self.self_ty,
@ -689,8 +689,8 @@ struct lookup {
}
};
let all_substs = {tps: vec::append(cand.self_substs.tps, m_substs)
with cand.self_substs};
let all_substs = {tps: vec::append(cand.self_substs.tps, m_substs),
.. cand.self_substs};
self.fcx.write_ty_substs(self.node_id, cand.fty, all_substs);

4
src/rustc/middle/typeck/check/regionck.rs

@ -112,8 +112,8 @@ fn regionck_visitor() -> rvt {
visit_stmt: visit_stmt,
visit_expr: visit_expr,
visit_block: visit_block,
visit_local: visit_local
with *visit::default_visitor()})
visit_local: visit_local,
.. *visit::default_visitor()})
}
fn visit_item(_item: @ast::item, &&_rcx: @rcx, _v: rvt) {

2
src/rustc/middle/typeck/check/regionmanip.rs

@ -16,7 +16,7 @@ fn replace_bound_regions_in_fn_ty(
// Take self_info apart; the self_ty part is the only one we want
// to update here.
let (self_ty, rebuild_self_info) = match self_info {
Some(s) => (Some(s.self_ty), |t| Some({self_ty: t with s})),
Some(s) => (Some(s.self_ty), |t| Some({self_ty: t,.. s})),
None => (None, |_t| None)
};

4
src/rustc/middle/typeck/check/vtable.rs

@ -464,8 +464,8 @@ fn resolve_in_block(fcx: @fn_ctxt, bl: ast::blk) {
visit::visit_block(bl, fcx, visit::mk_vt(@{
visit_expr: resolve_expr,
visit_item: fn@(_i: @ast::item, &&_e: @fn_ctxt,
_v: visit::vt<@fn_ctxt>) {}
with *visit::default_visitor()
_v: visit::vt<@fn_ctxt>) {},
.. *visit::default_visitor()
}));
}

4
src/rustc/middle/typeck/check/writeback.rs

@ -185,8 +185,8 @@ fn mk_visitor() -> visit::vt<wb_ctxt> {
visit_expr: visit_expr,
visit_block: visit_block,
visit_pat: visit_pat,
visit_local: visit_local
with *visit::default_visitor()})
visit_local: visit_local,
.. *visit::default_visitor()})
}
fn resolve_type_vars_in_expr(fcx: @fn_ctxt, e: @ast::expr) -> bool {

12
src/rustc/middle/typeck/coherence.rs

@ -212,8 +212,8 @@ struct CoherenceChecker {
// Nothing to do.
}
};
}
with *default_simple_visitor()
},
.. *default_simple_visitor()
}));
}
@ -237,8 +237,8 @@ struct CoherenceChecker {
// Nothing to do.
}
};
}
with *default_simple_visitor()
},
.. *default_simple_visitor()
}));
// Check trait coherence.
@ -501,8 +501,8 @@ struct CoherenceChecker {
visit_item(item, (), visitor);
}
}
}
with *default_visitor()
},
.. *default_visitor()
}));
}

4
src/rustc/middle/typeck/collect.rs

@ -66,8 +66,8 @@ fn collect_item_types(ccx: @crate_ctxt, crate: @ast::crate) {
visit::visit_crate(*crate, (), visit::mk_simple_visitor(@{
visit_item: |a|convert(ccx, a),
visit_foreign_item: |a|convert_foreign(ccx, a)
with *visit::default_simple_visitor()
visit_foreign_item: |a|convert_foreign(ccx, a),
.. *visit::default_simple_visitor()
}));
}

4
src/rustc/middle/typeck/infer/lattice.rs

@ -17,7 +17,7 @@ trait lattice_ops {
impl Lub: lattice_ops {
fn bnd(b: bounds<ty::t>) -> Option<ty::t> { b.ub }
fn with_bnd(b: bounds<ty::t>, t: ty::t) -> bounds<ty::t> {
{ub: Some(t) with b}
{ub: Some(t),.. b}
}
fn ty_bot(t: ty::t) -> cres<ty::t> {
Ok(t)
@ -27,7 +27,7 @@ impl Lub: lattice_ops {
impl Glb: lattice_ops {
fn bnd(b: bounds<ty::t>) -> Option<ty::t> { b.lb }
fn with_bnd(b: bounds<ty::t>, t: ty::t) -> bounds<ty::t> {
{lb: Some(t) with b}
{lb: Some(t),.. b}
}
fn ty_bot(_t: ty::t) -> cres<ty::t> {
Ok(ty::mk_bot(self.infcx.tcx))

4
src/rustc/middle/typeck/infer/sub.rs

@ -15,14 +15,14 @@ impl Sub: combine {
fn contratys(a: ty::t, b: ty::t) -> cres<ty::t> {
let opp = combine_fields {
a_is_expected: !self.a_is_expected, with *self
a_is_expected: !self.a_is_expected,.. *self
};
Sub(opp).tys(b, a)
}
fn contraregions(a: ty::region, b: ty::region) -> cres<ty::region> {
let opp = combine_fields {
a_is_expected: !self.a_is_expected, with *self
a_is_expected: !self.a_is_expected,.. *self
};
Sub(opp).regions(b, a)
}

2
src/rustc/util/common.rs

@ -51,7 +51,7 @@ fn loop_query(b: ast::blk, p: fn@(ast::expr_) -> bool) -> bool {
}
};
let v = visit::mk_vt(@{visit_expr: visit_expr
with *visit::default_visitor()});
,.. *visit::default_visitor()});
visit::visit_block(b, rs, v);
return *rs;
}

36
src/rustdoc/attr_pass.rs

@ -30,8 +30,8 @@ fn run(
fold_item: fold_item,
fold_enum: fold_enum,
fold_trait: fold_trait,
fold_impl: fold_impl
with *fold::default_any_fold(srv)
fold_impl: fold_impl,
.. *fold::default_any_fold(srv)
});
fold.fold_doc(fold, doc)
}
@ -52,10 +52,10 @@ fn fold_crate(
{
topmod: doc::moddoc_({
item: {
name: option::get_default(attrs.name, doc.topmod.name())
with doc.topmod.item
}
with *doc.topmod
name: option::get_default(attrs.name, doc.topmod.name()),
.. doc.topmod.item
},
.. *doc.topmod
})
}
}
@ -84,8 +84,8 @@ fn fold_item(
};
{
desc: desc
with doc
desc: desc,
.. doc
}
}
@ -162,11 +162,11 @@ fn fold_enum(
};
{
desc: desc
with variant
desc: desc,
.. variant
}
}
with doc
},
.. doc
}
}
@ -191,8 +191,8 @@ fn fold_trait(
let doc = fold::default_seq_fold_trait(fold, doc);
{
methods: merge_method_attrs(srv, doc.id(), doc.methods)
with doc
methods: merge_method_attrs(srv, doc.id(), doc.methods),
.. doc
}
}
@ -235,8 +235,8 @@ fn merge_method_attrs(
let desc = attrs.second();
{
desc: desc
with doc
desc: desc,
.. doc
}
}
}
@ -266,8 +266,8 @@ fn fold_impl(
let doc = fold::default_seq_fold_impl(fold, doc);
{
methods: merge_method_attrs(srv, doc.id(), doc.methods)
with doc
methods: merge_method_attrs(srv, doc.id(), doc.methods),
.. doc
}
}

24
src/rustdoc/config.rs

@ -141,8 +141,8 @@ fn config_from_opts(
let output_dir = getopts::opt_maybe_str(matches, opt_output_dir());
let output_dir = option::map(output_dir, |s| Path(s));
result::Ok({
output_dir: option::get_default(output_dir, config.output_dir)
with config
output_dir: option::get_default(output_dir, config.output_dir),
.. config
})
};
let result = do result::chain(result) |config| {
@ -154,8 +154,8 @@ fn config_from_opts(
|output_format| {
result::Ok({
output_format: output_format
with config
output_format: output_format,
.. config
})
}
}
@ -168,8 +168,8 @@ fn config_from_opts(
do result::chain(parse_output_style(output_style))
|output_style| {
result::Ok({
output_style: output_style
with config
output_style: output_style,
.. config
})
}
}
@ -180,8 +180,8 @@ fn config_from_opts(
config, pandoc_cmd, program_output);
do result::chain(pandoc_cmd) |pandoc_cmd| {
result::Ok({
pandoc_cmd: pandoc_cmd
with config
pandoc_cmd: pandoc_cmd,
.. config
})
}
};
@ -241,8 +241,8 @@ fn maybe_find_pandoc(
#[test]
fn should_find_pandoc() {
let config = {
output_format: pandoc_html
with default_config(&Path("test"))
output_format: pandoc_html,
.. default_config(&Path("test"))
};
let mock_program_output = fn~(_prog: &str, _args: &[~str]) -> {
status: int, out: ~str, err: ~str
@ -258,8 +258,8 @@ fn should_find_pandoc() {
#[test]
fn should_error_with_no_pandoc() {
let config = {
output_format: pandoc_html
with default_config(&Path("test"))
output_format: pandoc_html,
.. default_config(&Path("test"))
};
let mock_program_output = fn~(_prog: &str, _args: &[~str]) -> {
status: int, out: ~str, err: ~str

24
src/rustdoc/desc_to_brief_pass.rs

@ -23,8 +23,8 @@ fn run(
let fold = fold::fold({
fold_item: fold_item,
fold_trait: fold_trait,
fold_impl: fold_impl
with *fold::default_any_fold(())
fold_impl: fold_impl,
.. *fold::default_any_fold(())
});
fold.fold_doc(fold, doc)
}
@ -33,8 +33,8 @@ fn fold_item(fold: fold::fold<()>, doc: doc::itemdoc) -> doc::itemdoc {
let doc = fold::default_seq_fold_item(fold, doc);
{
brief: extract(doc.desc)
with doc
brief: extract(doc.desc),
.. doc
}
}
@ -43,10 +43,10 @@ fn fold_trait(fold: fold::fold<()>, doc: doc::traitdoc) -> doc::traitdoc {
{
methods: par::map(doc.methods, |doc| {
brief: extract(doc.desc)
with doc
})
with doc
brief: extract(doc.desc),
.. doc
}),
.. doc
}
}
@ -55,10 +55,10 @@ fn fold_impl(fold: fold::fold<()>, doc: doc::impldoc) -> doc::impldoc {
{
methods: par::map(doc.methods, |doc| {
brief: extract(doc.desc)
with doc
})
with doc
brief: extract(doc.desc),
.. doc
}),
.. doc
}
}

52
src/rustdoc/fold.rs

@ -142,8 +142,8 @@ fn default_seq_fold_doc<T>(fold: fold<T>, doc: doc::doc) -> doc::doc {
doc::itempage(fold_itemtag(fold, doc))
}
}
}
with *doc
},
.. *doc
})
}
@ -171,8 +171,8 @@ fn default_any_fold_mod<T:send copy>(
item: fold.fold_item(fold, doc.item),
items: par::map(doc.items, |itemtag, copy fold| {
fold_itemtag(fold, itemtag)
})
with *doc
}),
.. *doc
})
}
@ -184,8 +184,8 @@ fn default_seq_fold_mod<T>(
item: fold.fold_item(fold, doc.item),
items: vec::map(doc.items, |itemtag| {
fold_itemtag(fold, itemtag)
})
with *doc
}),
.. *doc
})
}
@ -197,8 +197,8 @@ fn default_par_fold_mod<T:send copy>(
item: fold.fold_item(fold, doc.item),
items: par::map(doc.items, |itemtag, copy fold| {
fold_itemtag(fold, itemtag)
})
with *doc
}),
.. *doc
})
}
@ -210,8 +210,8 @@ fn default_any_fold_nmod<T:send copy>(
item: fold.fold_item(fold, doc.item),
fns: par::map(doc.fns, |fndoc, copy fold| {
fold.fold_fn(fold, fndoc)
})
with doc
}),
.. doc
}
}
@ -223,8 +223,8 @@ fn default_seq_fold_nmod<T>(
item: fold.fold_item(fold, doc.item),
fns: vec::map(doc.fns, |fndoc| {
fold.fold_fn(fold, fndoc)
})
with doc
}),
.. doc
}
}
@ -236,8 +236,8 @@ fn default_par_fold_nmod<T:send copy>(
item: fold.fold_item(fold, doc.item),
fns: par::map(doc.fns, |fndoc, copy fold| {
fold.fold_fn(fold, fndoc)
})
with doc
}),
.. doc
}
}
@ -275,8 +275,8 @@ fn default_seq_fold_fn<T>(
doc: doc::fndoc
) -> doc::fndoc {
{
item: fold.fold_item(fold, doc.item)
with doc
item: fold.fold_item(fold, doc.item),
.. doc
}
}
@ -285,8 +285,8 @@ fn default_seq_fold_const<T>(
doc: doc::constdoc
) -> doc::constdoc {
{
item: fold.fold_item(fold, doc.item)
with doc
item: fold.fold_item(fold, doc.item),
.. doc
}
}
@ -295,8 +295,8 @@ fn default_seq_fold_enum<T>(
doc: doc::enumdoc
) -> doc::enumdoc {
{
item: fold.fold_item(fold, doc.item)
with doc
item: fold.fold_item(fold, doc.item),
.. doc
}
}
@ -305,8 +305,8 @@ fn default_seq_fold_trait<T>(
doc: doc::traitdoc
) -> doc::traitdoc {
{
item: fold.fold_item(fold, doc.item)
with doc
item: fold.fold_item(fold, doc.item),
.. doc
}
}
@ -315,8 +315,8 @@ fn default_seq_fold_impl<T>(
doc: doc::impldoc
) -> doc::impldoc {
{
item: fold.fold_item(fold, doc.item)
with doc
item: fold.fold_item(fold, doc.item),
.. doc
}
}
@ -325,8 +325,8 @@ fn default_seq_fold_type<T>(
doc: doc::tydoc
) -> doc::tydoc {
{
item: fold.fold_item(fold, doc.item)
with doc
item: fold.fold_item(fold, doc.item),
.. doc
}
}

16
src/rustdoc/markdown_index_pass.rs

@ -20,8 +20,8 @@ fn run(
) -> doc::doc {
let fold = fold::fold({
fold_mod: fold_mod,
fold_nmod: fold_nmod
with *fold::default_any_fold(config)
fold_nmod: fold_nmod,
.. *fold::default_any_fold(config)
});
fold.fold_doc(fold, doc)
}
@ -34,8 +34,8 @@ fn fold_mod(
let doc = fold::default_any_fold_mod(fold, doc);
doc::moddoc_({
index: Some(build_mod_index(doc, fold.ctxt))
with *doc
index: Some(build_mod_index(doc, fold.ctxt)),
.. *doc
})
}
@ -47,8 +47,8 @@ fn fold_nmod(
let doc = fold::default_any_fold_nmod(fold, doc);
{
index: Some(build_nmod_index(doc, fold.ctxt))
with doc
index: Some(build_nmod_index(doc, fold.ctxt)),
.. doc
}
}
@ -229,8 +229,8 @@ mod test {
fn mk_doc(output_style: config::output_style, source: ~str) -> doc::doc {
do astsrv::from_str(source) |srv| {
let config = {
output_style: output_style
with config::default_config(&Path("whatever"))
output_style: output_style,
.. config::default_config(&Path("whatever"))
};
let doc = extract::from_srv(srv, ~"");
let doc = attr_pass::mk_pass().f(srv, doc);

16
src/rustdoc/markdown_pass.rs

@ -537,12 +537,12 @@ fn should_correctly_indent_fn_signature() {
doc::cratepage({
topmod: doc::moddoc_({
items: ~[doc::fntag({
sig: Some(~"line 1\nline 2")
with doc.cratemod().fns()[0]
})]
with *doc.cratemod()
})
with doc.cratedoc()
sig: Some(~"line 1\nline 2"),
.. doc.cratemod().fns()[0]
})],
.. *doc.cratemod()
}),
.. doc.cratedoc()
})
]
});
@ -784,8 +784,8 @@ mod test {
do astsrv::from_str(source) |srv| {
let config = {
output_style: config::doc_per_crate
with config::default_config(&Path("whatever"))
output_style: config::doc_per_crate,
.. config::default_config(&Path("whatever"))
};
let doc = extract::from_srv(srv, ~"");

12
src/rustdoc/markdown_writer.rs

@ -205,8 +205,8 @@ fn should_use_markdown_file_name_based_off_crate() {
let config = {
output_dir: Path("output/dir"),
output_format: config::markdown,
output_style: config::doc_per_crate
with config::default_config(&Path("input/test.rc"))
output_style: config::doc_per_crate,
.. config::default_config(&Path("input/test.rc"))
};
let doc = test::mk_doc(~"test", ~"");
let page = doc::cratepage(doc.cratedoc());
@ -219,8 +219,8 @@ fn should_name_html_crate_file_name_index_html_when_doc_per_mod() {
let config = {
output_dir: Path("output/dir"),
output_format: config::pandoc_html,
output_style: config::doc_per_mod
with config::default_config(&Path("input/test.rc"))
output_style: config::doc_per_mod,
.. config::default_config(&Path("input/test.rc"))
};
let doc = test::mk_doc(~"", ~"");
let page = doc::cratepage(doc.cratedoc());
@ -233,8 +233,8 @@ fn should_name_mod_file_names_by_path() {
let config = {
output_dir: Path("output/dir"),
output_format: config::pandoc_html,
output_style: config::doc_per_mod
with config::default_config(&Path("input/test.rc"))
output_style: config::doc_per_mod,
.. config::default_config(&Path("input/test.rc"))
};
let doc = test::mk_doc(~"", ~"mod a { mod b { } }");
let modb = doc.cratemod().mods()[0].mods()[0];

12
src/rustdoc/page_pass.rs

@ -60,8 +60,8 @@ fn find_pages(doc: doc::doc, page_chan: page_chan) {
let fold = fold::fold({
fold_crate: fold_crate,
fold_mod: fold_mod,
fold_nmod: fold_nmod
with *fold::default_any_fold(page_chan)
fold_nmod: fold_nmod,
.. *fold::default_any_fold(page_chan)
});
fold.fold_doc(fold, doc);
@ -76,8 +76,8 @@ fn fold_crate(
let doc = fold::default_seq_fold_crate(fold, doc);
let page = doc::cratepage({
topmod: strip_mod(doc.topmod)
with doc
topmod: strip_mod(doc.topmod),
.. doc
});
comm::send(fold.ctxt, Some(page));
@ -110,8 +110,8 @@ fn strip_mod(doc: doc::moddoc) -> doc::moddoc {
doc::nmodtag(_) => false,
_ => true
}
}
with *doc
},
.. *doc
})
}

16
src/rustdoc/path_pass.rs

@ -26,16 +26,16 @@ fn run(srv: astsrv::srv, doc: doc::doc) -> doc::doc {
let fold = fold::fold({
fold_item: fold_item,
fold_mod: fold_mod,
fold_nmod: fold_nmod
with *fold::default_any_fold(ctxt)
fold_nmod: fold_nmod,
.. *fold::default_any_fold(ctxt)
});
fold.fold_doc(fold, doc)
}
fn fold_item(fold: fold::fold<ctxt>, doc: doc::itemdoc) -> doc::itemdoc {
{
path: fold.ctxt.path
with doc
path: fold.ctxt.path,
.. doc
}
}
@ -48,8 +48,8 @@ fn fold_mod(fold: fold::fold<ctxt>, doc: doc::moddoc) -> doc::moddoc {
if !is_topmod { vec::pop(fold.ctxt.path); }
doc::moddoc_({
item: fold.fold_item(fold, doc.item)
with *doc
item: fold.fold_item(fold, doc.item),
.. *doc
})
}
@ -59,8 +59,8 @@ fn fold_nmod(fold: fold::fold<ctxt>, doc: doc::nmoddoc) -> doc::nmoddoc {
vec::pop(fold.ctxt.path);
{
item: fold.fold_item(fold, doc.item)
with doc
item: fold.fold_item(fold, doc.item),
.. doc
}
}

8
src/rustdoc/prune_hidden_pass.rs

@ -13,8 +13,8 @@ fn mk_pass() -> pass {
fn run(srv: astsrv::srv, doc: doc::doc) -> doc::doc {
let fold = fold::fold({
fold_mod: fold_mod
with *fold::default_any_fold(srv)
fold_mod: fold_mod,
.. *fold::default_any_fold(srv)
});
fold.fold_doc(fold, doc)
}
@ -28,8 +28,8 @@ fn fold_mod(
doc::moddoc_({
items: vec::filter(doc.items, |itemtag| {
!is_hidden(fold.ctxt, itemtag.item())
})
with *doc
}),
.. *doc
})
}

8
src/rustdoc/rustdoc.rs

@ -53,8 +53,8 @@ fn test_run_passes() {
doc::cratepage({
topmod: doc::moddoc_({
item: {
name: doc.cratemod().name() + ~"two"
with doc.cratemod().item
name: doc.cratemod().name() + ~"two",
.. doc.cratemod().item
},
items: ~[],
index: None
@ -72,8 +72,8 @@ fn test_run_passes() {
doc::cratepage({
topmod: doc::moddoc_({
item: {
name: doc.cratemod().name() + ~"three"
with doc.cratemod().item
name: doc.cratemod().name() + ~"three",
.. doc.cratemod().item
},
items: ~[],
index: None

28
src/rustdoc/sectionalize_pass.rs

@ -15,8 +15,8 @@ fn run(_srv: astsrv::srv, doc: doc::doc) -> doc::doc {
let fold = fold::fold({
fold_item: fold_item,
fold_trait: fold_trait,
fold_impl: fold_impl
with *fold::default_any_fold(())
fold_impl: fold_impl,
.. *fold::default_any_fold(())
});
fold.fold_doc(fold, doc)
}
@ -27,8 +27,8 @@ fn fold_item(fold: fold::fold<()>, doc: doc::itemdoc) -> doc::itemdoc {
{
desc: desc,
sections: sections
with doc
sections: sections,
.. doc
}
}
@ -41,11 +41,11 @@ fn fold_trait(fold: fold::fold<()>, doc: doc::traitdoc) -> doc::traitdoc {
{
desc: desc,
sections: sections
with method
sections: sections,
..method
}
}
with doc
},
.. doc
}
}
@ -58,11 +58,11 @@ fn fold_impl(fold: fold::fold<()>, doc: doc::impldoc) -> doc::impldoc {
{
desc: desc,
sections: sections
with method
sections: sections,
.. method
}
}
with doc
},
.. doc
}
}
@ -109,8 +109,8 @@ fn sectionalize(desc: Option<~str>) -> (Option<~str>, ~[doc::section]) {
match copy current_section {
Some(section) => {
current_section = Some({
body: section.body + ~"\n" + line
with section
body: section.body + ~"\n" + line,
.. section
});
}
None => {

8
src/rustdoc/sort_pass.rs

@ -23,8 +23,8 @@ fn run(
lteq: item_lteq
) -> doc::doc {
let fold = fold::fold({
fold_mod: fold_mod
with *fold::default_any_fold(lteq)
fold_mod: fold_mod,
.. *fold::default_any_fold(lteq)
});
fold.fold_doc(fold, doc)
}
@ -36,8 +36,8 @@ fn fold_mod(
) -> doc::moddoc {
let doc = fold::default_any_fold_mod(fold, doc);
doc::moddoc_({
items: sort::merge_sort(fold.ctxt, doc.items)
with *doc
items: sort::merge_sort(fold.ctxt, doc.items),
.. *doc
})
}

28
src/rustdoc/text_pass.rs

@ -25,8 +25,8 @@ fn run(
fold_item: fold_item,
fold_enum: fold_enum,
fold_trait: fold_trait,
fold_impl: fold_impl
with *fold::default_any_fold(op)
fold_impl: fold_impl,
.. *fold::default_any_fold(op)
});
fold.fold_doc(fold, doc)
}
@ -41,8 +41,8 @@ fn fold_item(fold: fold::fold<op>, doc: doc::itemdoc) -> doc::itemdoc {
{
brief: maybe_apply_op(fold.ctxt, doc.brief),
desc: maybe_apply_op(fold.ctxt, doc.desc),
sections: apply_to_sections(fold.ctxt, doc.sections)
with doc
sections: apply_to_sections(fold.ctxt, doc.sections),
.. doc
}
}
@ -59,11 +59,11 @@ fn fold_enum(fold: fold::fold<op>, doc: doc::enumdoc) -> doc::enumdoc {
{
variants: do par::map(doc.variants) |variant, copy fold| {
{
desc: maybe_apply_op(fold.ctxt, variant.desc)
with variant
desc: maybe_apply_op(fold.ctxt, variant.desc),
.. variant
}
}
with doc
},
.. doc
}
}
@ -71,8 +71,8 @@ fn fold_trait(fold: fold::fold<op>, doc: doc::traitdoc) -> doc::traitdoc {
let doc = fold::default_seq_fold_trait(fold, doc);
{
methods: apply_to_methods(fold.ctxt, doc.methods)
with doc
methods: apply_to_methods(fold.ctxt, doc.methods),
.. doc
}
}
@ -81,8 +81,8 @@ fn apply_to_methods(op: op, docs: ~[doc::methoddoc]) -> ~[doc::methoddoc] {
{
brief: maybe_apply_op(op, doc.brief),
desc: maybe_apply_op(op, doc.desc),
sections: apply_to_sections(op, doc.sections)
with doc
sections: apply_to_sections(op, doc.sections),
.. doc
}
}
}
@ -91,8 +91,8 @@ fn fold_impl(fold: fold::fold<op>, doc: doc::impldoc) -> doc::impldoc {
let doc = fold::default_seq_fold_impl(fold, doc);
{
methods: apply_to_methods(fold.ctxt, doc.methods)
with doc
methods: apply_to_methods(fold.ctxt, doc.methods),
.. doc
}
}

36
src/rustdoc/tystr_pass.rs

@ -26,8 +26,8 @@ fn run(
fold_enum: fold_enum,
fold_trait: fold_trait,
fold_impl: fold_impl,
fold_type: fold_type
with *fold::default_any_fold(srv)
fold_type: fold_type,
.. *fold::default_any_fold(srv)
});
fold.fold_doc(fold, doc)
}
@ -40,8 +40,8 @@ fn fold_fn(
let srv = fold.ctxt;
{
sig: get_fn_sig(srv, doc.id())
with doc
sig: get_fn_sig(srv, doc.id()),
.. doc
}
}
@ -91,8 +91,8 @@ fn fold_const(
}
_ => fail ~"fold_const: id not bound to a const item"
}
})
with doc
}),
.. doc
}
}
@ -128,11 +128,11 @@ fn fold_enum(
};
{
sig: Some(sig)
with variant
sig: Some(sig),
.. variant
}
}
with doc
},
.. doc
}
}
@ -147,8 +147,8 @@ fn fold_trait(
doc: doc::traitdoc
) -> doc::traitdoc {
{
methods: merge_methods(fold.ctxt, doc.id(), doc.methods)
with doc
methods: merge_methods(fold.ctxt, doc.id(), doc.methods),
.. doc
}
}
@ -159,8 +159,8 @@ fn merge_methods(
) -> ~[doc::methoddoc] {
do par::map(docs) |doc| {
{
sig: get_method_sig(srv, item_id, doc.name)
with doc
sig: get_method_sig(srv, item_id, doc.name),
.. doc
}
}
}
@ -258,8 +258,8 @@ fn fold_impl(
{
trait_types: trait_types,
self_ty: self_ty,
methods: merge_methods(fold.ctxt, doc.id(), doc.methods)
with doc
methods: merge_methods(fold.ctxt, doc.id(), doc.methods),
.. doc
}
}
@ -311,8 +311,8 @@ fn fold_type(
}
_ => fail ~"expected type"
}
}
with doc
},
.. doc
}
}

2
src/test/compile-fail/fru-extra-field.rs

@ -7,5 +7,5 @@ type point = {x: int, y: int};
fn main() {
let origin: point = {x: 0, y: 0};
let origin3d: point = {z: 0 with origin};
let origin3d: point = {z: 0,.. origin};
}

2
src/test/compile-fail/liveness-init-in-fru.rs

@ -4,6 +4,6 @@ type point = {x: int, y: int};
fn main() {
let mut origin: point;
origin = {x: 10 with origin}; //~ ERROR use of possibly uninitialized variable: `origin`
origin = {x: 10,.. origin}; //~ ERROR use of possibly uninitialized variable: `origin`
copy origin;
}

2
src/test/compile-fail/rec-extend.rs

@ -4,5 +4,5 @@ fn main() {
let a = {foo: 0i};
let b = {foo: true with a};
let b = {foo: true,.. a};
}

2
src/test/compile-fail/record-with-resource.rs

@ -9,7 +9,7 @@ struct my_resource {
fn main() {
{
let a = {x: 0, y: my_resource(20)};
let b = {x: 2 with a};
let b = {x: 2,.. a};
log(error, (a, b));
}
}

2
src/test/run-fail/issue-948.rs

@ -1,5 +1,5 @@
// error-pattern:beep boop
fn main() {
let origin = {x: 0, y: 0};
let f: {x:int,y:int} = {x: (fail ~"beep boop") with origin};
let f: {x:int,y:int} = {x: (fail ~"beep boop"),.. origin};
}

4
src/test/run-pass/issue-2463.rs

@ -8,12 +8,12 @@ fn main() {
let y = {
f: 1,
g: 1,
with x
.. x
};
let z = {
f: 1,
with x
.. x
};
}

2
src/test/run-pass/morestack4.rs

@ -47,7 +47,7 @@ type biggy = {
fn getbig(i: biggy) {
if i.a00 != 0u64 {
getbig({a00: i.a00 - 1u64 with i});
getbig({a00: i.a00 - 1u64,.. i});
}
}

4
src/test/run-pass/rec-extend.rs

@ -6,8 +6,8 @@ type point = {x: int, y: int};
fn main() {
let origin: point = {x: 0, y: 0};
let right: point = {x: origin.x + 10 with origin};
let up: point = {y: origin.y + 10 with origin};
let right: point = {x: origin.x + 10,.. origin};
let up: point = {y: origin.y + 10,.. origin};
assert (origin.x == 0);
assert (origin.y == 0);
assert (right.x == 10);