From 1f71a0f48d18d80ff3be6970d582c5a67f976329 Mon Sep 17 00:00:00 2001 From: Marijn Haverbeke Date: Thu, 5 Jan 2012 14:55:23 +0100 Subject: [PATCH 1/3] Clean up some FIXMEs related to impls --- src/comp/middle/trans.rs | 6 ++---- src/comp/middle/typeck.rs | 2 -- 2 files changed, 2 insertions(+), 6 deletions(-) diff --git a/src/comp/middle/trans.rs b/src/comp/middle/trans.rs index 4325f0af52b6..6baef415ccd3 100644 --- a/src/comp/middle/trans.rs +++ b/src/comp/middle/trans.rs @@ -5354,7 +5354,7 @@ fn collect_item(ccx: @crate_ctxt, abi: @mutable option::t, register_fn(ccx, i.span, new_pt, "obj_ctor", tps, ctor_id); } ast::item_impl(tps, _, _, methods) { - let name = ccx.names.next(i.ident); + let name = i.ident + int::str(i.id); for m in methods { register_fn(ccx, i.span, pt + [name, m.ident], "impl_method", tps + m.tps, m.id); @@ -5418,9 +5418,7 @@ fn trans_constant(ccx: @crate_ctxt, it: @ast::item, &&pt: [str], ast::item_impl(tps, some(@{node: ast::ty_path(_, id), _}), _, ms) { let i_did = ast_util::def_id_of_def(ccx.tcx.def_map.get(id)); let ty = ty::lookup_item_type(ccx.tcx, i_did).ty; - // FIXME[impl] use the same name as used in collect_items, for - // slightly more consistent symbol names? - let new_pt = pt + [ccx.names.next(it.ident)]; + let new_pt = pt + [it.ident + int::str(it.id), "wrap"]; let extra_tps = vec::map(tps, {|p| param_bounds(ccx, p)}); let tbl = C_struct(vec::map(*ty::iface_methods(ccx.tcx, i_did), {|im| alt vec::find(ms, {|m| m.ident == im.ident}) { diff --git a/src/comp/middle/typeck.rs b/src/comp/middle/typeck.rs index 02e1ed9d4f2e..d426aa290e08 100644 --- a/src/comp/middle/typeck.rs +++ b/src/comp/middle/typeck.rs @@ -2920,8 +2920,6 @@ mod dict { bind_params(fcx, self_ty, n_tps) } else { {vars: [], ty: self_ty} }; let im_bs = ty::lookup_item_type(tcx, im.did).bounds; - // FIXME[impl] don't do this in fcx (or make - // unify transactional by scrubbing bindings on fail) alt unify::unify(fcx, ty, self_ty) { ures_ok(_) { if option::is_some(found) { From 60ae1590af034755b5cb1e1e71f2240a710299a2 Mon Sep 17 00:00:00 2001 From: Marijn Haverbeke Date: Thu, 5 Jan 2012 15:35:37 +0100 Subject: [PATCH 2/3] Switch to new param kind bound syntax And remove support for the old syntax --- src/comp/driver/driver.rs | 2 +- src/comp/front/attr.rs | 2 +- src/comp/front/test.rs | 2 +- src/comp/metadata/encoder.rs | 2 +- src/comp/metadata/tydecode.rs | 2 +- src/comp/middle/ast_map.rs | 6 +- src/comp/middle/debuginfo.rs | 4 +- src/comp/middle/ty.rs | 2 +- src/comp/syntax/ast_util.rs | 4 +- src/comp/syntax/ext/simplext.rs | 2 +- src/comp/syntax/parse/parser.rs | 18 +++--- src/comp/syntax/util/interner.rs | 6 +- src/comp/util/common.rs | 2 +- src/comp/util/filesearch.rs | 2 +- src/fuzzer/fuzzer.rs | 2 +- src/libcore/comm.rs | 20 +++---- src/libcore/either.rs | 10 ++-- src/libcore/float.rs | 4 +- src/libcore/option.rs | 8 +-- src/libcore/result.rs | 8 +-- src/libcore/task.rs | 10 ++-- src/libcore/vec.rs | 58 +++++++++---------- src/libstd/c_vec.rs | 4 +- src/libstd/comm.rs | 20 +++---- src/libstd/deque.rs | 8 +-- src/libstd/fun_treemap.rs | 6 +- src/libstd/list.rs | 18 +++--- src/libstd/map.rs | 41 ++++++------- src/libstd/smallintmap.rs | 10 ++-- src/libstd/sort.rs | 14 ++--- src/libstd/test.rs | 14 ++--- src/libstd/treemap.rs | 4 +- src/libstd/util.rs | 2 +- .../bench/task-perf-word-count-generic.rs | 38 ++++++------ src/test/compile-fail/unique-unique-kind.rs | 2 +- src/test/compile-fail/use-after-send.rs | 2 +- src/test/run-fail/bug-811.rs | 4 +- src/test/run-fail/port-type.rs | 2 +- src/test/run-pass/auto-instantiate.rs | 2 +- src/test/run-pass/bind-generic.rs | 4 +- src/test/run-pass/box-unbox.rs | 4 +- src/test/run-pass/expr-alt-generic-box2.rs | 2 +- src/test/run-pass/expr-alt-generic-unique1.rs | 2 +- src/test/run-pass/expr-alt-generic-unique2.rs | 2 +- src/test/run-pass/expr-alt-generic.rs | 2 +- src/test/run-pass/expr-block-generic-box2.rs | 2 +- .../run-pass/expr-block-generic-unique1.rs | 2 +- .../run-pass/expr-block-generic-unique2.rs | 2 +- src/test/run-pass/expr-block-generic.rs | 2 +- src/test/run-pass/expr-fn.rs | 2 +- src/test/run-pass/expr-if-generic-box2.rs | 2 +- src/test/run-pass/expr-if-generic.rs | 2 +- src/test/run-pass/fixed-point-bind-unique.rs | 4 +- src/test/run-pass/fn-bare-spawn.rs | 2 +- src/test/run-pass/foreach-unique-drop.rs | 2 +- src/test/run-pass/generic-alias-box.rs | 2 +- src/test/run-pass/generic-alias-unique.rs | 2 +- src/test/run-pass/generic-bind-2.rs | 2 +- src/test/run-pass/generic-bind.rs | 2 +- src/test/run-pass/generic-box.rs | 2 +- src/test/run-pass/generic-derived-type.rs | 4 +- src/test/run-pass/generic-drop-glue.rs | 2 +- src/test/run-pass/generic-exterior-box.rs | 4 +- src/test/run-pass/generic-exterior-unique.rs | 4 +- src/test/run-pass/generic-fn-infer.rs | 2 +- src/test/run-pass/generic-fn-unique.rs | 2 +- src/test/run-pass/generic-fn.rs | 2 +- .../run-pass/generic-obj-with-derived-type.rs | 2 +- src/test/run-pass/generic-obj.rs | 2 +- src/test/run-pass/generic-tup.rs | 2 +- src/test/run-pass/generic-unique.rs | 2 +- src/test/run-pass/issue-333.rs | 4 +- src/test/run-pass/ivec-add.rs | 2 +- src/test/run-pass/newtype-polymorphic.rs | 4 +- src/test/run-pass/non-boolean-pure-fns.rs | 8 +-- src/test/run-pass/obj-return-polytypes.rs | 2 +- src/test/run-pass/ret-none.rs | 2 +- src/test/run-pass/send-type-inference.rs | 4 +- src/test/run-pass/sendfn-generic-fn.rs | 4 +- src/test/run-pass/type-param-constraints.rs | 4 +- src/test/run-pass/unchecked-predicates.rs | 8 +-- src/test/run-pass/unique-assign-generic.rs | 2 +- src/test/run-pass/unique-generic-assign.rs | 2 +- src/test/run-pass/unique-kinds.rs | 8 +-- src/test/run-pass/vec-push.rs | 2 +- src/test/stdtest/deque.rs | 2 +- src/test/stdtest/task.rs | 2 +- 87 files changed, 251 insertions(+), 252 deletions(-) diff --git a/src/comp/driver/driver.rs b/src/comp/driver/driver.rs index b8a6ba287293..74aafca0a150 100644 --- a/src/comp/driver/driver.rs +++ b/src/comp/driver/driver.rs @@ -114,7 +114,7 @@ fn time(do_it: bool, what: str, thunk: fn@() -> T) -> T { fn inject_libcore_reference(sess: session::session, crate: @ast::crate) -> @ast::crate { - fn spanned(x: T) -> @ast::spanned { + fn spanned(x: T) -> @ast::spanned { ret @{node: x, span: {lo: 0u, hi: 0u, expanded_from: codemap::os_none}}; diff --git a/src/comp/front/attr.rs b/src/comp/front/attr.rs index 09c7ec8f12b7..5ae398e238cd 100644 --- a/src/comp/front/attr.rs +++ b/src/comp/front/attr.rs @@ -221,7 +221,7 @@ fn native_abi(attrs: [ast::attribute]) -> either::t { }; } -fn span(item: T) -> ast::spanned { +fn span(item: T) -> ast::spanned { ret {node: item, span: ast_util::dummy_sp()}; } diff --git a/src/comp/front/test.rs b/src/comp/front/test.rs index f8aa8bdac53d..1a0cdb2c5cdc 100644 --- a/src/comp/front/test.rs +++ b/src/comp/front/test.rs @@ -182,7 +182,7 @@ fn mk_test_module(cx: test_ctxt) -> @ast::item { ret @item; } -fn nospan(t: T) -> ast::spanned { +fn nospan(t: T) -> ast::spanned { ret {node: t, span: dummy_sp()}; } diff --git a/src/comp/metadata/encoder.rs b/src/comp/metadata/encoder.rs index 8c564ec627ae..de1f9eacbcb8 100644 --- a/src/comp/metadata/encoder.rs +++ b/src/comp/metadata/encoder.rs @@ -492,7 +492,7 @@ fn encode_info_for_items(ecx: @encode_ctxt, ebml_w: ebml::writer, // Path and definition ID indexing -fn create_index(index: [entry], hash_fn: fn(T) -> uint) -> +fn create_index(index: [entry], hash_fn: fn(T) -> uint) -> [@[entry]] { let buckets: [@mutable [entry]] = []; uint::range(0u, 256u) {|_i| buckets += [@mutable []]; }; diff --git a/src/comp/metadata/tydecode.rs b/src/comp/metadata/tydecode.rs index 9e87a17537b1..d67d04607539 100644 --- a/src/comp/metadata/tydecode.rs +++ b/src/comp/metadata/tydecode.rs @@ -145,7 +145,7 @@ fn parse_ty_constr_arg(st: @pstate, sd: str_def) -> } } -fn parse_constr(st: @pstate, sd: str_def, pser: arg_parser) -> +fn parse_constr(st: @pstate, sd: str_def, pser: arg_parser) -> @ty::constr_general { let sp = ast_util::dummy_sp(); // FIXME: use a real span let args: [@sp_constr_arg] = []; diff --git a/src/comp/middle/ast_map.rs b/src/comp/middle/ast_map.rs index abf3d0cac1ed..b5e53ab305ab 100644 --- a/src/comp/middle/ast_map.rs +++ b/src/comp/middle/ast_map.rs @@ -98,7 +98,7 @@ fn map_expr(cx: ctx, ex: @expr) { } } -fn new_smallintmap_int_adapter() -> std::map::hashmap { +fn new_smallintmap_int_adapter() -> std::map::hashmap { let key_idx = fn (&&key: int) -> uint { key as uint }; let idx_key = fn (idx: uint) -> int { idx as int }; ret new_smallintmap_adapter(key_idx, idx_key); @@ -109,11 +109,11 @@ fn new_smallintmap_int_adapter() -> std::map::hashmap { // the entire codebase adapting all the callsites to the different // interface. // FIXME: hashmap and smallintmap should support the same interface. -fn new_smallintmap_adapter(key_idx: fn(K) -> uint, +fn new_smallintmap_adapter(key_idx: fn(K) -> uint, idx_key: fn(uint) -> K) -> std::map::hashmap { - obj adapter(map: smallintmap::smallintmap, + obj adapter(map: smallintmap::smallintmap, key_idx: fn(K) -> uint, idx_key: fn(uint) -> K) { diff --git a/src/comp/middle/debuginfo.rs b/src/comp/middle/debuginfo.rs index bdb76dfd9210..1c74cb7b1714 100644 --- a/src/comp/middle/debuginfo.rs +++ b/src/comp/middle/debuginfo.rs @@ -118,7 +118,7 @@ tag debug_metadata { retval_metadata(@metadata); } -fn cast_safely(val: T) -> U unsafe { +fn cast_safely(val: T) -> U unsafe { let val2 = val; let val3 = unsafe::reinterpret_cast(val2); unsafe::leak(val2); @@ -138,7 +138,7 @@ fn md_from_metadata(val: debug_metadata) -> T unsafe { } } -fn cached_metadata(cache: metadata_cache, mdtag: int, +fn cached_metadata(cache: metadata_cache, mdtag: int, eq: block(md: T) -> bool) -> option::t unsafe { if cache.contains_key(mdtag) { let items = cache.get(mdtag); diff --git a/src/comp/middle/ty.rs b/src/comp/middle/ty.rs index 76a3591cd183..50f015512f42 100644 --- a/src/comp/middle/ty.rs +++ b/src/comp/middle/ty.rs @@ -414,7 +414,7 @@ fn mk_rcache() -> creader_cache { ret map::mk_hashmap(hash_cache_entry, eq_cache_entries); } -fn new_ty_hash() -> map::hashmap { map::new_uint_hash() } +fn new_ty_hash() -> map::hashmap { map::new_uint_hash() } fn mk_ctxt(s: session::session, dm: resolve::def_map, amap: ast_map::map, freevars: freevars::freevar_map) -> ctxt { diff --git a/src/comp/syntax/ast_util.rs b/src/comp/syntax/ast_util.rs index 7a77861ae0b7..121abc1ce5c3 100644 --- a/src/comp/syntax/ast_util.rs +++ b/src/comp/syntax/ast_util.rs @@ -1,7 +1,7 @@ import codemap::span; import ast::*; -fn respan(sp: span, t: T) -> spanned { +fn respan(sp: span, t: T) -> spanned { ret {node: t, span: sp}; } @@ -201,7 +201,7 @@ fn eq_def_id(&&a: def_id, &&b: def_id) -> bool { a == b } -fn new_def_id_hash() -> std::map::hashmap { +fn new_def_id_hash() -> std::map::hashmap { std::map::mk_hashmap(hash_def_id, eq_def_id) } diff --git a/src/comp/syntax/ext/simplext.rs b/src/comp/syntax/ext/simplext.rs index 371370c5eda6..8f6f1a5828af 100644 --- a/src/comp/syntax/ext/simplext.rs +++ b/src/comp/syntax/ext/simplext.rs @@ -103,7 +103,7 @@ fn elts_to_ell(cx: ext_ctxt, elts: [@expr]) -> } } -fn option_flatten_map(f: fn@(T) -> option::t, v: [T]) -> +fn option_flatten_map(f: fn@(T) -> option::t, v: [T]) -> option::t<[U]> { let res = []; for elem: T in v { diff --git a/src/comp/syntax/parse/parser.rs b/src/comp/syntax/parse/parser.rs index 990132e01bff..d9edeefd44d5 100644 --- a/src/comp/syntax/parse/parser.rs +++ b/src/comp/syntax/parse/parser.rs @@ -210,7 +210,7 @@ fn expect_gt(p: parser) { } } -fn spanned(lo: uint, hi: uint, node: T) -> spanned { +fn spanned(lo: uint, hi: uint, node: T) -> spanned { ret {node: node, span: ast_util::mk_sp(lo, hi)}; } @@ -378,7 +378,7 @@ fn parse_constr_in_type(p: parser) -> @ast::ty_constr { } -fn parse_constrs(pser: block(parser) -> @ast::constr_general, +fn parse_constrs(pser: block(parser) -> @ast::constr_general, p: parser) -> [@ast::constr_general] { let constrs: [@ast::constr_general] = []; @@ -554,7 +554,7 @@ fn parse_fn_block_arg(p: parser) -> ast::arg { ret {mode: m, ty: t, ident: i, id: p.get_id()}; } -fn parse_seq_to_before_gt(sep: option::t, +fn parse_seq_to_before_gt(sep: option::t, f: block(parser) -> T, p: parser) -> [T] { let first = true; @@ -571,7 +571,7 @@ fn parse_seq_to_before_gt(sep: option::t, ret v; } -fn parse_seq_to_gt(sep: option::t, +fn parse_seq_to_gt(sep: option::t, f: block(parser) -> T, p: parser) -> [T] { let v = parse_seq_to_before_gt(sep, f, p); expect_gt(p); @@ -579,7 +579,7 @@ fn parse_seq_to_gt(sep: option::t, ret v; } -fn parse_seq_lt_gt(sep: option::t, +fn parse_seq_lt_gt(sep: option::t, f: block(parser) -> T, p: parser) -> spanned<[T]> { let lo = p.get_lo_pos(); @@ -590,7 +590,7 @@ fn parse_seq_lt_gt(sep: option::t, ret spanned(lo, hi, result); } -fn parse_seq_to_end(ket: token::token, sep: seq_sep, +fn parse_seq_to_end(ket: token::token, sep: seq_sep, f: block(parser) -> T, p: parser) -> [T] { let val = parse_seq_to_before_end(ket, sep, f, p); p.bump(); @@ -612,7 +612,7 @@ fn seq_sep_none() -> seq_sep { ret {sep: option::none, trailing_opt: false}; } -fn parse_seq_to_before_end(ket: token::token, +fn parse_seq_to_before_end(ket: token::token, sep: seq_sep, f: block(parser) -> T, p: parser) -> [T] { let first: bool = true; @@ -629,7 +629,7 @@ fn parse_seq_to_before_end(ket: token::token, } -fn parse_seq(bra: token::token, ket: token::token, +fn parse_seq(bra: token::token, ket: token::token, sep: seq_sep, f: block(parser) -> T, p: parser) -> spanned<[T]> { let lo = p.get_lo_pos(); @@ -1700,8 +1700,6 @@ fn parse_block_tail(p: parser, lo: uint, s: ast::blk_check_mode) -> ast::blk { fn parse_ty_param(p: parser) -> ast::ty_param { let bounds = []; - if eat_word(p, "send") { bounds += [ast::bound_send]; } - else if eat_word(p, "copy") { bounds += [ast::bound_copy]; } let ident = parse_ident(p); if eat(p, token::COLON) { while p.peek() != token::COMMA && p.peek() != token::GT { diff --git a/src/comp/syntax/util/interner.rs b/src/comp/syntax/util/interner.rs index 2c1589085f2f..ab411baaf5aa 100644 --- a/src/comp/syntax/util/interner.rs +++ b/src/comp/syntax/util/interner.rs @@ -12,12 +12,12 @@ type interner = hasher: hashfn, eqer: eqfn}; -fn mk(hasher: hashfn, eqer: eqfn) -> interner { +fn mk(hasher: hashfn, eqer: eqfn) -> interner { let m = map::mk_hashmap::(hasher, eqer); ret {map: m, mutable vect: [], hasher: hasher, eqer: eqer}; } -fn intern(itr: interner, val: T) -> uint { +fn intern(itr: interner, val: T) -> uint { alt itr.map.find(val) { some(idx) { ret idx; } none. { @@ -32,7 +32,7 @@ fn intern(itr: interner, val: T) -> uint { // |get| isn't "pure" in the traditional sense, because it can go from // failing to returning a value as items are interned. But for typestate, // where we first check a pred and then rely on it, ceasing to fail is ok. -pure fn get(itr: interner, idx: uint) -> T { +pure fn get(itr: interner, idx: uint) -> T { unchecked { itr.vect[idx] } diff --git a/src/comp/util/common.rs b/src/comp/util/common.rs index 03a6136656a0..611949ef51d7 100644 --- a/src/comp/util/common.rs +++ b/src/comp/util/common.rs @@ -21,7 +21,7 @@ fn hash_def(d: ast::def_id) -> uint { ret h; } -fn new_def_hash() -> std::map::hashmap { +fn new_def_hash() -> std::map::hashmap { let hasher: std::map::hashfn = hash_def; let eqer: std::map::eqfn = def_eq; ret std::map::mk_hashmap::(hasher, eqer); diff --git a/src/comp/util/filesearch.rs b/src/comp/util/filesearch.rs index b7942ce8f48b..ce8a1d7fde05 100644 --- a/src/comp/util/filesearch.rs +++ b/src/comp/util/filesearch.rs @@ -55,7 +55,7 @@ fn mk_filesearch(maybe_sysroot: option::t, } // FIXME #1001: This can't be an obj method -fn search(filesearch: filesearch, pick: pick) -> option::t { +fn search(filesearch: filesearch, pick: pick) -> option::t { for lib_search_path in filesearch.lib_search_paths() { #debug("searching %s", lib_search_path); for path in fs::list_dir(lib_search_path) { diff --git a/src/fuzzer/fuzzer.rs b/src/fuzzer/fuzzer.rs index 91cb090b83cd..8e821fc45a67 100644 --- a/src/fuzzer/fuzzer.rs +++ b/src/fuzzer/fuzzer.rs @@ -226,7 +226,7 @@ fn check_variants_of_ast(crate: ast::crate, codemap: codemap::codemap, check_variants_T(crate, codemap, filename, "ty", stolen.tys, pprust::ty_to_str, replace_ty_in_crate, cx); } -fn check_variants_T( +fn check_variants_T( crate: ast::crate, codemap: codemap::codemap, filename: str, diff --git a/src/libcore/comm.rs b/src/libcore/comm.rs index e00205a522b4..d8051dfabd17 100644 --- a/src/libcore/comm.rs +++ b/src/libcore/comm.rs @@ -39,7 +39,7 @@ native mod rustrt { type void; type rust_port; - fn chan_id_send(t: *sys::type_desc, + fn chan_id_send(t: *sys::type_desc, target_task: task::task, target_port: port_id, data: T) -> ctypes::uintptr_t; @@ -55,7 +55,7 @@ native mod rustrt { #[abi = "rust-intrinsic"] native mod rusti { - fn call_with_retptr(&&f: fn@(*uint)) -> T; + fn call_with_retptr(&&f: fn@(*uint)) -> T; } type port_id = int; @@ -78,11 +78,11 @@ dropped. Channels may be duplicated and themselves transmitted over other channels. */ -tag chan { +tag chan { chan_t(task::task, port_id); } -resource port_ptr(po: *rustrt::rust_port) { +resource port_ptr(po: *rustrt::rust_port) { // Once the port is detached it's guaranteed not to receive further // messages rustrt::rust_port_detach(po); @@ -106,7 +106,7 @@ transmitted. If a port value is copied, both copies refer to the same port. Ports may be associated with multiple s. */ -tag port { port_t(@port_ptr); } +tag port { port_t(@port_ptr); } /* Function: send @@ -116,7 +116,7 @@ Sends data over a channel. The sent data is moved into the channel, whereupon the caller loses access to it. */ -fn send(ch: chan, -data: T) { +fn send(ch: chan, -data: T) { let chan_t(t, p) = ch; let res = rustrt::chan_id_send(sys::get_type_desc::(), t, p, data); if res != 0u unsafe { @@ -131,7 +131,7 @@ Function: port Constructs a port. */ -fn port() -> port { +fn port() -> port { port_t(@port_ptr(rustrt::new_port(sys::size_of::()))) } @@ -143,10 +143,10 @@ Receive from a port. If no data is available on the port then the task will block until data becomes available. */ -fn recv(p: port) -> T { recv_(***p) } +fn recv(p: port) -> T { recv_(***p) } // Receive on a raw port pointer -fn recv_(p: *rustrt::rust_port) -> T { +fn recv_(p: *rustrt::rust_port) -> T { // FIXME: Due to issue 1185 we can't use a return pointer when // calling C code, and since we can't create our own return // pointer on the stack, we're going to call a little intrinsic @@ -179,6 +179,6 @@ Constructs a channel. The channel is bound to the port used to construct it. */ -fn chan(p: port) -> chan { +fn chan(p: port) -> chan { chan_t(task::get_task(), rustrt::get_port_id(***p)) } diff --git a/src/libcore/either.rs b/src/libcore/either.rs index f3571ea5bcf7..e6956930686e 100644 --- a/src/libcore/either.rs +++ b/src/libcore/either.rs @@ -39,7 +39,7 @@ Function: lefts Extracts from a vector of either all the left values. */ -fn lefts(eithers: [t]) -> [T] { +fn lefts(eithers: [t]) -> [T] { let result: [T] = []; for elt: t in eithers { alt elt { left(l) { result += [l]; } _ {/* fallthrough */ } } @@ -52,7 +52,7 @@ Function: rights Extracts from a vector of either all the right values */ -fn rights(eithers: [t]) -> [U] { +fn rights(eithers: [t]) -> [U] { let result: [U] = []; for elt: t in eithers { alt elt { right(r) { result += [r]; } _ {/* fallthrough */ } } @@ -68,7 +68,7 @@ Extracts from a vector of either all the left values and right values Returns a structure containing a vector of left values and a vector of right values. */ -fn partition(eithers: [t]) +fn partition(eithers: [t]) -> {lefts: [T], rights: [U]} { let lefts: [T] = []; let rights: [U] = []; @@ -83,7 +83,7 @@ Function: flip Flips between left and right of a given either */ -pure fn flip(eith: t) -> t { +pure fn flip(eith: t) -> t { alt eith { right(r) { left(r) } left(l) { right(l) } @@ -96,7 +96,7 @@ Function: to_result Converts either::t to a result::t, making the "right" choice an ok result, and the "left" choice a fail */ -pure fn to_result(eith: t) -> result::t { +pure fn to_result(eith: t) -> result::t { alt eith { right(r) { result::ok(r) } left(l) { result::err(l) } diff --git a/src/libcore/float.rs b/src/libcore/float.rs index fdc5dda996d1..dcc44b366058 100644 --- a/src/libcore/float.rs +++ b/src/libcore/float.rs @@ -467,14 +467,14 @@ Function: min Returns the minimum of two values */ -pure fn min(x: T, y: T) -> T { x < y ? x : y } +pure fn min(x: T, y: T) -> T { x < y ? x : y } /* Function: max Returns the maximum of two values */ -pure fn max(x: T, y: T) -> T { x < y ? y : x } +pure fn max(x: T, y: T) -> T { x < y ? y : x } /* Function: acos diff --git a/src/libcore/option.rs b/src/libcore/option.rs index e0a137ca9e84..453f38567a82 100644 --- a/src/libcore/option.rs +++ b/src/libcore/option.rs @@ -30,13 +30,13 @@ Failure: Fails if the value equals `none`. */ -pure fn get(opt: t) -> T { +pure fn get(opt: t) -> T { alt opt { some(x) { ret x; } none. { fail "option none"; } } } /* */ -fn map(opt: t, f: block(T) -> U) -> t { +fn map(opt: t, f: block(T) -> U) -> t { alt opt { some(x) { some(f(x)) } none. { none } } } @@ -61,7 +61,7 @@ Function: from_maybe Returns the contained value or a default */ -pure fn from_maybe(def: T, opt: t) -> T { +pure fn from_maybe(def: T, opt: t) -> T { alt opt { some(x) { x } none. { def } } } @@ -70,7 +70,7 @@ Function: maybe Applies a function to the contained value or returns a default */ -fn maybe(def: U, opt: t, f: block(T) -> U) -> U { +fn maybe(def: U, opt: t, f: block(T) -> U) -> U { alt opt { none. { def } some(t) { f(t) } } } diff --git a/src/libcore/result.rs b/src/libcore/result.rs index 91038474eadd..52af0421e584 100644 --- a/src/libcore/result.rs +++ b/src/libcore/result.rs @@ -37,7 +37,7 @@ Failure: If the result is an error */ -fn get(res: t) -> T { +fn get(res: t) -> T { alt res { ok(t) { t } err(_) { @@ -57,7 +57,7 @@ Failure: If the result is not an error */ -fn get_err(res: t) -> U { +fn get_err(res: t) -> U { alt res { err(u) { u } ok(_) { @@ -87,7 +87,7 @@ pure fn failure(res: t) -> bool { !success(res) } -pure fn to_either(res: t) -> either::t { +pure fn to_either(res: t) -> either::t { alt res { ok(res) { either::right(res) } err(fail_) { either::left(fail_) } @@ -110,7 +110,7 @@ Example: > }) */ -fn chain(res: t, op: block(T) -> t) +fn chain(res: t, op: block(T) -> t) -> t { alt res { ok(t) { op(t) } diff --git a/src/libcore/task.rs b/src/libcore/task.rs index 503a336f7cd4..5de9c8347fe0 100644 --- a/src/libcore/task.rs +++ b/src/libcore/task.rs @@ -236,7 +236,7 @@ Returns: A handle to the new task */ -fn spawn(-data: T, f: fn(T)) -> task { +fn spawn(-data: T, f: fn(T)) -> task { spawn_inner(data, f, none) } @@ -249,7 +249,7 @@ termination Immediately before termination, either on success or failure, the spawned task will send a message on the provided channel. */ -fn spawn_notify(-data: T, f: fn(T), +fn spawn_notify(-data: T, f: fn(T), notify: comm::chan) -> task { spawn_inner(data, f, some(notify)) } @@ -263,7 +263,7 @@ This is a convenience wrapper around spawn_notify which, when paired with can be easily used to spawn a task then wait for it to complete. */ -fn spawn_joinable(-data: T, f: fn(T)) -> joinable_task { +fn spawn_joinable(-data: T, f: fn(T)) -> joinable_task { let p = comm::port::(); let id = spawn_notify(data, f, comm::chan::(p)); ret (id, p); @@ -279,11 +279,11 @@ fn spawn_joinable(-data: T, f: fn(T)) -> joinable_task { // // After the transition this should all be rewritten. -fn spawn_inner(-data: T, f: fn(T), +fn spawn_inner(-data: T, f: fn(T), notify: option>) -> task unsafe { - fn wrapper(data: *u8, f: fn(T)) unsafe { + fn wrapper(data: *u8, f: fn(T)) unsafe { let data: ~T = unsafe::reinterpret_cast(data); f(*data); } diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs index 0c1db7119af8..32bb2f46a491 100644 --- a/src/libcore/vec.rs +++ b/src/libcore/vec.rs @@ -121,7 +121,7 @@ Creates and initializes an immutable vector. Creates an immutable vector of size `n_elts` and initializes the elements to the value `t`. */ -fn init_elt(t: T, n_elts: uint) -> [T] { +fn init_elt(t: T, n_elts: uint) -> [T] { let v = []; reserve(v, n_elts); let i: uint = 0u; @@ -138,7 +138,7 @@ Creates and initializes a mutable vector. Creates a mutable vector of size `n_elts` and initializes the elements to the value `t`. */ -fn init_elt_mut(t: T, n_elts: uint) -> [mutable T] { +fn init_elt_mut(t: T, n_elts: uint) -> [mutable T] { let v = [mutable]; reserve(v, n_elts); let i: uint = 0u; @@ -153,7 +153,7 @@ Function: to_mut Produces a mutable vector from an immutable vector. */ -fn to_mut(v: [T]) -> [mutable T] { +fn to_mut(v: [T]) -> [mutable T] { let vres = [mutable]; for t: T in v { vres += [mutable t]; } ret vres; @@ -165,7 +165,7 @@ Function: from_mut Produces an immutable vector from a mutable vector. */ -fn from_mut(v: [mutable T]) -> [T] { +fn from_mut(v: [mutable T]) -> [T] { let vres = []; for t: T in v { vres += [t]; } ret vres; @@ -181,7 +181,7 @@ Returns the first element of a vector Predicates: (v) */ -pure fn head(v: [const T]) : is_not_empty(v) -> T { ret v[0]; } +pure fn head(v: [const T]) : is_not_empty(v) -> T { ret v[0]; } /* Function: tail @@ -191,7 +191,7 @@ Returns all but the first element of a vector Predicates: (v) */ -fn tail(v: [const T]) : is_not_empty(v) -> [T] { +fn tail(v: [const T]) : is_not_empty(v) -> [T] { ret slice(v, 1u, len(v)); } @@ -206,7 +206,7 @@ Returns all but the last elemnt of a vector Preconditions: `v` is not empty */ -fn init(v: [const T]) -> [T] { +fn init(v: [const T]) -> [T] { assert len(v) != 0u; slice(v, 0u, len(v) - 1u) } @@ -221,7 +221,7 @@ Returns: An option containing the last element of `v` if `v` is not empty, or none if `v` is empty. */ -pure fn last(v: [const T]) -> option::t { +pure fn last(v: [const T]) -> option::t { if len(v) == 0u { ret none; } ret some(v[len(v) - 1u]); } @@ -234,7 +234,7 @@ Returns the last element of a non-empty vector `v` Predicates: (v) */ -pure fn last_total(v: [const T]) : is_not_empty(v) -> T { +pure fn last_total(v: [const T]) : is_not_empty(v) -> T { ret v[len(v) - 1u]; } @@ -243,7 +243,7 @@ Function: slice Returns a copy of the elements from [`start`..`end`) from `v`. */ -fn slice(v: [const T], start: uint, end: uint) -> [T] { +fn slice(v: [const T], start: uint, end: uint) -> [T] { assert (start <= end); assert (end <= len(v)); let result = []; @@ -259,7 +259,7 @@ Function: slice_mut Returns a copy of the elements from [`start`..`end`) from `v`. */ -fn slice_mut(v: [const T], start: uint, end: uint) -> [mutable T] { +fn slice_mut(v: [const T], start: uint, end: uint) -> [mutable T] { assert (start <= end); assert (end <= len(v)); let result = [mutable]; @@ -277,7 +277,7 @@ Function: shift Removes the first element from a vector and return it */ -fn shift(&v: [const T]) -> T { +fn shift(&v: [const T]) -> T { let ln = len::(v); assert (ln > 0u); let e = v[0]; @@ -291,7 +291,7 @@ Function: pop Remove the last element from a vector and return it */ -fn pop(&v: [const T]) -> T { +fn pop(&v: [const T]) -> T { let ln = len(v); assert (ln > 0u); ln -= 1u; @@ -305,7 +305,7 @@ Function: push Append an element to a vector and return it */ -fn push(&v: [T], initval: T) { +fn push(&v: [T], initval: T) { grow(v, 1u, initval) } @@ -325,7 +325,7 @@ v - The vector to grow n - The number of elements to add initval - The value for the new elements */ -fn grow(&v: [T], n: uint, initval: T) { +fn grow(&v: [T], n: uint, initval: T) { reserve(v, next_power_of_two(len(v) + n)); let i: uint = 0u; while i < n { v += [initval]; i += 1u; } @@ -344,7 +344,7 @@ v - The vector to grow n - The number of elements to add initval - The value for the new elements */ -fn grow_mut(&v: [mutable T], n: uint, initval: T) { +fn grow_mut(&v: [mutable T], n: uint, initval: T) { reserve(v, next_power_of_two(len(v) + n)); let i: uint = 0u; while i < n { v += [mutable initval]; i += 1u; } @@ -380,7 +380,7 @@ Sets the element at position `index` to `val`. If `index` is past the end of the vector, expands the vector by replicating `initval` to fill the intervening space. */ -fn grow_set(&v: [mutable T], index: uint, initval: T, val: T) { +fn grow_set(&v: [mutable T], index: uint, initval: T, val: T) { if index >= len(v) { grow_mut(v, index - len(v) + 1u, initval); } v[index] = val; } @@ -405,7 +405,7 @@ Function: map_mut Apply a function to each element of a mutable vector and return the results */ -fn map_mut(v: [const T], f: block(T) -> U) -> [U] { +fn map_mut(v: [const T], f: block(T) -> U) -> [U] { let result = []; reserve(result, len(v)); for elem: T in v { @@ -420,7 +420,7 @@ Function: map2 Apply a function to each pair of elements and return the results */ -fn map2(v0: [T], v1: [U], f: block(T, U) -> V) -> [V] { +fn map2(v0: [T], v1: [U], f: block(T, U) -> V) -> [V] { let v0_len = len(v0); if v0_len != len(v1) { fail; } let u: [V] = []; @@ -437,7 +437,7 @@ Apply a function to each element of a vector and return the results If function `f` returns `none` then that element is excluded from the resulting vector. */ -fn filter_map(v: [const T], f: block(T) -> option::t) +fn filter_map(v: [const T], f: block(T) -> option::t) -> [U] { let result = []; for elem: T in v { @@ -458,7 +458,7 @@ holds. Apply function `f` to each element of `v` and return a vector containing only those elements for which `f` returned true. */ -fn filter(v: [T], f: block(T) -> bool) -> [T] { +fn filter(v: [T], f: block(T) -> bool) -> [T] { let result = []; for elem: T in v { if f(elem) { result += [elem]; } @@ -472,7 +472,7 @@ Function: concat Concatenate a vector of vectors. Flattens a vector of vectors of T into a single vector of T. */ -fn concat(v: [const [const T]]) -> [T] { +fn concat(v: [const [const T]]) -> [T] { let new: [T] = []; for inner: [T] in v { new += inner; } ret new; @@ -483,7 +483,7 @@ Function: foldl Reduce a vector from left to right */ -fn foldl(z: T, v: [const U], p: block(T, U) -> T) -> T { +fn foldl(z: T, v: [const U], p: block(T, U) -> T) -> T { let accum = z; iter(v) { |elt| accum = p(accum, elt); @@ -496,7 +496,7 @@ Function: foldr Reduce a vector from right to left */ -fn foldr(v: [const T], z: U, p: block(T, U) -> U) -> U { +fn foldr(v: [const T], z: U, p: block(T, U) -> U) -> U { let accum = z; riter(v) { |elt| accum = p(elt, accum); @@ -591,7 +591,7 @@ Apply function `f` to each element of `v`, starting from the first. When function `f` returns true then an option containing the element is returned. If `f` matches no elements then none is returned. */ -fn find(v: [T], f: block(T) -> bool) -> option::t { +fn find(v: [T], f: block(T) -> bool) -> option::t { for elt: T in v { if f(elt) { ret some(elt); } } ret none; } @@ -637,7 +637,7 @@ vector contains the first element of the i-th tuple of the input vector, and the i-th element of the second vector contains the second element of the i-th tuple of the input vector. */ -fn unzip(v: [(T, U)]) -> ([T], [U]) { +fn unzip(v: [(T, U)]) -> ([T], [U]) { let as = [], bs = []; for (a, b) in v { as += [a]; bs += [b]; } ret (as, bs); @@ -655,7 +655,7 @@ Preconditions: (v, u) */ -fn zip(v: [T], u: [U]) : same_length(v, u) -> [(T, U)] { +fn zip(v: [T], u: [U]) : same_length(v, u) -> [(T, U)] { let zipped = []; let sz = len(v), i = 0u; assert (sz == len(u)); @@ -694,7 +694,7 @@ Function: reversed Returns a vector with the order of elements reversed */ -fn reversed(v: [const T]) -> [T] { +fn reversed(v: [const T]) -> [T] { let rs: [T] = []; let i = len::(v); if i == 0u { ret rs; } else { i -= 1u; } @@ -805,7 +805,7 @@ is sorted then the permutations are lexicographically sorted). The total number of permutations produced is `len(v)!`. If `v` contains repeated elements, then some permutations are repeated. */ -fn permute(v: [const T], put: block([T])) { +fn permute(v: [const T], put: block([T])) { let ln = len(v); if ln == 0u { put([]); diff --git a/src/libstd/c_vec.rs b/src/libstd/c_vec.rs index 7c2f1be70840..4374a7ffb993 100644 --- a/src/libstd/c_vec.rs +++ b/src/libstd/c_vec.rs @@ -108,7 +108,7 @@ Failure: If `ofs` is greater or equal to the length of the vector */ -fn get(t: t, ofs: uint) -> T { +fn get(t: t, ofs: uint) -> T { assert ofs < (*t).size; ret unsafe { *ptr::mut_offset((*t).base, ofs) }; } @@ -122,7 +122,7 @@ Failure: If `ofs` is greater or equal to the length of the vector */ -fn set(t: t, ofs: uint, v: T) { +fn set(t: t, ofs: uint, v: T) { assert ofs < (*t).size; unsafe { *ptr::mut_offset((*t).base, ofs) = v }; } diff --git a/src/libstd/comm.rs b/src/libstd/comm.rs index aee8beba1116..86aeed3826c4 100644 --- a/src/libstd/comm.rs +++ b/src/libstd/comm.rs @@ -41,7 +41,7 @@ native mod rustrt { type void; type rust_port; - fn chan_id_send(t: *sys::type_desc, + fn chan_id_send(t: *sys::type_desc, target_task: task::task, target_port: port_id, data: T) -> ctypes::uintptr_t; @@ -57,7 +57,7 @@ native mod rustrt { #[abi = "rust-intrinsic"] native mod rusti { - fn call_with_retptr(&&f: fn@(*uint)) -> T; + fn call_with_retptr(&&f: fn@(*uint)) -> T; } type port_id = int; @@ -80,11 +80,11 @@ dropped. Channels may be duplicated and themselves transmitted over other channels. */ -tag chan { +tag chan { chan_t(task::task, port_id); } -resource port_ptr(po: *rustrt::rust_port) { +resource port_ptr(po: *rustrt::rust_port) { // Once the port is detached it's guaranteed not to receive further // messages rustrt::rust_port_detach(po); @@ -108,7 +108,7 @@ transmitted. If a port value is copied, both copies refer to the same port. Ports may be associated with multiple s. */ -tag port { port_t(@port_ptr); } +tag port { port_t(@port_ptr); } /* Function: send @@ -118,7 +118,7 @@ Sends data over a channel. The sent data is moved into the channel, whereupon the caller loses access to it. */ -fn send(ch: chan, -data: T) { +fn send(ch: chan, -data: T) { let chan_t(t, p) = ch; let res = rustrt::chan_id_send(sys::get_type_desc::(), t, p, data); if res != 0u unsafe { @@ -133,7 +133,7 @@ Function: port Constructs a port. */ -fn port() -> port { +fn port() -> port { port_t(@port_ptr(rustrt::new_port(sys::size_of::()))) } @@ -145,10 +145,10 @@ Receive from a port. If no data is available on the port then the task will block until data becomes available. */ -fn recv(p: port) -> T { recv_(***p) } +fn recv(p: port) -> T { recv_(***p) } // Receive on a raw port pointer -fn recv_(p: *rustrt::rust_port) -> T { +fn recv_(p: *rustrt::rust_port) -> T { // FIXME: Due to issue 1185 we can't use a return pointer when // calling C code, and since we can't create our own return // pointer on the stack, we're going to call a little intrinsic @@ -181,6 +181,6 @@ Constructs a channel. The channel is bound to the port used to construct it. */ -fn chan(p: port) -> chan { +fn chan(p: port) -> chan { chan_t(task::get_task(), rustrt::get_port_id(***p)) } diff --git a/src/libstd/deque.rs b/src/libstd/deque.rs index 8da26c55b105..05c3c6c2b0ae 100644 --- a/src/libstd/deque.rs +++ b/src/libstd/deque.rs @@ -33,7 +33,7 @@ Section: Functions /* Function: create */ -fn create() -> t { +fn create() -> t { type cell = option::t; let initial_capacity: uint = 32u; // 2^5 @@ -41,7 +41,7 @@ fn create() -> t { * Grow is only called on full elts, so nelts is also len(elts), unlike * elsewhere. */ - fn grow(nelts: uint, lo: uint, elts: [mutable cell]) -> + fn grow(nelts: uint, lo: uint, elts: [mutable cell]) -> [mutable cell] { assert (nelts == vec::len(elts)); let rv = [mutable]; @@ -57,10 +57,10 @@ fn create() -> t { ret rv; } - fn get(elts: [mutable cell], i: uint) -> T { + fn get(elts: [mutable cell], i: uint) -> T { ret alt elts[i] { option::some(t) { t } _ { fail } }; } - obj deque(mutable nelts: uint, + obj deque(mutable nelts: uint, mutable lo: uint, mutable hi: uint, mutable elts: [mutable cell]) { diff --git a/src/libstd/fun_treemap.rs b/src/libstd/fun_treemap.rs index 1f4e6b9491ad..046f565577a0 100644 --- a/src/libstd/fun_treemap.rs +++ b/src/libstd/fun_treemap.rs @@ -50,7 +50,7 @@ Function: insert Insert a value into the map */ -fn insert(m: treemap, k: K, v: V) -> treemap { +fn insert(m: treemap, k: K, v: V) -> treemap { @alt m { @empty. { node(@k, @v, @empty, @empty) } @node(@kk, vv, left, right) { @@ -68,7 +68,7 @@ Function: find Find a value based on the key */ -fn find(m: treemap, k: K) -> option { +fn find(m: treemap, k: K) -> option { alt *m { empty. { none } node(@kk, @v, left, right) { @@ -84,7 +84,7 @@ Function: traverse Visit all pairs in the map in order. */ -fn traverse(m: treemap, f: block(K, V)) { +fn traverse(m: treemap, f: block(K, V)) { alt *m { empty. { } node(@k, @v, _, _) { diff --git a/src/libstd/list.rs b/src/libstd/list.rs index aabc34993851..efd633467efd 100644 --- a/src/libstd/list.rs +++ b/src/libstd/list.rs @@ -27,7 +27,7 @@ Function: from_vec Create a list from a vector */ -fn from_vec(v: [const T]) -> list { +fn from_vec(v: [const T]) -> list { *vec::foldr(v, @nil::, { |h, t| @cons(h, t) }) } @@ -46,7 +46,7 @@ ls - The list to fold z - The initial value f - The function to apply */ -fn foldl(ls: list, z: T, f: block(T, U) -> T) -> T { +fn foldl(ls: list, z: T, f: block(T, U) -> T) -> T { let accum: T = z; iter(ls) {|elt| accum = f(accum, elt);} accum @@ -61,7 +61,7 @@ Apply function `f` to each element of `v`, starting from the first. When function `f` returns true then an option containing the element is returned. If `f` matches no elements then none is returned. */ -fn find(ls: list, f: block(T) -> option::t) +fn find(ls: list, f: block(T) -> option::t) -> option::t { let ls = ls; while true { @@ -80,7 +80,7 @@ Function: has Returns true if a list contains an element with the given value */ -fn has(ls: list, elt: T) -> bool { +fn has(ls: list, elt: T) -> bool { let ls = ls; while true { alt ls { @@ -96,7 +96,7 @@ Function: is_empty Returns true if the list is empty. */ -pure fn is_empty(ls: list) -> bool { +pure fn is_empty(ls: list) -> bool { alt ls { nil. { true } _ { false } @@ -108,7 +108,7 @@ Function: is_not_empty Returns true if the list is not empty. */ -pure fn is_not_empty(ls: list) -> bool { +pure fn is_not_empty(ls: list) -> bool { ret !is_empty(ls); } @@ -128,7 +128,7 @@ Function: tail Returns all but the first element of a list */ -pure fn tail(ls: list) : is_not_empty(ls) -> list { +pure fn tail(ls: list) : is_not_empty(ls) -> list { alt ls { cons(_, tl) { ret *tl; } nil. { fail "list empty" } @@ -140,7 +140,7 @@ Function: head Returns the first element of a list */ -pure fn head(ls: list) : is_not_empty(ls) -> T { +pure fn head(ls: list) : is_not_empty(ls) -> T { alt ls { cons(hd, _) { ret hd; } nil. { fail "list empty" } @@ -152,7 +152,7 @@ Function: append Appends one list to another */ -pure fn append(l: list, m: list) -> list { +pure fn append(l: list, m: list) -> list { alt l { nil. { ret m; } cons(x, xs) { let rest = append(*xs, m); ret cons(x, @rest); } diff --git a/src/libstd/map.rs b/src/libstd/map.rs index 3b6a45b90601..db47160216c4 100644 --- a/src/libstd/map.rs +++ b/src/libstd/map.rs @@ -108,32 +108,32 @@ type hashmap = obj { /* Section: Operations */ mod chained { - type entry = { + type entry = { hash: uint, key: K, mutable value: V, mutable next: chain }; - tag chain { + tag chain { present(@entry); absent; } - type t = { + type t = { mutable size: uint, mutable chains: [mutable chain], hasher: hashfn, eqer: eqfn }; - tag search_result { + tag search_result { not_found; found_first(uint, @entry); found_after(@entry, @entry); } - fn search_rem(tbl: t, + fn search_rem(tbl: t, k: K, h: uint, idx: uint, @@ -163,7 +163,7 @@ mod chained { util::unreachable(); } - fn search_tbl( + fn search_tbl( tbl: t, k: K, h: uint) -> search_result { let idx = h % vec::len(tbl.chains); alt tbl.chains[idx] { @@ -185,7 +185,7 @@ mod chained { } } - fn insert(tbl: t, k: K, v: V) -> bool { + fn insert(tbl: t, k: K, v: V) -> bool { let hash = tbl.hasher(k); alt search_tbl(tbl, k, hash) { not_found. { @@ -210,7 +210,7 @@ mod chained { } } - fn get(tbl: t, k: K) -> core::option::t { + fn get(tbl: t, k: K) -> core::option::t { alt search_tbl(tbl, k, tbl.hasher(k)) { not_found. { ret core::option::none; @@ -226,7 +226,7 @@ mod chained { } } - fn remove(tbl: t, k: K) -> core::option::t { + fn remove(tbl: t, k: K) -> core::option::t { alt search_tbl(tbl, k, tbl.hasher(k)) { not_found. { ret core::option::none; @@ -246,11 +246,11 @@ mod chained { } } - fn chains(nchains: uint) -> [mutable chain] { + fn chains(nchains: uint) -> [mutable chain] { ret vec::init_elt_mut(absent, nchains); } - fn foreach_entry(chain0: chain, + fn foreach_entry(chain0: chain, blk: block(@entry)) { let chain = chain0; while true { @@ -265,7 +265,7 @@ mod chained { } } - fn foreach_chain(chains: [const chain], + fn foreach_chain(chains: [const chain], blk: block(@entry)) { let i = 0u, n = vec::len(chains); while i < n { @@ -274,7 +274,7 @@ mod chained { } } - fn rehash(tbl: t) { + fn rehash(tbl: t) { let old_chains = tbl.chains; let n_old_chains = vec::len(old_chains); let n_new_chains: uint = uint::next_power_of_two(n_old_chains + 1u); @@ -286,7 +286,7 @@ mod chained { } } - fn items(tbl: t, blk: block(K,V)) { + fn items(tbl: t, blk: block(K,V)) { let tbl_chains = tbl.chains; // Satisfy alias checker. foreach_chain(tbl_chains) { |entry| let key = entry.key; @@ -295,7 +295,7 @@ mod chained { } } - obj o(tbl: @t, + obj o(tbl: @t, lf: util::rational) { fn size() -> uint { ret tbl.size; @@ -343,7 +343,8 @@ mod chained { } } - fn mk(hasher: hashfn, eqer: eqfn) -> hashmap { + fn mk(hasher: hashfn, eqer: eqfn) + -> hashmap { let initial_capacity: uint = 32u; // 2^5 let t = @{mutable size: 0u, mutable chains: chains(initial_capacity), @@ -363,7 +364,7 @@ Parameters: hasher - The hash function for key type K eqer - The equality function for key type K */ -fn mk_hashmap(hasher: hashfn, eqer: eqfn) +fn mk_hashmap(hasher: hashfn, eqer: eqfn) -> hashmap { ret chained::mk(hasher, eqer); } @@ -373,7 +374,7 @@ Function: new_str_hash Construct a hashmap for string keys */ -fn new_str_hash() -> hashmap { +fn new_str_hash() -> hashmap { ret mk_hashmap(str::hash, str::eq); } @@ -382,7 +383,7 @@ Function: new_int_hash Construct a hashmap for int keys */ -fn new_int_hash() -> hashmap { +fn new_int_hash() -> hashmap { fn hash_int(&&x: int) -> uint { ret x as uint; } fn eq_int(&&a: int, &&b: int) -> bool { ret a == b; } ret mk_hashmap(hash_int, eq_int); @@ -393,7 +394,7 @@ Function: new_uint_hash Construct a hashmap for uint keys */ -fn new_uint_hash() -> hashmap { +fn new_uint_hash() -> hashmap { fn hash_uint(&&x: uint) -> uint { ret x; } fn eq_uint(&&a: uint, &&b: uint) -> bool { ret a == b; } ret mk_hashmap(hash_uint, eq_uint); diff --git a/src/libstd/smallintmap.rs b/src/libstd/smallintmap.rs index 5ba1366ccb57..d40adc84739f 100644 --- a/src/libstd/smallintmap.rs +++ b/src/libstd/smallintmap.rs @@ -30,7 +30,7 @@ Function: insert Add a value to the map. If the map already contains a value for the specified key then the original value is replaced. */ -fn insert(m: smallintmap, key: uint, val: T) { +fn insert(m: smallintmap, key: uint, val: T) { vec::grow_set::>(m.v, key, none::, some::(val)); } @@ -40,7 +40,7 @@ Function: find Get the value for the specified key. If the key does not exist in the map then returns none. */ -fn find(m: smallintmap, key: uint) -> option::t { +fn find(m: smallintmap, key: uint) -> option::t { if key < vec::len::>(m.v) { ret m.v[key]; } ret none::; } @@ -54,7 +54,7 @@ Failure: If the key does not exist in the map */ -fn get(m: smallintmap, key: uint) -> T { +fn get(m: smallintmap, key: uint) -> T { alt find(m, key) { none. { #error("smallintmap::get(): key not present"); fail; } some(v) { ret v; } @@ -66,13 +66,13 @@ Method: contains_key Returns true if the map contains a value for the specified key */ -fn contains_key(m: smallintmap, key: uint) -> bool { +fn contains_key(m: smallintmap, key: uint) -> bool { ret !option::is_none(find::(m, key)); } // FIXME: Are these really useful? -fn truncate(m: smallintmap, len: uint) { +fn truncate(m: smallintmap, len: uint) { m.v = vec::slice_mut::>(m.v, 0u, len); } diff --git a/src/libstd/sort.rs b/src/libstd/sort.rs index 38ab4f3cfb18..190497b48dd6 100644 --- a/src/libstd/sort.rs +++ b/src/libstd/sort.rs @@ -20,8 +20,8 @@ Merge sort. Returns a new vector containing the sorted list. Has worst case O(n log n) performance, best case O(n), but is not space efficient. This is a stable sort. */ -fn merge_sort(le: lteq, v: [const T]) -> [T] { - fn merge(le: lteq, a: [T], b: [T]) -> [T] { +fn merge_sort(le: lteq, v: [const T]) -> [T] { + fn merge(le: lteq, a: [T], b: [T]) -> [T] { let rs: [T] = []; let a_len: uint = len::(a); let a_ix: uint = 0u; @@ -46,7 +46,7 @@ fn merge_sort(le: lteq, v: [const T]) -> [T] { ret merge::(le, merge_sort::(le, a), merge_sort::(le, b)); } -fn part(compare_func: lteq, arr: [mutable T], left: uint, +fn part(compare_func: lteq, arr: [mutable T], left: uint, right: uint, pivot: uint) -> uint { let pivot_value = arr[pivot]; arr[pivot] <-> arr[right]; @@ -63,7 +63,7 @@ fn part(compare_func: lteq, arr: [mutable T], left: uint, ret storage_index; } -fn qsort(compare_func: lteq, arr: [mutable T], left: uint, +fn qsort(compare_func: lteq, arr: [mutable T], left: uint, right: uint) { if right > left { let pivot = (left + right) / 2u; @@ -84,12 +84,12 @@ Quicksort. Sorts a mutable vector in place. Has worst case O(n^2) performance, average case O(n log n). This is an unstable sort. */ -fn quick_sort(compare_func: lteq, arr: [mutable T]) { +fn quick_sort(compare_func: lteq, arr: [mutable T]) { if len::(arr) == 0u { ret; } qsort::(compare_func, arr, 0u, len::(arr) - 1u); } -fn qsort3(compare_func_lt: lteq, compare_func_eq: lteq, +fn qsort3(compare_func_lt: lteq, compare_func_eq: lteq, arr: [mutable T], left: int, right: int) { if right <= left { ret; } let v: T = arr[right]; @@ -150,7 +150,7 @@ According to these slides this is the algorithm of choice for This is an unstable sort. */ -fn quick_sort3(compare_func_lt: lteq, compare_func_eq: lteq, +fn quick_sort3(compare_func_lt: lteq, compare_func_eq: lteq, arr: [mutable T]) { if len::(arr) == 0u { ret; } qsort3::(compare_func_lt, compare_func_eq, arr, 0, diff --git a/src/libstd/test.rs b/src/libstd/test.rs index 4c0a52116cc6..43a869f03194 100644 --- a/src/libstd/test.rs +++ b/src/libstd/test.rs @@ -115,7 +115,7 @@ fn run_tests_console(opts: test_opts, run_tests_console_(opts, tests, default_test_to_task) } -fn run_tests_console_(opts: test_opts, tests: [test_desc], +fn run_tests_console_(opts: test_opts, tests: [test_desc], to_task: test_to_task) -> bool { type test_state = @@ -127,7 +127,7 @@ fn run_tests_console_(opts: test_opts, tests: [test_desc], mutable ignored: uint, mutable failures: [test_desc]}; - fn callback(event: testevent, st: test_state) { + fn callback(event: testevent, st: test_state) { alt event { te_filtered(filtered_tests) { st.total = vec::len(filtered_tests); @@ -220,7 +220,7 @@ tag testevent { te_result(test_desc, test_result); } -fn run_tests(opts: test_opts, tests: [test_desc], +fn run_tests(opts: test_opts, tests: [test_desc], to_task: test_to_task, callback: fn@(testevent)) { @@ -254,7 +254,7 @@ fn run_tests(opts: test_opts, tests: [test_desc], fn get_concurrency() -> uint { rustrt::sched_threads() } -fn filter_tests(opts: test_opts, +fn filter_tests(opts: test_opts, tests: [test_desc]) -> [test_desc] { let filtered = tests; @@ -268,7 +268,7 @@ fn filter_tests(opts: test_opts, option::none. { "" } }; - fn filter_fn(test: test_desc, filter_str: str) -> + fn filter_fn(test: test_desc, filter_str: str) -> option::t> { if str::find(test.name, filter_str) >= 0 { ret option::some(test); @@ -284,7 +284,7 @@ fn filter_tests(opts: test_opts, filtered = if !opts.run_ignored { filtered } else { - fn filter(test: test_desc) -> option::t> { + fn filter(test: test_desc) -> option::t> { if test.ignore { ret option::some({name: test.name, fn: test.fn, @@ -310,7 +310,7 @@ fn filter_tests(opts: test_opts, type test_future = {test: test_desc, wait: fn@() -> test_result}; -fn run_test(test: test_desc, +fn run_test(test: test_desc, to_task: test_to_task) -> test_future { if test.ignore { ret {test: test, wait: fn () -> test_result { tr_ignored }}; diff --git a/src/libstd/treemap.rs b/src/libstd/treemap.rs index 74d40f1c05db..646fde401db5 100644 --- a/src/libstd/treemap.rs +++ b/src/libstd/treemap.rs @@ -44,7 +44,7 @@ Function: insert Insert a value into the map */ -fn insert(m: treemap, k: K, v: V) { +fn insert(m: treemap, k: K, v: V) { alt m { @empty. { *m = node(@k, @v, @mutable empty, @mutable empty); } @node(@kk, _, _, _) { @@ -63,7 +63,7 @@ Function: find Find a value based on the key */ -fn find(m: treemap, k: K) -> option { +fn find(m: treemap, k: K) -> option { alt *m { empty. { none } node(@kk, @v, _, _) { diff --git a/src/libstd/util.rs b/src/libstd/util.rs index f4d984a8937c..f7bfc18a2570 100644 --- a/src/libstd/util.rs +++ b/src/libstd/util.rs @@ -7,7 +7,7 @@ Function: id The identity function */ -pure fn id(x: T) -> T { x } +pure fn id(x: T) -> T { x } /* Function: unreachable diff --git a/src/test/bench/task-perf-word-count-generic.rs b/src/test/bench/task-perf-word-count-generic.rs index cf8986aa0f73..e13603aec910 100644 --- a/src/test/bench/task-perf-word-count-generic.rs +++ b/src/test/bench/task-perf-word-count-generic.rs @@ -55,25 +55,25 @@ mod map_reduce { export reducer; export map_reduce; - type putter = fn(K, V); + type putter = fn(K, V); // FIXME: the first K1 parameter should probably be a -, but that // doesn't parse at the moment. - type mapper = fn(K1, putter); + type mapper = fn(K1, putter); - type getter = fn() -> option; + type getter = fn() -> option; - type reducer = fn(K, getter); + type reducer = fn(K, getter); - tag ctrl_proto { + tag ctrl_proto { find_reducer(K, chan>>); mapper_done; } - tag reduce_proto { emit_val(V); done; ref; release; } + tag reduce_proto { emit_val(V); done; ref; release; } - fn start_mappers(map: mapper, + fn start_mappers(map: mapper, ctrl: chan>, inputs: [K1]) -> [joinable_task] { let tasks = []; @@ -84,15 +84,15 @@ mod map_reduce { ret tasks; } - fn map_task(-map: mapper, + fn map_task(-map: mapper, -ctrl: chan>, -input: K1) { // log(error, "map_task " + input); let intermediates = treemap::init(); - fn emit(im: treemap::treemap>>, + fn emit(im: treemap::treemap>>, ctrl: chan>, key: K2, val: V) { let c; alt treemap::find(im, key) { @@ -110,15 +110,15 @@ mod map_reduce { map(input, bind emit(intermediates, ctrl, _, _)); - fn finish(_k: K, v: chan>) { + fn finish(_k: K, v: chan>) { send(v, release); } treemap::traverse(intermediates, finish); send(ctrl, mapper_done); } - fn reduce_task(-reduce: reducer, -key: K, + fn reduce_task(-reduce: reducer, -key: K, -out: chan>>) { let p = port(); @@ -127,7 +127,7 @@ mod map_reduce { let ref_count = 0; let is_done = false; - fn get(p: port>, + fn get(p: port>, &ref_count: int, &is_done: bool) -> option { while !is_done || ref_count > 0 { @@ -150,8 +150,8 @@ mod map_reduce { reduce(key, bind get(p, ref_count, is_done)); } - fn map_reduce(map: mapper, reduce: reducer, + fn map_reduce(map: mapper, reduce: reducer, inputs: [K1]) { let ctrl = port(); @@ -195,7 +195,7 @@ mod map_reduce { } } - fn finish(_k: K, v: chan>) { + fn finish(_k: K, v: chan>) { send(v, done); } treemap::traverse(reducers, finish); diff --git a/src/test/compile-fail/unique-unique-kind.rs b/src/test/compile-fail/unique-unique-kind.rs index ad172f7ae83d..8845e15721f9 100644 --- a/src/test/compile-fail/unique-unique-kind.rs +++ b/src/test/compile-fail/unique-unique-kind.rs @@ -1,6 +1,6 @@ // error-pattern: instantiating a sendable type parameter with a copyable type -fn f(i: T) { +fn f(i: T) { } fn main() { diff --git a/src/test/compile-fail/use-after-send.rs b/src/test/compile-fail/use-after-send.rs index 7dc3f7b4a329..858cc62a944a 100644 --- a/src/test/compile-fail/use-after-send.rs +++ b/src/test/compile-fail/use-after-send.rs @@ -1,5 +1,5 @@ // error-pattern: Unsatisfied precondition constraint -fn send(ch: _chan, -data: T) { +fn send(ch: _chan, -data: T) { log(debug, ch); log(debug, data); fail; diff --git a/src/test/run-fail/bug-811.rs b/src/test/run-fail/bug-811.rs index a257a903fd24..62206f939949 100644 --- a/src/test/run-fail/bug-811.rs +++ b/src/test/run-fail/bug-811.rs @@ -4,8 +4,8 @@ fn test00_start(ch: chan_t, message: int) { send(ch, copy message); } type task_id = int; type port_id = int; -type chan_t = {task: task_id, port: port_id}; +type chan_t = {task: task_id, port: port_id}; -fn send(ch: chan_t, -data: T) { fail; } +fn send(ch: chan_t, -data: T) { fail; } fn main() { fail "quux"; } diff --git a/src/test/run-fail/port-type.rs b/src/test/run-fail/port-type.rs index a43c7ce0e694..3c7ebf8c18ca 100644 --- a/src/test/run-fail/port-type.rs +++ b/src/test/run-fail/port-type.rs @@ -5,7 +5,7 @@ import comm::port; import comm::send; import comm::recv; -fn echo(c: chan, oc: chan>) { +fn echo(c: chan, oc: chan>) { // Tests that the type argument in port gets // visited let p = port::(); diff --git a/src/test/run-pass/auto-instantiate.rs b/src/test/run-pass/auto-instantiate.rs index ed8c71aecbad..0d5429e1980b 100644 --- a/src/test/run-pass/auto-instantiate.rs +++ b/src/test/run-pass/auto-instantiate.rs @@ -2,7 +2,7 @@ // -*- rust -*- -fn f(x: T, y: U) -> {a: T, b: U} { ret {a: x, b: y}; } +fn f(x: T, y: U) -> {a: T, b: U} { ret {a: x, b: y}; } fn main() { log(debug, f({x: 3, y: 4, z: 5}, 4).a.x); diff --git a/src/test/run-pass/bind-generic.rs b/src/test/run-pass/bind-generic.rs index e12caefe1401..579b304f839e 100644 --- a/src/test/run-pass/bind-generic.rs +++ b/src/test/run-pass/bind-generic.rs @@ -1,4 +1,4 @@ -fn wrapper3(i: T, j: int) { +fn wrapper3(i: T, j: int) { log(debug, i); log(debug, j); // This is a regression test that the spawn3 thunk to wrapper3 @@ -6,7 +6,7 @@ fn wrapper3(i: T, j: int) { assert j == 123456789; } -fn spawn3(i: T, j: int) { +fn spawn3(i: T, j: int) { let wrapped = bind wrapper3(i, j); wrapped(); } diff --git a/src/test/run-pass/box-unbox.rs b/src/test/run-pass/box-unbox.rs index 61f932bb9392..be9981ccdbe3 100644 --- a/src/test/run-pass/box-unbox.rs +++ b/src/test/run-pass/box-unbox.rs @@ -1,8 +1,8 @@ -type box = {c: @T}; +type box = {c: @T}; -fn unbox(b: box) -> T { ret *b.c; } +fn unbox(b: box) -> T { ret *b.c; } fn main() { let foo: int = 17; diff --git a/src/test/run-pass/expr-alt-generic-box2.rs b/src/test/run-pass/expr-alt-generic-box2.rs index bc19200e3237..c2f933a3480a 100644 --- a/src/test/run-pass/expr-alt-generic-box2.rs +++ b/src/test/run-pass/expr-alt-generic-box2.rs @@ -4,7 +4,7 @@ // -*- rust -*- type compare = fn@(T, T) -> bool; -fn test_generic(expected: T, eq: compare) { +fn test_generic(expected: T, eq: compare) { let actual: T = alt true { true { expected } }; assert (eq(expected, actual)); } diff --git a/src/test/run-pass/expr-alt-generic-unique1.rs b/src/test/run-pass/expr-alt-generic-unique1.rs index 301d56389b12..2bbb0fea5f79 100644 --- a/src/test/run-pass/expr-alt-generic-unique1.rs +++ b/src/test/run-pass/expr-alt-generic-unique1.rs @@ -3,7 +3,7 @@ // -*- rust -*- type compare = fn@(~T, ~T) -> bool; -fn test_generic(expected: ~T, eq: compare) { +fn test_generic(expected: ~T, eq: compare) { let actual: ~T = alt true { true { expected } }; assert (eq(expected, actual)); } diff --git a/src/test/run-pass/expr-alt-generic-unique2.rs b/src/test/run-pass/expr-alt-generic-unique2.rs index 5640dca0b4eb..30581222bfa3 100644 --- a/src/test/run-pass/expr-alt-generic-unique2.rs +++ b/src/test/run-pass/expr-alt-generic-unique2.rs @@ -4,7 +4,7 @@ // -*- rust -*- type compare = fn@(T, T) -> bool; -fn test_generic(expected: T, eq: compare) { +fn test_generic(expected: T, eq: compare) { let actual: T = alt true { true { expected } }; assert (eq(expected, actual)); } diff --git a/src/test/run-pass/expr-alt-generic.rs b/src/test/run-pass/expr-alt-generic.rs index 5a2f7d8b71cd..393cb1b7a4ec 100644 --- a/src/test/run-pass/expr-alt-generic.rs +++ b/src/test/run-pass/expr-alt-generic.rs @@ -4,7 +4,7 @@ // -*- rust -*- type compare = fn@(T, T) -> bool; -fn test_generic(expected: T, eq: compare) { +fn test_generic(expected: T, eq: compare) { let actual: T = alt true { true { expected } }; assert (eq(expected, actual)); } diff --git a/src/test/run-pass/expr-block-generic-box2.rs b/src/test/run-pass/expr-block-generic-box2.rs index ba98b8546a11..4ffc190716c4 100644 --- a/src/test/run-pass/expr-block-generic-box2.rs +++ b/src/test/run-pass/expr-block-generic-box2.rs @@ -4,7 +4,7 @@ // -*- rust -*- type compare = fn@(T, T) -> bool; -fn test_generic(expected: T, eq: compare) { +fn test_generic(expected: T, eq: compare) { let actual: T = { expected }; assert (eq(expected, actual)); } diff --git a/src/test/run-pass/expr-block-generic-unique1.rs b/src/test/run-pass/expr-block-generic-unique1.rs index 8942201fa9c2..060fba26051c 100644 --- a/src/test/run-pass/expr-block-generic-unique1.rs +++ b/src/test/run-pass/expr-block-generic-unique1.rs @@ -3,7 +3,7 @@ // -*- rust -*- type compare = fn@(~T, ~T) -> bool; -fn test_generic(expected: ~T, eq: compare) { +fn test_generic(expected: ~T, eq: compare) { let actual: ~T = { expected }; assert (eq(expected, actual)); } diff --git a/src/test/run-pass/expr-block-generic-unique2.rs b/src/test/run-pass/expr-block-generic-unique2.rs index fba64608186a..ce6489cdd12d 100644 --- a/src/test/run-pass/expr-block-generic-unique2.rs +++ b/src/test/run-pass/expr-block-generic-unique2.rs @@ -4,7 +4,7 @@ // -*- rust -*- type compare = fn@(T, T) -> bool; -fn test_generic(expected: T, eq: compare) { +fn test_generic(expected: T, eq: compare) { let actual: T = { expected }; assert (eq(expected, actual)); } diff --git a/src/test/run-pass/expr-block-generic.rs b/src/test/run-pass/expr-block-generic.rs index 4424d144e150..bf31ffd58088 100644 --- a/src/test/run-pass/expr-block-generic.rs +++ b/src/test/run-pass/expr-block-generic.rs @@ -6,7 +6,7 @@ // Tests for standalone blocks as expressions with dynamic type sizes type compare = fn@(T, T) -> bool; -fn test_generic(expected: T, eq: compare) { +fn test_generic(expected: T, eq: compare) { let actual: T = { expected }; assert (eq(expected, actual)); } diff --git a/src/test/run-pass/expr-fn.rs b/src/test/run-pass/expr-fn.rs index 5cd3f2a178b2..a3bd2449bb20 100644 --- a/src/test/run-pass/expr-fn.rs +++ b/src/test/run-pass/expr-fn.rs @@ -9,7 +9,7 @@ fn test_vec() { } fn test_generic() { - fn f(t: T) -> T { t } + fn f(t: T) -> T { t } assert (f(10) == 10); } diff --git a/src/test/run-pass/expr-if-generic-box2.rs b/src/test/run-pass/expr-if-generic-box2.rs index da00556eb4e7..01daf198dfe2 100644 --- a/src/test/run-pass/expr-if-generic-box2.rs +++ b/src/test/run-pass/expr-if-generic-box2.rs @@ -4,7 +4,7 @@ // -*- rust -*- type compare = fn@(T, T) -> bool; -fn test_generic(expected: T, not_expected: T, eq: compare) { +fn test_generic(expected: T, not_expected: T, eq: compare) { let actual: T = if true { expected } else { not_expected }; assert (eq(expected, actual)); } diff --git a/src/test/run-pass/expr-if-generic.rs b/src/test/run-pass/expr-if-generic.rs index f98a8742cc2d..9c565f35f676 100644 --- a/src/test/run-pass/expr-if-generic.rs +++ b/src/test/run-pass/expr-if-generic.rs @@ -6,7 +6,7 @@ // Tests for if as expressions with dynamic type sizes type compare = fn@(T, T) -> bool; -fn test_generic(expected: T, not_expected: T, eq: compare) { +fn test_generic(expected: T, not_expected: T, eq: compare) { let actual: T = if true { expected } else { not_expected }; assert (eq(expected, actual)); } diff --git a/src/test/run-pass/fixed-point-bind-unique.rs b/src/test/run-pass/fixed-point-bind-unique.rs index bbfc3f53f263..dac5ffd0416b 100644 --- a/src/test/run-pass/fixed-point-bind-unique.rs +++ b/src/test/run-pass/fixed-point-bind-unique.rs @@ -1,8 +1,8 @@ -fn fix_help(f: fn(fn@(A) -> B, A) -> B, x: A) -> B { +fn fix_help(f: fn(fn@(A) -> B, A) -> B, x: A) -> B { ret f(bind fix_help(f, _), x); } -fn fix(f: fn(fn@(A) -> B, A) -> B) -> fn@(A) -> B { +fn fix(f: fn(fn@(A) -> B, A) -> B) -> fn@(A) -> B { ret bind fix_help(f, _); } diff --git a/src/test/run-pass/fn-bare-spawn.rs b/src/test/run-pass/fn-bare-spawn.rs index 59a57b8597ce..ab4f40236bec 100644 --- a/src/test/run-pass/fn-bare-spawn.rs +++ b/src/test/run-pass/fn-bare-spawn.rs @@ -1,6 +1,6 @@ // This is what the signature to spawn should look like with bare functions -fn spawn(val: T, f: fn(T)) { +fn spawn(val: T, f: fn(T)) { f(val); } diff --git a/src/test/run-pass/foreach-unique-drop.rs b/src/test/run-pass/foreach-unique-drop.rs index 5b696a0efe9c..1c8f900b2e06 100644 --- a/src/test/run-pass/foreach-unique-drop.rs +++ b/src/test/run-pass/foreach-unique-drop.rs @@ -1,5 +1,5 @@ -obj ob(k: K) { +obj ob(k: K) { fn foo(it: block(~{a: K})) { it(~{a: k}); } } diff --git a/src/test/run-pass/generic-alias-box.rs b/src/test/run-pass/generic-alias-box.rs index f44ef370e2cc..b9bc823a8b99 100644 --- a/src/test/run-pass/generic-alias-box.rs +++ b/src/test/run-pass/generic-alias-box.rs @@ -1,6 +1,6 @@ -fn id(t: T) -> T { ret t; } +fn id(t: T) -> T { ret t; } fn main() { let expected = @100; diff --git a/src/test/run-pass/generic-alias-unique.rs b/src/test/run-pass/generic-alias-unique.rs index 4746a588a56b..0af9855de0d2 100644 --- a/src/test/run-pass/generic-alias-unique.rs +++ b/src/test/run-pass/generic-alias-unique.rs @@ -1,6 +1,6 @@ -fn id(t: T) -> T { ret t; } +fn id(t: T) -> T { ret t; } fn main() { let expected = ~100; diff --git a/src/test/run-pass/generic-bind-2.rs b/src/test/run-pass/generic-bind-2.rs index c633cb2d08a5..eeb9cf25f8ff 100644 --- a/src/test/run-pass/generic-bind-2.rs +++ b/src/test/run-pass/generic-bind-2.rs @@ -1,6 +1,6 @@ -fn id(t: T) -> T { ret t; } +fn id(t: T) -> T { ret t; } fn main() { let t = {a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7}; diff --git a/src/test/run-pass/generic-bind.rs b/src/test/run-pass/generic-bind.rs index 8464bfb02415..d0d3ea98a476 100644 --- a/src/test/run-pass/generic-bind.rs +++ b/src/test/run-pass/generic-bind.rs @@ -1,6 +1,6 @@ -fn id(t: T) -> T { ret t; } +fn id(t: T) -> T { ret t; } fn main() { let t = {_0: 1, _1: 2, _2: 3, _3: 4, _4: 5, _5: 6, _6: 7}; diff --git a/src/test/run-pass/generic-box.rs b/src/test/run-pass/generic-box.rs index 87465ae6a93d..14fb924492aa 100644 --- a/src/test/run-pass/generic-box.rs +++ b/src/test/run-pass/generic-box.rs @@ -1,6 +1,6 @@ -fn box(x: {x: T, y: T, z: T}) -> @{x: T, y: T, z: T} { ret @x; } +fn box(x: {x: T, y: T, z: T}) -> @{x: T, y: T, z: T} { ret @x; } fn main() { let x: @{x: int, y: int, z: int} = box::({x: 1, y: 2, z: 3}); diff --git a/src/test/run-pass/generic-derived-type.rs b/src/test/run-pass/generic-derived-type.rs index 032a5c3f9d69..39f4c0d14729 100644 --- a/src/test/run-pass/generic-derived-type.rs +++ b/src/test/run-pass/generic-derived-type.rs @@ -1,8 +1,8 @@ -fn g(x: X) -> X { ret x; } +fn g(x: X) -> X { ret x; } -fn f(t: T) -> {a: T, b: T} { +fn f(t: T) -> {a: T, b: T} { type pair = {a: T, b: T}; let x: pair = {a: t, b: t}; diff --git a/src/test/run-pass/generic-drop-glue.rs b/src/test/run-pass/generic-drop-glue.rs index ced0ecfbe9e0..15583f9904b8 100644 --- a/src/test/run-pass/generic-drop-glue.rs +++ b/src/test/run-pass/generic-drop-glue.rs @@ -1,5 +1,5 @@ -fn f(t: T) { let t1: T = t; } +fn f(t: T) { let t1: T = t; } fn main() { let x = {x: @10, y: @12}; f(x); } diff --git a/src/test/run-pass/generic-exterior-box.rs b/src/test/run-pass/generic-exterior-box.rs index 41315e156430..8c042a9e76d6 100644 --- a/src/test/run-pass/generic-exterior-box.rs +++ b/src/test/run-pass/generic-exterior-box.rs @@ -1,8 +1,8 @@ -type recbox = {x: @T}; +type recbox = {x: @T}; -fn reclift(t: T) -> recbox { ret {x: @t}; } +fn reclift(t: T) -> recbox { ret {x: @t}; } fn main() { let foo: int = 17; diff --git a/src/test/run-pass/generic-exterior-unique.rs b/src/test/run-pass/generic-exterior-unique.rs index 1a97c1347481..6f985120d42b 100644 --- a/src/test/run-pass/generic-exterior-unique.rs +++ b/src/test/run-pass/generic-exterior-unique.rs @@ -1,6 +1,6 @@ -type recbox = {x: ~T}; +type recbox = {x: ~T}; -fn reclift(t: T) -> recbox { ret {x: ~t}; } +fn reclift(t: T) -> recbox { ret {x: ~t}; } fn main() { let foo: int = 17; diff --git a/src/test/run-pass/generic-fn-infer.rs b/src/test/run-pass/generic-fn-infer.rs index 57d4052e5a07..31f0008fc0b4 100644 --- a/src/test/run-pass/generic-fn-infer.rs +++ b/src/test/run-pass/generic-fn-infer.rs @@ -4,6 +4,6 @@ // -*- rust -*- // Issue #45: infer type parameters in function applications -fn id(x: T) -> T { ret x; } +fn id(x: T) -> T { ret x; } fn main() { let x: int = 42; let y: int = id(x); assert (x == y); } diff --git a/src/test/run-pass/generic-fn-unique.rs b/src/test/run-pass/generic-fn-unique.rs index 7333350e3b22..749341c1a191 100644 --- a/src/test/run-pass/generic-fn-unique.rs +++ b/src/test/run-pass/generic-fn-unique.rs @@ -1,4 +1,4 @@ -fn f(x: ~T) -> ~T { ret x; } +fn f(x: ~T) -> ~T { ret x; } fn main() { let x = f(~3); log(debug, *x); } diff --git a/src/test/run-pass/generic-fn.rs b/src/test/run-pass/generic-fn.rs index ac2d6f5aad33..6f854efa8578 100644 --- a/src/test/run-pass/generic-fn.rs +++ b/src/test/run-pass/generic-fn.rs @@ -2,7 +2,7 @@ // -*- rust -*- -fn id(x: T) -> T { ret x; } +fn id(x: T) -> T { ret x; } type triple = {x: int, y: int, z: int}; diff --git a/src/test/run-pass/generic-obj-with-derived-type.rs b/src/test/run-pass/generic-obj-with-derived-type.rs index 2186b12022d7..2c4e1804af53 100644 --- a/src/test/run-pass/generic-obj-with-derived-type.rs +++ b/src/test/run-pass/generic-obj-with-derived-type.rs @@ -1,6 +1,6 @@ -obj handle(data: T) { +obj handle(data: T) { fn get() -> T { ret data; } } diff --git a/src/test/run-pass/generic-obj.rs b/src/test/run-pass/generic-obj.rs index ab693787182d..5eedeecb5bc1 100644 --- a/src/test/run-pass/generic-obj.rs +++ b/src/test/run-pass/generic-obj.rs @@ -1,6 +1,6 @@ -obj buf(data: {_0: T, _1: T, _2: T}) { +obj buf(data: {_0: T, _1: T, _2: T}) { fn get(i: int) -> T { if i == 0 { ret data._0; diff --git a/src/test/run-pass/generic-tup.rs b/src/test/run-pass/generic-tup.rs index 2b5f81d526d5..58a33b809460 100644 --- a/src/test/run-pass/generic-tup.rs +++ b/src/test/run-pass/generic-tup.rs @@ -1,4 +1,4 @@ -fn get_third(t: (T, T, T)) -> T { let (_, _, x) = t; ret x; } +fn get_third(t: (T, T, T)) -> T { let (_, _, x) = t; ret x; } fn main() { log(debug, get_third((1, 2, 3))); diff --git a/src/test/run-pass/generic-unique.rs b/src/test/run-pass/generic-unique.rs index 3b6b19ce450d..686bd36888e3 100644 --- a/src/test/run-pass/generic-unique.rs +++ b/src/test/run-pass/generic-unique.rs @@ -1,5 +1,5 @@ -fn box(x: {x: T, y: T, z: T}) -> ~{x: T, y: T, z: T} { ret ~x; } +fn box(x: {x: T, y: T, z: T}) -> ~{x: T, y: T, z: T} { ret ~x; } fn main() { let x: ~{x: int, y: int, z: int} = box::({x: 1, y: 2, z: 3}); diff --git a/src/test/run-pass/issue-333.rs b/src/test/run-pass/issue-333.rs index 793df760b4b3..be253b9afdd5 100644 --- a/src/test/run-pass/issue-333.rs +++ b/src/test/run-pass/issue-333.rs @@ -1,5 +1,5 @@ -fn quux(x: T) -> T { let f = bind id::(_); ret f(x); } +fn quux(x: T) -> T { let f = bind id::(_); ret f(x); } -fn id(x: T) -> T { ret x; } +fn id(x: T) -> T { ret x; } fn main() { assert (quux(10) == 10); } diff --git a/src/test/run-pass/ivec-add.rs b/src/test/run-pass/ivec-add.rs index 9e45b0283866..e79ca8bae38b 100644 --- a/src/test/run-pass/ivec-add.rs +++ b/src/test/run-pass/ivec-add.rs @@ -1,4 +1,4 @@ -fn double(a: T) -> [T] { ret [a] + [a]; } +fn double(a: T) -> [T] { ret [a] + [a]; } fn double_int(a: int) -> [int] { ret [a] + [a]; } diff --git a/src/test/run-pass/newtype-polymorphic.rs b/src/test/run-pass/newtype-polymorphic.rs index 5bb2171dfd2e..f25665ca86c1 100644 --- a/src/test/run-pass/newtype-polymorphic.rs +++ b/src/test/run-pass/newtype-polymorphic.rs @@ -1,8 +1,8 @@ tag myvec = [X]; -fn myvec_deref(mv: myvec) -> [X] { ret *mv; } +fn myvec_deref(mv: myvec) -> [X] { ret *mv; } -fn myvec_elt(mv: myvec) -> X { ret mv[0]; } +fn myvec_elt(mv: myvec) -> X { ret mv[0]; } fn main() { let mv = myvec([1, 2, 3]); diff --git a/src/test/run-pass/non-boolean-pure-fns.rs b/src/test/run-pass/non-boolean-pure-fns.rs index 27f3b530154d..d74fb81a3b99 100644 --- a/src/test/run-pass/non-boolean-pure-fns.rs +++ b/src/test/run-pass/non-boolean-pure-fns.rs @@ -2,19 +2,19 @@ use std; import std::list::*; -pure fn pure_length_go(ls: list, acc: uint) -> uint { +pure fn pure_length_go(ls: list, acc: uint) -> uint { alt ls { nil. { acc } cons(_, tl) { pure_length_go(*tl, acc + 1u) } } } -pure fn pure_length(ls: list) -> uint { pure_length_go(ls, 0u) } +pure fn pure_length(ls: list) -> uint { pure_length_go(ls, 0u) } -pure fn nonempty_list(ls: list) -> bool { pure_length(ls) > 0u } +pure fn nonempty_list(ls: list) -> bool { pure_length(ls) > 0u } // Of course, the compiler can't take advantage of the // knowledge that ls is a cons node. Future work. // Also, this is pretty contrived since nonempty_list // could be a "tag refinement", if we implement those. -fn safe_head(ls: list) : nonempty_list(ls) -> T { +fn safe_head(ls: list) : nonempty_list(ls) -> T { check is_not_empty(ls); ret head(ls); } diff --git a/src/test/run-pass/obj-return-polytypes.rs b/src/test/run-pass/obj-return-polytypes.rs index ebfcf37e79d8..4c1f8d54ced4 100644 --- a/src/test/run-pass/obj-return-polytypes.rs +++ b/src/test/run-pass/obj-return-polytypes.rs @@ -6,7 +6,7 @@ tag clam { signed(int); unsigned(uint); } fn getclam() -> clam { ret signed::(42); } -obj impatience() { +obj impatience() { fn moreclam() -> clam { be getclam::(); } } diff --git a/src/test/run-pass/ret-none.rs b/src/test/run-pass/ret-none.rs index fe91c15c72de..7481bfe9100c 100644 --- a/src/test/run-pass/ret-none.rs +++ b/src/test/run-pass/ret-none.rs @@ -2,6 +2,6 @@ tag option { none; some(T); } -fn f() -> option { ret none; } +fn f() -> option { ret none; } fn main() { f::(); } diff --git a/src/test/run-pass/send-type-inference.rs b/src/test/run-pass/send-type-inference.rs index 1c88d0182f62..432985bcb7fa 100644 --- a/src/test/run-pass/send-type-inference.rs +++ b/src/test/run-pass/send-type-inference.rs @@ -4,9 +4,9 @@ import comm::send; import comm::port; // tests that ctrl's type gets inferred properly -type command = {key: K, val: V}; +type command = {key: K, val: V}; -fn cache_server(c: chan>>) { +fn cache_server(c: chan>>) { let ctrl = port(); send(c, chan(ctrl)); } diff --git a/src/test/run-pass/sendfn-generic-fn.rs b/src/test/run-pass/sendfn-generic-fn.rs index 3c19958fa311..66177fd04aec 100644 --- a/src/test/run-pass/sendfn-generic-fn.rs +++ b/src/test/run-pass/sendfn-generic-fn.rs @@ -8,7 +8,7 @@ fn main() { test05(); } type pair = { a: A, b: B }; -fn make_generic_record(a: A, b: B) -> pair { +fn make_generic_record(a: A, b: B) -> pair { ret {a: a, b: b}; } @@ -24,7 +24,7 @@ fn test05_start(&&f: sendfn(&&float, &&str) -> pair) { assert q.b == "Ho"; } -fn spawn(f: fn(sendfn(A,B)->pair)) { +fn spawn(f: fn(sendfn(A,B)->pair)) { let arg = sendfn(a: A, b: B) -> pair { ret make_generic_record(a, b); }; diff --git a/src/test/run-pass/type-param-constraints.rs b/src/test/run-pass/type-param-constraints.rs index def6e72f4d9a..7fdaa061ee6e 100644 --- a/src/test/run-pass/type-param-constraints.rs +++ b/src/test/run-pass/type-param-constraints.rs @@ -1,6 +1,6 @@ fn p_foo(pinned: T) { } -fn s_foo(shared: T) { } -fn u_foo(unique: T) { } +fn s_foo(shared: T) { } +fn u_foo(unique: T) { } resource r(i: int) { } diff --git a/src/test/run-pass/unchecked-predicates.rs b/src/test/run-pass/unchecked-predicates.rs index 035b18f80512..e43cdaacb8be 100644 --- a/src/test/run-pass/unchecked-predicates.rs +++ b/src/test/run-pass/unchecked-predicates.rs @@ -7,7 +7,7 @@ import std::list::*; // Can't easily be written as a "pure fn" because there's // no syntax for specifying that f is pure. -fn pure_foldl(ls: list, u: U, f: block(T, U) -> U) -> U { +fn pure_foldl(ls: list, u: U, f: block(T, U) -> U) -> U { alt ls { nil. { u } cons(hd, tl) { f(hd, pure_foldl(*tl, f(hd, u), f)) } @@ -16,18 +16,18 @@ fn pure_foldl(ls: list, u: U, f: block(T, U) -> U) -> U { // Shows how to use an "unchecked" block to call a general // fn from a pure fn -pure fn pure_length(ls: list) -> uint { +pure fn pure_length(ls: list) -> uint { fn count(_t: T, &&u: uint) -> uint { u + 1u } unchecked{ pure_foldl(ls, 0u, bind count(_, _)) } } -pure fn nonempty_list(ls: list) -> bool { pure_length(ls) > 0u } +pure fn nonempty_list(ls: list) -> bool { pure_length(ls) > 0u } // Of course, the compiler can't take advantage of the // knowledge that ls is a cons node. Future work. // Also, this is pretty contrived since nonempty_list // could be a "tag refinement", if we implement those. -fn safe_head(ls: list) : nonempty_list(ls) -> T { +fn safe_head(ls: list) : nonempty_list(ls) -> T { check is_not_empty(ls); ret head(ls) } diff --git a/src/test/run-pass/unique-assign-generic.rs b/src/test/run-pass/unique-assign-generic.rs index 372cca1c667c..ba8b4bb57236 100644 --- a/src/test/run-pass/unique-assign-generic.rs +++ b/src/test/run-pass/unique-assign-generic.rs @@ -1,4 +1,4 @@ -fn f(t: T) -> T { +fn f(t: T) -> T { let t1 = t; t1 } diff --git a/src/test/run-pass/unique-generic-assign.rs b/src/test/run-pass/unique-generic-assign.rs index 4370bb4a791d..f8fd6f62c265 100644 --- a/src/test/run-pass/unique-generic-assign.rs +++ b/src/test/run-pass/unique-generic-assign.rs @@ -1,6 +1,6 @@ // Issue #976 -fn f(x: ~T) { +fn f(x: ~T) { let _x2 = x; } fn main() { } diff --git a/src/test/run-pass/unique-kinds.rs b/src/test/run-pass/unique-kinds.rs index ab88437331cb..4600081e45a9 100644 --- a/src/test/run-pass/unique-kinds.rs +++ b/src/test/run-pass/unique-kinds.rs @@ -1,10 +1,10 @@ fn sendable() { - fn f(i: T, j: T) { + fn f(i: T, j: T) { assert i == j; } - fn g(i: T, j: T) { + fn g(i: T, j: T) { assert i != j; } @@ -18,11 +18,11 @@ fn sendable() { fn copyable() { - fn f(i: T, j: T) { + fn f(i: T, j: T) { assert i == j; } - fn g(i: T, j: T) { + fn g(i: T, j: T) { assert i != j; } diff --git a/src/test/run-pass/vec-push.rs b/src/test/run-pass/vec-push.rs index 92da692e482d..bf6b7638eacf 100644 --- a/src/test/run-pass/vec-push.rs +++ b/src/test/run-pass/vec-push.rs @@ -1,5 +1,5 @@ -fn push(&v: [const T], t: T) { v += [t]; } +fn push(&v: [const T], t: T) { v += [t]; } fn main() { let v = [1, 2, 3]; push(v, 1); } diff --git a/src/test/stdtest/deque.rs b/src/test/stdtest/deque.rs index a94b1739b324..ef763131a414 100644 --- a/src/test/stdtest/deque.rs +++ b/src/test/stdtest/deque.rs @@ -81,7 +81,7 @@ fn test_boxes(a: @int, b: @int, c: @int, d: @int) { type eqfn = fn@(T, T) -> bool; -fn test_parameterized(e: eqfn, a: T, b: T, c: T, d: T) { +fn test_parameterized(e: eqfn, a: T, b: T, c: T, d: T) { let deq: deque::t = deque::create::(); assert (deq.size() == 0u); deq.add_front(a); diff --git a/src/test/stdtest/task.rs b/src/test/stdtest/task.rs index 31299e703be3..3a08606f47ec 100644 --- a/src/test/stdtest/task.rs +++ b/src/test/stdtest/task.rs @@ -70,7 +70,7 @@ fn test_join_convenient() { #[ignore] fn spawn_polymorphic() { // FIXME #1038: Can't spawn palymorphic functions - /*fn foo(x: T) { log(error, x); } + /*fn foo(x: T) { log(error, x); } task::spawn(true, foo); task::spawn(42, foo);*/ From cc929fc9f9de6cf2d44df46ffc4b4d6e58e3a508 Mon Sep 17 00:00:00 2001 From: Marijn Haverbeke Date: Thu, 5 Jan 2012 16:04:59 +0100 Subject: [PATCH 3/3] Clean up translating of def_ids in metadata reader Reduces the amount of closure allocation, and makes the code cleaner. --- src/comp/metadata/creader.rs | 3 +- src/comp/metadata/csearch.rs | 51 +++--------- src/comp/metadata/cstore.rs | 5 +- src/comp/metadata/decoder.rs | 135 ++++++++++++++++---------------- src/comp/metadata/tydecode.rs | 143 ++++++++++++++++------------------ 5 files changed, 149 insertions(+), 188 deletions(-) diff --git a/src/comp/metadata/creader.rs b/src/comp/metadata/creader.rs index 21ead604d31d..167e6bbcbabd 100644 --- a/src/comp/metadata/creader.rs +++ b/src/comp/metadata/creader.rs @@ -260,7 +260,8 @@ fn resolve_crate(e: env, ident: ast::ident, metas: [@ast::meta_item], // Now resolve the crates referenced by this crate let cnum_map = resolve_crate_deps(e, cdata); - let cmeta = {name: ident, data: cdata, cnum_map: cnum_map}; + let cmeta = @{name: ident, data: cdata, + cnum_map: cnum_map, cnum: cnum}; let cstore = e.sess.get_cstore(); cstore::set_crate_data(cstore, cnum, cmeta); diff --git a/src/comp/metadata/csearch.rs b/src/comp/metadata/csearch.rs index 364dd7aef21f..3b0eac2d3cef 100644 --- a/src/comp/metadata/csearch.rs +++ b/src/comp/metadata/csearch.rs @@ -58,32 +58,27 @@ fn resolve_path(cstore: cstore::cstore, cnum: ast::crate_num, fn get_tag_variants(tcx: ty::ctxt, def: ast::def_id) -> [ty::variant_info] { let cstore = tcx.sess.get_cstore(); - let cnum = def.crate; - let cdata = cstore::get_crate_data(cstore, cnum).data; - let resolver = bind translate_def_id(cstore, cnum, _); - ret decoder::get_tag_variants(cdata, def, tcx, resolver) + let cdata = cstore::get_crate_data(cstore, def.crate); + ret decoder::get_tag_variants(cdata, def.node, tcx) } fn get_impls_for_mod(cstore: cstore::cstore, def: ast::def_id, name: option::t) -> @[@middle::resolve::_impl] { - let cdata = cstore::get_crate_data(cstore, def.crate).data; - let resolver = bind translate_def_id(cstore, def.crate, _); - decoder::get_impls_for_mod(cdata, def, name, resolver) + let cdata = cstore::get_crate_data(cstore, def.crate); + decoder::get_impls_for_mod(cdata, def.node, name) } fn get_iface_methods(tcx: ty::ctxt, def: ast::def_id) -> @[ty::method] { let cstore = tcx.sess.get_cstore(); - let cdata = cstore::get_crate_data(cstore, def.crate).data; - let resolver = bind translate_def_id(cstore, def.crate, _); - decoder::get_iface_methods(cdata, def, tcx, resolver) + let cdata = cstore::get_crate_data(cstore, def.crate); + decoder::get_iface_methods(cdata, def.node, tcx) } fn get_type(tcx: ty::ctxt, def: ast::def_id) -> ty::ty_param_bounds_and_ty { let cstore = tcx.sess.get_cstore(); - let cdata = cstore::get_crate_data(cstore, def.crate).data; - let resolver = bind translate_def_id(cstore, def.crate, _); - decoder::get_type(cdata, def, tcx, resolver) + let cdata = cstore::get_crate_data(cstore, def.crate); + decoder::get_type(cdata, def.node, tcx) } fn get_item_name(cstore: cstore::cstore, cnum: int, id: int) -> ast::ident { @@ -94,34 +89,8 @@ fn get_item_name(cstore: cstore::cstore, cnum: int, id: int) -> ast::ident { fn get_impl_iface(tcx: ty::ctxt, def: ast::def_id) -> option::t { let cstore = tcx.sess.get_cstore(); - let cdata = cstore::get_crate_data(cstore, def.crate).data; - let resolver = bind translate_def_id(cstore, def.crate, _); - decoder::get_impl_iface(cdata, def, tcx, resolver) -} - -// Translates a def_id from an external crate to a def_id for the current -// compilation environment. We use this when trying to load types from -// external crates - if those types further refer to types in other crates -// then we must translate the crate number from that encoded in the external -// crate to the correct local crate number. -fn translate_def_id(cstore: cstore::cstore, searched_crate: ast::crate_num, - def_id: ast::def_id) -> ast::def_id { - - let ext_cnum = def_id.crate; - let node_id = def_id.node; - - assert (searched_crate != ast::local_crate); - assert (ext_cnum != ast::local_crate); - - let cmeta = cstore::get_crate_data(cstore, searched_crate); - - let local_cnum = - alt cmeta.cnum_map.find(ext_cnum) { - option::some(n) { n } - option::none. { fail "didn't find a crate in the cnum_map"; } - }; - - ret {crate: local_cnum, node: node_id}; + let cdata = cstore::get_crate_data(cstore, def.crate); + decoder::get_impl_iface(cdata, def.node, tcx) } // Local Variables: diff --git a/src/comp/metadata/cstore.rs b/src/comp/metadata/cstore.rs index b85051ea09a3..de56aa236f53 100644 --- a/src/comp/metadata/cstore.rs +++ b/src/comp/metadata/cstore.rs @@ -30,7 +30,10 @@ export get_dep_hashes; // own crate numbers. type cnum_map = map::hashmap; -type crate_metadata = {name: str, data: @[u8], cnum_map: cnum_map}; +type crate_metadata = @{name: str, + data: @[u8], + cnum_map: cnum_map, + cnum: ast::crate_num}; // This is a bit of an experiment at encapsulating the data in cstore. By // keeping all the data in a non-exported tag variant, it's impossible for diff --git a/src/comp/metadata/decoder.rs b/src/comp/metadata/decoder.rs index 95bd8e5811df..a253e116fe8a 100644 --- a/src/comp/metadata/decoder.rs +++ b/src/comp/metadata/decoder.rs @@ -1,14 +1,13 @@ // Decoding metadata from a single crate's metadata -import core::{vec, option, str}; import std::{ebml, io}; import syntax::{ast, ast_util}; import front::attr; import middle::ty; import common::*; -import tydecode::{parse_def_id, parse_ty_data}; +import tydecode::{parse_ty_data, parse_def_id, parse_bounds_data}; import syntax::print::pprust; -import cstore; +import cmd=cstore::crate_metadata; export get_symbol; export get_tag_variants; @@ -24,7 +23,6 @@ export list_crate_metadata; export crate_dep; export get_crate_deps; export get_crate_hash; -export external_resolver; export get_impls_for_mod; export get_iface_methods; // A function that takes a def_id relative to the crate being searched and @@ -32,7 +30,6 @@ export get_iface_methods; // def_id for an item defined in another crate, somebody needs to figure out // what crate that's in and give us a def_id that makes sense for the current // build. -type external_resolver = fn@(ast::def_id) -> ast::def_id; fn lookup_hash(d: ebml::doc, eq_fn: fn@([u8]) -> bool, hash: uint) -> [ebml::doc] { @@ -91,66 +88,50 @@ fn variant_tag_id(d: ebml::doc) -> ast::def_id { ret parse_def_id(ebml::doc_data(tagdoc)); } -fn parse_external_def_id(this_cnum: ast::crate_num, - extres: external_resolver, s: str) -> - ast::def_id { - let buf = str::bytes(s); - let external_def_id = parse_def_id(buf); - - - // This item was defined in the crate we're searching if it's has the - // local crate number, otherwise we need to search a different crate - if external_def_id.crate == ast::local_crate { - ret {crate: this_cnum, node: external_def_id.node}; - } else { ret extres(external_def_id); } -} - -fn doc_type(doc: ebml::doc, this_cnum: ast::crate_num, tcx: ty::ctxt, - extres: external_resolver) -> ty::t { +fn doc_type(doc: ebml::doc, tcx: ty::ctxt, cdata: cmd) -> ty::t { let tp = ebml::get_doc(doc, tag_items_data_item_type); - let def_parser = bind parse_external_def_id(this_cnum, extres, _); - parse_ty_data(tp.data, this_cnum, tp.start, def_parser, tcx) + parse_ty_data(tp.data, cdata.cnum, tp.start, tcx, {|did| + translate_def_id(cdata, did) + }) } -fn item_type(item: ebml::doc, this_cnum: ast::crate_num, tcx: ty::ctxt, - extres: external_resolver) -> ty::t { - let t = doc_type(item, this_cnum, tcx, extres); +fn item_type(item: ebml::doc, tcx: ty::ctxt, cdata: cmd) -> ty::t { + let t = doc_type(item, tcx, cdata); if family_names_type(item_family(item)) { ty::mk_named(tcx, t, @item_name(item)) } else { t } } -fn item_impl_iface(item: ebml::doc, this_cnum: ast::crate_num, tcx: ty::ctxt, - extres: external_resolver) -> option::t { +fn item_impl_iface(item: ebml::doc, tcx: ty::ctxt, cdata: cmd) + -> option::t { let result = none; ebml::tagged_docs(item, tag_impl_iface) {|ity| - let def_parser = bind parse_external_def_id(this_cnum, extres, _); - let t = parse_ty_data(ity.data, this_cnum, ity.start, def_parser, - tcx); + let t = parse_ty_data(ity.data, cdata.cnum, ity.start, tcx, {|did| + translate_def_id(cdata, did) + }); result = some(t); } result } -fn item_impl_iface_did(item: ebml::doc, this_cnum: ast::crate_num, - extres: external_resolver) +fn item_impl_iface_did(item: ebml::doc, cdata: cmd) -> option::t { let result = none; ebml::tagged_docs(item, tag_impl_iface_did) {|doc| - let s = str::unsafe_from_bytes(ebml::doc_data(doc)); - result = some(parse_external_def_id(this_cnum, extres, s)); + let did = translate_def_id(cdata, parse_def_id(ebml::doc_data(doc))); + result = some(did); } result } -fn item_ty_param_bounds(item: ebml::doc, this_cnum: ast::crate_num, - tcx: ty::ctxt, extres: external_resolver) +fn item_ty_param_bounds(item: ebml::doc, tcx: ty::ctxt, cdata: cmd) -> @[ty::param_bounds] { let bounds = []; - let def_parser = bind parse_external_def_id(this_cnum, extres, _); ebml::tagged_docs(item, tag_items_data_item_ty_param_bounds) {|p| - bounds += [tydecode::parse_bounds_data(p.data, p.start, - this_cnum, def_parser, tcx)]; + let bd = parse_bounds_data(p.data, p.start, cdata.cnum, tcx, {|did| + translate_def_id(cdata, did) + }); + bounds += [bd]; } @bounds } @@ -162,13 +143,12 @@ fn item_ty_param_count(item: ebml::doc) -> uint { n } -fn tag_variant_ids(item: ebml::doc, this_cnum: ast::crate_num) -> - [ast::def_id] { +fn tag_variant_ids(item: ebml::doc, cdata: cmd) -> [ast::def_id] { let ids: [ast::def_id] = []; let v = tag_items_data_item_variant; ebml::tagged_docs(item, v) {|p| let ext = parse_def_id(ebml::doc_data(p)); - ids += [{crate: this_cnum, node: ext.node}]; + ids += [{crate: cdata.cnum, node: ext.node}]; }; ret ids; } @@ -230,12 +210,12 @@ fn lookup_def(cnum: ast::crate_num, data: @[u8], did_: ast::def_id) -> ret def; } -fn get_type(data: @[u8], def: ast::def_id, tcx: ty::ctxt, - extres: external_resolver) -> ty::ty_param_bounds_and_ty { - let item = lookup_item(def.node, data); - let t = item_type(item, def.crate, tcx, extres); +fn get_type(cdata: cmd, id: ast::node_id, tcx: ty::ctxt) + -> ty::ty_param_bounds_and_ty { + let item = lookup_item(id, cdata.data); + let t = item_type(item, tcx, cdata); let tp_bounds = if family_has_type_params(item_family(item)) { - item_ty_param_bounds(item, def.crate, tcx, extres) + item_ty_param_bounds(item, tcx, cdata) } else { @[] }; ret {bounds: tp_bounds, ty: t}; } @@ -244,27 +224,25 @@ fn get_type_param_count(data: @[u8], id: ast::node_id) -> uint { item_ty_param_count(lookup_item(id, data)) } -fn get_impl_iface(data: @[u8], def: ast::def_id, tcx: ty::ctxt, - extres: external_resolver) -> option::t { - item_impl_iface(lookup_item(def.node, data), def.crate, tcx, extres) +fn get_impl_iface(cdata: cmd, id: ast::node_id, tcx: ty::ctxt) + -> option::t { + item_impl_iface(lookup_item(id, cdata.data), tcx, cdata) } fn get_symbol(data: @[u8], id: ast::node_id) -> str { ret item_symbol(lookup_item(id, data)); } -fn get_tag_variants(_data: @[u8], def: ast::def_id, tcx: ty::ctxt, - extres: external_resolver) -> [ty::variant_info] { - let external_crate_id = def.crate; - let data = - cstore::get_crate_data(tcx.sess.get_cstore(), external_crate_id).data; +fn get_tag_variants(cdata: cmd, id: ast::node_id, tcx: ty::ctxt) + -> [ty::variant_info] { + let data = cdata.data; let items = ebml::get_doc(ebml::new_doc(data), tag_items); - let item = find_item(def.node, items); + let item = find_item(id, items); let infos: [ty::variant_info] = []; - let variant_ids = tag_variant_ids(item, external_crate_id); + let variant_ids = tag_variant_ids(item, cdata); for did: ast::def_id in variant_ids { let item = find_item(did.node, items); - let ctor_ty = item_type(item, external_crate_id, tcx, extres); + let ctor_ty = item_type(item, tcx, cdata); let arg_tys: [ty::t] = []; alt ty::struct(tcx, ctor_ty) { ty::ty_fn(f) { @@ -290,17 +268,17 @@ fn item_impl_methods(data: @[u8], item: ebml::doc, base_tps: uint) rslt } -fn get_impls_for_mod(data: @[u8], m_def: ast::def_id, - name: option::t, extres: external_resolver) +fn get_impls_for_mod(cdata: cmd, m_id: ast::node_id, + name: option::t) -> @[@middle::resolve::_impl] { - let mod_item = lookup_item(m_def.node, data), result = []; + let data = cdata.data; + let mod_item = lookup_item(m_id, data), result = []; ebml::tagged_docs(mod_item, tag_mod_impl) {|doc| - let did = parse_external_def_id( - m_def.crate, extres, str::unsafe_from_bytes(ebml::doc_data(doc))); + let did = translate_def_id(cdata, parse_def_id(ebml::doc_data(doc))); let item = lookup_item(did.node, data), nm = item_name(item); if alt name { some(n) { n == nm } none. { true } } { let base_tps = item_ty_param_count(doc); - let i_did = item_impl_iface_did(item, m_def.crate, extres); + let i_did = item_impl_iface_did(item, cdata); result += [@{did: did, iface_did: i_did, ident: nm, methods: item_impl_methods(data, doc, base_tps)}]; } @@ -308,13 +286,14 @@ fn get_impls_for_mod(data: @[u8], m_def: ast::def_id, @result } -fn get_iface_methods(data: @[u8], def: ast::def_id, tcx: ty::ctxt, - extres: external_resolver) -> @[ty::method] { - let item = lookup_item(def.node, data), result = []; +fn get_iface_methods(cdata: cmd, id: ast::node_id, tcx: ty::ctxt) + -> @[ty::method] { + let data = cdata.data; + let item = lookup_item(id, data), result = []; ebml::tagged_docs(item, tag_item_method) {|mth| - let bounds = item_ty_param_bounds(mth, def.crate, tcx, extres); + let bounds = item_ty_param_bounds(mth, tcx, cdata); let name = item_name(mth); - let ty = doc_type(mth, def.crate, tcx, extres); + let ty = doc_type(mth, tcx, cdata); let fty = alt ty::struct(tcx, ty) { ty::ty_fn(f) { f } }; result += [{ident: name, tps: bounds, fty: fty}]; } @@ -489,6 +468,22 @@ fn list_crate_metadata(bytes: @[u8], out: io::writer) { list_crate_items(bytes, md, out); } +// Translates a def_id from an external crate to a def_id for the current +// compilation environment. We use this when trying to load types from +// external crates - if those types further refer to types in other crates +// then we must translate the crate number from that encoded in the external +// crate to the correct local crate number. +fn translate_def_id(cdata: cmd, did: ast::def_id) -> ast::def_id { + if did.crate == ast::local_crate { + ret {crate: cdata.cnum, node: did.node}; + } + + alt cdata.cnum_map.find(did.crate) { + option::some(n) { ret {crate: n, node: did.node}; } + option::none. { fail "didn't find a crate in the cnum_map"; } + } +} + // Local Variables: // mode: rust // fill-column: 78; diff --git a/src/comp/metadata/tydecode.rs b/src/comp/metadata/tydecode.rs index d67d04607539..4ba9ae3fadeb 100644 --- a/src/comp/metadata/tydecode.rs +++ b/src/comp/metadata/tydecode.rs @@ -8,8 +8,7 @@ import syntax::ast_util; import syntax::ast_util::respan; import middle::ty; -export parse_def_id; -export parse_ty_data; +export parse_ty_data, parse_def_id; export parse_bounds_data; // Compact string representation for ty::t values. API ty_str & @@ -17,7 +16,7 @@ export parse_bounds_data; // data buffer. Whatever format you choose should not contain pipe characters. // Callback to translate defs to strs or back: -type str_def = fn@(str) -> ast::def_id; +type conv_did = block(ast::def_id) -> ast::def_id; type pstate = {data: @[u8], crate: int, mutable pos: uint, tcx: ty::ctxt}; @@ -31,12 +30,12 @@ fn next(st: @pstate) -> u8 { ret ch; } -fn parse_ident(st: @pstate, sd: str_def, last: char) -> ast::ident { +fn parse_ident(st: @pstate, last: char) -> ast::ident { fn is_last(b: char, c: char) -> bool { ret c == b; } - ret parse_ident_(st, sd, bind is_last(last, _)); + ret parse_ident_(st, bind is_last(last, _)); } -fn parse_ident_(st: @pstate, _sd: str_def, is_last: fn@(char) -> bool) -> +fn parse_ident_(st: @pstate, is_last: fn@(char) -> bool) -> ast::ident { let rslt = ""; while !is_last(peek(st) as char) { @@ -46,28 +45,26 @@ fn parse_ident_(st: @pstate, _sd: str_def, is_last: fn@(char) -> bool) -> } -fn parse_ty_data(data: @[u8], crate_num: int, pos: uint, sd: str_def, - tcx: ty::ctxt) -> ty::t { +fn parse_ty_data(data: @[u8], crate_num: int, pos: uint, tcx: ty::ctxt, + conv: conv_did) -> ty::t { let st = @{data: data, crate: crate_num, mutable pos: pos, tcx: tcx}; - parse_ty(st, sd) + parse_ty(st, conv) } -fn parse_ret_ty(st: @pstate, sd: str_def) -> (ast::ret_style, ty::t) { +fn parse_ret_ty(st: @pstate, conv: conv_did) -> (ast::ret_style, ty::t) { alt peek(st) as char { '!' { next(st); (ast::noreturn, ty::mk_bot(st.tcx)) } - _ { (ast::return_val, parse_ty(st, sd)) } + _ { (ast::return_val, parse_ty(st, conv)) } } } -fn parse_constrs(st: @pstate, sd: str_def) -> [@ty::constr] { +fn parse_constrs(st: @pstate, conv: conv_did) -> [@ty::constr] { let rslt: [@ty::constr] = []; alt peek(st) as char { ':' { do { next(st); - let one: @ty::constr = - parse_constr::(st, sd, parse_constr_arg); - rslt += [one]; + rslt += [parse_constr(st, conv, parse_constr_arg)]; } while peek(st) as char == ';' } _ { } @@ -76,15 +73,13 @@ fn parse_constrs(st: @pstate, sd: str_def) -> [@ty::constr] { } // FIXME less copy-and-paste -fn parse_ty_constrs(st: @pstate, sd: str_def) -> [@ty::type_constr] { +fn parse_ty_constrs(st: @pstate, conv: conv_did) -> [@ty::type_constr] { let rslt: [@ty::type_constr] = []; alt peek(st) as char { ':' { do { next(st); - let one: @ty::type_constr = - parse_constr::<@path>(st, sd, parse_ty_constr_arg); - rslt += [one]; + rslt += [parse_constr(st, conv, parse_ty_constr_arg)]; } while peek(st) as char == ';' } _ { } @@ -92,10 +87,10 @@ fn parse_ty_constrs(st: @pstate, sd: str_def) -> [@ty::type_constr] { ret rslt; } -fn parse_path(st: @pstate, sd: str_def) -> @ast::path { +fn parse_path(st: @pstate) -> @ast::path { let idents: [ast::ident] = []; fn is_last(c: char) -> bool { ret c == '(' || c == ':'; } - idents += [parse_ident_(st, sd, is_last)]; + idents += [parse_ident_(st, is_last)]; while true { alt peek(st) as char { ':' { next(st); next(st); } @@ -103,16 +98,14 @@ fn parse_path(st: @pstate, sd: str_def) -> @ast::path { if c == '(' { ret @respan(ast_util::dummy_sp(), {global: false, idents: idents, types: []}); - } else { idents += [parse_ident_(st, sd, is_last)]; } + } else { idents += [parse_ident_(st, is_last)]; } } } } fail "parse_path: ill-formed path"; } -type arg_parser = fn(@pstate, str_def) -> ast::constr_arg_general_; - -fn parse_constr_arg(st: @pstate, _sd: str_def) -> ast::fn_constr_arg { +fn parse_constr_arg(st: @pstate) -> ast::fn_constr_arg { alt peek(st) as char { '*' { st.pos += 1u; ret ast::carg_base; } c { @@ -129,7 +122,7 @@ fn parse_constr_arg(st: @pstate, _sd: str_def) -> ast::fn_constr_arg { } /* else { - auto lit = parse_lit(st, sd, ','); + auto lit = parse_lit(st, conv, ','); args += [respan(st.span, ast::carg_lit(lit))]; } */ @@ -137,25 +130,25 @@ fn parse_constr_arg(st: @pstate, _sd: str_def) -> ast::fn_constr_arg { } } -fn parse_ty_constr_arg(st: @pstate, sd: str_def) -> - ast::constr_arg_general_<@path> { +fn parse_ty_constr_arg(st: @pstate) -> ast::constr_arg_general_<@path> { alt peek(st) as char { '*' { st.pos += 1u; ret ast::carg_base; } - c { ret ast::carg_ident(parse_path(st, sd)); } + c { ret ast::carg_ident(parse_path(st)); } } } -fn parse_constr(st: @pstate, sd: str_def, pser: arg_parser) -> - @ty::constr_general { +fn parse_constr(st: @pstate, conv: conv_did, + pser: block(@pstate) -> ast::constr_arg_general_) + -> @ty::constr_general { let sp = ast_util::dummy_sp(); // FIXME: use a real span let args: [@sp_constr_arg] = []; - let pth = parse_path(st, sd); + let pth = parse_path(st); let ignore: char = next(st) as char; assert (ignore == '('); - let def = parse_def(st, sd); + let def = parse_def(st, conv); let an_arg: constr_arg_general_; do { - an_arg = pser(st, sd); + an_arg = pser(st); // FIXME use a real span args += [@respan(sp, an_arg)]; ignore = next(st) as char; @@ -164,11 +157,11 @@ fn parse_constr(st: @pstate, sd: str_def, pser: arg_parser) -> ret @respan(sp, {path: pth, args: args, id: def}); } -fn parse_ty_rust_fn(st: @pstate, sd: str_def, p: ast::proto) -> ty::t { - ret ty::mk_fn(st.tcx, {proto: p with parse_ty_fn(st, sd)}); +fn parse_ty_rust_fn(st: @pstate, conv: conv_did, p: ast::proto) -> ty::t { + ret ty::mk_fn(st.tcx, {proto: p with parse_ty_fn(st, conv)}); } -fn parse_ty(st: @pstate, sd: str_def) -> ty::t { +fn parse_ty(st: @pstate, conv: conv_did) -> ty::t { alt next(st) as char { 'n' { ret ty::mk_nil(st.tcx); } 'z' { ret ty::mk_bot(st.tcx); } @@ -194,28 +187,28 @@ fn parse_ty(st: @pstate, sd: str_def) -> ty::t { 'S' { ret ty::mk_str(st.tcx); } 't' { assert (next(st) as char == '['); - let def = parse_def(st, sd); + let def = parse_def(st, conv); let params: [ty::t] = []; - while peek(st) as char != ']' { params += [parse_ty(st, sd)]; } + while peek(st) as char != ']' { params += [parse_ty(st, conv)]; } st.pos = st.pos + 1u; ret ty::mk_tag(st.tcx, def, params); } 'x' { assert (next(st) as char == '['); - let def = parse_def(st, sd); + let def = parse_def(st, conv); let params: [ty::t] = []; - while peek(st) as char != ']' { params += [parse_ty(st, sd)]; } + while peek(st) as char != ']' { params += [parse_ty(st, conv)]; } st.pos = st.pos + 1u; ret ty::mk_iface(st.tcx, def, params); } 'p' { - let did = parse_def(st, sd); + let did = parse_def(st, conv); ret ty::mk_param(st.tcx, parse_int(st) as uint, did); } - '@' { ret ty::mk_box(st.tcx, parse_mt(st, sd)); } - '~' { ret ty::mk_uniq(st.tcx, parse_mt(st, sd)); } - '*' { ret ty::mk_ptr(st.tcx, parse_mt(st, sd)); } - 'I' { ret ty::mk_vec(st.tcx, parse_mt(st, sd)); } + '@' { ret ty::mk_box(st.tcx, parse_mt(st, conv)); } + '~' { ret ty::mk_uniq(st.tcx, parse_mt(st, conv)); } + '*' { ret ty::mk_ptr(st.tcx, parse_mt(st, conv)); } + 'I' { ret ty::mk_vec(st.tcx, parse_mt(st, conv)); } 'R' { assert (next(st) as char == '['); let fields: [ty::field] = []; @@ -225,7 +218,7 @@ fn parse_ty(st: @pstate, sd: str_def) -> ty::t { name += str::unsafe_from_byte(next(st)); } st.pos = st.pos + 1u; - fields += [{ident: name, mt: parse_mt(st, sd)}]; + fields += [{ident: name, mt: parse_mt(st, conv)}]; } st.pos = st.pos + 1u; ret ty::mk_rec(st.tcx, fields); @@ -233,24 +226,24 @@ fn parse_ty(st: @pstate, sd: str_def) -> ty::t { 'T' { assert (next(st) as char == '['); let params = []; - while peek(st) as char != ']' { params += [parse_ty(st, sd)]; } + while peek(st) as char != ']' { params += [parse_ty(st, conv)]; } st.pos = st.pos + 1u; ret ty::mk_tup(st.tcx, params); } 's' { - ret parse_ty_rust_fn(st, sd, ast::proto_send); + ret parse_ty_rust_fn(st, conv, ast::proto_send); } 'F' { - ret parse_ty_rust_fn(st, sd, ast::proto_shared(ast::sugar_normal)); + ret parse_ty_rust_fn(st, conv, ast::proto_shared(ast::sugar_normal)); } 'f' { - ret parse_ty_rust_fn(st, sd, ast::proto_bare); + ret parse_ty_rust_fn(st, conv, ast::proto_bare); } 'B' { - ret parse_ty_rust_fn(st, sd, ast::proto_block); + ret parse_ty_rust_fn(st, conv, ast::proto_block); } 'N' { - let func = parse_ty_fn(st, sd); + let func = parse_ty_fn(st, conv); ret ty::mk_native_fn(st.tcx, func.inputs, func.output); } 'O' { @@ -266,22 +259,22 @@ fn parse_ty(st: @pstate, sd: str_def) -> ty::t { name += str::unsafe_from_byte(next(st)); } methods += [{ident: name, tps: @[], - fty: {proto: proto with parse_ty_fn(st, sd)}}]; + fty: {proto: proto with parse_ty_fn(st, conv)}}]; } st.pos += 1u; ret ty::mk_obj(st.tcx, methods); } 'r' { assert (next(st) as char == '['); - let def = parse_def(st, sd); - let inner = parse_ty(st, sd); + let def = parse_def(st, conv); + let inner = parse_ty(st, conv); let params: [ty::t] = []; - while peek(st) as char != ']' { params += [parse_ty(st, sd)]; } + while peek(st) as char != ']' { params += [parse_ty(st, conv)]; } st.pos = st.pos + 1u; ret ty::mk_res(st.tcx, def, inner, params); } 'X' { ret ty::mk_var(st.tcx, parse_int(st)); } - 'E' { let def = parse_def(st, sd); ret ty::mk_native(st.tcx, def); } + 'E' { let def = parse_def(st, conv); ret ty::mk_native(st.tcx, def); } 'Y' { ret ty::mk_type(st.tcx); } 'y' { ret ty::mk_send_type(st.tcx); } 'C' { ret ty::mk_opaque_closure(st.tcx); } @@ -294,7 +287,7 @@ fn parse_ty(st: @pstate, sd: str_def) -> ty::t { some(tt) { ret tt; } none. { let ps = @{pos: pos with *st}; - let tt = parse_ty(ps, sd); + let tt = parse_ty(ps, conv); st.tcx.rcache.insert({cnum: st.crate, pos: pos, len: len}, tt); ret tt; } @@ -302,8 +295,8 @@ fn parse_ty(st: @pstate, sd: str_def) -> ty::t { } 'A' { assert (next(st) as char == '['); - let tt = parse_ty(st, sd); - let tcs = parse_ty_constrs(st, sd); + let tt = parse_ty(st, conv); + let tcs = parse_ty_constrs(st, conv); assert (next(st) as char == ']'); ret ty::mk_constr(st.tcx, tt, tcs); } @@ -311,21 +304,21 @@ fn parse_ty(st: @pstate, sd: str_def) -> ty::t { } } -fn parse_mt(st: @pstate, sd: str_def) -> ty::mt { +fn parse_mt(st: @pstate, conv: conv_did) -> ty::mt { let mut; alt peek(st) as char { 'm' { next(st); mut = ast::mut; } '?' { next(st); mut = ast::maybe_mut; } _ { mut = ast::imm; } } - ret {ty: parse_ty(st, sd), mut: mut}; + ret {ty: parse_ty(st, conv), mut: mut}; } -fn parse_def(st: @pstate, sd: str_def) -> ast::def_id { - let def = ""; - while peek(st) as char != '|' { def += str::unsafe_from_byte(next(st)); } +fn parse_def(st: @pstate, conv: conv_did) -> ast::def_id { + let def = []; + while peek(st) as char != '|' { def += [next(st)]; } st.pos = st.pos + 1u; - ret sd(def); + ret conv(parse_def_id(def)); } fn parse_int(st: @pstate) -> int { @@ -354,7 +347,7 @@ fn parse_hex(st: @pstate) -> uint { ret n; } -fn parse_ty_fn(st: @pstate, sd: str_def) -> ty::fn_ty { +fn parse_ty_fn(st: @pstate, conv: conv_did) -> ty::fn_ty { assert (next(st) as char == '['); let inputs: [ty::arg] = []; while peek(st) as char != ']' { @@ -366,11 +359,11 @@ fn parse_ty_fn(st: @pstate, sd: str_def) -> ty::fn_ty { '#' { ast::by_val } }; st.pos += 1u; - inputs += [{mode: mode, ty: parse_ty(st, sd)}]; + inputs += [{mode: mode, ty: parse_ty(st, conv)}]; } st.pos += 1u; // eat the ']' - let cs = parse_constrs(st, sd); - let (ret_style, ret_ty) = parse_ret_ty(st, sd); + let cs = parse_constrs(st, conv); + let (ret_style, ret_ty) = parse_ret_ty(st, conv); ret {proto: ast::proto_bare, inputs: inputs, output: ret_ty, ret_style: ret_style, constraints: cs}; } @@ -399,19 +392,19 @@ fn parse_def_id(buf: [u8]) -> ast::def_id { } fn parse_bounds_data(data: @[u8], start: uint, - crate_num: int, sd: str_def, tcx: ty::ctxt) + crate_num: int, tcx: ty::ctxt, conv: conv_did) -> @[ty::param_bound] { let st = @{data: data, crate: crate_num, mutable pos: start, tcx: tcx}; - parse_bounds(st, sd) + parse_bounds(st, conv) } -fn parse_bounds(st: @pstate, sd: str_def) -> @[ty::param_bound] { +fn parse_bounds(st: @pstate, conv: conv_did) -> @[ty::param_bound] { let bounds = []; while true { bounds += [alt next(st) as char { 'S' { ty::bound_send } 'C' { ty::bound_copy } - 'I' { ty::bound_iface(parse_ty(st, sd)) } + 'I' { ty::bound_iface(parse_ty(st, conv)) } '.' { break; } }]; }