bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Get rid of places that expected foo.bar to implicitly bind.

Browse source
This commit is contained in:
Michael Sullivan 2012-07-09 19:12:50 -07:00
parent 25b152397d
commit 40fc1737b2
3 changed files with 52 additions and 49 deletions
Download patch file Download diff file Expand all files Collapse all files

71
src/libsyntax/fold.rs
View file

@ -119,7 +119,7 @@ fn fold_mac_(m: mac, fld: ast_fold) -> mac {
alt m.node { alt m.node {
mac_invoc(pth, arg, body) { mac_invoc(pth, arg, body) {
mac_invoc(fld.fold_path(pth), mac_invoc(fld.fold_path(pth),
option::map(arg, fld.fold_expr), body) option::map(arg, |x| fld.fold_expr(x)), body)
} }
mac_invoc_tt(pth, tt) { m.node } mac_invoc_tt(pth, tt) { m.node }
mac_embed_type(ty) { mac_embed_type(fld.fold_ty(ty)) } mac_embed_type(ty) { mac_embed_type(fld.fold_ty(ty)) }
@ -136,7 +136,7 @@ fn fold_fn_decl(decl: ast::fn_decl, fld: ast_fold) -> ast::fn_decl {
output: fld.fold_ty(decl.output), output: fld.fold_ty(decl.output),
purity: decl.purity, purity: decl.purity,
cf: decl.cf, cf: decl.cf,
constraints: vec::map(decl.constraints, fld.fold_constr)} constraints: vec::map(decl.constraints, |x| fld.fold_constr(x))}
} }
fn fold_ty_param_bound(tpb: ty_param_bound, fld: ast_fold) -> ty_param_bound { fn fold_ty_param_bound(tpb: ty_param_bound, fld: ast_fold) -> ty_param_bound {
@ -160,7 +160,7 @@ fn noop_fold_crate(c: crate_, fld: ast_fold) -> crate_ {
let fold_meta_item = |x| fold_meta_item_(x, fld); let fold_meta_item = |x| fold_meta_item_(x, fld);
let fold_attribute = |x| fold_attribute_(x, fld); let fold_attribute = |x| fold_attribute_(x, fld);
ret {directives: vec::map(c.directives, fld.fold_crate_directive), ret {directives: vec::map(c.directives, |x| fld.fold_crate_directive(x)),
module: fld.fold_mod(c.module), module: fld.fold_mod(c.module),
attrs: vec::map(c.attrs, fold_attribute), attrs: vec::map(c.attrs, fold_attribute),
config: vec::map(c.config, fold_meta_item)}; config: vec::map(c.config, fold_meta_item)};
@ -174,7 +174,7 @@ fn noop_fold_crate_directive(cd: crate_directive_, fld: ast_fold) ->
} }
cdir_dir_mod(id, cds, attrs) { cdir_dir_mod(id, cds, attrs) {
cdir_dir_mod(fld.fold_ident(id), cdir_dir_mod(fld.fold_ident(id),
vec::map(cds, fld.fold_crate_directive), vec::map(cds, |x| fld.fold_crate_directive(x)),
/* FIXME (#2543) */ copy attrs) /* FIXME (#2543) */ copy attrs)
} }
cdir_view_item(vi) { cdir_view_item(fld.fold_view_item(vi)) } cdir_view_item(vi) { cdir_view_item(fld.fold_view_item(vi)) }
@ -203,7 +203,7 @@ fn noop_fold_foreign_item(&&ni: @foreign_item, fld: ast_fold)
cf: fdec.cf, cf: fdec.cf,
constraints: constraints:
vec::map(fdec.constraints, vec::map(fdec.constraints,
fld.fold_constr)}, |x| fld.fold_constr(x))},
fold_ty_params(typms, fld)) fold_ty_params(typms, fld))
} }
}, },
@ -248,7 +248,7 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
fold_ty_params(typms, fld), fold_ty_params(typms, fld),
rp) } rp) }
item_enum(variants, typms, r) { item_enum(variants, typms, r) {
item_enum(vec::map(variants, fld.fold_variant), item_enum(vec::map(variants, |x| fld.fold_variant(x)),
fold_ty_params(typms, fld), fold_ty_params(typms, fld),
r) r)
} }
@ -265,7 +265,7 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
item_class( item_class(
/* FIXME (#2543) */ copy typms, /* FIXME (#2543) */ copy typms,
vec::map(traits, |p| fold_trait_ref(p, fld)), vec::map(traits, |p| fold_trait_ref(p, fld)),
vec::map(items, fld.fold_class_item), vec::map(items, |x| fld.fold_class_item(x)),
{node: {body: ctor_body, {node: {body: ctor_body,
dec: ctor_decl, dec: ctor_decl,
id: ctor_id with ctor.node} id: ctor_id with ctor.node}
@ -276,7 +276,7 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
rp, rp,
ifce.map(|p| fold_trait_ref(p, fld)), ifce.map(|p| fold_trait_ref(p, fld)),
fld.fold_ty(ty), fld.fold_ty(ty),
vec::map(methods, fld.fold_method)) vec::map(methods, |x| fld.fold_method(x)))
} }
item_trait(tps, rp, methods) { item_trait(tps, rp, methods) {
item_trait(fold_ty_params(tps, fld), item_trait(fold_ty_params(tps, fld),
@ -308,9 +308,9 @@ fn noop_fold_method(&&m: @method, fld: ast_fold) -> @method {
fn noop_fold_block(b: blk_, fld: ast_fold) -> blk_ { fn noop_fold_block(b: blk_, fld: ast_fold) -> blk_ {
ret {view_items: vec::map(b.view_items, fld.fold_view_item), ret {view_items: vec::map(b.view_items, |x| fld.fold_view_item(x)),
stmts: vec::map(b.stmts, fld.fold_stmt), stmts: vec::map(b.stmts, |x| fld.fold_stmt(x)),
expr: option::map(b.expr, fld.fold_expr), expr: option::map(b.expr, |x| fld.fold_expr(x)),
id: fld.new_id(b.id), id: fld.new_id(b.id),
rules: b.rules}; rules: b.rules};
} }
@ -324,8 +324,8 @@ fn noop_fold_stmt(s: stmt_, fld: ast_fold) -> stmt_ {
} }
fn noop_fold_arm(a: arm, fld: ast_fold) -> arm { fn noop_fold_arm(a: arm, fld: ast_fold) -> arm {
ret {pats: vec::map(a.pats, fld.fold_pat), ret {pats: vec::map(a.pats, |x| fld.fold_pat(x)),
guard: option::map(a.guard, fld.fold_expr), guard: option::map(a.guard, |x| fld.fold_expr(x)),
body: fld.fold_block(a.body)}; body: fld.fold_block(a.body)};
} }
@ -333,12 +333,13 @@ fn noop_fold_pat(p: pat_, fld: ast_fold) -> pat_ {
ret alt p { ret alt p {
pat_wild { pat_wild } pat_wild { pat_wild }
pat_ident(pth, sub) { pat_ident(pth, sub) {
pat_ident(fld.fold_path(pth), option::map(sub, fld.fold_pat)) pat_ident(fld.fold_path(pth),
option::map(sub, |x| fld.fold_pat(x)))
} }
pat_lit(e) { pat_lit(fld.fold_expr(e)) } pat_lit(e) { pat_lit(fld.fold_expr(e)) }
pat_enum(pth, pats) { pat_enum(pth, pats) {
pat_enum(fld.fold_path(pth), option::map(pats, pat_enum(fld.fold_path(pth), option::map(pats,
|pats| vec::map(pats, fld.fold_pat))) |pats| vec::map(pats, |x| fld.fold_pat(x))))
} }
pat_rec(fields, etc) { pat_rec(fields, etc) {
let mut fs = ~[]; let mut fs = ~[];
@ -349,7 +350,7 @@ fn noop_fold_pat(p: pat_, fld: ast_fold) -> pat_ {
} }
pat_rec(fs, etc) pat_rec(fs, etc)
} }
pat_tup(elts) { pat_tup(vec::map(elts, fld.fold_pat)) } pat_tup(elts) { pat_tup(vec::map(elts, |x| fld.fold_pat(x))) }
pat_box(inner) { pat_box(fld.fold_pat(inner)) } pat_box(inner) { pat_box(fld.fold_pat(inner)) }
pat_uniq(inner) { pat_uniq(fld.fold_pat(inner)) } pat_uniq(inner) { pat_uniq(fld.fold_pat(inner)) }
pat_range(e1, e2) { pat_range(e1, e2) {
@ -360,7 +361,7 @@ fn noop_fold_pat(p: pat_, fld: ast_fold) -> pat_ {
fn noop_fold_decl(d: decl_, fld: ast_fold) -> decl_ { fn noop_fold_decl(d: decl_, fld: ast_fold) -> decl_ {
alt d { alt d {
decl_local(ls) { decl_local(vec::map(ls, fld.fold_local)) } decl_local(ls) { decl_local(vec::map(ls, |x| fld.fold_local(x))) }
decl_item(it) { decl_item(it) {
alt fld.fold_item(it) { alt fld.fold_item(it) {
some(it_folded) { decl_item(it_folded) } some(it_folded) { decl_item(it_folded) }
@ -400,15 +401,16 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
expr_vstore(fld.fold_expr(e), v) expr_vstore(fld.fold_expr(e), v)
} }
expr_vec(exprs, mutt) { expr_vec(exprs, mutt) {
expr_vec(fld.map_exprs(fld.fold_expr, exprs), mutt) expr_vec(fld.map_exprs(|x| fld.fold_expr(x), exprs), mutt)
} }
expr_rec(fields, maybe_expr) { expr_rec(fields, maybe_expr) {
expr_rec(vec::map(fields, fold_field), expr_rec(vec::map(fields, fold_field),
option::map(maybe_expr, fld.fold_expr)) option::map(maybe_expr, |x| fld.fold_expr(x)))
} }
expr_tup(elts) { expr_tup(vec::map(elts, fld.fold_expr)) } expr_tup(elts) { expr_tup(vec::map(elts, |x| fld.fold_expr(x))) }
expr_call(f, args, blk) { expr_call(f, args, blk) {
expr_call(fld.fold_expr(f), fld.map_exprs(fld.fold_expr, args), expr_call(fld.fold_expr(f),
fld.map_exprs(|x| fld.fold_expr(x), args),
blk) blk)
} }
expr_binary(binop, lhs, rhs) { expr_binary(binop, lhs, rhs) {
@ -422,7 +424,7 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
expr_addr_of(m, ohs) { expr_addr_of(m, fld.fold_expr(ohs)) } expr_addr_of(m, ohs) { expr_addr_of(m, fld.fold_expr(ohs)) }
expr_if(cond, tr, fl) { expr_if(cond, tr, fl) {
expr_if(fld.fold_expr(cond), fld.fold_block(tr), expr_if(fld.fold_expr(cond), fld.fold_block(tr),
option::map(fl, fld.fold_expr)) option::map(fl, |x| fld.fold_expr(x)))
} }
expr_while(cond, body) { expr_while(cond, body) {
expr_while(fld.fold_expr(cond), fld.fold_block(body)) expr_while(fld.fold_expr(cond), fld.fold_block(body))
@ -431,7 +433,8 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
expr_loop(fld.fold_block(body)) expr_loop(fld.fold_block(body))
} }
expr_alt(expr, arms, mode) { expr_alt(expr, arms, mode) {
expr_alt(fld.fold_expr(expr), vec::map(arms, fld.fold_arm), mode) expr_alt(fld.fold_expr(expr),
vec::map(arms, |x| fld.fold_arm(x)), mode)
} }
expr_fn(proto, decl, body, captures) { expr_fn(proto, decl, body, captures) {
expr_fn(proto, fold_fn_decl(decl, fld), expr_fn(proto, fold_fn_decl(decl, fld),
@ -462,22 +465,22 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
} }
expr_field(el, id, tys) { expr_field(el, id, tys) {
expr_field(fld.fold_expr(el), fld.fold_ident(id), expr_field(fld.fold_expr(el), fld.fold_ident(id),
vec::map(tys, fld.fold_ty)) vec::map(tys, |x| fld.fold_ty(x)))
} }
expr_index(el, er) { expr_index(el, er) {
expr_index(fld.fold_expr(el), fld.fold_expr(er)) expr_index(fld.fold_expr(el), fld.fold_expr(er))
} }
expr_path(pth) { expr_path(fld.fold_path(pth)) } expr_path(pth) { expr_path(fld.fold_path(pth)) }
expr_fail(e) { expr_fail(option::map(e, fld.fold_expr)) } expr_fail(e) { expr_fail(option::map(e, |x| fld.fold_expr(x))) }
expr_break | expr_again { copy e } expr_break | expr_again { copy e }
expr_ret(e) { expr_ret(option::map(e, fld.fold_expr)) } 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), expr_log(i, lv, e) { expr_log(i, fld.fold_expr(lv),
fld.fold_expr(e)) } fld.fold_expr(e)) }
expr_assert(e) { expr_assert(fld.fold_expr(e)) } expr_assert(e) { expr_assert(fld.fold_expr(e)) }
expr_check(m, e) { expr_check(m, fld.fold_expr(e)) } expr_check(m, e) { expr_check(m, fld.fold_expr(e)) }
expr_if_check(cond, tr, fl) { expr_if_check(cond, tr, fl) {
expr_if_check(fld.fold_expr(cond), fld.fold_block(tr), expr_if_check(fld.fold_expr(cond), fld.fold_block(tr),
option::map(fl, fld.fold_expr)) option::map(fl, |x| fld.fold_expr(x)))
} }
expr_mac(mac) { expr_mac(fold_mac(mac)) } expr_mac(mac) { expr_mac(fold_mac(mac)) }
} }
@ -505,7 +508,7 @@ fn noop_fold_ty(t: ty_, fld: ast_fold) -> ty_ {
ty_tup(tys) {ty_tup(vec::map(tys, |ty| fld.fold_ty(ty)))} ty_tup(tys) {ty_tup(vec::map(tys, |ty| fld.fold_ty(ty)))}
ty_path(path, id) {ty_path(fld.fold_path(path), fld.new_id(id))} ty_path(path, id) {ty_path(fld.fold_path(path), fld.new_id(id))}
ty_constr(ty, constrs) {ty_constr(fld.fold_ty(ty), ty_constr(ty, constrs) {ty_constr(fld.fold_ty(ty),
vec::map(constrs, fld.fold_ty_constr))} vec::map(constrs, |x| fld.fold_ty_constr(x)))}
ty_vstore(t, vs) {ty_vstore(fld.fold_ty(t), vs)} ty_vstore(t, vs) {ty_vstore(fld.fold_ty(t), vs)}
ty_mac(mac) {ty_mac(fold_mac(mac))} ty_mac(mac) {ty_mac(fold_mac(mac))}
} }
@ -524,13 +527,13 @@ fn noop_fold_ty_constr(c: ty_constr_, fld: ast_fold) -> ty_constr_ {
} }
// ...nor do modules // ...nor do modules
fn noop_fold_mod(m: _mod, fld: ast_fold) -> _mod { fn noop_fold_mod(m: _mod, fld: ast_fold) -> _mod {
ret {view_items: vec::map(m.view_items, fld.fold_view_item), ret {view_items: vec::map(m.view_items, |x| fld.fold_view_item(x)),
items: vec::filter_map(m.items, fld.fold_item)}; items: vec::filter_map(m.items, |x| fld.fold_item(x))};
} }
fn noop_fold_foreign_mod(nm: foreign_mod, fld: ast_fold) -> foreign_mod { fn noop_fold_foreign_mod(nm: foreign_mod, fld: ast_fold) -> foreign_mod {
ret {view_items: vec::map(nm.view_items, fld.fold_view_item), ret {view_items: vec::map(nm.view_items, |x| fld.fold_view_item(x)),
items: vec::map(nm.items, fld.fold_foreign_item)} items: vec::map(nm.items, |x| fld.fold_foreign_item(x))}
} }
fn noop_fold_variant(v: variant_, fld: ast_fold) -> variant_ { fn noop_fold_variant(v: variant_, fld: ast_fold) -> variant_ {
@ -560,9 +563,9 @@ fn noop_fold_ident(&&i: ident, _fld: ast_fold) -> ident {
fn noop_fold_path(&&p: path, fld: ast_fold) -> path { fn noop_fold_path(&&p: path, fld: ast_fold) -> path {
ret {span: fld.new_span(p.span), global: p.global, ret {span: fld.new_span(p.span), global: p.global,
idents: vec::map(p.idents, fld.fold_ident), idents: vec::map(p.idents, |x| fld.fold_ident(x)),
rp: p.rp, rp: p.rp,
types: vec::map(p.types, fld.fold_ty)}; types: vec::map(p.types, |x| fld.fold_ty(x))};
} }
fn noop_fold_local(l: local_, fld: ast_fold) -> local_ { fn noop_fold_local(l: local_, fld: ast_fold) -> local_ {

10
src/rustc/front/config.rs
View file

@ -54,8 +54,8 @@ fn fold_mod(cx: ctxt, m: ast::_mod, fld: fold::ast_fold) ->
let filtered_items = vec::filter_map(m.items, item_filter); let filtered_items = vec::filter_map(m.items, item_filter);
let view_item_filter = |a| filter_view_item(cx, a); let view_item_filter = |a| filter_view_item(cx, a);
let filtered_view_items = vec::filter_map(m.view_items, view_item_filter); let filtered_view_items = vec::filter_map(m.view_items, view_item_filter);
ret {view_items: vec::map(filtered_view_items, fld.fold_view_item), ret {view_items: vec::map(filtered_view_items, |x| fld.fold_view_item(x)),
items: vec::filter_map(filtered_items, fld.fold_item)}; items: vec::filter_map(filtered_items, |x| fld.fold_item(x))};
} }
fn filter_foreign_item(cx: ctxt, &&item: @ast::foreign_item) -> fn filter_foreign_item(cx: ctxt, &&item: @ast::foreign_item) ->
@ -72,7 +72,7 @@ fn fold_foreign_mod(cx: ctxt, nm: ast::foreign_mod,
let view_item_filter = |a| filter_view_item(cx, a); let view_item_filter = |a| filter_view_item(cx, a);
let filtered_view_items = vec::filter_map( let filtered_view_items = vec::filter_map(
nm.view_items, view_item_filter); nm.view_items, view_item_filter);
ret {view_items: vec::map(filtered_view_items, fld.fold_view_item), ret {view_items: vec::map(filtered_view_items, |x| fld.fold_view_item(x)),
items: filtered_items}; items: filtered_items};
} }
@ -98,8 +98,8 @@ fn fold_block(cx: ctxt, b: ast::blk_, fld: fold::ast_fold) ->
let filter = |a| filter_stmt(cx, a); let filter = |a| filter_stmt(cx, a);
let filtered_stmts = vec::filter_map(b.stmts, filter); let filtered_stmts = vec::filter_map(b.stmts, filter);
ret {view_items: b.view_items, ret {view_items: b.view_items,
stmts: vec::map(filtered_stmts, fld.fold_stmt), stmts: vec::map(filtered_stmts, |x| fld.fold_stmt(x)),
expr: option::map(b.expr, fld.fold_expr), expr: option::map(b.expr, |x| fld.fold_expr(x)),
id: b.id, id: b.id,
rules: b.rules}; rules: b.rules};
} }

20
src/test/run-pass/numeric-method-autoexport.rs
View file

@ -11,11 +11,11 @@ fn main() {
assert 15i32.add(6i32) == 21i32; assert 15i32.add(6i32) == 21i32;
assert 15i64.add(6i64) == 21i64; assert 15i64.add(6i64) == 21i64;
// times // times
let bar = 15.times; 15.times(|| false);
let bar = 15i8.times; 15i8.times(|| false);
let bar = 15i16.times; 15i16.times(|| false);
let bar = 15i32.times; 15i32.times(|| false);
let bar = 15i64.times; 15i64.times(|| false);
// uints // uints
// num // num
@ -25,11 +25,11 @@ fn main() {
assert 15u32.add(6u32) == 21u32; assert 15u32.add(6u32) == 21u32;
assert 15u64.add(6u64) == 21u64; assert 15u64.add(6u64) == 21u64;
// times // times
let bar = 15u.times; 15u.times(|| false);
let bar = 15u8.times; 15u8.times(|| false);
let bar = 15u16.times; 15u16.times(|| false);
let bar = 15u32.times; 15u32.times(|| false);
let bar = 15u64.times; 15u64.times(|| false);
// floats // floats
// num // num