OpenE2K
/
rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge pull request #2684 from mozilla/incoming 

Incoming
This commit is contained in:
Brian Anderson 2012-06-20 20:45:19 -07:00
parent 8395305e71 f331cd9324
commit 0a6943dd31
128 changed files with 639 additions and 892 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

67
doc/rust.md
View File

@ -330,24 +330,32 @@ An _integer literal_ has one of three forms:
* A _binary literal_ starts with the character sequence `U+0030` `U+0062`
(`0b`) and continues as any mixture binary digits and underscores.
By default, an integer literal is of type `int`. An integer literal may be
followed (immediately, without any spaces) by an _integer suffix_, which
changes the type of the literal. There are two kinds of integer literal
suffix:
An integer literal may be followed (immediately, without any spaces) by an
_integer suffix_, which changes the type of the literal. There are two kinds
of integer literal suffix:
* The `u` suffix gives the literal type `uint`.
* The `i` and `u` suffixes give the literal type `int` or `uint`,
respectively.
* Each of the signed and unsigned machine types `u8`, `i8`,
`u16`, `i16`, `u32`, `i32`, `u64` and `i64`
give the literal the corresponding machine type.
The type of an _unsuffixed_ integer literal is determined by type inference.
If a integer type can be _uniquely_ determined from the surrounding program
context, the unsuffixed integer literal has that type. If the program context
underconstrains the type, the unsuffixed integer literal's type is `int`; if
the program context overconstrains the type, it is considered a static type
error.
Examples of integer literals of various forms:
~~~~
123; // type int
123; 0xff00; // type determined by program context;
// defaults to int in absence of type
// information
123u; // type uint
123_u; // type uint
0xff00; // type int
0xff_u8; // type u8
0b1111_1111_1001_0000_i32; // type i32
~~~~
@ -980,7 +988,7 @@ fn pure_foldl<T, U: copy>(ls: list<T>, u: U, f: fn(&&T, &&U) -> U) -> U {
pure fn pure_length<T>(ls: list<T>) -> uint {
fn count<T>(_t: T, &&u: uint) -> uint { u + 1u }
unchecked {
pure_foldl(ls, 0u, count(_, _))
pure_foldl(ls, 0u, count)
}
}
~~~~
@ -1941,49 +1949,6 @@ An example of a call expression:
let x: int = add(1, 2);
~~~~
### Bind expressions
A _bind expression_ constructs a new function from an existing function.^[The
`bind` expression is analogous to the `bind` expression in the Sather
language.] The new function has zero or more of its arguments *bound* into a
new, hidden boxed tuple that holds the bindings. For each concrete argument
passed in the `bind` expression, the corresponding parameter in the existing
function is *omitted* as a parameter of the new function. For each argument
passed the placeholder symbol `_` in the `bind` expression, the corresponding
parameter of the existing function is *retained* as a parameter of the new
function.
Any subsequent invocation of the new function with residual arguments causes
invocation of the existing function with the combination of bound arguments
and residual arguments that was specified during the binding.
An example of a `bind` expression:
~~~~{.xfail-test}
fn add(x: int, y: int) -> int {
ret x + y;
}
type single_param_fn = fn(int) -> int;
let add4: single_param_fn = bind add(4, _);
let add5: single_param_fn = bind add(_, 5);
assert (add(4,5) == add4(5));
assert (add(4,5) == add5(4));
~~~~
A `bind` expression generally stores a copy of the bound arguments in a
hidden, boxed tuple, owned by the resulting first-class function. For each
bound slot in the bound function's signature, space is allocated in the hidden
tuple and populated with a copy of the bound value.
A `bind` expression is an alternative way of constructing a shared function
closure; the [`fn@` expression](#shared-function-expressions) form is another
way.
### Shared function expressions
*TODO*.

70
doc/tutorial.md
View File

@ -396,15 +396,58 @@ synonym.
## Literals
### Numeric literals
Integers can be written in decimal (`144`), hexadecimal (`0x90`), and
binary (`0b10010000`) base. Without a suffix, an integer literal is
considered to be of type `int`. Add a `u` (`144u`) to make it a `uint`
instead. Literals of the fixed-size integer types can be created by
the literal with the type name (`255u8`, `50i64`, etc).
binary (`0b10010000`) base.
If you write an integer literal without a suffix (`3`, `-500`, etc.),
the Rust compiler will try to infer its type based on type annotations
and function signatures in the surrounding program. For example, here
the type of `x` is inferred to be `u16` because it is passed to a
function that takes a `u16` argument:
~~~~~
let x = 3;
fn identity_u16(n: u16) -> u16 { n }
identity_u16(x);
~~~~
On the other hand, if the program gives conflicting information about
what the type of the unsuffixed literal should be, you'll get an error
message.
~~~~~{.xfail-test}
let x = 3;
let y: i32 = 3;
fn identity_u8(n: u8) -> u8 { n }
fn identity_u16(n: u16) -> u16 { n }
identity_u8(x); // after this, `x` is assumed to have type `u8`
identity_u16(x); // raises a type error (expected `u16` but found `u8`)
identity_u16(y); // raises a type error (expected `u16` but found `i32`)
~~~~
In the absence of any type annotations at all, Rust will assume that
an unsuffixed integer literal has type `int`.
~~~~
let n = 50;
log(error, n); // n is an int
~~~~
It's also possible to avoid any type ambiguity by writing integer
literals with a suffix. The suffixes `i` and `u` are for the types
`int` and `uint`, respectively: the literal `-3i` has type `int`,
while `127u` has type `uint`. For the fixed-size integer types, just
suffix the literal with the type name: `255u8`, `50i64`, etc.
Note that, in Rust, no implicit conversion between integer types
happens. If you are adding one to a variable of type `uint`, you must
type `v += 1u`—saying `+= 1` will give you a type error.
happens. If you are adding one to a variable of type `uint`, saying
`+= 1u8` will give you a type error.
Floating point numbers are written `0.0`, `1e6`, or `2.1e-4`. Without
a suffix, the literal is assumed to be of type `float`. Suffixes `f32`
@ -412,6 +455,8 @@ and `f64` can be used to create literals of a specific type. The
suffix `f` can be used to write `float` literals without a dot or
exponent: `3f`.
### Other literals
The nil literal is written just like the type: `()`. The keywords
`true` and `false` produce the boolean literals.
@ -903,19 +948,6 @@ argument to every element of a vector, producing a new vector.
Even when a closure takes no parameters, you must still write the bars
for the parameter list, as in `{|| ...}`.
## Binding
Partial application is done using the `bind` keyword in Rust.
~~~~
let findx = bind str::find_char(_, 'x');
~~~~
Binding a function produces a boxed closure (`fn@` type) in which some
of the arguments to the bound function have already been provided.
`findx` will be a function taking a single string argument, and
returning the position where the letter `x` occurs.
## Iteration
Functions taking closures provide a good way to define non-trivial

4
src/cargo/cargo.rs
View File

@ -328,8 +328,8 @@ fn load_crate(filename: str) -> option<crate> {
mut deps: []
};
let v = visit::mk_simple_visitor(@{
visit_view_item: bind goto_view_item(e, _),
visit_item: bind goto_item(e, _),
visit_view_item: {|a|goto_view_item(e, a)},
visit_item: {|a|goto_item(e, a)},
with *visit::default_simple_visitor()
});

2
src/compiletest/runtest.rs
View File

@ -325,7 +325,7 @@ fn compose_and_run_compiler(
let abs_ab = path::connect(config.aux_base, rel_ab);
let aux_args =
make_compile_args(config, props, ["--lib"] + extra_link_args,
bind make_lib_name(_, _, testfile), abs_ab);
{|a,b|make_lib_name(a, b, testfile)}, abs_ab);
let auxres = compose_and_run(config, abs_ab, aux_args, [],
config.compile_lib_path, option::none);
if auxres.status != 0 {

32
src/fuzzer/fuzzer.rs
View File

@ -139,8 +139,8 @@ fn steal(crate: ast::crate, tm: test_mode) -> stolen_stuff {
let exprs = @mut [];
let tys = @mut [];
let v = visit::mk_simple_visitor(@{
visit_expr: bind stash_expr_if(safe_to_steal_expr, exprs, _, tm),
visit_ty: bind stash_ty_if(safe_to_steal_ty, tys, _, tm)
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::visit_crate(crate, (), v);
@ -188,8 +188,8 @@ fn replace_expr_in_crate(crate: ast::crate, i: uint,
}
}
let afp =
@{fold_expr: fold::wrap(bind fold_expr_rep(j, i,
newexpr.node, _, _, tm))
@{fold_expr: fold::wrap({|a,b|
fold_expr_rep(j, i, newexpr.node, a, b, tm)})
with *fold::default_ast_fold()};
let af = fold::make_fold(afp);
let crate2: @ast::crate = @af.fold_crate(crate);
@ -211,7 +211,7 @@ 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(bind fold_ty_rep(j, i, newty.node, _, _, tm))
@{fold_ty: fold::wrap({|a,b|fold_ty_rep(j, i, newty.node, a, b, tm)})
with *fold::default_ast_fold()};
let af = fold::make_fold(afp);
let crate2: @ast::crate = @af.fold_crate(crate);
@ -235,7 +235,7 @@ fn check_variants_of_ast(crate: ast::crate, codemap: codemap::codemap,
filename: str, cx: context) {
let stolen = steal(crate, cx.mode);
let extra_exprs = vec::filter(common_exprs(),
bind safe_to_use_expr(_, cx.mode));
{|a|safe_to_use_expr(a, cx.mode)});
check_variants_T(crate, codemap, filename, "expr",
extra_exprs + stolen.exprs, pprust::expr_to_str,
replace_expr_in_crate, cx);
@ -268,13 +268,13 @@ fn check_variants_T<T: copy>(
// testing the string for stability is easier and ok for now.
let handler = diagnostic::mk_handler(none);
let str3 =
@as_str(bind pprust::print_crate(
@as_str({|a|pprust::print_crate(
codemap,
diagnostic::mk_span_handler(handler, codemap),
crate2,
filename,
io::str_reader(""), _,
pprust::no_ann()));
io::str_reader(""), a,
pprust::no_ann())});
alt cx.mode {
tm_converge {
check_roundtrip_convergence(str3, 1u);
@ -421,12 +421,12 @@ fn parse_and_print(code: @str) -> str {
let crate = parse::parse_crate_from_source_str(
filename, code, [], sess);
io::with_str_reader(*code) { |rdr|
as_str(bind pprust::print_crate(sess.cm,
as_str({|a|pprust::print_crate(sess.cm,
sess.span_diagnostic,
crate,
filename,
rdr, _,
pprust::no_ann()))
rdr, a,
pprust::no_ann())})
}
}
@ -439,7 +439,7 @@ fn has_raw_pointers(c: ast::crate) -> bool {
}
}
let v =
visit::mk_simple_visitor(@{visit_ty: bind visit_ty(has_rp, _)
visit::mk_simple_visitor(@{visit_ty: {|a|visit_ty(has_rp, a)}
with *visit::default_simple_visitor()});
visit::visit_crate(c, (), v);
ret *has_rp;
@ -565,12 +565,12 @@ fn check_variants(files: [str], cx: context) {
s, [], sess);
io::with_str_reader(*s) { |rdr|
#error("%s",
as_str(bind pprust::print_crate(sess.cm,
as_str({|a|pprust::print_crate(sess.cm,
sess.span_diagnostic,
crate,
file,
rdr, _,
pprust::no_ann())));
rdr, a,
pprust::no_ann())}));
}
check_variants_of_ast(*crate, sess.cm, file, cx);
}

4
src/libcore/comm.rs
View File

@ -177,11 +177,11 @@ fn peek<T: send>(p: port<T>) -> bool { peek_(***p) }
#[doc(hidden)]
fn recv_chan<T: send>(ch: comm::chan<T>) -> T {
as_raw_port(ch, recv_(_))
as_raw_port(ch, {|x|recv_(x)})
}
fn peek_chan<T: send>(ch: comm::chan<T>) -> bool {
as_raw_port(ch, peek_(_))
as_raw_port(ch, {|x|peek_(x)})
}
#[doc = "Receive on a raw port pointer"]

2
src/libcore/extfmt.rs
View File

@ -174,7 +174,7 @@ mod ct {
let curr: [flag] = [f];
ret {flags: curr + rest, next: j};
}
let more = bind more_(_, s, i, lim);
let more = {|x|more_(x, s, i, lim)};
let f = s[i];
ret if f == '-' as u8 {
more(flag_left_justify)

2
src/libstd/bitv.rs
View File

@ -185,7 +185,7 @@ Converts the bitvector to a vector of uint with the same length.
Each uint in the resulting vector has either value 0u or 1u.
"]
fn to_vec(v: bitv) -> [uint] {
let sub = bind init_to_vec(v, _);
let sub = {|x|init_to_vec(v, x)};
ret vec::from_fn::<uint>(v.nbits, sub);
}

2
src/libstd/c_vec.rs
View File

@ -136,7 +136,7 @@ mod tests {
assert mem as int != 0;
ret unsafe { c_vec_with_dtor(mem as *mut u8, n as uint,
bind free(mem)) };
{||free(mem)}) };
}
#[test]

2
src/libstd/deque.rs
View File

@ -292,7 +292,7 @@ mod tests {
two(17, 42));
#debug("*** test parameterized: taggypar<int>");
let eq4: eqfn<taggypar<int>> = bind taggypareq::<int>(_, _);
let eq4: eqfn<taggypar<int>> = {|x,y|taggypareq::<int>(x, y)};
test_parameterized::<taggypar<int>>(eq4, onepar::<int>(1),
twopar::<int>(1, 2),
threepar::<int>(1, 2, 3),

8
src/libstd/test.rs
View File

@ -162,7 +162,7 @@ fn run_tests_console(opts: test_opts,
mut ignored: 0u,
mut failures: []};
run_tests(opts, tests, bind callback(_, st));
run_tests(opts, tests, {|x|callback(x, st)});
assert (st.passed + st.failed + st.ignored == st.total);
let success = st.failed == 0u;
@ -349,7 +349,7 @@ fn filter_tests(opts: test_opts,
} else { ret option::none; }
}
let filter = bind filter_fn(_, filter_str);
let filter = {|x|filter_fn(x, filter_str)};
vec::filter_map(filtered, filter)
};
@ -367,7 +367,7 @@ fn filter_tests(opts: test_opts,
} else { ret option::none; }
};
vec::filter_map(filtered, bind filter(_))
vec::filter_map(filtered, {|x|filter(x)})
};
// Sort the tests alphabetically
@ -376,7 +376,7 @@ fn filter_tests(opts: test_opts,
fn lteq(t1: test_desc, t2: test_desc) -> bool {
str::le(t1.name, t2.name)
}
sort::merge_sort(bind lteq(_, _), filtered)
sort::merge_sort({|x,y|lteq(x, y)}, filtered)
};
ret filtered;

2
src/libstd/treemap.rs
View File

@ -125,7 +125,7 @@ mod tests {
fn t(n: @mut int, &&k: int, &&_v: ()) {
assert (*n == k); *n += 1;
}
traverse(m, bind t(n, _, _));
traverse(m, {|x,y|t(n, x, y)});
}
#[test]

1
src/libsyntax/ast.rs
View File

@ -300,7 +300,6 @@ enum expr_ {
expr_rec([field], option<@expr>),
expr_call(@expr, [@expr], bool), // True iff last argument is a block
expr_tup([@expr]),
expr_bind(@expr, [option<@expr>]),
expr_binary(binop, @expr, @expr),
expr_unary(unop, @expr),
expr_lit(@lit),

10
src/libsyntax/ext/auto_serialize.rs
View File

@ -267,7 +267,7 @@ impl helpers for ext_ctxt {
}
let fld = fold::make_fold(@{
new_span: repl_sp(_, ast_util::dummy_sp(), span)
new_span: {|a|repl_sp(a, ast_util::dummy_sp(), span)}
with *fold::default_ast_fold()
});
@ -757,8 +757,8 @@ fn ty_fns(cx: ext_ctxt, name: ast::ident, ty: @ast::ty, tps: [ast::ty_param])
let span = ty.span;
[
mk_ser_fn(cx, span, name, tps, ser_ty(_, _, ty, _, _)),
mk_deser_fn(cx, span, name, tps, deser_ty(_, _, ty, _))
mk_ser_fn(cx, span, name, tps, {|a,b,c,d|ser_ty(a, b, ty, c, d)}),
mk_deser_fn(cx, span, name, tps, {|a,b,c|deser_ty(a, b, ty, c)})
]
}
@ -860,8 +860,8 @@ fn enum_fns(cx: ext_ctxt, e_name: ast::ident, e_span: span,
-> [@ast::item] {
[
mk_ser_fn(cx, e_span, e_name, tps,
ser_enum(_, _, e_name, e_span, variants, _, _)),
{|a,b,c,d|ser_enum(a, b, e_name, e_span, variants, c, d)}),
mk_deser_fn(cx, e_span, e_name, tps,
deser_enum(_, _, e_name, e_span, variants, _))
{|a,b,c|deser_enum(a, b, e_name, e_span, variants, c)})
]
}

8
src/libsyntax/ext/expand.rs
View File

@ -130,10 +130,10 @@ fn expand_crate(parse_sess: parse::parse_sess,
let afp = default_ast_fold();
let cx: ext_ctxt = mk_ctxt(parse_sess, cfg);
let f_pre =
@{fold_expr: bind expand_expr(exts, cx, _, _, _, afp.fold_expr),
fold_mod: bind expand_mod_items(exts, cx, _, _, afp.fold_mod),
fold_item: bind expand_item(cx, _, _, afp.fold_item),
new_span: bind new_span(cx, _)
@{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(cx, a, b, afp.fold_item)},
new_span: {|a|new_span(cx, a)}
with *afp};
let f = make_fold(f_pre);
let cm = parse_expr_from_source_str("<core-macros>",

4
src/libsyntax/ext/fmt.rs
View File

@ -23,7 +23,9 @@ fn expand_syntax_ext(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
fn parse_fmt_err_(cx: ext_ctxt, sp: span, msg: str) -> ! {
cx.span_fatal(sp, msg);
}
let parse_fmt_err = bind parse_fmt_err_(cx, fmtspan, _);
let parse_fmt_err = fn@(s: str) -> ! {
parse_fmt_err_(cx, fmtspan, s)
};
let pieces = parse_fmt_string(fmt, parse_fmt_err);
ret pieces_to_expr(cx, sp, pieces, args);
}

8
src/libsyntax/ext/qquote.rs
View File

@ -274,10 +274,10 @@ fn replace<T>(node: T, repls: [fragment], ff: fn (ast_fold, T) -> T)
-> T
{
let aft = default_ast_fold();
let f_pre = @{fold_expr: bind replace_expr(repls, _, _, _,
aft.fold_expr),
fold_ty: bind replace_ty(repls, _, _, _,
aft.fold_ty)
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};
ret ff(make_fold(f_pre), node);
}

50
src/libsyntax/ext/simplext.rs
View File

@ -113,7 +113,7 @@ fn a_d_map(ad: arb_depth<matchable>, f: selector) -> match_result {
alt ad {
leaf(x) { ret f(x); }
seq(ads, span) {
alt option_flatten_map(bind a_d_map(_, f), *ads) {
alt option_flatten_map({|x| a_d_map(x, f)}, *ads) {
none { ret none; }
some(ts) { ret some(seq(@ts, span)); }
}
@ -128,7 +128,7 @@ fn compose_sels(s1: selector, s2: selector) -> selector {
some(matches) { a_d_map(matches, s2) }
}
}
ret bind scomp(s1, s2, _);
ret {|x|scomp(s1, s2, x)};
}
@ -190,16 +190,22 @@ fn transcribe(cx: ext_ctxt, b: bindings, body: @expr) -> @expr {
}
let afp = default_ast_fold();
let f_pre =
@{fold_ident: bind transcribe_ident(cx, b, idx_path, _, _),
fold_path: bind transcribe_path(cx, b, idx_path, _, _),
fold_expr:
bind transcribe_expr(cx, b, idx_path, _, _, _, afp.fold_expr),
fold_ty: bind transcribe_type(cx, b, idx_path,
_, _, _, afp.fold_ty),
fold_block:
bind transcribe_block(cx, b, idx_path, _, _, _, afp.fold_block),
map_exprs: bind transcribe_exprs(cx, b, idx_path, _, _),
new_id: bind new_id(_, cx)
@{fold_ident: {|x,y|transcribe_ident(cx, b, idx_path, x, y)},
fold_path: {|x,y|transcribe_path(cx, b, idx_path, x, y)},
fold_expr: {|x,y,z|
transcribe_expr(cx, b, idx_path, x, y, z, afp.fold_expr)
},
fold_ty: {|x,y,z|
transcribe_type(cx, b, idx_path,
x, y, z, afp.fold_ty)
},
fold_block: {|x,y,z|
transcribe_block(cx, b, idx_path, x, y, z, afp.fold_block)
},
map_exprs: {|x,y|
transcribe_exprs(cx, b, idx_path, x, y)
},
new_id: {|x|new_id(x, cx)}
with *afp};
let f = make_fold(f_pre);
let result = f.fold_expr(body);
@ -249,7 +255,7 @@ 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: bind mark_ident(_, _, b, idents)
@{fold_ident: {|x,y|mark_ident(x, y, b, idents)}
with *default_ast_fold()};
let f = make_fold(f_pre);
f.fold_expr(e); // ignore result
@ -475,7 +481,7 @@ fn p_t_s_rec(cx: ext_ctxt, m: matchable, s: selector, b: binders) {
_ { cx.bug("broken traversal in p_t_s_r") }
}
}
b.literal_ast_matchers.push(bind select(cx, _, e));
b.literal_ast_matchers.push({|x|select(cx, x, e)});
}
}
}
@ -517,7 +523,7 @@ fn p_t_s_r_path(cx: ext_ctxt, p: @path, s: selector, b: binders) {
if b.real_binders.contains_key(p_id) {
cx.span_fatal(p.span, "duplicate binding identifier");
}
b.real_binders.insert(p_id, compose_sels(s, bind select(cx, _)));
b.real_binders.insert(p_id, compose_sels(s, {|x|select(cx, x)}));
}
none { }
}
@ -562,7 +568,7 @@ fn p_t_s_r_mac(cx: ext_ctxt, mac: ast::mac, s: selector, b: binders) {
_ { none }
}
}
let final_step = bind select_pt_1(cx, _, select_pt_2);
let final_step = {|x|select_pt_1(cx, x, select_pt_2)};
b.real_binders.insert(id, compose_sels(s, final_step));
}
none { no_des(cx, pth.span, "under `#<>`"); }
@ -582,7 +588,7 @@ fn p_t_s_r_mac(cx: ext_ctxt, mac: ast::mac, s: selector, b: binders) {
_ { none }
}
}
let final_step = bind select_pt_1(cx, _, select_pt_2);
let final_step = {|x|select_pt_1(cx, x, select_pt_2)};
b.real_binders.insert(id, compose_sels(s, final_step));
}
none { no_des(cx, blk.span, "under `#{}`"); }
@ -619,7 +625,7 @@ fn p_t_s_r_ellipses(cx: ext_ctxt, repeat_me: @expr, offset: uint, s: selector,
}
}
p_t_s_rec(cx, match_expr(repeat_me),
compose_sels(s, bind select(cx, repeat_me, offset, _)), b);
compose_sels(s, {|x|select(cx, repeat_me, offset, x)}), b);
}
@ -643,7 +649,7 @@ fn p_t_s_r_length(cx: ext_ctxt, len: uint, at_least: bool, s: selector,
}
}
b.literal_ast_matchers.push(
compose_sels(s, bind len_select(cx, _, at_least, len)));
compose_sels(s, {|x|len_select(cx, x, at_least, len)}));
}
fn p_t_s_r_actual_vector(cx: ext_ctxt, elts: [@expr], _repeat_after: bool,
@ -664,7 +670,7 @@ fn p_t_s_r_actual_vector(cx: ext_ctxt, elts: [@expr], _repeat_after: bool,
}
}
p_t_s_rec(cx, match_expr(elts[idx]),
compose_sels(s, bind select(cx, _, idx)), b);
compose_sels(s, {|x, copy idx|select(cx, x, idx)}), b);
idx += 1u;
}
}
@ -739,7 +745,9 @@ fn add_new_extension(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
}
}
let ext = bind generic_extension(_, _, _, _, clauses);
let ext = {|a,b,c,d, move clauses|
generic_extension(a,b,c,d,clauses)
};
ret {ident:
alt macro_name {

32
src/libsyntax/fold.rs
View File

@ -87,7 +87,7 @@ fn fold_meta_item_(&&mi: @meta_item, fld: ast_fold) -> @meta_item {
alt mi.node {
meta_word(id) { meta_word(fld.fold_ident(id)) }
meta_list(id, mis) {
let fold_meta_item = bind fold_meta_item_(_, fld);
let fold_meta_item = {|x|fold_meta_item_(x, fld)};
meta_list(/* FIXME: bad */ copy id,
vec::map(mis, fold_meta_item))
}
@ -130,7 +130,7 @@ fn fold_mac_(m: mac, fld: ast_fold) -> mac {
}
fn fold_fn_decl(decl: ast::fn_decl, fld: ast_fold) -> ast::fn_decl {
ret {inputs: vec::map(decl.inputs, bind fold_arg_(_, fld)),
ret {inputs: vec::map(decl.inputs, {|x| fold_arg_(x, fld)}),
output: fld.fold_ty(decl.output),
purity: decl.purity,
cf: decl.cf,
@ -147,16 +147,16 @@ fn fold_ty_param_bound(tpb: ty_param_bound, fld: ast_fold) -> ty_param_bound {
fn fold_ty_param(tp: ty_param, fld: ast_fold) -> ty_param {
{ident: /* FIXME: bad */ copy tp.ident,
id: fld.new_id(tp.id),
bounds: @vec::map(*tp.bounds, fold_ty_param_bound(_, fld))}
bounds: @vec::map(*tp.bounds, {|x|fold_ty_param_bound(x, fld)})}
}
fn fold_ty_params(tps: [ty_param], fld: ast_fold) -> [ty_param] {
vec::map(tps, fold_ty_param(_, fld))
vec::map(tps, {|x|fold_ty_param(x, fld)})
}
fn noop_fold_crate(c: crate_, fld: ast_fold) -> crate_ {
let fold_meta_item = bind fold_meta_item_(_, fld);
let fold_attribute = bind fold_attribute_(_, fld);
let fold_meta_item = {|x|fold_meta_item_(x, fld)};
let fold_attribute = {|x|fold_attribute_(x, fld)};
ret {directives: vec::map(c.directives, fld.fold_crate_directive),
module: fld.fold_mod(c.module),
@ -186,8 +186,8 @@ fn noop_fold_view_item(vi: view_item_, _fld: ast_fold) -> view_item_ {
fn noop_fold_native_item(&&ni: @native_item, fld: ast_fold) -> @native_item {
let fold_arg = bind fold_arg_(_, fld);
let fold_attribute = bind fold_attribute_(_, fld);
let fold_arg = {|x|fold_arg_(x, fld)};
let fold_attribute = {|x|fold_attribute_(x, fld)};
ret @{ident: fld.fold_ident(ni.ident),
attrs: vec::map(ni.attrs, fold_attribute),
@ -209,7 +209,7 @@ fn noop_fold_native_item(&&ni: @native_item, fld: ast_fold) -> @native_item {
}
fn noop_fold_item(&&i: @item, fld: ast_fold) -> @item {
let fold_attribute = bind fold_attribute_(_, fld);
let fold_attribute = {|x|fold_attribute_(x, fld)};
ret @{ident: fld.fold_ident(i.ident),
attrs: vec::map(i.attrs, fold_attribute),
@ -381,9 +381,9 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
expr: fld.fold_expr(field.node.expr)},
span: fld.new_span(field.span)};
}
let fold_field = bind fold_field_(_, fld);
let fold_field = {|x|fold_field_(x, fld)};
let fold_mac = bind fold_mac_(_, fld);
let fold_mac = {|x|fold_mac_(x, fld)};
ret alt e {
expr_new(p, i, v) {
@ -406,10 +406,6 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
expr_call(fld.fold_expr(f), fld.map_exprs(fld.fold_expr, args),
blk)
}
expr_bind(f, args) {
let opt_map_se = bind option::map(_, fld.fold_expr);
expr_bind(fld.fold_expr(f), vec::map(args, opt_map_se))
}
expr_binary(binop, lhs, rhs) {
expr_binary(binop, fld.fold_expr(lhs), fld.fold_expr(rhs))
}
@ -483,7 +479,7 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
}
fn noop_fold_ty(t: ty_, fld: ast_fold) -> ty_ {
let fold_mac = bind fold_mac_(_, fld);
let fold_mac = {|x|fold_mac_(x, fld)};
fn fold_mt(mt: mt, fld: ast_fold) -> mt {
{ty: fld.fold_ty(mt.ty), mutbl: mt.mutbl}
}
@ -536,10 +532,10 @@ fn noop_fold_variant(v: variant_, fld: ast_fold) -> variant_ {
fn fold_variant_arg_(va: variant_arg, fld: ast_fold) -> variant_arg {
ret {ty: fld.fold_ty(va.ty), id: fld.new_id(va.id)};
}
let fold_variant_arg = bind fold_variant_arg_(_, fld);
let fold_variant_arg = {|x|fold_variant_arg_(x, fld)};
let args = vec::map(v.args, fold_variant_arg);
let fold_attribute = bind fold_attribute_(_, fld);
let fold_attribute = {|x|fold_attribute_(x, fld)};
let attrs = vec::map(v.attrs, fold_attribute);
let de = alt v.disr_expr {

5
src/libsyntax/parse.rs
View File

@ -17,8 +17,9 @@ import attr::parser_attr;
import common::parser_common;
import ast::node_id;
import util::interner;
import lexer::{string_reader_as_reader, tt_reader_as_reader,
reader, string_reader, tt_reader};
// FIXME: resolve badness
import lexer::*;//{string_reader_as_reader, tt_reader_as_reader,
//reader, string_reader, tt_reader};
import diagnostic::{span_handler, mk_span_handler, mk_handler, emitter};
type parse_sess = @{

27
src/libsyntax/parse/parser.rs
View File

@ -829,14 +829,6 @@ class parser {
let ex_ext = self.parse_syntax_ext();
hi = ex_ext.span.hi;
ex = ex_ext.node;
} else if self.eat_keyword("bind") {
let e = self.parse_expr_res(RESTRICT_NO_CALL_EXPRS);
let es = self.parse_unspanned_seq(
token::LPAREN, token::RPAREN,
seq_sep_trailing_disallowed(token::COMMA),
{|p| p.parse_expr_or_hole()});
hi = self.span.hi;
ex = expr_bind(e, es);
} else if self.eat_keyword("fail") {
if can_begin_expr(self.token) {
let e = self.parse_expr();
@ -1008,19 +1000,13 @@ class parser {
alt copy self.token {
// expr(...)
token::LPAREN if self.permits_call() {
let es_opt = self.parse_unspanned_seq(
let es = self.parse_unspanned_seq(
token::LPAREN, token::RPAREN,
seq_sep_trailing_disallowed(token::COMMA),
{|p| p.parse_expr_or_hole()});
{|p| p.parse_expr()});
hi = self.span.hi;
let nd =
if vec::any(es_opt, {|e| option::is_none(e) }) {
expr_bind(self.to_expr(e), es_opt)
} else {
let es = vec::map(es_opt) {|e| option::get(e) };
expr_call(self.to_expr(e), es, false)
};
let nd = expr_call(self.to_expr(e), es, false);
e = self.mk_pexpr(lo, hi, nd);
}
@ -1370,13 +1356,6 @@ class parser {
ret self.parse_expr_res(UNRESTRICTED);
}
fn parse_expr_or_hole() -> option<@expr> {
alt self.token {
token::UNDERSCORE { self.bump(); ret none; }
_ { ret some(self.parse_expr()); }
}
}
fn parse_expr_res(r: restriction) -> @expr {
let old = self.restriction;
self.restriction = r;

1
src/libsyntax/parse/token.rs
View File

@ -250,7 +250,6 @@ fn contextual_keyword_table() -> hashmap<str, ()> {
let words = str_hash();
let keys = [
"as",
"bind",
"else",
"implements",
"move",

24
src/libsyntax/print/pprust.rs
View File

@ -102,7 +102,7 @@ fn typarams_to_str(tps: [ast::ty_param]) -> str {
}
fn path_to_str(&&p: @ast::path) -> str {
ret to_str(p, bind print_path(_, _, false));
ret to_str(p, {|a,b|print_path(a, b, false)});
}
fn fun_to_str(decl: ast::fn_decl, name: ast::ident,
@ -840,7 +840,7 @@ fn print_mac(s: ps, m: ast::mac) {
some(@{node: ast::expr_vec(_, _), _}) { }
_ { word(s.s, " "); }
}
option::iter(arg, bind print_expr(s, _));
option::iter(arg, {|a|print_expr(s, a)});
// FIXME: extension 'body' (#2339)
}
ast::mac_embed_type(ty) {
@ -938,24 +938,6 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
print_expr(s, option::get(blk));
}
}
ast::expr_bind(func, args) {
fn print_opt(s: ps, expr: option<@ast::expr>) {
alt expr {
some(expr) { print_expr(s, expr); }
_ { word(s.s, "_"); }
}
}
// "bind" keyword is only needed if there are no "_" arguments.
if !vec::any(args) {|arg| option::is_none(arg) } {
word_nbsp(s, "bind");
}
print_expr(s, func);
popen(s);
commasep(s, inconsistent, args, print_opt);
pclose(s);
}
ast::expr_binary(op, lhs, rhs) {
let prec = operator_prec(op);
print_op_maybe_parens(s, lhs, prec);
@ -1780,7 +1762,7 @@ fn ast_ty_fn_constr_to_str(&&c: @ast::constr) -> str {
}
fn ast_fn_constr_to_str(decl: ast::fn_decl, &&c: @ast::constr) -> str {
let arg_to_str = bind fn_arg_idx_to_str(decl, _);
let arg_to_str = {|a|fn_arg_idx_to_str(decl, a)};
ret path_to_str(c.node.path) +
constr_args_to_str(arg_to_str, c.node.args);
}

81
src/libsyntax/visit.rs
View File

@ -65,22 +65,22 @@ type visitor<E> =
visit_class_item: fn@(@class_member, E, vt<E>)};
fn default_visitor<E>() -> visitor<E> {
ret @{visit_mod: bind visit_mod::<E>(_, _, _, _, _),
visit_view_item: bind visit_view_item::<E>(_, _, _),
visit_native_item: bind visit_native_item::<E>(_, _, _),
visit_item: bind visit_item::<E>(_, _, _),
visit_local: bind visit_local::<E>(_, _, _),
visit_block: bind visit_block::<E>(_, _, _),
visit_stmt: bind visit_stmt::<E>(_, _, _),
visit_arm: bind visit_arm::<E>(_, _, _),
visit_pat: bind visit_pat::<E>(_, _, _),
visit_decl: bind visit_decl::<E>(_, _, _),
visit_expr: bind visit_expr::<E>(_, _, _),
visit_ty: bind skip_ty::<E>(_, _, _),
visit_ty_params: bind visit_ty_params::<E>(_, _, _),
visit_constr: bind visit_constr::<E>(_, _, _, _, _),
visit_fn: bind visit_fn::<E>(_, _, _, _, _, _, _),
visit_class_item: bind visit_class_item::<E>(_,_,_)};
ret @{visit_mod: {|a,b,c,d,e|visit_mod::<E>(a, b, c, d, e)},
visit_view_item: {|a,b,c|visit_view_item::<E>(a, b, c)},
visit_native_item: {|a,b,c|visit_native_item::<E>(a, b, c)},
visit_item: {|a,b,c|visit_item::<E>(a, b, c)},
visit_local: {|a,b,c|visit_local::<E>(a, b, c)},
visit_block: {|a,b,c|visit_block::<E>(a, b, c)},
visit_stmt: {|a,b,c|visit_stmt::<E>(a, b, c)},
visit_arm: {|a,b,c|visit_arm::<E>(a, b, c)},
visit_pat: {|a,b,c|visit_pat::<E>(a, b, c)},
visit_decl: {|a,b,c|visit_decl::<E>(a, b, c)},
visit_expr: {|a,b,c|visit_expr::<E>(a, b, c)},
visit_ty: {|a,b,c|skip_ty::<E>(a, b, c)},
visit_ty_params: {|a,b,c|visit_ty_params::<E>(a, b, c)},
visit_constr: {|a,b,c,d,e|visit_constr::<E>(a, b, c, d, e)},
visit_fn: {|a,b,c,d,e,f,g|visit_fn::<E>(a, b, c, d, e, f, g)},
visit_class_item: {|a,b,c|visit_class_item::<E>(a, b, c)}};
}
fn visit_crate<E>(c: crate, e: E, v: vt<E>) {
@ -377,10 +377,6 @@ fn visit_expr<E>(ex: @expr, e: E, v: vt<E>) {
visit_exprs(args, e, v);
v.visit_expr(callee, e, v);
}
expr_bind(callee, args) {
v.visit_expr(callee, e, v);
for args.each {|eo| visit_expr_opt(eo, e, v); }
}
expr_binary(_, a, b) { v.visit_expr(a, e, v); v.visit_expr(b, e, v); }
expr_addr_of(_, x) | expr_unary(_, x) |
expr_loop_body(x) | expr_do_body(x) |
@ -559,9 +555,9 @@ fn mk_simple_visitor(v: simple_visitor) -> vt<()> {
visit_fn(fk, decl, body, sp, id, e, v);
}
let visit_ty = if v.visit_ty == simple_ignore_ty {
bind skip_ty(_, _, _)
{|a,b,c| skip_ty(a, b, c)}
} else {
bind v_ty(v.visit_ty, _, _, _)
{|a,b,c| v_ty(v.visit_ty, a, b, c)}
};
fn v_class_item(f: fn@(@class_member),
cm: @class_member, &&e: (),
@ -569,24 +565,33 @@ fn mk_simple_visitor(v: simple_visitor) -> vt<()> {
f(cm);
visit_class_item(cm, e, v);
}
ret mk_vt(@{visit_mod: bind v_mod(v.visit_mod, _, _, _, _, _),
visit_view_item: bind v_view_item(v.visit_view_item, _, _, _),
ret mk_vt(@{visit_mod: {|a,b,c,d,e|v_mod(v.visit_mod, a, b, c, d, e)},
visit_view_item: {|a,b,c|
v_view_item(v.visit_view_item, a, b, c)
},
visit_native_item:
bind v_native_item(v.visit_native_item, _, _, _),
visit_item: bind v_item(v.visit_item, _, _, _),
visit_local: bind v_local(v.visit_local, _, _, _),
visit_block: bind v_block(v.visit_block, _, _, _),
visit_stmt: bind v_stmt(v.visit_stmt, _, _, _),
visit_arm: bind v_arm(v.visit_arm, _, _, _),
visit_pat: bind v_pat(v.visit_pat, _, _, _),
visit_decl: bind v_decl(v.visit_decl, _, _, _),
visit_expr: bind v_expr(v.visit_expr, _, _, _),
{|a,b,c|v_native_item(v.visit_native_item, a, b, c)},
visit_item: {|a,b,c|v_item(v.visit_item, a, b, c)},
visit_local: {|a,b,c|v_local(v.visit_local, a, b, c)},
visit_block: {|a,b,c|v_block(v.visit_block, a, b, c)},
visit_stmt: {|a,b,c|v_stmt(v.visit_stmt, a, b, c)},
visit_arm: {|a,b,c|v_arm(v.visit_arm, a, b, c)},
visit_pat: {|a,b,c|v_pat(v.visit_pat, a, b, c)},
visit_decl: {|a,b,c|v_decl(v.visit_decl, a, b, c)},
visit_expr: {|a,b,c|v_expr(v.visit_expr, a, b, c)},
visit_ty: visit_ty,
visit_ty_params: bind v_ty_params(v.visit_ty_params, _, _, _),
visit_constr: bind v_constr(v.visit_constr, _, _, _, _, _),
visit_fn: bind v_fn(v.visit_fn, _, _, _, _, _, _, _),
visit_class_item: bind v_class_item(v.visit_class_item, _, _,
_)
visit_ty_params: {|a,b,c|
v_ty_params(v.visit_ty_params, a, b, c)
},
visit_constr: {|a,b,c,d,e|
v_constr(v.visit_constr, a, b, c, d, e)
},
visit_fn: {|a,b,c,d,e,f,g|
v_fn(v.visit_fn, a, b, c, d, e, f, g)
},
visit_class_item: {|a,b,c|
v_class_item(v.visit_class_item, a, b, c)
}
});
}

7
src/rustc/back/rpath.rs
View File

@ -94,7 +94,10 @@ fn get_rpaths_relative_to_output(os: session::os,
cwd: path::path,
output: path::path,
libs: [path::path]) -> [str] {
vec::map(libs, bind get_rpath_relative_to_output(os, cwd, output, _))
vec::map(libs, {|a|
check not_win32(os);
get_rpath_relative_to_output(os, cwd, output, a)
})
}
fn get_rpath_relative_to_output(os: session::os,
@ -149,7 +152,7 @@ fn get_relative_to(abs1: path::path, abs2: path::path) -> path::path {
}
fn get_absolute_rpaths(cwd: path::path, libs: [path::path]) -> [str] {
vec::map(libs, bind get_absolute_rpath(cwd, _))
vec::map(libs, {|a|get_absolute_rpath(cwd, a)})
}
fn get_absolute_rpath(cwd: path::path, &&lib: path::path) -> str {

4
src/rustc/back/upcall.rs
View File

@ -43,8 +43,8 @@ fn declare_upcalls(targ_cfg: @session::config,
fn nothrow(f: ValueRef) -> ValueRef {
base::set_no_unwind(f); f
}
let d = bind decl(llmod, "upcall_", _, _, _);
let dv = bind decl(llmod, "upcall_", _, _, T_void());
let d = {|a,b,c|decl(llmod, "upcall_", a, b, c)};
let dv = {|a,b|decl(llmod, "upcall_", a, b, T_void())};
let int_t = T_int(targ_cfg);
let size_t = T_size_t(targ_cfg);

106
src/rustc/driver/driver.rs
View File

@ -132,7 +132,7 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg,
-> {crate: @ast::crate, tcx: option<ty::ctxt>} {
let time_passes = sess.time_passes();
let mut crate = time(time_passes, "parsing",
bind parse_input(sess, cfg, input));
{||parse_input(sess, cfg, input)});
if upto == cu_parse { ret {crate: crate, tcx: none}; }
sess.building_library = session::building_library(
@ -140,75 +140,87 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg,
crate =
time(time_passes, "configuration",
bind front::config::strip_unconfigured_items(crate));
{|copy crate|front::config::strip_unconfigured_items(crate)});
crate =
time(time_passes, "maybe building test harness",
bind front::test::modify_for_testing(sess, crate));
{|copy crate|front::test::modify_for_testing(sess, crate)});
crate =
time(time_passes, "expansion",
bind syntax::ext::expand::expand_crate(
sess.parse_sess, sess.opts.cfg, crate));
{|copy crate|syntax::ext::expand::expand_crate(
sess.parse_sess, sess.opts.cfg, crate)});
if upto == cu_expand { ret {crate: crate, tcx: none}; }
crate =
time(time_passes, "intrinsic injection",
bind front::intrinsic_inject::inject_intrinsic(sess, crate));
time(time_passes, "intrinsic injection", {|copy crate|
front::intrinsic_inject::inject_intrinsic(sess, crate)
});
crate =
time(time_passes, "core injection",
bind front::core_inject::maybe_inject_libcore_ref(sess, crate));
time(time_passes, "core injection", {|copy crate|
front::core_inject::maybe_inject_libcore_ref(sess, crate)
});
time(time_passes, "building warning settings table",
bind lint::build_settings_crate(sess, crate));
time(time_passes, "building warning settings table", {|copy crate|
lint::build_settings_crate(sess, crate)
});
let ast_map =
time(time_passes, "ast indexing",
bind syntax::ast_map::map_crate(sess.diagnostic(), *crate));
time(time_passes, "external crate/lib resolution",
bind creader::read_crates(
sess.diagnostic(), *crate, sess.cstore,
sess.filesearch,
session::sess_os_to_meta_os(sess.targ_cfg.os),
sess.opts.static));
time(time_passes, "ast indexing", {|copy crate|
syntax::ast_map::map_crate(sess.diagnostic(), *crate)
});
time(time_passes, "external crate/lib resolution", {|copy crate|
creader::read_crates(
sess.diagnostic(), *crate, sess.cstore,
sess.filesearch,
session::sess_os_to_meta_os(sess.targ_cfg.os),
sess.opts.static)
});
let {def_map, exp_map, impl_map} =
time(time_passes, "resolution",
bind resolve::resolve_crate(sess, ast_map, crate));
time(time_passes, "resolution", {|copy crate|
resolve::resolve_crate(sess, ast_map, crate)
});
let freevars =
time(time_passes, "freevar finding",
bind freevars::annotate_freevars(def_map, crate));
time(time_passes, "freevar finding", {|copy crate|
freevars::annotate_freevars(def_map, crate)
});
let region_map =
time(time_passes, "region resolution",
bind middle::region::resolve_crate(sess, def_map, crate));
time(time_passes, "region resolution", {|copy crate|
middle::region::resolve_crate(sess, def_map, crate)
});
let ty_cx = ty::mk_ctxt(sess, def_map, ast_map, freevars, region_map);
let (method_map, vtable_map) =
time(time_passes, "typechecking",
bind typeck::check_crate(ty_cx, impl_map, crate));
time(time_passes, "const checking",
bind middle::check_const::check_crate(sess, crate, ast_map, def_map,
method_map, ty_cx));
time(time_passes, "typechecking", {|copy crate|
typeck::check_crate(ty_cx, impl_map, crate)
});
time(time_passes, "const checking", {|copy crate|
middle::check_const::check_crate(
sess, crate, ast_map, def_map, method_map, ty_cx)
});
if upto == cu_typeck { ret {crate: crate, tcx: some(ty_cx)}; }
time(time_passes, "block-use checking",
bind middle::block_use::check_crate(ty_cx, crate));
{|copy crate|middle::block_use::check_crate(ty_cx, crate)});
time(time_passes, "loop checking",
bind middle::check_loop::check_crate(ty_cx, crate));
{|copy crate|middle::check_loop::check_crate(ty_cx, crate)});
time(time_passes, "alt checking",
bind middle::check_alt::check_crate(ty_cx, crate));
{|copy crate|middle::check_alt::check_crate(ty_cx, crate)});
let last_use_map =
time(time_passes, "liveness checking",
bind middle::liveness::check_crate(ty_cx, method_map, crate));
time(time_passes, "liveness checking", {|copy crate|
middle::liveness::check_crate(ty_cx, method_map, crate)
});
time(time_passes, "typestate checking",
bind middle::tstate::ck::check_crate(ty_cx, crate));
{|copy crate|middle::tstate::ck::check_crate(ty_cx, crate)});
let (root_map, mutbl_map) = time(
time_passes, "borrow checking",
bind middle::borrowck::check_crate(ty_cx, method_map,
last_use_map, crate));
time(time_passes, "kind checking",
bind kind::check_crate(ty_cx, method_map, last_use_map, crate));
{|copy crate|middle::borrowck::check_crate(ty_cx, method_map,
last_use_map, crate)});
time(time_passes, "kind checking", {|copy crate|
kind::check_crate(ty_cx, method_map, last_use_map, crate)
});
time(time_passes, "lint checking",
bind lint::check_crate(ty_cx, crate));
{|copy crate|lint::check_crate(ty_cx, crate)});
if upto == cu_no_trans { ret {crate: crate, tcx: some(ty_cx)}; }
let outputs = option::get(outputs);
@ -220,11 +232,11 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg,
let (llmod, link_meta) =
time(time_passes, "translation",
bind trans::base::trans_crate(
{|copy crate|trans::base::trans_crate(
sess, crate, ty_cx, outputs.obj_filename,
exp_map, maps));
exp_map, maps)});
time(time_passes, "LLVM passes",
bind link::write::run_passes(sess, llmod, outputs.obj_filename));
{||link::write::run_passes(sess, llmod, outputs.obj_filename)});
let stop_after_codegen =
sess.opts.output_type != link::output_type_exe ||
@ -233,8 +245,8 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg,
if stop_after_codegen { ret {crate: crate, tcx: some(ty_cx)}; }
time(time_passes, "linking",
bind link::link_binary(sess, outputs.obj_filename,
outputs.out_filename, link_meta));
{||link::link_binary(sess, outputs.obj_filename,
outputs.out_filename, link_meta)});
ret {crate: crate, tcx: some(ty_cx)};
}
@ -303,7 +315,7 @@ fn pretty_print_input(sess: session, cfg: ast::crate_cfg, input: input,
alt ppm {
ppm_typed {
ann = {pre: ann_paren_for_expr,
post: bind ann_typed_post(option::get(tcx), _)};
post: {|a|ann_typed_post(option::get(tcx), a)}};
}
ppm_identified | ppm_expanded_identified {
ann = {pre: ann_paren_for_expr, post: ann_identified_post};

2
src/rustc/driver/rustc.rs
View File

@ -169,7 +169,7 @@ fn run_compiler(args: [str], demitter: diagnostic::emitter) {
let pretty =
option::map(getopts::opt_default(match, "pretty",
"normal"),
bind parse_pretty(sess, _));
{|a|parse_pretty(sess, a)});
alt pretty {
some::<pp_mode>(ppm) { pretty_print_input(sess, cfg, input, ppm); ret; }
none::<pp_mode> {/* continue */ }

12
src/rustc/front/config.rs
View File

@ -24,9 +24,9 @@ fn strip_items(crate: @ast::crate, in_cfg: in_cfg_pred)
let ctxt = @{in_cfg: in_cfg};
let precursor =
@{fold_mod: bind fold_mod(ctxt, _, _),
fold_block: fold::wrap(bind fold_block(ctxt, _, _)),
fold_native_mod: bind fold_native_mod(ctxt, _, _)
@{fold_mod: {|a,b|fold_mod(ctxt, a, b)},
fold_block: fold::wrap({|a,b|fold_block(ctxt, a, b)}),
fold_native_mod: {|a,b|fold_native_mod(ctxt, a, b)}
with *fold::default_ast_fold()};
let fold = fold::make_fold(precursor);
@ -41,7 +41,7 @@ fn filter_item(cx: ctxt, &&item: @ast::item) ->
fn fold_mod(cx: ctxt, m: ast::_mod, fld: fold::ast_fold) ->
ast::_mod {
let filter = bind filter_item(cx, _);
let filter = {|a|filter_item(cx, a)};
let filtered_items = vec::filter_map(m.items, filter);
ret {view_items: vec::map(m.view_items, fld.fold_view_item),
items: vec::map(filtered_items, fld.fold_item)};
@ -56,7 +56,7 @@ fn filter_native_item(cx: ctxt, &&item: @ast::native_item) ->
fn fold_native_mod(cx: ctxt, nm: ast::native_mod,
fld: fold::ast_fold) -> ast::native_mod {
let filter = bind filter_native_item(cx, _);
let filter = {|a|filter_native_item(cx, a)};
let filtered_items = vec::filter_map(nm.items, filter);
ret {view_items: vec::map(nm.view_items, fld.fold_view_item),
items: filtered_items};
@ -81,7 +81,7 @@ fn filter_stmt(cx: ctxt, &&stmt: @ast::stmt) ->
fn fold_block(cx: ctxt, b: ast::blk_, fld: fold::ast_fold) ->
ast::blk_ {
let filter = bind filter_stmt(cx, _);
let filter = {|a|filter_stmt(cx, a)};
let filtered_stmts = vec::filter_map(b.stmts, filter);
ret {view_items: b.view_items,
stmts: vec::map(filtered_stmts, fld.fold_stmt),

6
src/rustc/front/test.rs
View File

@ -44,9 +44,9 @@ fn generate_test_harness(sess: session::session,
testfns: dvec()};
let precursor =
@{fold_crate: fold::wrap(bind fold_crate(cx, _, _)),
fold_item: bind fold_item(cx, _, _),
fold_mod: bind fold_mod(cx, _, _) with *fold::default_ast_fold()};
@{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()};
let fold = fold::make_fold(precursor);
let res = @fold.fold_crate(*crate);

4
src/rustc/metadata/creader.rs
View File

@ -31,8 +31,8 @@ fn read_crates(diag: span_handler, crate: ast::crate,
mut next_crate_num: 1};
let v =
visit::mk_simple_visitor(@{visit_view_item:
bind visit_view_item(e, _),
visit_item: bind visit_item(e, _)
{|a|visit_view_item(e, a)},
visit_item: {|a|visit_item(e, a)}
with *visit::default_simple_visitor()});
visit::visit_crate(crate, (), v);
dump_crates(e.crate_cache);

4
src/rustc/metadata/decoder.rs
View File

@ -77,7 +77,7 @@ fn maybe_find_item(item_id: int, items: ebml::doc) -> option<ebml::doc> {
fn eq_item(bytes: [u8], item_id: int) -> bool {
ret io::u64_from_be_bytes(bytes, 0u, 4u) as int == item_id;
}
let eqer = bind eq_item(_, item_id);
let eqer = {|a|eq_item(a, item_id)};
let found = lookup_hash(items, eqer, hash_node_id(item_id));
if vec::len(found) == 0u {
ret option::none::<ebml::doc>;
@ -213,7 +213,7 @@ fn resolve_path(path: [ast::ident], data: @[u8]) -> [ast::def_id] {
let s = ast_util::path_name_i(path);
let md = ebml::doc(data);
let paths = ebml::get_doc(md, tag_paths);
let eqer = bind eq_item(_, s);
let eqer = {|a|eq_item(a, s)};
let mut result: [ast::def_id] = [];
#debug("resolve_path: looking up %s", s);
for lookup_hash(paths, eqer, hash_path(s)).each {|doc|

6
src/rustc/metadata/encoder.rs
View File

@ -271,7 +271,7 @@ fn encode_type_param_bounds(ebml_w: ebml::writer, ecx: @encode_ctxt,
let ty_str_ctxt = @{diag: ecx.diag,
ds: def_to_str,
tcx: ecx.tcx,
reachable: reachable(ecx, _),
reachable: {|a|reachable(ecx, a)},
abbrevs: tyencode::ac_use_abbrevs(ecx.type_abbrevs)};
for params.each {|param|
ebml_w.start_tag(tag_items_data_item_ty_param_bounds);
@ -292,7 +292,7 @@ fn write_type(ecx: @encode_ctxt, ebml_w: ebml::writer, typ: ty::t) {
@{diag: ecx.diag,
ds: def_to_str,
tcx: ecx.tcx,
reachable: reachable(ecx, _),
reachable: {|a|reachable(ecx, a)},
abbrevs: tyencode::ac_use_abbrevs(ecx.type_abbrevs)};
tyencode::enc_ty(ebml_w.writer, ty_str_ctxt, typ);
}
@ -551,7 +551,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
index: @mut [entry<int>]) {
*index += [{val: item.id, pos: ebml_w.writer.tell()}];
}
let add_to_index = bind add_to_index_(item, copy ebml_w, index);
let add_to_index = {|copy ebml_w|add_to_index_(item, ebml_w, index)};
alt item.node {
item_const(_, _) {

2
src/rustc/metadata/tydecode.rs
View File

@ -37,7 +37,7 @@ fn next_byte(st: @pstate) -> u8 {
fn parse_ident(st: @pstate, last: char) -> ast::ident {
fn is_last(b: char, c: char) -> bool { ret c == b; }
ret parse_ident_(st, bind is_last(last, _));
ret parse_ident_(st, {|a|is_last(last, a)});
}
fn parse_ident_(st: @pstate, is_last: fn@(char) -> bool) ->

10
src/rustc/middle/astencode.rs
View File

@ -445,8 +445,8 @@ fn decode_ast(par_doc: ebml::doc) -> ast::inlined_item {
fn renumber_ast(xcx: extended_decode_ctxt, ii: ast::inlined_item)
-> ast::inlined_item {
let fld = fold::make_fold(@{
new_id: xcx.tr_id(_),
new_span: xcx.tr_span(_)
new_id: {|a|xcx.tr_id(a)},
new_span: {|a|xcx.tr_span(a)}
with *fold::default_ast_fold()
});
@ -697,7 +697,7 @@ impl helpers for @e::encode_ctxt {
@{diag: self.tcx.sess.diagnostic(),
ds: e::def_to_str,
tcx: self.tcx,
reachable: encoder::reachable(self, _),
reachable: {|a|encoder::reachable(self, a)},
abbrevs: tyencode::ac_use_abbrevs(self.type_abbrevs)}
}
}
@ -903,7 +903,7 @@ impl decoder for ebml::ebml_deserializer {
tydecode::parse_ty_data(
self.parent.data, xcx.dcx.cdata.cnum, self.pos, xcx.dcx.tcx,
xcx.tr_def_id(_))
{|a|xcx.tr_def_id(a)})
}
fn read_tys(xcx: extended_decode_ctxt) -> [ty::t] {
@ -913,7 +913,7 @@ impl decoder for ebml::ebml_deserializer {
fn read_bounds(xcx: extended_decode_ctxt) -> @[ty::param_bound] {
tydecode::parse_bounds_data(
self.parent.data, self.pos, xcx.dcx.cdata.cnum, xcx.dcx.tcx,
xcx.tr_def_id(_))
{|a|xcx.tr_def_id(a)})
}
fn read_ty_param_bounds_and_ty(xcx: extended_decode_ctxt)

2
src/rustc/middle/borrowck/categorization.rs
View File

@ -170,7 +170,7 @@ impl public_methods for borrowck_ctxt {
self.cat_def(expr.id, expr.span, expr_ty, def)
}
ast::expr_addr_of(*) | ast::expr_call(*) | ast::expr_bind(*) |
ast::expr_addr_of(*) | ast::expr_call(*) |
ast::expr_swap(*) | ast::expr_move(*) | ast::expr_assign(*) |
ast::expr_assign_op(*) | ast::expr_fn(*) | ast::expr_fn_block(*) |
ast::expr_assert(*) | ast::expr_check(*) | ast::expr_ret(*) |

4
src/rustc/middle/check_alt.rs
View File

@ -13,8 +13,8 @@ import std::map::hashmap;
fn check_crate(tcx: ty::ctxt, crate: @crate) {
visit::visit_crate(*crate, (), visit::mk_vt(@{
visit_expr: bind check_expr(tcx, _, _, _),
visit_local: bind check_local(tcx, _, _, _)
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::<()>()
}));
tcx.sess.abort_if_errors();

6
src/rustc/middle/check_const.rs
View File

@ -8,9 +8,11 @@ fn check_crate(sess: session, crate: @crate, ast_map: ast_map::map,
def_map: resolve::def_map,
method_map: typeck::method_map, tcx: ty::ctxt) {
visit::visit_crate(*crate, false, visit::mk_vt(@{
visit_item: check_item(sess, ast_map, def_map, _, _, _),
visit_item: {|a,b,c|check_item(sess, ast_map, def_map, a, b, c)},
visit_pat: check_pat,
visit_expr: bind check_expr(sess, def_map, method_map, tcx, _, _, _)
visit_expr: {|a,b,c|
check_expr(sess, def_map, method_map, tcx, a, b, c)
}
with *visit::default_visitor()
}));
sess.abort_if_errors();

3
src/rustc/middle/kind.rs
View File

@ -240,9 +240,6 @@ fn check_expr(e: @expr, cx: ctx, v: visit::vt<ctx>) {
expr_tup(exprs) | expr_vec(exprs, _) {
for exprs.each {|expr| maybe_copy(cx, expr); }
}
expr_bind(_, args) {
for args.each {|a| alt a { some(ex) { maybe_copy(cx, ex); } _ {} } }
}
expr_call(f, args, _) {
let mut i = 0u;
for ty::ty_fn_args(ty::expr_ty(cx.tcx, f)).each {|arg_t|

14
src/rustc/middle/lint.rs
View File

@ -331,7 +331,7 @@ fn check_item_while_true(cx: ty::ctxt, it: @ast::item) {
alt cond.node {
ast::expr_lit(@{node: ast::lit_bool(true),_}) {
cx.sess.span_lint(
while_true, it.id, e.id,
while_true, e.id, it.id,
e.span,
"denote infinite loops with loop { ... }");
}
@ -357,14 +357,14 @@ fn check_item_ctypes(cx: ty::ctxt, it: @ast::item) {
alt cx.def_map.get(id) {
ast::def_prim_ty(ast::ty_int(ast::ty_i)) {
cx.sess.span_lint(
ctypes, fn_id, id,
ctypes, id, fn_id,
ty.span,
"found rust type `int` in native module, while \
libc::c_int or libc::c_long should be used");
}
ast::def_prim_ty(ast::ty_uint(ast::ty_u)) {
cx.sess.span_lint(
ctypes, fn_id, id,
ctypes, id, fn_id,
ty.span,
"found rust type `uint` in native module, while \
libc::c_uint or libc::c_ulong should be used");
@ -400,7 +400,7 @@ fn check_item_path_statement(cx: ty::ctxt, it: @ast::item) {
node: ast::expr_path(@path),
span: _}, _) {
cx.sess.span_lint(
path_statement, it.id, id,
path_statement, id, it.id,
s.span,
"path statement with no effect");
}
@ -423,7 +423,7 @@ fn check_item_old_vecs(cx: ty::ctxt, it: @ast::item) {
ast::expr_lit(@{node: ast::lit_str(_), span:_})
if ! uses_vstore.contains_key(e.id) {
cx.sess.span_lint(
old_vecs, it.id, e.id,
old_vecs, e.id, it.id,
e.span, "deprecated vec/str expr");
}
ast::expr_vstore(@inner, _) {
@ -438,7 +438,7 @@ fn check_item_old_vecs(cx: ty::ctxt, it: @ast::item) {
ast::ty_vec(_)
if ! uses_vstore.contains_key(t.id) {
cx.sess.span_lint(
old_vecs, it.id, t.id,
old_vecs, t.id, it.id,
t.span, "deprecated vec type");
}
@ -446,7 +446,7 @@ fn check_item_old_vecs(cx: ty::ctxt, it: @ast::item) {
rp: none, types: _}, _)
if ids == [@"str"] && (! uses_vstore.contains_key(t.id)) {
cx.sess.span_lint(
old_vecs, it.id, t.id,
old_vecs, t.id, it.id,
t.span, "deprecated str type");
}

14
src/rustc/middle/liveness.rs
View File

@ -468,7 +468,7 @@ fn visit_expr(expr: @expr, &&self: @ir_maps, vt: vt<@ir_maps>) {
// otherwise, live nodes are not required:
expr_index(*) | expr_field(*) | expr_vstore(*) |
expr_vec(*) | expr_rec(*) | expr_call(*) | expr_tup(*) |
expr_bind(*) | expr_new(*) | expr_log(*) | expr_binary(*) |
expr_new(*) | expr_log(*) | expr_binary(*) |
expr_assert(*) | expr_check(*) | expr_addr_of(*) | expr_copy(*) |
expr_loop_body(*) | expr_do_body(*) | expr_cast(*) |
expr_unary(*) | expr_fail(*) |
@ -1081,16 +1081,6 @@ class liveness {
self.propagate_through_exprs(exprs, succ)
}
expr_bind(f, args) {
let succ = args.foldr(succ) { |arg, succ|
alt arg {
none {succ}
some(e) {self.propagate_through_expr(e, succ)}
}
};
self.propagate_through_expr(f, succ)
}
expr_binary(op, l, r) if ast_util::lazy_binop(op) {
let r_succ = self.propagate_through_expr(r, succ);
@ -1464,7 +1454,7 @@ fn check_expr(expr: @expr, &&self: @liveness, vt: vt<@liveness>) {
expr_while(*) | expr_loop(*) |
expr_index(*) | expr_field(*) | expr_vstore(*) |
expr_vec(*) | expr_rec(*) | expr_tup(*) |
expr_bind(*) | expr_new(*) | expr_log(*) | expr_binary(*) |
expr_new(*) | expr_log(*) | expr_binary(*) |
expr_assert(*) | expr_check(*) | expr_copy(*) |
expr_loop_body(*) | expr_do_body(*) |
expr_cast(*) | expr_unary(*) | expr_fail(*) |

43
src/rustc/middle/resolve.rs
View File

@ -328,8 +328,8 @@ fn map_crate(e: @env, c: @ast::crate) {
// First, find all the modules, and index the names that they contain
let v_map_mod =
@{visit_view_item: bind index_vi(e, _, _, _),
visit_item: bind index_i(e, _, _, _),
@{visit_view_item: {|a,b,c|index_vi(e, a, b, c)},
visit_item: {|a,b,c|index_i(e, a, b, c)},
visit_block: visit_block_with_scope
with *visit::default_visitor::<scopes>()};
visit::visit_crate(*c, top_scope(), visit::mk_vt(v_map_mod));
@ -345,9 +345,9 @@ fn map_crate(e: @env, c: @ast::crate) {
// Next, assemble the links for globbed imports and exports.
let v_link_glob =
@{visit_view_item: bind link_glob(e, _, _, _),
@{visit_view_item: {|a,b,c|link_glob(e, a, b, c)},
visit_block: visit_block_with_scope,
visit_item: bind visit_item_with_scope(e, _, _, _)
visit_item: {|a,b,c|visit_item_with_scope(e, a, b, c)}
with *visit::default_visitor::<scopes>()};
visit::visit_crate(*c, top_scope(), visit::mk_vt(v_link_glob));
@ -414,17 +414,19 @@ fn resolve_names(e: @env, c: @ast::crate) {
e.used_imports.track = true;
let v =
@{visit_native_item: visit_native_item_with_scope,
visit_item: bind walk_item(e, _, _, _),
visit_item: {|a,b,c|walk_item(e, a, b, c)},
visit_block: visit_block_with_scope,
visit_decl: visit_decl_with_scope,
visit_arm: visit_arm_with_scope,
visit_local: bind visit_local_with_scope(e, _, _, _),
visit_pat: bind walk_pat(e, _, _, _),
visit_expr: bind walk_expr(e, _, _, _),
visit_ty: bind walk_ty(e, _, _, _),
visit_ty_params: bind walk_tps(e, _, _, _),
visit_constr: bind walk_constr(e, _, _, _, _, _),
visit_fn: bind visit_fn_with_scope(e, _, _, _, _, _, _, _)
visit_local: {|a,b,c|visit_local_with_scope(e, a, b, c)},
visit_pat: {|a,b,c|walk_pat(e, a, b, c)},
visit_expr: {|a,b,c|walk_expr(e, a, b ,c)},
visit_ty: {|a,b,c|walk_ty(e, a, b, c)},
visit_ty_params: {|a,b,c|walk_tps(e, a, b, c)},
visit_constr: {|a,b,c,d,f|walk_constr(e, a, b, c, d, f)},
visit_fn: {|a,b,c,d,f,g,h|
visit_fn_with_scope(e, a, b, c, d, f, g, h)
}
with *visit::default_visitor()};
visit::visit_crate(*c, top_scope(), visit::mk_vt(v));
e.used_imports.track = false;
@ -1713,11 +1715,12 @@ fn check_for_collisions(e: @env, c: ast::crate) {
};
// Other scopes have to be checked the hard way.
let v =
@{visit_item: bind check_item(e, _, _, _),
visit_block: bind check_block(e, _, _, _),
visit_arm: bind check_arm(e, _, _, _),
visit_expr: bind check_expr(e, _, _, _),
visit_ty: bind check_ty(e, _, _, _) with *visit::default_visitor()};
@{visit_item: {|a,b,c|check_item(e, a, b, c)},
visit_block: {|a,b,c|check_block(e, a, b, c)},
visit_arm: {|a,b,c|check_arm(e, a, b, c)},
visit_expr: {|a,b,c|check_expr(e, a, b, c)},
visit_ty: {|a,b,c|check_ty(e, a, b, c)}
with *visit::default_visitor()};
visit::visit_crate(c, (), visit::mk_vt(v));
}
@ -2157,9 +2160,9 @@ type iscopes = @list<@[@_impl]>;
fn resolve_impls(e: @env, c: @ast::crate) {
visit::visit_crate(*c, @nil, visit::mk_vt(@{
visit_block: bind visit_block_with_impl_scope(e, _, _, _),
visit_mod: bind visit_mod_with_impl_scope(e, _, _, _, _, _),
visit_expr: bind resolve_impl_in_expr(e, _, _, _)
visit_block: {|a,b,c|visit_block_with_impl_scope(e, a, b, c)},
visit_mod: {|a,b,c,d,f|visit_mod_with_impl_scope(e, a, b, c, d, f)},
visit_expr: {|a,b,c|resolve_impl_in_expr(e, a, b, c)}
with *visit::default_visitor()
}));
}

2
src/rustc/middle/trans/alt.rs
View File

@ -663,7 +663,7 @@ fn trans_alt_inner(scope_cx: block, expr: @ast::expr, arms: [ast::arm],
*done = some(fail_cx.llbb);
ret fail_cx.llbb;
}
some(bind mk_fail(scope_cx, expr.span, fail_cx))
some({||mk_fail(scope_cx, expr.span, fail_cx)})
}
ast::alt_exhaustive { none }
};

21
src/rustc/middle/trans/base.rs
View File

@ -920,7 +920,7 @@ enum scalar_type { nil_type, signed_int, unsigned_int, floating_point, }
fn compare_scalar_types(cx: block, lhs: ValueRef, rhs: ValueRef,
t: ty::t, op: ast::binop) -> result {
let f = bind compare_scalar_values(cx, lhs, rhs, _, op);
let f = {|a|compare_scalar_values(cx, lhs, rhs, a, op)};
alt ty::get(t).struct {
ty::ty_nil { ret rslt(cx, f(nil_type)); }
@ -950,7 +950,7 @@ fn compare_scalar_values(cx: block, lhs: ValueRef, rhs: ValueRef,
cx.tcx().sess.bug("compare_scalar_values: must be a\
comparison operator");
}
let die = bind die_(cx);
let die = fn@() -> ! { die_(cx) };
alt nt {
nil_type {
// We don't need to do actual comparisons for nil.
@ -1609,7 +1609,8 @@ fn trans_compare(cx: block, op: ast::binop, lhs: ValueRef,
fn cast_shift_expr_rhs(cx: block, op: ast::binop,
lhs: ValueRef, rhs: ValueRef) -> ValueRef {
cast_shift_rhs(op, lhs, rhs,
bind Trunc(cx, _, _), bind ZExt(cx, _, _))
{|a,b|Trunc(cx, a, b)},
{|a,b|ZExt(cx, a, b)})
}
fn cast_shift_const_rhs(op: ast::binop,
@ -2343,7 +2344,9 @@ fn maybe_instantiate_inline(ccx: @crate_ctxt, fn_id: ast::def_id)
none { // Not seen yet
alt csearch::maybe_get_item_ast(
ccx.tcx, fn_id,
bind astencode::decode_inlined_item(_, _, ccx.maps, _, _)) {
{|a,b,c,d|
astencode::decode_inlined_item(a, b, ccx.maps, c, d)
}) {
csearch::not_found {
ccx.external.insert(fn_id, none);
@ -3664,10 +3667,6 @@ fn trans_expr(bcx: block, e: @ast::expr, dest: dest) -> block {
ast::expr_do_body(blk) {
ret trans_expr(bcx, blk, dest);
}
ast::expr_bind(f, args) {
ret closure::trans_bind(
bcx, f, args, e.id, dest);
}
ast::expr_copy(a) {
if !expr_is_lval(bcx, a) {
ret trans_expr(bcx, a, dest);
@ -5351,7 +5350,7 @@ 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: bind trans_constant(ccx, _)
visit_item: {|a|trans_constant(ccx, a)}
with *visit::default_simple_visitor()
}));
}
@ -5495,14 +5494,14 @@ fn crate_ctxt_to_encode_parms(cx: @crate_ctxt)
-> encoder::encode_parms {
let encode_inlined_item =
bind astencode::encode_inlined_item(_, _, _, _, cx.maps);
{|a,b,c,d|astencode::encode_inlined_item(a, b, c, d, cx.maps)};
ret {
diag: cx.sess.diagnostic(),
tcx: cx.tcx,
reachable: cx.reachable,
reexports: reexports(cx),
impl_map: impl_map(cx, _),
impl_map: {|a|impl_map(cx, a)},
item_symbols: cx.item_symbols,
discrim_symbols: cx.discrim_symbols,
link_meta: cx.link_meta,

8
src/rustc/middle/trans/closure.rs
View File

@ -426,14 +426,6 @@ fn trans_expr_fn(bcx: block,
ret bcx;
}
fn trans_bind(cx: block, f: @ast::expr, args: [option<@ast::expr>],
id: ast::node_id, dest: dest) -> block {
let _icx = cx.insn_ctxt("closure::trans_bind");
let f_res = trans_callee(cx, f);
ret trans_bind_1(cx, expr_ty(cx, f), f_res, args,
node_id_type(cx, id), dest);
}
fn trans_bind_1(cx: block, outgoing_fty: ty::t,
f_res: lval_maybe_callee,
args: [option<@ast::expr>], pair_ty: ty::t,

10
src/rustc/middle/trans/common.rs
View File

@ -232,7 +232,7 @@ fn add_clean(cx: block, val: ValueRef, ty: ty::t) {
ty_to_str(cx.ccx().tcx, ty)];
let cleanup_type = cleanup_type(cx.tcx(), ty);
in_scope_cx(cx) {|info|
info.cleanups += [clean(bind base::drop_ty(_, val, ty),
info.cleanups += [clean({|a|base::drop_ty(a, val, ty)},
cleanup_type)];
scope_clean_changed(info);
}
@ -252,7 +252,7 @@ fn add_clean_temp(cx: block, val: ValueRef, ty: ty::t) {
}
}
in_scope_cx(cx) {|info|
info.cleanups += [clean_temp(val, bind do_drop(_, val, ty),
info.cleanups += [clean_temp(val, {|a|do_drop(a, val, ty)},
cleanup_type)];
scope_clean_changed(info);
}
@ -264,14 +264,14 @@ fn add_clean_temp_mem(cx: block, val: ValueRef, ty: ty::t) {
ty_to_str(cx.ccx().tcx, ty)];
let cleanup_type = cleanup_type(cx.tcx(), ty);
in_scope_cx(cx) {|info|
info.cleanups += [clean_temp(val, bind base::drop_ty(_, val, ty),
info.cleanups += [clean_temp(val, {|a|base::drop_ty(a, val, ty)},
cleanup_type)];
scope_clean_changed(info);
}
}
fn add_clean_free(cx: block, ptr: ValueRef, shared: bool) {
let free_fn = if shared { bind base::trans_unique_free(_, ptr) }
else { bind base::trans_free(_, ptr) };
let free_fn = if shared { {|a|base::trans_unique_free(a, ptr)} }
else { {|a|base::trans_free(a, ptr)} };
in_scope_cx(cx) {|info|
info.cleanups += [clean_temp(ptr, free_fn,
normal_exit_and_unwind)];

2
src/rustc/middle/trans/type_use.rs
View File

@ -223,7 +223,7 @@ fn mark_for_expr(cx: ctx, e: @expr) {
expr_while(_, _) | expr_fail(_) | expr_break | expr_cont |
expr_unary(_, _) | expr_lit(_) | expr_assert(_) | expr_check(_, _) |
expr_if_check(_, _, _) | expr_mac(_) | expr_addr_of(_, _) |
expr_ret(_) | expr_loop(_) | expr_bind(_, _) |
expr_ret(_) | expr_loop(_) |
expr_loop_body(_) | expr_do_body(_) {}
}
}

12
src/rustc/middle/tstate/annotate.rs
View File

@ -27,11 +27,11 @@ fn collect_ids_local(tcx: ty::ctxt, l: @local, rs: @mut [node_id]) {
fn node_ids_in_fn(tcx: ty::ctxt, body: blk, rs: @mut [node_id]) {
let collect_ids =
visit::mk_simple_visitor(@{visit_expr: bind collect_ids_expr(_, rs),
visit_block: bind collect_ids_block(_, rs),
visit_stmt: bind collect_ids_stmt(_, rs),
visit_local:
bind collect_ids_local(tcx, _, rs)
visit::mk_simple_visitor(@{visit_expr: {|a|collect_ids_expr(a, rs)},
visit_block: {|a|collect_ids_block(a, rs)},
visit_stmt: {|a|collect_ids_stmt(a, rs)},
visit_local: {|a|
collect_ids_local(tcx, a, rs)}
with *visit::default_simple_visitor()});
collect_ids.visit_block(body, (), collect_ids);
}
@ -59,7 +59,7 @@ fn annotate_in_fn(ccx: crate_ctxt, _fk: visit::fn_kind, _decl: fn_decl,
fn annotate_crate(ccx: crate_ctxt, crate: crate) {
let do_ann =
visit::mk_simple_visitor(
@{visit_fn: bind annotate_in_fn(ccx, _, _, _, _, _)
@{visit_fn: {|a,b,c,d,e|annotate_in_fn(ccx, a, b, c, d, e)}
with *visit::default_simple_visitor()});
visit::visit_crate(crate, (), do_ann);
}

2
src/rustc/middle/tstate/auxiliary.rs
View File

@ -551,7 +551,7 @@ fn expr_to_constr_arg(tcx: ty::ctxt, e: @expr) -> @constr_arg_use {
}
fn exprs_to_constr_args(tcx: ty::ctxt, args: [@expr]) -> [@constr_arg_use] {
let f = bind expr_to_constr_arg(tcx, _);
let f = {|a|expr_to_constr_arg(tcx, a)};
let mut rslt: [@constr_arg_use] = [];
for args.each {|e| rslt += [f(e)]; }
rslt

2
src/rustc/middle/tstate/bitvectors.rs
View File

@ -138,7 +138,7 @@ fn relax_precond_block(fcx: fn_ctxt, i: node_id, b: blk) {
visit_stmt: relax_precond_stmt,
visit_item:
fn@(_i: @item, _cx: relax_ctxt, _vt: visit::vt<relax_ctxt>) { },
visit_fn: bind do_nothing(_, _, _, _, _, _, _)
visit_fn: do_nothing
with *visitor};
let v1 = visit::mk_vt(visitor);
v1.visit_block(b, cx, v1);

4
src/rustc/middle/tstate/ck.rs
View File

@ -80,7 +80,9 @@ fn check_states_against_conditions(fcx: fn_ctxt,
let visitor = visit::mk_vt(
@{visit_stmt: check_states_stmt,
visit_expr: check_states_expr,
visit_fn: bind do_nothing::<fn_ctxt>(_, _, _, _, _, _, _)
visit_fn: {|a,b,c,d,e,f,g|
do_nothing::<fn_ctxt>(a, b, c, d, e, f, g)
}
with *visit::default_visitor::<fn_ctxt>()});
visit::visit_fn(fk, f_decl, f_body, sp, id, fcx, visitor);
}

10
src/rustc/middle/tstate/collect_locals.rs
View File

@ -43,7 +43,7 @@ fn find_locals(tcx: ty::ctxt,
let visitor = visit::default_visitor::<ctxt>();
let visitor =
@{visit_expr: collect_pred,
visit_fn: bind do_nothing(_, _, _, _, _, _, _)
visit_fn: do_nothing
with *visitor};
visit::visit_fn(fk, f_decl, f_body, sp,
id, cx, visit::mk_vt(visitor));
@ -147,9 +147,11 @@ fn mk_fn_info(ccx: crate_ctxt,
to bit number) */
fn mk_f_to_fn_info(ccx: crate_ctxt, c: @crate) {
let visitor =
visit::mk_simple_visitor(@{visit_fn:
bind mk_fn_info(ccx, _, _, _, _, _)
with *visit::default_simple_visitor()});
visit::mk_simple_visitor(@{
visit_fn: {|a,b,c,d,e|
mk_fn_info(ccx, a, b, c, d, e)
}
with *visit::default_simple_visitor()});
visit::visit_crate(*c, (), visitor);
}
//

22
src/rustc/middle/tstate/pre_post_conditions.rs
View File

@ -81,7 +81,7 @@ fn find_pre_post_exprs(fcx: fn_ctxt, args: [@expr], id: node_id) {
fn get_pp(ccx: crate_ctxt, &&e: @expr) -> pre_and_post {
ret expr_pp(ccx, e);
}
let pps = vec::map(args, bind get_pp(fcx.ccx, _));
let pps = vec::map(args, {|a|get_pp(fcx.ccx, a)});
set_pre_and_post(fcx.ccx, id, seq_preconds(fcx, pps),
seq_postconds(fcx, vec::map(pps, get_post)));
@ -414,7 +414,7 @@ fn find_pre_post_expr(fcx: fn_ctxt, e: @expr) {
let e_pp =
{precondition: empty_prestate(num_local_vars),
postcondition: false_postcond(num_local_vars)};
let g = bind combine_pp(antec_pp, fcx, _, _);
let g = {|a,b|combine_pp(antec_pp, fcx, a, b)};
let alts_overall_pp =
vec::foldl(e_pp, alt_pps, g);
set_pre_and_post(fcx.ccx, e.id, alts_overall_pp.precondition,
@ -449,22 +449,6 @@ fn find_pre_post_expr(fcx: fn_ctxt, e: @expr) {
expr_if_check(p, conseq, maybe_alt) {
join_then_else(fcx, p, conseq, maybe_alt, e.id, if_check);
}
expr_bind(operator, maybe_args) {
let mut args = [];
let mut cmodes = callee_modes(fcx, operator.id);
let mut modes = [];
let mut i = 0;
for maybe_args.each {|expr_opt|
alt expr_opt {
none {/* no-op */ }
some(expr) { modes += [cmodes[i]]; args += [expr]; }
}
i += 1;
}
args += [operator]; /* ??? order of eval? */
forget_args_moved_in(fcx, e, modes, args);
find_pre_post_exprs(fcx, args, e.id);
}
expr_break { clear_pp(expr_pp(fcx.ccx, e)); }
expr_cont { clear_pp(expr_pp(fcx.ccx, e)); }
expr_mac(_) { fcx.ccx.tcx.sess.bug("unexpanded macro"); }
@ -572,7 +556,7 @@ fn find_pre_post_block(fcx: fn_ctxt, b: blk) {
}
for b.node.stmts.each {|s| do_one_(fcx, s); }
fn do_inner_(fcx: fn_ctxt, &&e: @expr) { find_pre_post_expr(fcx, e); }
let do_inner = bind do_inner_(fcx, _);
let do_inner = {|a|do_inner_(fcx, a)};
option::map::<@expr, ()>(b.node.expr, do_inner);
let mut pps: [pre_and_post] = [];

15
src/rustc/middle/tstate/states.rs
View File

@ -305,21 +305,6 @@ fn find_pre_post_state_expr(fcx: fn_ctxt, pres: prestate, e: @expr) -> bool {
operands,
controlflow_expr(fcx.ccx, operator));
}
expr_bind(operator, maybe_args) {
let mut args = [];
let callee_ops = callee_arg_init_ops(fcx, operator.id);
let mut ops = [];
let mut i = 0;
for maybe_args.each {|a_opt|
alt a_opt {
none {/* no-op */ }
some(a) { ops += [callee_ops[i]]; args += [a]; }
}
i += 1;
}
ret find_pre_post_state_call(fcx, pres, operator, e.id, ops, args,
return_val);
}
expr_path(_) { ret pure_exp(fcx.ccx, e.id, pres); }
expr_log(_, lvl, ex) {
ret find_pre_post_state_two(fcx, pres, lvl, ex, e.id, oper_pure);

25
src/rustc/middle/ty.rs
View File

@ -2991,8 +2991,8 @@ fn is_binopable(_cx: ctxt, ty: t, op: ast::binop) -> bool {
ty_bool { tycat_bool }
ty_int(_) | ty_uint(_) | ty_var_integral(_) { tycat_int }
ty_float(_) { tycat_float }
ty_estr(_) | ty_str { tycat_str }
ty_evec(_, _) | ty_vec(_) { tycat_vec }
ty_str { tycat_str }
ty_vec(_) { tycat_vec }
ty_rec(_) | ty_tup(_) | ty_enum(_, _) { tycat_struct }
ty_bot { tycat_bot }
_ { tycat_other }
@ -3002,21 +3002,18 @@ fn is_binopable(_cx: ctxt, ty: t, op: ast::binop) -> bool {
const t: bool = true;
const f: bool = false;
let tbl = [
/*. add, shift, bit
. sub, rel, logic
. mult, eq, */
/*other*/
/*bool*/
/*int*/
/*float*/
/*str*/
/*vec*/
/*bot*/
let tbl =
[[f, f, f, f, t, t, f, f], [f, f, f, f, t, t, t, t],
[t, t, t, t, t, t, t, f], [t, t, t, f, t, t, f, f],
[t, f, f, f, t, t, f, f], [t, f, f, f, t, t, f, f],
[f, f, f, f, t, t, f, f], [t, t, t, t, t, t, t, t]]; /*struct*/
/*other*/ [f, f, f, f, t, t, f, f],
/*bool*/ [f, f, f, f, t, t, t, t],
/*int*/ [t, t, t, t, t, t, t, f],
/*float*/ [t, t, t, f, t, t, f, f],
/*str*/ [t, f, f, f, t, t, f, f],
/*vec*/ [t, f, f, f, t, t, f, f],
/*bot*/ [f, f, f, f, t, t, f, f],
/*struct*/ [t, t, t, t, t, t, t, t]];
ret tbl[tycat(ty)][opcat(op)];
}

136
src/rustc/middle/typeck/check.rs
View File

@ -134,7 +134,7 @@ impl methods for isr_alist {
fn check_item_types(ccx: @crate_ctxt, crate: @ast::crate) {
let visit = visit::mk_simple_visitor(@{
visit_item: bind check_item(ccx, _)
visit_item: {|a|check_item(ccx, a)}
with *visit::default_simple_visitor()
});
visit::visit_crate(*crate, (), visit);
@ -1132,7 +1132,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
// and so forth. - Niko
fcx.write_nil(expr.id);
}
ast::expr_unary(unop, oper) {
ast::expr_unary(unop, oprnd) {
let exp_inner = unpack_expected(fcx, expected) {|sty|
alt unop {
ast::box(_) | ast::uniq(_) {
@ -1145,17 +1145,17 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
ast::deref { none }
}
};
bot = check_expr(fcx, oper, exp_inner);
let mut oper_t = fcx.expr_ty(oper);
bot = check_expr(fcx, oprnd, exp_inner);
let mut oprnd_t = fcx.expr_ty(oprnd);
alt unop {
ast::box(mutbl) {
oper_t = ty::mk_box(tcx, {ty: oper_t, mutbl: mutbl});
oprnd_t = ty::mk_box(tcx, {ty: oprnd_t, mutbl: mutbl});
}
ast::uniq(mutbl) {
oper_t = ty::mk_uniq(tcx, {ty: oper_t, mutbl: mutbl});
oprnd_t = ty::mk_uniq(tcx, {ty: oprnd_t, mutbl: mutbl});
}
ast::deref {
let sty = structure_of(fcx, expr.span, oper_t);
let sty = structure_of(fcx, expr.span, oprnd_t);
// deref'ing an unsafe pointer requires that we be in an unsafe
// context
@ -1169,7 +1169,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
}
alt ty::deref_sty(tcx, sty, true) {
some(mt) { oper_t = mt.ty }
some(mt) { oprnd_t = mt.ty }
none {
alt sty {
ty::ty_enum(*) {
@ -1183,39 +1183,46 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
tcx.sess.span_err(
expr.span,
#fmt["type %s cannot be dereferenced",
fcx.infcx.ty_to_str(oper_t)]);
fcx.infcx.ty_to_str(oprnd_t)]);
}
}
}
}
}
ast::not {
oper_t = structurally_resolved_type(fcx, oper.span, oper_t);
if !(ty::type_is_integral(oper_t) ||
ty::get(oper_t).struct == ty::ty_bool) {
oper_t = check_user_unop(fcx, "!", "!", expr,
oper, oper_t);
oprnd_t = structurally_resolved_type(fcx, oprnd.span, oprnd_t);
if !(ty::type_is_integral(oprnd_t) ||
ty::get(oprnd_t).struct == ty::ty_bool) {
oprnd_t = check_user_unop(fcx, "!", "!", expr,
oprnd, oprnd_t);
}
}
ast::neg {
oper_t = structurally_resolved_type(fcx, oper.span, oper_t);
if !(ty::type_is_integral(oper_t) ||
ty::type_is_fp(oper_t)) {
oper_t = check_user_unop(fcx, "-", "unary-", expr,
oper, oper_t);
// If the operand's type is an integral type variable, we
// don't want to resolve it yet, because the rest of the
// typing context might not have had the opportunity to
// constrain it yet.
if !(ty::type_is_var_integral(oprnd_t)) {
oprnd_t = structurally_resolved_type(fcx, oprnd.span,
oprnd_t);
}
if !(ty::type_is_integral(oprnd_t) ||
ty::type_is_fp(oprnd_t)) {
oprnd_t = check_user_unop(fcx, "-", "unary-", expr,
oprnd, oprnd_t);
}
}
}
fcx.write_ty(id, oper_t);
fcx.write_ty(id, oprnd_t);
}
ast::expr_addr_of(mutbl, oper) {
bot = check_expr(fcx, oper, unpack_expected(fcx, expected) {|ty|
ast::expr_addr_of(mutbl, oprnd) {
bot = check_expr(fcx, oprnd, unpack_expected(fcx, expected) {|ty|
alt ty { ty::ty_rptr(_, mt) { some(mt.ty) } _ { none } }
});
let region = region_of(fcx, oper);
let tm = { ty: fcx.expr_ty(oper), mutbl: mutbl };
let oper_t = ty::mk_rptr(tcx, region, tm);
fcx.write_ty(id, oper_t);
let region = region_of(fcx, oprnd);
let tm = { ty: fcx.expr_ty(oprnd), mutbl: mutbl };
let oprnd_t = ty::mk_rptr(tcx, region, tm);
fcx.write_ty(id, oprnd_t);
}
ast::expr_path(pth) {
let defn = lookup_def(fcx, pth.span, id);
@ -1327,7 +1334,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
tcx.sess.span_fatal(
expr.span, #fmt("a loop function's last argument \
should return `bool`, not `%s`",
ty_to_str(tcx, fty.output)));
fcx.infcx.ty_to_str(fty.output)));
}
}
(ty::mk_fn(tcx, {output: ty::mk_nil(tcx) with fty}), fty.proto)
@ -1389,63 +1396,6 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
};
fcx.write_ty(id, typ);
}
ast::expr_bind(f, args) {
// Call the generic checker.
bot = check_expr(fcx, f, none);
let {fty, bot: ccob_bot} = {
let fn_ty = fcx.expr_ty(f);
check_call_or_bind(fcx, expr.span, expr.id, fn_ty, args)
};
bot |= ccob_bot;
// TODO: Perform substitutions on the return type.
// Pull the argument and return types out.
let mut proto, arg_tys, rt, cf, constrs;
alt structure_of(fcx, expr.span, fty) {
// FIXME:
// probably need to munge the constrs to drop constraints
// for any bound args (contingent on #2588 not getting accepted)
ty::ty_fn(f) {
proto = f.proto;
arg_tys = f.inputs;
rt = f.output;
cf = f.ret_style;
constrs = f.constraints;
}
_ { fail "LHS of bind expr didn't have a function type?!"; }
}
let proto = alt proto {
ast::proto_bare | ast::proto_box | ast::proto_uniq {
ast::proto_box
}
ast::proto_any | ast::proto_block {
tcx.sess.span_err(expr.span,
#fmt["cannot bind %s closures",
proto_to_str(proto)]);
proto // dummy value so compilation can proceed
}
};
// For each blank argument, add the type of that argument
// to the resulting function type.
let mut out_args = [];
let mut i = 0u;
while i < vec::len(args) {
alt args[i] {
some(_) {/* no-op */ }
none { out_args += [arg_tys[i]]; }
}
i += 1u;
}
let ft = ty::mk_fn(tcx, {purity: ast::impure_fn, proto: proto,
inputs: out_args, output: rt,
ret_style: cf, constraints: constrs});
fcx.write_ty(id, ft);
}
ast::expr_call(f, args, _) {
bot = check_call(fcx, expr.span, expr.id, f, args);
}
@ -1464,12 +1414,12 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
_ {
if ty::type_is_nil(t_e) {
tcx.sess.span_err(expr.span, "cast from nil: " +
ty_to_str(tcx, t_e) + " as " +
ty_to_str(tcx, t_1));
fcx.infcx.ty_to_str(t_e) + " as " +
fcx.infcx.ty_to_str(t_1));
} else if ty::type_is_nil(t_1) {
tcx.sess.span_err(expr.span, "cast to nil: " +
ty_to_str(tcx, t_e) + " as " +
ty_to_str(tcx, t_1));
fcx.infcx.ty_to_str(t_e) + " as " +
fcx.infcx.ty_to_str(t_1));
}
let t_1_is_scalar = type_is_scalar(fcx, expr.span, t_1);
@ -1483,8 +1433,8 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
*/
tcx.sess.span_err(expr.span,
"non-scalar cast: " +
ty_to_str(tcx, t_e) + " as " +
ty_to_str(tcx, t_1));
fcx.infcx.ty_to_str(t_e) + " as " +
fcx.infcx.ty_to_str(t_1));
}
}
}
@ -1632,7 +1582,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
let t_err = fcx.infcx.resolve_type_vars_if_possible(expr_t);
let msg = #fmt["attempted access of field %s on type %s, but \
no public field or method with that name was found",
*field, ty_to_str(tcx, t_err)];
*field, fcx.infcx.ty_to_str(t_err)];
tcx.sess.span_err(expr.span, msg);
// NB: Adding a bogus type to allow typechecking to continue
fcx.write_ty(id, fcx.infcx.next_ty_var());
@ -1660,7 +1610,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
_ {
tcx.sess.span_fatal(
expr.span, "cannot index a value of type `" +
ty_to_str(tcx, base_t) + "`");
fcx.infcx.ty_to_str(base_t) + "`");
}
}
}
@ -1701,7 +1651,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
none {
let t_err = fcx.infcx.resolve_type_vars_if_possible(p_ty);
let msg = #fmt["no `alloc()` method found for type `%s`",
ty_to_str(tcx, t_err)];
fcx.infcx.ty_to_str(t_err)];
tcx.sess.span_err(expr.span, msg);
}
}

2
src/rustc/middle/typeck/check/alt.rs
View File

@ -198,7 +198,7 @@ fn check_pat(pcx: pat_ctxt, pat: @ast::pat, expected: ty::t) {
ret str::eq(*name, *f.ident);
}
for fields.each {|f|
alt vec::find(ex_fields, bind matches(f.ident, _)) {
alt vec::find(ex_fields, {|a|matches(f.ident, a)}) {
some(field) {
check_pat(pcx, f.pat, field.mt.ty);
}

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

@ -53,8 +53,8 @@ fn collect_item_types(ccx: @crate_ctxt, crate: @ast::crate) {
}
visit::visit_crate(*crate, (), visit::mk_simple_visitor(@{
visit_item: bind convert(ccx, _),
visit_native_item: bind convert_native(ccx, _)
visit_item: {|a|convert(ccx, a)},
visit_native_item: {|a|convert_native(ccx, a)}
with *visit::default_simple_visitor()
}));
}

24
src/rustc/middle/typeck/infer.rs
View File

@ -119,6 +119,28 @@ is valid. This basically corresponds to the block nesting structure:
the regions for outer block scopes are superregions of those for inner
block scopes.
## Integral type variables
There is a third variety of type variable that we use only for
inferring the types of unsuffixed integer literals. Integral type
variables differ from general-purpose type variables in that there's
no subtyping relationship among the various integral types, so instead
of associating each variable with an upper and lower bound, we
represent the set of possible integral types it can take on with an
`int_ty_set`, which is a bitvector with one bit for each integral
type. Because intersecting these sets with each other is simpler than
merging bounds, we don't need to do so transactionally as we do for
general-purpose type variables.
We could conceivably define a subtyping relationship among integral
types based on their ranges, but we choose not to open that particular
can of worms. Our strategy is to treat integral type variables as
unknown until the typing context constrains them to a unique integral
type, at which point they take on that type. If the typing context
overconstrains the type, it's a type error; if we reach the point at
which type variables must be resolved and an integral type variable is
still underconstrained, it defaults to `int` as a last resort.
## GLB/LUB
Computing the greatest-lower-bound and least-upper-bound of two
@ -829,7 +851,7 @@ impl unify_methods for infer_ctxt {
}
} else if nde_a.rank < nde_b.rank {
#debug["vars(): b has smaller rank"];
// b has geater rank, so a should redirect to b.
// b has greater rank, so a should redirect to b.
self.set(vb, a_id, redirect(b_id));
self.set_var_to_merged_bounds(
vb, b_id, a_bounds, b_bounds, nde_b.rank).then {||

26
src/rustc/util/common.rs
View File

@ -34,25 +34,33 @@ fn field_exprs(fields: [ast::field]) -> [@ast::expr] {
}
// Takes a predicate p, returns true iff p is true for any subexpressions
// of b
fn block_expr_query(b: ast::blk, p: fn@(ast::expr_) -> bool) -> bool {
// of b -- skipping any inner loops (loop, while, loop_body)
fn loop_query(b: ast::blk, p: fn@(ast::expr_) -> bool) -> bool {
let rs = @mut false;
let visit_expr = {|flag: @mut bool, e: @ast::expr| *flag |= p(e.node)};
let v =
visit::mk_simple_visitor(@{visit_expr: bind visit_expr(rs, _)
with *visit::default_simple_visitor()});
visit::visit_block(b, (), v);
let visit_expr = {|e: @ast::expr, &&flag: @mut bool,
v: visit::vt<@mut bool>|
*flag |= p(e.node);
alt e.node {
// Skip inner loops, since a break in the inner loop isn't a
// break inside the outer loop
ast::expr_loop(*) | ast::expr_while(*) | ast::expr_loop_body(*) {}
_ { visit::visit_expr(e, flag, v); }
}
};
let v = visit::mk_vt(@{visit_expr: visit_expr
with *visit::default_visitor()});
visit::visit_block(b, rs, v);
ret *rs;
}
fn has_nonlocal_exits(b: ast::blk) -> bool {
block_expr_query(b) {|e| alt e {
loop_query(b) {|e| alt e {
ast::expr_break | ast::expr_cont { true }
_ { false }}}
}
fn may_break(b: ast::blk) -> bool {
block_expr_query(b) {|e| alt e {
loop_query(b) {|e| alt e {
ast::expr_break { true }
_ { false }}}
}

4
src/rustdoc/prune_unexported_pass.rs
View File

@ -62,7 +62,9 @@ fn exported_items_from_mod(
srv: astsrv::srv,
doc: doc::moddoc
) -> [doc::itemtag] {
exported_items_from(srv, doc, bind is_exported_from_mod(_, doc.id(), _))
exported_items_from(srv, doc, {|a,b|
is_exported_from_mod(a, doc.id(), b)
})
}
fn exported_items_from(

6
src/rustdoc/reexport_pass.rs
View File

@ -68,13 +68,13 @@ fn from_assoc_list<K:copy, V:copy>(
fn from_def_assoc_list<V:copy>(
list: [(ast::def_id, V)]
) -> map::hashmap<ast::def_id, V> {
from_assoc_list(list, bind ast_util::new_def_hash())
from_assoc_list(list, ast_util::new_def_hash)
}
fn from_str_assoc_list<V:copy>(
list: [(str, V)]
) -> map::hashmap<str, V> {
from_assoc_list(list, bind map::str_hash())
from_assoc_list(list, map::str_hash)
}
fn build_reexport_def_set(srv: astsrv::srv) -> def_set {
@ -256,7 +256,7 @@ fn for_each_reexported_impl(
f: fn@(ast::node_id, resolve::_impl)
) {
let visitor = @{
visit_mod: bind visit_mod(ctxt, f, _, _, _)
visit_mod: {|a,b,c|visit_mod(ctxt, f, a, b, c)}
with *visit::default_simple_visitor()
};
let visitor = visit::mk_simple_visitor(visitor);

8
src/snapshots.txt
View File

@ -1,3 +1,11 @@
S 2012-06-19 de491ea
freebsd-x86_64 b5c1080df70136bb316286e1973fa2b5734c9a01
winnt-i386 fa1c7b2295dbde00269f859b8cb637a59a8deec4
linux-i386 88886207b1f594ce9b3d6db1a6fcbaf94d710c0a
linux-x86_64 d8711b88786d58d0079623beeace070ca6a85635
macos-i386 9074b395dc92f1e54dec2e757daaf05dc86d6208
macos-x86_64 2cb02b7063191ed9400b3ed91c6aefad2799593d
S 2012-06-14 623d825
macos-x86_64 ab8d81cf3f538cd259cbec2be9615688482f9bc1
macos-i386 1ec2b3425fab510684858bb7b28f2c2ad474d5af

10
src/test/auxiliary/issue_2242_a.rs Normal file
View File

@ -0,0 +1,10 @@
#[link(name = "a", vers = "0.1")];
#[crate_type = "lib"];
iface to_str {
fn to_str() -> str;
}
impl of to_str for str {
fn to_str() -> str { self }
}

9
src/test/auxiliary/issue_2242_b.rs Normal file
View File

@ -0,0 +1,9 @@
#[link(name = "b", vers = "0.1")];
#[crate_type = "lib"];
use a;
import a::to_str;
impl of to_str for int {
fn to_str() -> str { #fmt("%?", self) }
}

10
src/test/auxiliary/issue_2242_c.rs Normal file
View File

@ -0,0 +1,10 @@
#[link(name = "c", vers = "0.1")];
#[crate_type = "lib"];
use a;
import a::to_str;
impl of to_str for bool {
fn to_str() -> str { #fmt("%b", self) }
}

2
src/test/bench/sudoku.rs
View File

@ -77,7 +77,7 @@ fn solve_grid(g: grid_t) {
if color != 0u8 { bitv::set(colors, color as uint, false); }
}
let it = bind drop_color(g, avail, _, _);
let it = {|a,b|drop_color(g, avail, a, b)};
for u8::range(0u8, 9u8) { |idx|
it(idx, col); /* check same column fields */

8
src/test/bench/task-perf-word-count-generic.rs
View File

@ -129,7 +129,7 @@ mod map_reduce {
send(c, emit_val(val));
}
map(input, bind emit(intermediates, ctrl, _, _));
map(input, {|a,b|emit(intermediates, ctrl, a, b)});
fn finish<K: copy send, V: copy send>(_k: K, v: chan<reduce_proto<V>>)
{
@ -148,8 +148,8 @@ mod map_reduce {
send(out, chan(p));
let ref_count = 0;
let is_done = false;
let mut ref_count = 0;
let mut is_done = false;
fn get<V: copy send>(p: port<reduce_proto<V>>,
&ref_count: int, &is_done: bool)
@ -171,7 +171,7 @@ mod map_reduce {
ret none;
}
reduce(key, bind get(p, ref_count, is_done));
reduce(key, {||get(p, ref_count, is_done)});
}
fn map_reduce<K1: copy send, K2: copy send, V: copy send>(

4
src/test/bench/task-perf-word-count.rs
View File

@ -91,7 +91,7 @@ mod map_reduce {
send(c, emit_val(val));
}
map(input, bind emit(intermediates, ctrl, _, _));
map(input, {|a,b|emit(intermediates, ctrl, a, b)});
for intermediates.each_value {|v| send(v, release); }
@ -125,7 +125,7 @@ mod map_reduce {
ret none;
}
reduce(key, bind get(p, state));
reduce(key, {||get(p, state)});
}
fn map_reduce(-inputs: [str]) {

4
src/test/compile-fail/auto-deref-bind.rs
View File

@ -1,4 +0,0 @@
// error-pattern: mismatched types
fn add1(i: int) -> int { ret i + 1; }
fn main() { let f = @add1; let g = bind f(5); }

10
src/test/compile-fail/bind-stack-closure.rs
View File

@ -1,10 +0,0 @@
fn foo(x: fn()) {
bind x(); //! ERROR cannot bind fn closures
}
fn bar(x: fn&()) {
bind x(); //! ERROR cannot bind fn& closures
}
fn main() {
}

7
src/test/compile-fail/crust-no-bind.rs
View File

@ -1,7 +0,0 @@
// error-pattern:expected function or native function but found *u8
crust fn f() {
}
fn main() {
let x = bind f();
}

8
src/test/compile-fail/fn-bare-bind.rs
View File

@ -1,8 +0,0 @@
fn f() {
}
fn main() {
// Can't produce a bare function by binding
let g: native fn() = bind f();
//!^ ERROR mismatched types: expected `native fn()` but found `fn@()`
}

4
src/test/compile-fail/index_message.rs Normal file
View File

@ -0,0 +1,4 @@
fn main() {
let z = ();
log(debug, z[0]); //! ERROR cannot index a value of type `()`
}

2
src/test/compile-fail/liveness-uninit-after-item.rs
View File

@ -1,6 +1,6 @@
fn main() {
let bar;
fn baz(_x: int) { }
bind baz(bar); //! ERROR use of possibly uninitialized variable: `bar`
baz(bar); //! ERROR use of possibly uninitialized variable: `bar`
}

2
src/test/compile-fail/tstate-unsat-after-item.rs
View File

@ -4,6 +4,6 @@ fn even(i: int) : is_even(i) -> int { i }
fn main() {
let x = 4;
fn baz(_x: int) { }
bind baz(even(x)); //! ERROR unsatisfied precondition
baz(even(x)); //! ERROR unsatisfied precondition
}

22
src/test/compile-fail/tutorial-suffix-inference-test.rs Normal file
View File

@ -0,0 +1,22 @@
fn main() {
let x = 3;
let y: i32 = 3;
fn identity_u8(n: u8) -> u8 { n }
fn identity_u16(n: u16) -> u16 { n }
identity_u8(x); // after this, `x` is assumed to have type `u8`
identity_u16(x);
//!^ ERROR mismatched types: expected `u16` but found `u8`
identity_u16(y);
//!^ ERROR mismatched types: expected `u16` but found `i32`
let a = 3i;
fn identity_i(n: int) -> int { n }
identity_i(a); // ok
identity_u16(a);
//!^ ERROR mismatched types: expected `u16` but found `int`
}

9
src/test/compile-fail/unsafe-fn-used-in-bind.rs
View File

@ -1,9 +0,0 @@
// -*- rust -*-
unsafe fn f(x: int, y: int) -> int { ret x + y; }
fn main() {
let x = bind f(3, _);
//!^ ERROR access to unsafe function requires unsafe function or block
let y = x(4);
}

3
src/test/run-fail/unwind-closure.rs
View File

@ -5,6 +5,7 @@ fn f(a: @int) {
}
fn main() {
let g = bind f(@0);
let b = @0;
let g = {|move b|f(b)};
g();
}

54
src/test/run-pass/auto_serialize.rs
View File

@ -81,55 +81,55 @@ fn main() {
@plus(@val(22u), @val(5u))),
"plus(@minus(@val(3u), @val(10u)), \
@plus(@val(22u), @val(5u)))",
serialize_expr(_, _),
deserialize_expr(_),
serialize_expr(_, _));
serialize_expr,
deserialize_expr,
serialize_expr);
test_ser_and_deser({lo: 0u, hi: 5u, node: 22u},
"{lo: 0u, hi: 5u, node: 22u}",
serialize_spanned_uint(_, _),
deserialize_spanned_uint(_),
serialize_spanned_uint(_, _));
serialize_spanned_uint,
deserialize_spanned_uint,
serialize_spanned_uint);
test_ser_and_deser(an_enum({v: [1u, 2u, 3u]}),
"an_enum({v: [1u, 2u, 3u]})",
serialize_an_enum(_, _),
deserialize_an_enum(_),
serialize_an_enum(_, _));
serialize_an_enum,
deserialize_an_enum,
serialize_an_enum);
test_ser_and_deser({x: 3u, y: 5u},
"{x: 3u, y: 5u}",
serialize_point(_, _),
deserialize_point(_),
serialize_point(_, _));
serialize_point,
deserialize_point,
serialize_point);
test_ser_and_deser([1u, 2u, 3u],
"[1u, 2u, 3u]",
serialize_uint_vec(_, _),
deserialize_uint_vec(_),
serialize_uint_vec(_, _));
serialize_uint_vec,
deserialize_uint_vec,
serialize_uint_vec);
test_ser_and_deser(top(22u),
"top(22u)",
serialize_uint_quark(_, _),
deserialize_uint_quark(_),
serialize_uint_quark(_, _));
serialize_uint_quark,
deserialize_uint_quark,
serialize_uint_quark);
test_ser_and_deser(bottom(222u),
"bottom(222u)",
serialize_uint_quark(_, _),
deserialize_uint_quark(_),
serialize_uint_quark(_, _));
serialize_uint_quark,
deserialize_uint_quark,
serialize_uint_quark);
test_ser_and_deser(a,
"a",
serialize_c_like(_, _),
deserialize_c_like(_),
serialize_c_like(_, _));
serialize_c_like,
deserialize_c_like,
serialize_c_like);
test_ser_and_deser(b,
"b",
serialize_c_like(_, _),
deserialize_c_like(_),
serialize_c_like(_, _));
serialize_c_like,
deserialize_c_like,
serialize_c_like);
}

5
src/test/run-pass/bind-exterior.rs
View File

@ -1,5 +0,0 @@
fn foo(a: @int, b: @int) -> int { ret *a + *b; }
fn main() { let f1 = bind foo(@10, @12); assert (f1() == 22); }

16
src/test/run-pass/bind-generic.rs
View File

@ -1,16 +0,0 @@
fn wrapper3<T: copy>(i: T, j: int) {
log(debug, i);
log(debug, j);
// This is a regression test that the spawn3 thunk to wrapper3
// correctly finds the value of j
assert j == 123456789;
}
fn spawn3<T: copy>(i: T, j: int) {
let wrapped = bind wrapper3(i, j);
wrapped();
}
fn main() {
spawn3(127u8, 123456789);
}

11
src/test/run-pass/bind-interior.rs
View File

@ -1,11 +0,0 @@
// -*- rust -*-
fn f(n: int) -> int { ret n; }
fn main() {
let g: fn@() -> int = bind f(10);
let i: int = g();
assert (i == 10);
}

20
src/test/run-pass/bind-methods.rs
View File

@ -1,20 +0,0 @@
iface foo {
fn foo() -> int;
fn bar(p: int) -> int;
}
impl of foo for int {
fn foo() -> int { self }
fn bar(p: int) -> int { p * self.foo() }
}
impl <T: foo> of foo for [T] {
fn foo() -> int { vec::foldl(0, self, {|a, b| a + b.foo()}) }
fn bar(p: int) -> int { p + self.len() as int }
}
fn main() {
let x = [1, 2, 3];
let y = x.foo, z = [4, 5, 6].foo;
assert y() + z() == 21;
let a = x.bar, b = bind [4, 5, 6].bar(_);
assert a(1) + b(2) + z() == 24;
}

21
src/test/run-pass/bind-native-fn.rs
View File

@ -1,21 +0,0 @@
// From #1174:
// xfail-fast
use std;
import str;
import libc::*;
#[nolink]
native mod libc {
fn write(fd: core::libc::c_int, buf: *u8, nbyte: core::libc::size_t);
}
fn main() {
let s = "hello world\n";
let b = str::bytes(s);
let l = str::len(s) as core::libc::size_t;
let b8 = unsafe { vec::unsafe::to_ptr(b) };
libc::write(0i32, b8, l);
let a = bind libc::write(0i32, _, _);
a(b8, l);
}

10
src/test/run-pass/bind-native.rs
View File

@ -1,10 +0,0 @@
/*
Can we bind native things?
*/
#[abi = "cdecl"]
native mod rustrt {
fn rand_new() -> *libc::c_void;
}
fn main() { bind rustrt::rand_new(); }

7
src/test/run-pass/bind-parameterized-args-2.rs
View File

@ -1,7 +0,0 @@
fn main() {
fn echo<T>(c: int, x: fn@(T)) { #error("wee"); }
let y = echo(42, _);
y(fn@(&&i: str) { });
}

7
src/test/run-pass/bind-parameterized-args.rs
View File

@ -1,7 +0,0 @@
fn main() {
fn echo<T>(c: int, x: [T]) { }
let y: fn@([int]) = echo(42, _);
y([1]);
}

11
src/test/run-pass/bind-thunk.rs
View File

@ -1,11 +0,0 @@
// -*- rust -*-
fn f() -> int { ret 42; }
fn main() {
let g: fn@() -> int = bind f();
let i: int = g();
assert (i == 42);
}

11
src/test/run-pass/bind-trivial.rs
View File

@ -1,11 +0,0 @@
// -*- rust -*-
fn f(n: int) -> int { ret n; }
fn main() {
let g: fn@(int) -> int = f(_);
let i: int = g(42);
assert (i == 42);
}

2
src/test/run-pass/block-fn-coerce.rs
View File

@ -2,6 +2,6 @@ fn force(f: fn() -> int) -> int { ret f(); }
fn main() {
fn f() -> int { ret 7; }
assert (force(f) == 7);
let g = bind force(f);
let g = {||force(f)};
assert (g() == 7);
}

4
src/test/run-pass/cycle-collection2.rs
View File

@ -4,7 +4,7 @@ fn nop() { }
fn nop_foo(_x : @foo) { }
fn main() {
let w = @{ mut z: bind nop() };
let x = bind nop_foo(w);
let w = @{ mut z: {||nop()} };
let x = {||nop_foo(w)};
w.z = x;
}

4
src/test/run-pass/cycle-collection4.rs
View File

@ -4,7 +4,7 @@ fn nop() { }
fn nop_foo(_y: [int], _x : @foo) { }
fn main() {
let w = @{ mut z: bind nop() };
let x = bind nop_foo([], w);
let w = @{ mut z: {||nop()} };
let x = {||nop_foo([], w)};
w.z = x;
}

4
src/test/run-pass/cycle-collection5.rs
View File

@ -6,7 +6,7 @@ fn nop_foo(_y: @int, _x : @foo) { }
fn o() -> @int { @10 }
fn main() {
let w = @{ mut z: bind nop() };
let x = bind nop_foo(o(), w);
let w = @{ mut z: {||nop()} };
let x = {||nop_foo(o(), w)};
w.z = x;
}

5
src/test/run-pass/drop-bind-thunk-args.rs
View File

@ -1,5 +0,0 @@
fn f(x: @int) { }
fn main() { let x = @10; let ff = f(_); ff(x); ff(x); }

5
src/test/run-pass/drop-parametric-closure-with-bound-box.rs
View File

@ -1,5 +0,0 @@
fn f<T>(i: @uint, t: T) { }
fn main() { let x = f::<char>(@0xdeafbeefu, _); }

2
src/test/run-pass/empty-tag.rs
View File

@ -5,6 +5,6 @@ fn wrapper3(i: chan) {
}
fn main() {
let wrapped = bind wrapper3(chan_t);
let wrapped = {||wrapper3(chan_t)};
wrapped();
}

3
src/test/run-pass/expr-alt-generic-box1.rs
View File

@ -11,8 +11,7 @@ fn test_generic<T>(expected: @T, eq: compare<T>) {
fn test_box() {
fn compare_box(b1: @bool, b2: @bool) -> bool { ret *b1 == *b2; }
let eq = compare_box(_, _);
test_generic::<bool>(@true, eq);
test_generic::<bool>(@true, compare_box);
}
fn main() { test_box(); }

3
src/test/run-pass/expr-alt-generic-box2.rs
View File

@ -11,8 +11,7 @@ fn test_generic<T: copy>(expected: T, eq: compare<T>) {
fn test_vec() {
fn compare_box(&&v1: @int, &&v2: @int) -> bool { ret v1 == v2; }
let eq = compare_box(_, _);
test_generic::<@int>(@1, eq);
test_generic::<@int>(@1, compare_box);
}
fn main() { test_vec(); }

3
src/test/run-pass/expr-alt-generic-unique1.rs
View File

@ -10,8 +10,7 @@ fn test_generic<T: copy>(expected: ~T, eq: compare<T>) {
fn test_box() {
fn compare_box(b1: ~bool, b2: ~bool) -> bool { ret *b1 == *b2; }
let eq = compare_box(_, _);
test_generic::<bool>(~true, eq);
test_generic::<bool>(~true, compare_box);
}
fn main() { test_box(); }

Some files were not shown because too many files have changed in this diff Show More