Skip to content

Commit 40fc173

Browse files
msullivanmsullivan
committed
Get rid of places that expected foo.bar to implicitly bind.
1 parent 25b1523 commit 40fc173

File tree

3 files changed

+52
-49
lines changed

3 files changed

+52
-49
lines changed

Diff for: ‎src/libsyntax/fold.rs

+37-34
Original file line numberDiff line numberDiff line change
@@ -119,7 +119,7 @@ fn fold_mac_(m: mac, fld: ast_fold) -> mac {
119119
alt m.node {
120120
mac_invoc(pth, arg, body) {
121121
mac_invoc(fld.fold_path(pth),
122-
option::map(arg, fld.fold_expr), body)
122+
option::map(arg, |x| fld.fold_expr(x)), body)
123123
}
124124
mac_invoc_tt(pth, tt) { m.node }
125125
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 {
136136
output: fld.fold_ty(decl.output),
137137
purity: decl.purity,
138138
cf: decl.cf,
139-
constraints: vec::map(decl.constraints, fld.fold_constr)}
139+
constraints: vec::map(decl.constraints, |x| fld.fold_constr(x))}
140140
}
141141

142142
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_ {
160160
let fold_meta_item = |x| fold_meta_item_(x, fld);
161161
let fold_attribute = |x| fold_attribute_(x, fld);
162162

163-
ret {directives: vec::map(c.directives, fld.fold_crate_directive),
163+
ret {directives: vec::map(c.directives, |x| fld.fold_crate_directive(x)),
164164
module: fld.fold_mod(c.module),
165165
attrs: vec::map(c.attrs, fold_attribute),
166166
config: vec::map(c.config, fold_meta_item)};
@@ -174,7 +174,7 @@ fn noop_fold_crate_directive(cd: crate_directive_, fld: ast_fold) ->
174174
}
175175
cdir_dir_mod(id, cds, attrs) {
176176
cdir_dir_mod(fld.fold_ident(id),
177-
vec::map(cds, fld.fold_crate_directive),
177+
vec::map(cds, |x| fld.fold_crate_directive(x)),
178178
/* FIXME (#2543) */ copy attrs)
179179
}
180180
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)
203203
cf: fdec.cf,
204204
constraints:
205205
vec::map(fdec.constraints,
206-
fld.fold_constr)},
206+
|x| fld.fold_constr(x))},
207207
fold_ty_params(typms, fld))
208208
}
209209
},
@@ -248,7 +248,7 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
248248
fold_ty_params(typms, fld),
249249
rp) }
250250
item_enum(variants, typms, r) {
251-
item_enum(vec::map(variants, fld.fold_variant),
251+
item_enum(vec::map(variants, |x| fld.fold_variant(x)),
252252
fold_ty_params(typms, fld),
253253
r)
254254
}
@@ -265,7 +265,7 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
265265
item_class(
266266
/* FIXME (#2543) */ copy typms,
267267
vec::map(traits, |p| fold_trait_ref(p, fld)),
268-
vec::map(items, fld.fold_class_item),
268+
vec::map(items, |x| fld.fold_class_item(x)),
269269
{node: {body: ctor_body,
270270
dec: ctor_decl,
271271
id: ctor_id with ctor.node}
@@ -276,7 +276,7 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
276276
rp,
277277
ifce.map(|p| fold_trait_ref(p, fld)),
278278
fld.fold_ty(ty),
279-
vec::map(methods, fld.fold_method))
279+
vec::map(methods, |x| fld.fold_method(x)))
280280
}
281281
item_trait(tps, rp, methods) {
282282
item_trait(fold_ty_params(tps, fld),
@@ -308,9 +308,9 @@ fn noop_fold_method(&&m: @method, fld: ast_fold) -> @method {
308308

309309

310310
fn noop_fold_block(b: blk_, fld: ast_fold) -> blk_ {
311-
ret {view_items: vec::map(b.view_items, fld.fold_view_item),
312-
stmts: vec::map(b.stmts, fld.fold_stmt),
313-
expr: option::map(b.expr, fld.fold_expr),
311+
ret {view_items: vec::map(b.view_items, |x| fld.fold_view_item(x)),
312+
stmts: vec::map(b.stmts, |x| fld.fold_stmt(x)),
313+
expr: option::map(b.expr, |x| fld.fold_expr(x)),
314314
id: fld.new_id(b.id),
315315
rules: b.rules};
316316
}
@@ -324,21 +324,22 @@ fn noop_fold_stmt(s: stmt_, fld: ast_fold) -> stmt_ {
324324
}
325325

326326
fn noop_fold_arm(a: arm, fld: ast_fold) -> arm {
327-
ret {pats: vec::map(a.pats, fld.fold_pat),
328-
guard: option::map(a.guard, fld.fold_expr),
327+
ret {pats: vec::map(a.pats, |x| fld.fold_pat(x)),
328+
guard: option::map(a.guard, |x| fld.fold_expr(x)),
329329
body: fld.fold_block(a.body)};
330330
}
331331

332332
fn noop_fold_pat(p: pat_, fld: ast_fold) -> pat_ {
333333
ret alt p {
334334
pat_wild { pat_wild }
335335
pat_ident(pth, sub) {
336-
pat_ident(fld.fold_path(pth), option::map(sub, fld.fold_pat))
336+
pat_ident(fld.fold_path(pth),
337+
option::map(sub, |x| fld.fold_pat(x)))
337338
}
338339
pat_lit(e) { pat_lit(fld.fold_expr(e)) }
339340
pat_enum(pth, pats) {
340341
pat_enum(fld.fold_path(pth), option::map(pats,
341-
|pats| vec::map(pats, fld.fold_pat)))
342+
|pats| vec::map(pats, |x| fld.fold_pat(x))))
342343
}
343344
pat_rec(fields, etc) {
344345
let mut fs = ~[];
@@ -349,7 +350,7 @@ fn noop_fold_pat(p: pat_, fld: ast_fold) -> pat_ {
349350
}
350351
pat_rec(fs, etc)
351352
}
352-
pat_tup(elts) { pat_tup(vec::map(elts, fld.fold_pat)) }
353+
pat_tup(elts) { pat_tup(vec::map(elts, |x| fld.fold_pat(x))) }
353354
pat_box(inner) { pat_box(fld.fold_pat(inner)) }
354355
pat_uniq(inner) { pat_uniq(fld.fold_pat(inner)) }
355356
pat_range(e1, e2) {
@@ -360,7 +361,7 @@ fn noop_fold_pat(p: pat_, fld: ast_fold) -> pat_ {
360361

361362
fn noop_fold_decl(d: decl_, fld: ast_fold) -> decl_ {
362363
alt d {
363-
decl_local(ls) { decl_local(vec::map(ls, fld.fold_local)) }
364+
decl_local(ls) { decl_local(vec::map(ls, |x| fld.fold_local(x))) }
364365
decl_item(it) {
365366
alt fld.fold_item(it) {
366367
some(it_folded) { decl_item(it_folded) }
@@ -400,15 +401,16 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
400401
expr_vstore(fld.fold_expr(e), v)
401402
}
402403
expr_vec(exprs, mutt) {
403-
expr_vec(fld.map_exprs(fld.fold_expr, exprs), mutt)
404+
expr_vec(fld.map_exprs(|x| fld.fold_expr(x), exprs), mutt)
404405
}
405406
expr_rec(fields, maybe_expr) {
406407
expr_rec(vec::map(fields, fold_field),
407-
option::map(maybe_expr, fld.fold_expr))
408+
option::map(maybe_expr, |x| fld.fold_expr(x)))
408409
}
409-
expr_tup(elts) { expr_tup(vec::map(elts, fld.fold_expr)) }
410+
expr_tup(elts) { expr_tup(vec::map(elts, |x| fld.fold_expr(x))) }
410411
expr_call(f, args, blk) {
411-
expr_call(fld.fold_expr(f), fld.map_exprs(fld.fold_expr, args),
412+
expr_call(fld.fold_expr(f),
413+
fld.map_exprs(|x| fld.fold_expr(x), args),
412414
blk)
413415
}
414416
expr_binary(binop, lhs, rhs) {
@@ -422,7 +424,7 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
422424
expr_addr_of(m, ohs) { expr_addr_of(m, fld.fold_expr(ohs)) }
423425
expr_if(cond, tr, fl) {
424426
expr_if(fld.fold_expr(cond), fld.fold_block(tr),
425-
option::map(fl, fld.fold_expr))
427+
option::map(fl, |x| fld.fold_expr(x)))
426428
}
427429
expr_while(cond, body) {
428430
expr_while(fld.fold_expr(cond), fld.fold_block(body))
@@ -431,7 +433,8 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
431433
expr_loop(fld.fold_block(body))
432434
}
433435
expr_alt(expr, arms, mode) {
434-
expr_alt(fld.fold_expr(expr), vec::map(arms, fld.fold_arm), mode)
436+
expr_alt(fld.fold_expr(expr),
437+
vec::map(arms, |x| fld.fold_arm(x)), mode)
435438
}
436439
expr_fn(proto, decl, body, captures) {
437440
expr_fn(proto, fold_fn_decl(decl, fld),
@@ -462,22 +465,22 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
462465
}
463466
expr_field(el, id, tys) {
464467
expr_field(fld.fold_expr(el), fld.fold_ident(id),
465-
vec::map(tys, fld.fold_ty))
468+
vec::map(tys, |x| fld.fold_ty(x)))
466469
}
467470
expr_index(el, er) {
468471
expr_index(fld.fold_expr(el), fld.fold_expr(er))
469472
}
470473
expr_path(pth) { expr_path(fld.fold_path(pth)) }
471-
expr_fail(e) { expr_fail(option::map(e, fld.fold_expr)) }
474+
expr_fail(e) { expr_fail(option::map(e, |x| fld.fold_expr(x))) }
472475
expr_break | expr_again { copy e }
473-
expr_ret(e) { expr_ret(option::map(e, fld.fold_expr)) }
476+
expr_ret(e) { expr_ret(option::map(e, |x| fld.fold_expr(x))) }
474477
expr_log(i, lv, e) { expr_log(i, fld.fold_expr(lv),
475478
fld.fold_expr(e)) }
476479
expr_assert(e) { expr_assert(fld.fold_expr(e)) }
477480
expr_check(m, e) { expr_check(m, fld.fold_expr(e)) }
478481
expr_if_check(cond, tr, fl) {
479482
expr_if_check(fld.fold_expr(cond), fld.fold_block(tr),
480-
option::map(fl, fld.fold_expr))
483+
option::map(fl, |x| fld.fold_expr(x)))
481484
}
482485
expr_mac(mac) { expr_mac(fold_mac(mac)) }
483486
}
@@ -505,7 +508,7 @@ fn noop_fold_ty(t: ty_, fld: ast_fold) -> ty_ {
505508
ty_tup(tys) {ty_tup(vec::map(tys, |ty| fld.fold_ty(ty)))}
506509
ty_path(path, id) {ty_path(fld.fold_path(path), fld.new_id(id))}
507510
ty_constr(ty, constrs) {ty_constr(fld.fold_ty(ty),
508-
vec::map(constrs, fld.fold_ty_constr))}
511+
vec::map(constrs, |x| fld.fold_ty_constr(x)))}
509512
ty_vstore(t, vs) {ty_vstore(fld.fold_ty(t), vs)}
510513
ty_mac(mac) {ty_mac(fold_mac(mac))}
511514
}
@@ -524,13 +527,13 @@ fn noop_fold_ty_constr(c: ty_constr_, fld: ast_fold) -> ty_constr_ {
524527
}
525528
// ...nor do modules
526529
fn noop_fold_mod(m: _mod, fld: ast_fold) -> _mod {
527-
ret {view_items: vec::map(m.view_items, fld.fold_view_item),
528-
items: vec::filter_map(m.items, fld.fold_item)};
530+
ret {view_items: vec::map(m.view_items, |x| fld.fold_view_item(x)),
531+
items: vec::filter_map(m.items, |x| fld.fold_item(x))};
529532
}
530533

531534
fn noop_fold_foreign_mod(nm: foreign_mod, fld: ast_fold) -> foreign_mod {
532-
ret {view_items: vec::map(nm.view_items, fld.fold_view_item),
533-
items: vec::map(nm.items, fld.fold_foreign_item)}
535+
ret {view_items: vec::map(nm.view_items, |x| fld.fold_view_item(x)),
536+
items: vec::map(nm.items, |x| fld.fold_foreign_item(x))}
534537
}
535538

536539
fn noop_fold_variant(v: variant_, fld: ast_fold) -> variant_ {
@@ -560,9 +563,9 @@ fn noop_fold_ident(&&i: ident, _fld: ast_fold) -> ident {
560563

561564
fn noop_fold_path(&&p: path, fld: ast_fold) -> path {
562565
ret {span: fld.new_span(p.span), global: p.global,
563-
idents: vec::map(p.idents, fld.fold_ident),
566+
idents: vec::map(p.idents, |x| fld.fold_ident(x)),
564567
rp: p.rp,
565-
types: vec::map(p.types, fld.fold_ty)};
568+
types: vec::map(p.types, |x| fld.fold_ty(x))};
566569
}
567570

568571
fn noop_fold_local(l: local_, fld: ast_fold) -> local_ {

Diff for: ‎src/rustc/front/config.rs

+5-5
Original file line numberDiff line numberDiff line change
@@ -54,8 +54,8 @@ fn fold_mod(cx: ctxt, m: ast::_mod, fld: fold::ast_fold) ->
5454
let filtered_items = vec::filter_map(m.items, item_filter);
5555
let view_item_filter = |a| filter_view_item(cx, a);
5656
let filtered_view_items = vec::filter_map(m.view_items, view_item_filter);
57-
ret {view_items: vec::map(filtered_view_items, fld.fold_view_item),
58-
items: vec::filter_map(filtered_items, fld.fold_item)};
57+
ret {view_items: vec::map(filtered_view_items, |x| fld.fold_view_item(x)),
58+
items: vec::filter_map(filtered_items, |x| fld.fold_item(x))};
5959
}
6060

6161
fn filter_foreign_item(cx: ctxt, &&item: @ast::foreign_item) ->
@@ -72,7 +72,7 @@ fn fold_foreign_mod(cx: ctxt, nm: ast::foreign_mod,
7272
let view_item_filter = |a| filter_view_item(cx, a);
7373
let filtered_view_items = vec::filter_map(
7474
nm.view_items, view_item_filter);
75-
ret {view_items: vec::map(filtered_view_items, fld.fold_view_item),
75+
ret {view_items: vec::map(filtered_view_items, |x| fld.fold_view_item(x)),
7676
items: filtered_items};
7777
}
7878

@@ -98,8 +98,8 @@ fn fold_block(cx: ctxt, b: ast::blk_, fld: fold::ast_fold) ->
9898
let filter = |a| filter_stmt(cx, a);
9999
let filtered_stmts = vec::filter_map(b.stmts, filter);
100100
ret {view_items: b.view_items,
101-
stmts: vec::map(filtered_stmts, fld.fold_stmt),
102-
expr: option::map(b.expr, fld.fold_expr),
101+
stmts: vec::map(filtered_stmts, |x| fld.fold_stmt(x)),
102+
expr: option::map(b.expr, |x| fld.fold_expr(x)),
103103
id: b.id,
104104
rules: b.rules};
105105
}

Diff for: ‎src/test/run-pass/numeric-method-autoexport.rs

+10-10
Original file line numberDiff line numberDiff line change
@@ -11,11 +11,11 @@ fn main() {
1111
assert 15i32.add(6i32) == 21i32;
1212
assert 15i64.add(6i64) == 21i64;
1313
// times
14-
let bar = 15.times;
15-
let bar = 15i8.times;
16-
let bar = 15i16.times;
17-
let bar = 15i32.times;
18-
let bar = 15i64.times;
14+
15.times(|| false);
15+
15i8.times(|| false);
16+
15i16.times(|| false);
17+
15i32.times(|| false);
18+
15i64.times(|| false);
1919

2020
// uints
2121
// num
@@ -25,11 +25,11 @@ fn main() {
2525
assert 15u32.add(6u32) == 21u32;
2626
assert 15u64.add(6u64) == 21u64;
2727
// times
28-
let bar = 15u.times;
29-
let bar = 15u8.times;
30-
let bar = 15u16.times;
31-
let bar = 15u32.times;
32-
let bar = 15u64.times;
28+
15u.times(|| false);
29+
15u8.times(|| false);
30+
15u16.times(|| false);
31+
15u32.times(|| false);
32+
15u64.times(|| false);
3333

3434
// floats
3535
// num

0 commit comments

Comments
 (0)