rust-lang/rust
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

core: Replace map/map_default with map_ref/map_default_ref

Browse Source
This commit is contained in:
Brian Anderson
2012-09-26 16:27:12 -07:00
parent 64de6d638d
commit e8fe718bfd
30 changed files with 79 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
src/libsyntax/fold.rs
View File

@@ -114,7 +114,7 @@ fn fold_mac_(m: mac, fld: ast_fold) -> mac {
match m.node {
mac_invoc(pth, arg, body) => {
mac_invoc(fld.fold_path(pth),
option::map(&arg, |x| fld.fold_expr(x)), body)
option::map(&arg, |x| fld.fold_expr(*x)), body)
}
mac_invoc_tt(*) => m.node,
mac_ellipsis => mac_ellipsis,
@@ -243,7 +243,7 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
variants: vec::map(enum_definition.variants,
|x| fld.fold_variant(*x)),
common: option::map(&enum_definition.common,
|x| fold_struct_def(x, fld))
|x| fold_struct_def(*x, fld))
}), fold_ty_params(typms, fld))
}
item_class(struct_def, typms) => {
@@ -252,7 +252,7 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
}
item_impl(tps, ifce, ty, methods) => {
item_impl(fold_ty_params(tps, fld),
ifce.map(|p| fold_trait_ref(p, fld)),
ifce.map(|p| fold_trait_ref(*p, fld)),
fld.fold_ty(ty),
vec::map(methods, |x| fld.fold_method(*x)))
}
@@ -292,7 +292,7 @@ fn fold_struct_def(struct_def: @ast::struct_def, fld: ast_fold)
let dtor_id = fld.new_id(dtor.node.id);
{node: {body: dtor_body,
id: dtor_id,.. dtor.node},
.. dtor}};
.. *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)),
@@ -332,7 +332,7 @@ fn noop_fold_method(&&m: @method, fld: ast_fold) -> @method {
fn noop_fold_block(b: blk_, fld: ast_fold) -> blk_ {
return {view_items: vec::map(b.view_items, |x| fld.fold_view_item(*x)),
stmts: vec::map(b.stmts, |x| fld.fold_stmt(*x)),
expr: option::map(&b.expr, |x| fld.fold_expr(x)),
expr: option::map(&b.expr, |x| fld.fold_expr(*x)),
id: fld.new_id(b.id),
rules: b.rules};
}
@@ -347,7 +347,7 @@ fn noop_fold_stmt(s: stmt_, fld: ast_fold) -> stmt_ {
fn noop_fold_arm(a: arm, fld: ast_fold) -> arm {
return {pats: vec::map(a.pats, |x| fld.fold_pat(*x)),
guard: option::map(&a.guard, |x| fld.fold_expr(x)),
guard: option::map(&a.guard, |x| fld.fold_expr(*x)),
body: fld.fold_block(a.body)};
}
@@ -357,12 +357,12 @@ fn noop_fold_pat(p: pat_, fld: ast_fold) -> pat_ {
pat_ident(binding_mode, pth, sub) => {
pat_ident(binding_mode,
fld.fold_path(pth),
option::map(&sub, |x| fld.fold_pat(x)))
option::map(&sub, |x| fld.fold_pat(*x)))
}
pat_lit(e) => pat_lit(fld.fold_expr(e)),
pat_enum(pth, pats) => {
pat_enum(fld.fold_path(pth), option::map(&pats,
|pats| vec::map(pats, |x| fld.fold_pat(*x))))
|pats| vec::map(*pats, |x| fld.fold_pat(*x))))
}
pat_rec(fields, etc) => {
let mut fs = ~[];
@@ -432,7 +432,7 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
expr_repeat(fld.fold_expr(expr), fld.fold_expr(count), mutt),
expr_rec(fields, maybe_expr) => {
expr_rec(vec::map(fields, |x| fold_field(*x)),
option::map(&maybe_expr, |x| fld.fold_expr(x)))
option::map(&maybe_expr, |x| fld.fold_expr(*x)))
}
expr_tup(elts) => expr_tup(vec::map(elts, |x| fld.fold_expr(*x))),
expr_call(f, args, blk) => {
@@ -451,14 +451,14 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
expr_addr_of(m, ohs) => expr_addr_of(m, fld.fold_expr(ohs)),
expr_if(cond, tr, fl) => {
expr_if(fld.fold_expr(cond), fld.fold_block(tr),
option::map(&fl, |x| fld.fold_expr(x)))
option::map(&fl, |x| fld.fold_expr(*x)))
}
expr_while(cond, body) => {
expr_while(fld.fold_expr(cond), fld.fold_block(body))
}
expr_loop(body, opt_ident) => {
expr_loop(fld.fold_block(body),
option::map(&opt_ident, |x| fld.fold_ident(x)))
option::map(&opt_ident, |x| fld.fold_ident(*x)))
}
expr_match(expr, arms) => {
expr_match(fld.fold_expr(expr),
@@ -500,12 +500,12 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
expr_index(fld.fold_expr(el), fld.fold_expr(er))
}
expr_path(pth) => expr_path(fld.fold_path(pth)),
expr_fail(e) => expr_fail(option::map(&e, |x| fld.fold_expr(x))),
expr_fail(e) => expr_fail(option::map(&e, |x| fld.fold_expr(*x))),
expr_break(opt_ident) =>
expr_break(option::map(&opt_ident, |x| fld.fold_ident(x))),
expr_break(option::map(&opt_ident, |x| fld.fold_ident(*x))),
expr_again(opt_ident) =>
expr_again(option::map(&opt_ident, |x| fld.fold_ident(x))),
expr_ret(e) => expr_ret(option::map(&e, |x| fld.fold_expr(x))),
expr_again(option::map(&opt_ident, |x| fld.fold_ident(*x))),
expr_ret(e) => expr_ret(option::map(&e, |x| fld.fold_expr(*x))),
expr_log(i, lv, e) => expr_log(i, fld.fold_expr(lv),
fld.fold_expr(e)),
expr_assert(e) => expr_assert(fld.fold_expr(e)),
@@ -513,7 +513,7 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
expr_struct(path, fields, maybe_expr) => {
expr_struct(fld.fold_path(path),
vec::map(fields, |x| fold_field(*x)),
option::map(&maybe_expr, |x| fld.fold_expr(x)))
option::map(&maybe_expr, |x| fld.fold_expr(*x)))
}
}
}
@@ -577,7 +577,7 @@ fn noop_fold_variant(v: variant_, fld: ast_fold) -> variant_ {
let dtor_id = fld.new_id(dtor.node.id);
{node: {body: dtor_body,
id: dtor_id,.. dtor.node},
.. dtor}};
.. *dtor}};
kind = struct_variant_kind(@{
traits: ~[],
fields: vec::map(struct_def.fields,
@@ -593,7 +593,7 @@ fn noop_fold_variant(v: variant_, fld: ast_fold) -> variant_ {
let variants = vec::map(enum_definition.variants,
|x| fld.fold_variant(*x));
let common = option::map(&enum_definition.common,
|x| fold_struct_def(x, fld));
|x| fold_struct_def(*x, fld));
kind = enum_variant_kind(ast::enum_def({ variants: variants,
common: common }));
}