From 917afa4cc9d323a888bb174f46c17610aeebfb2b Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Thu, 14 Jul 2011 17:26:10 -0700 Subject: [PATCH] rustc: Remove a bunch of exterior vectors --- src/comp/back/link.rs | 14 ++- src/comp/back/upcall.rs | 80 +++++++------- src/comp/driver/rustc.rs | 15 ++- src/comp/driver/session.rs | 5 +- src/comp/metadata/creader.rs | 9 +- src/comp/metadata/csearch.rs | 2 +- src/comp/metadata/cstore.rs | 34 +++--- src/comp/metadata/decoder.rs | 27 +++-- src/comp/metadata/tydecode.rs | 1 - src/comp/middle/alias.rs | 183 ++++++++++++++++---------------- src/comp/middle/resolve.rs | 6 +- src/comp/middle/typeck.rs | 2 +- src/comp/syntax/codemap.rs | 33 +++--- src/comp/syntax/parse/eval.rs | 5 +- src/comp/syntax/parse/lexer.rs | 24 ++--- src/comp/syntax/parse/parser.rs | 148 ++++++++++---------------- src/comp/syntax/print/pp.rs | 38 +++---- src/comp/syntax/print/pprust.rs | 7 +- 18 files changed, 302 insertions(+), 331 deletions(-) diff --git a/src/comp/back/link.rs b/src/comp/back/link.rs index 2586fb9ba92..aa0f71ff8e2 100644 --- a/src/comp/back/link.rs +++ b/src/comp/back/link.rs @@ -7,7 +7,7 @@ import middle::ty; import metadata::encoder; import std::str; import std::fs; -import std::vec; +import std::ivec; import std::option; import option::some; import option::none; @@ -360,10 +360,14 @@ fn build_link_meta(&session::session sess, &ast::crate c, case (some(?v)) { v } case (none) { auto name = { - auto os = str::split(fs::basename(output), '.' as u8); - assert (vec::len(os) >= 2u); - vec::pop(os); - str::connect(os, ".") + auto os_vec = str::split(fs::basename(output), '.' as u8); + // FIXME: Remove this vec->ivec conversion. + auto os = ~[]; + for (str s in os_vec) { os += ~[s]; } + + assert (ivec::len(os) >= 2u); + ivec::pop(os); + str::connect_ivec(os, ".") }; warn_missing(sess, "name", name); name diff --git a/src/comp/back/upcall.rs b/src/comp/back/upcall.rs index 6d95b25b95b..400ed3beab8 100644 --- a/src/comp/back/upcall.rs +++ b/src/comp/back/upcall.rs @@ -64,7 +64,7 @@ fn declare_upcalls(type_names tn, TypeRef tydesc_type, TypeRef taskptr_type, ModuleRef llmod) -> @upcalls { fn decl(type_names tn, TypeRef tydesc_type, TypeRef taskptr_type, - ModuleRef llmod, str name, vec[TypeRef] tys, + ModuleRef llmod, str name, TypeRef[] tys, TypeRef rv) -> ValueRef { let TypeRef[] arg_tys = ~[taskptr_type]; for (TypeRef t in tys) { arg_tys += ~[t]; } @@ -76,62 +76,62 @@ fn declare_upcalls(type_names tn, TypeRef tydesc_type, TypeRef taskptr_type, // FIXME: Sigh:.. remove this when I fix the typechecker pushdown. // --pcwalton - let vec[TypeRef] empty_vec = []; - ret @rec(grow_task=dv("grow_task", [T_size_t()]), - log_int=dv("log_int", [T_i32(), T_i32()]), - log_float=dv("log_float", [T_i32(), T_f32()]), - log_double=dv("log_double", [T_i32(), T_ptr(T_f64())]), - log_str=dv("log_str", [T_i32(), T_ptr(T_str())]), - trace_word=dv("trace_word", [T_int()]), - trace_str=dv("trace_str", [T_ptr(T_i8())]), - new_port=d("new_port", [T_size_t()], T_opaque_port_ptr()), - del_port=dv("del_port", [T_opaque_port_ptr()]), - new_chan=d("new_chan", [T_opaque_port_ptr()], + let TypeRef[] empty_vec = ~[]; + ret @rec(grow_task=dv("grow_task", ~[T_size_t()]), + log_int=dv("log_int", ~[T_i32(), T_i32()]), + log_float=dv("log_float", ~[T_i32(), T_f32()]), + log_double=dv("log_double", ~[T_i32(), T_ptr(T_f64())]), + log_str=dv("log_str", ~[T_i32(), T_ptr(T_str())]), + trace_word=dv("trace_word", ~[T_int()]), + trace_str=dv("trace_str", ~[T_ptr(T_i8())]), + new_port=d("new_port", ~[T_size_t()], T_opaque_port_ptr()), + del_port=dv("del_port", ~[T_opaque_port_ptr()]), + new_chan=d("new_chan", ~[T_opaque_port_ptr()], T_opaque_chan_ptr()), - flush_chan=dv("flush_chan", [T_opaque_chan_ptr()]), - del_chan=dv("del_chan", [T_opaque_chan_ptr()]), - clone_chan=d("clone_chan", [taskptr_type, T_opaque_chan_ptr()], + flush_chan=dv("flush_chan", ~[T_opaque_chan_ptr()]), + del_chan=dv("del_chan", ~[T_opaque_chan_ptr()]), + clone_chan=d("clone_chan", ~[taskptr_type, T_opaque_chan_ptr()], T_opaque_chan_ptr()), _yield=dv("yield", empty_vec), - sleep=dv("sleep", [T_size_t()]), - send=dv("send", [T_opaque_chan_ptr(), T_ptr(T_i8())]), - recv=dv("recv", [T_ptr(T_ptr(T_i8())), T_opaque_port_ptr()]), - _fail=dv("fail", [T_ptr(T_i8()), T_ptr(T_i8()), T_size_t()]), - kill=dv("kill", [taskptr_type]), + sleep=dv("sleep", ~[T_size_t()]), + send=dv("send", ~[T_opaque_chan_ptr(), T_ptr(T_i8())]), + recv=dv("recv", ~[T_ptr(T_ptr(T_i8())), T_opaque_port_ptr()]), + _fail=dv("fail", ~[T_ptr(T_i8()), T_ptr(T_i8()), T_size_t()]), + kill=dv("kill", ~[taskptr_type]), exit=dv("exit", empty_vec), - malloc=d("malloc", [T_size_t(), T_ptr(tydesc_type)], + malloc=d("malloc", ~[T_size_t(), T_ptr(tydesc_type)], T_ptr(T_i8())), - free=dv("free", [T_ptr(T_i8()), T_int()]), + free=dv("free", ~[T_ptr(T_i8()), T_int()]), shared_malloc=d("shared_malloc", - [T_size_t(), T_ptr(tydesc_type)], T_ptr(T_i8())), - shared_free=dv("shared_free", [T_ptr(T_i8())]), - mark=d("mark", [T_ptr(T_i8())], T_int()), - new_str=d("new_str", [T_ptr(T_i8()), T_size_t()], + ~[T_size_t(), T_ptr(tydesc_type)], T_ptr(T_i8())), + shared_free=dv("shared_free", ~[T_ptr(T_i8())]), + mark=d("mark", ~[T_ptr(T_i8())], T_int()), + new_str=d("new_str", ~[T_ptr(T_i8()), T_size_t()], T_ptr(T_str())), - dup_str=d("dup_str", [taskptr_type, T_ptr(T_str())], + dup_str=d("dup_str", ~[taskptr_type, T_ptr(T_str())], T_ptr(T_str())), - new_vec=d("new_vec", [T_size_t(), T_ptr(tydesc_type)], + new_vec=d("new_vec", ~[T_size_t(), T_ptr(tydesc_type)], T_opaque_vec_ptr()), vec_append=d("vec_append", - [T_ptr(tydesc_type), T_ptr(tydesc_type), - T_ptr(T_opaque_vec_ptr()), T_opaque_vec_ptr(), - T_bool()], T_void()), + ~[T_ptr(tydesc_type), T_ptr(tydesc_type), + T_ptr(T_opaque_vec_ptr()), T_opaque_vec_ptr(), + T_bool()], T_void()), get_type_desc=d("get_type_desc", - [T_ptr(T_nil()), T_size_t(), T_size_t(), - T_size_t(), T_ptr(T_ptr(tydesc_type))], + ~[T_ptr(T_nil()), T_size_t(), T_size_t(), + T_size_t(), T_ptr(T_ptr(tydesc_type))], T_ptr(tydesc_type)), - new_task=d("new_task", [T_ptr(T_str())], taskptr_type), + new_task=d("new_task", ~[T_ptr(T_str())], taskptr_type), start_task=d("start_task", - [taskptr_type, T_int(), T_int(), T_size_t()], - taskptr_type), - ivec_resize=d("ivec_resize", [T_ptr(T_opaque_ivec()), T_int()], + ~[taskptr_type, T_int(), T_int(), T_size_t()], + taskptr_type), + ivec_resize=d("ivec_resize", ~[T_ptr(T_opaque_ivec()), T_int()], T_void()), - ivec_spill=d("ivec_spill", [T_ptr(T_opaque_ivec()), T_int()], + ivec_spill=d("ivec_spill", ~[T_ptr(T_opaque_ivec()), T_int()], T_void()), ivec_resize_shared=d("ivec_resize_shared", - [T_ptr(T_opaque_ivec()), T_int()], T_void()), + ~[T_ptr(T_opaque_ivec()), T_int()], T_void()), ivec_spill_shared=d("ivec_spill_shared", - [T_ptr(T_opaque_ivec()), T_int()], T_void())); + ~[T_ptr(T_opaque_ivec()), T_int()], T_void())); } // // Local Variables: diff --git a/src/comp/driver/rustc.rs b/src/comp/driver/rustc.rs index abf7e99a57d..83e775c847d 100644 --- a/src/comp/driver/rustc.rs +++ b/src/comp/driver/rustc.rs @@ -301,8 +301,12 @@ fn build_session_options(str binary, getopts::match match, str binary_dir) -> @session::options { auto library = opt_present(match, "lib"); auto static = opt_present(match, "static"); - auto library_search_paths = [binary_dir + "/lib"]; - library_search_paths += getopts::opt_strs(match, "L"); + + auto library_search_paths = ~[binary_dir + "/lib"]; + // FIXME: Remove this vec->ivec conversion. + auto lsp_vec = getopts::opt_strs(match, "L"); + for (str lsp in lsp_vec) { library_search_paths += ~[lsp]; } + auto output_type = if (opt_present(match, "parse-only")) { link::output_type_none @@ -398,7 +402,7 @@ fn opts() -> vec[getopts::opt] { } fn main(vec[str] args) { - auto binary = vec::shift[str](args); + auto binary = vec::shift(args); auto binary_dir = fs::dirname(binary); auto match = alt (getopts::getopts(args, opts())) { @@ -554,7 +558,10 @@ fn main(vec[str] args) { gcc_args += ["-l" + libarg]; } - gcc_args += cstore::get_used_link_args(cstore); + // FIXME: Remove this ivec->vec conversion. + auto ula = cstore::get_used_link_args(cstore); + for (str arg in ula) { gcc_args += [arg]; } + auto used_libs = cstore::get_used_libraries(cstore); for (str l in used_libs) { gcc_args += ["-l" + l]; diff --git a/src/comp/driver/session.rs b/src/comp/driver/session.rs index 1689d35c4ad..f07fbc6f859 100644 --- a/src/comp/driver/session.rs +++ b/src/comp/driver/session.rs @@ -10,7 +10,6 @@ import std::option; import std::option::some; import std::option::none; import std::str; -import std::vec; import syntax::parse::parser::parse_sess; tag os { os_win32; os_macos; os_linux; } @@ -36,14 +35,14 @@ type options = bool time_passes, bool time_llvm_passes, back::link::output_type output_type, - vec[str] library_search_paths, + str[] library_search_paths, str sysroot, // The crate config requested for the session, which may be combined // with additional crate configurations during the compile process ast::crate_cfg cfg, bool test); -type crate_metadata = rec(str name, vec[u8] data); +type crate_metadata = rec(str name, u8[] data); obj session(@config targ_cfg, @options opts, diff --git a/src/comp/metadata/creader.rs b/src/comp/metadata/creader.rs index 9e5ae8ff27b..33b160c5c1f 100644 --- a/src/comp/metadata/creader.rs +++ b/src/comp/metadata/creader.rs @@ -14,7 +14,6 @@ import back::x86; import util::common; import std::ivec; import std::str; -import std::vec; import std::fs; import std::ioivec; import std::option; @@ -47,7 +46,7 @@ fn read_crates(session::session sess, type env = @rec(session::session sess, @hashmap[str, int] crate_cache, - vec[str] library_search_paths, + str[] library_search_paths, mutable ast::crate_num next_crate_num); fn visit_view_item(env e, &@ast::view_item i) { @@ -128,7 +127,7 @@ fn default_native_lib_naming(session::session sess, bool static) -> fn find_library_crate(&session::session sess, &ast::ident ident, &(@ast::meta_item)[] metas, - &vec[str] library_search_paths) + &str[] library_search_paths) -> option::t[tup(str, @u8[])] { attr::require_unique_names(sess, metas); @@ -162,7 +161,7 @@ fn find_library_crate(&session::session sess, &ast::ident ident, fn find_library_crate_aux(&rec(str prefix, str suffix) nn, str crate_name, &(@ast::meta_item)[] metas, - &vec[str] library_search_paths) -> + &str[] library_search_paths) -> option::t[tup(str, @u8[])] { let str prefix = nn.prefix + crate_name; // FIXME: we could probably use a 'glob' function in std::fs but it will @@ -220,7 +219,7 @@ fn get_metadata_section(str filename) -> option::t[@u8[]] { fn load_library_crate(&session::session sess, span span, &ast::ident ident, &(@ast::meta_item)[] metas, - &vec[str] library_search_paths) -> tup(str, @u8[]) { + &str[] library_search_paths) -> tup(str, @u8[]) { alt (find_library_crate(sess, ident, metas, library_search_paths)) { case (some(?t)) { diff --git a/src/comp/metadata/csearch.rs b/src/comp/metadata/csearch.rs index f051f164130..f2f24b9b71f 100644 --- a/src/comp/metadata/csearch.rs +++ b/src/comp/metadata/csearch.rs @@ -26,7 +26,7 @@ fn get_type_param_count(&cstore::cstore cstore, &ast::def_id def) -> uint { } fn lookup_defs(&cstore::cstore cstore, ast::crate_num cnum, - vec[ast::ident] path) -> vec[ast::def] { + &ast::ident[] path) -> ast::def[] { auto cdata = cstore::get_crate_data(cstore, cnum).data; ret decoder::lookup_defs(cdata, cnum, path); } diff --git a/src/comp/metadata/cstore.rs b/src/comp/metadata/cstore.rs index 9c743125a01..7f150c088b1 100644 --- a/src/comp/metadata/cstore.rs +++ b/src/comp/metadata/cstore.rs @@ -1,8 +1,8 @@ // The crate store - a central repo for information collected about external // crates and libraries +import std::ivec; import std::map; -import std::vec; import std::str; import syntax::ast; @@ -42,9 +42,9 @@ tag cstore { type cstore_private = @rec(map::hashmap[ast::crate_num, crate_metadata] metas, use_crate_map use_crate_map, - mutable vec[str] used_crate_files, - mutable vec[str] used_libraries, - mutable vec[str] used_link_args); + mutable str[] used_crate_files, + mutable str[] used_libraries, + mutable str[] used_link_args); // Map from node_id's of local use statements to crate numbers type use_crate_map = map::hashmap[ast::node_id, ast::crate_num]; @@ -61,9 +61,9 @@ fn mk_cstore() -> cstore { auto crate_map = map::new_int_hash[ast::crate_num](); ret private(@rec(metas = meta_cache, use_crate_map = crate_map, - mutable used_crate_files = [], - mutable used_libraries = [], - mutable used_link_args = [])); + mutable used_crate_files = ~[], + mutable used_libraries = ~[], + mutable used_link_args = ~[])); } fn get_crate_data(&cstore cstore, ast::crate_num cnum) -> crate_metadata { @@ -86,35 +86,39 @@ iter iter_crate_data(&cstore cstore) -> @tup(ast::crate_num, crate_metadata) { } fn add_used_crate_file(&cstore cstore, &str lib) { - if (!vec::member(lib, p(cstore).used_crate_files)) { - p(cstore).used_crate_files += [lib]; + if (!ivec::member(lib, p(cstore).used_crate_files)) { + p(cstore).used_crate_files += ~[lib]; } } -fn get_used_crate_files(&cstore cstore) -> vec[str] { +fn get_used_crate_files(&cstore cstore) -> str[] { ret p(cstore).used_crate_files; } fn add_used_library(&cstore cstore, &str lib) -> bool { if (lib == "") { ret false; } - if (vec::member(lib, p(cstore).used_libraries)) { + if (ivec::member(lib, p(cstore).used_libraries)) { ret false; } - p(cstore).used_libraries += [lib]; + p(cstore).used_libraries += ~[lib]; ret true; } -fn get_used_libraries(&cstore cstore) -> vec[str] { +fn get_used_libraries(&cstore cstore) -> str[] { ret p(cstore).used_libraries; } fn add_used_link_args(&cstore cstore, &str args) { - p(cstore).used_link_args += str::split(args, ' ' as u8); + auto used_link_args_vec = str::split(args, ' ' as u8); + // TODO: Remove this vec->ivec conversion. + for (str ula in used_link_args_vec) { + p(cstore).used_link_args += ~[ula]; + } } -fn get_used_link_args(&cstore cstore) -> vec[str] { +fn get_used_link_args(&cstore cstore) -> str[] { ret p(cstore).used_link_args; } diff --git a/src/comp/metadata/decoder.rs b/src/comp/metadata/decoder.rs index 4dc8f0dfdc4..14c69503175 100644 --- a/src/comp/metadata/decoder.rs +++ b/src/comp/metadata/decoder.rs @@ -3,7 +3,6 @@ import std::ebmlivec; import std::ivec; import std::option; -import std::vec; import std::str; import std::ioivec; import std::map::hashmap; @@ -125,38 +124,38 @@ fn item_ty_param_count(&ebmlivec::doc item) -> uint { } fn tag_variant_ids(&ebmlivec::doc item, - ast::crate_num this_cnum) -> vec[ast::def_id] { - let vec[ast::def_id] ids = []; + ast::crate_num this_cnum) -> ast::def_id[] { + let ast::def_id[] ids = ~[]; auto v = tag_items_data_item_variant; for each (ebmlivec::doc p in ebmlivec::tagged_docs(item, v)) { auto ext = parse_def_id(ebmlivec::doc_data(p)); - vec::push[ast::def_id](ids, tup(this_cnum, ext._1)); + ids += ~[tup(this_cnum, ext._1)]; } ret ids; } // Given a path and serialized crate metadata, returns the ID of the // definition the path refers to. -fn resolve_path(vec[ast::ident] path, @u8[] data) -> vec[ast::def_id] { +fn resolve_path(&ast::ident[] path, @u8[] data) -> ast::def_id[] { fn eq_item(&u8[] data, str s) -> bool { ret str::eq(str::unsafe_from_bytes_ivec(data), s); } - auto s = str::connect(path, "::"); + auto s = str::connect_ivec(path, "::"); auto md = ebmlivec::new_doc(data); auto paths = ebmlivec::get_doc(md, tag_paths); auto eqer = bind eq_item(_, s); - let vec[ast::def_id] result = []; + let ast::def_id[] result = ~[]; for (ebmlivec::doc doc in lookup_hash(paths, eqer, hash_path(s))) { auto did_doc = ebmlivec::get_doc(doc, tag_def_id); - vec::push(result, parse_def_id(ebmlivec::doc_data(did_doc))); + result += ~[parse_def_id(ebmlivec::doc_data(did_doc))]; } ret result; } // Crate metadata queries -fn lookup_defs(&@u8[] data, ast::crate_num cnum, - vec[ast::ident] path) -> vec[ast::def] { - ret vec::map(bind lookup_def(cnum, data, _), resolve_path(path, data)); +fn lookup_defs(&@u8[] data, ast::crate_num cnum, &ast::ident[] path) + -> ast::def[] { + ret ivec::map(bind lookup_def(cnum, data, _), resolve_path(path, data)); } @@ -352,8 +351,8 @@ fn get_crate_attributes(@u8[] data) -> ast::attribute[] { type crate_dep = tup(ast::crate_num, str); -fn get_crate_deps(@u8[] data) -> vec[crate_dep] { - let vec[crate_dep] deps = []; +fn get_crate_deps(@u8[] data) -> crate_dep[] { + let crate_dep[] deps = ~[]; auto cratedoc = ebmlivec::new_doc(data); auto depsdoc = ebmlivec::get_doc(cratedoc, tag_crate_deps); auto crate_num = 1; @@ -361,7 +360,7 @@ fn get_crate_deps(@u8[] data) -> vec[crate_dep] { ebmlivec::tagged_docs(depsdoc, tag_crate_dep)) { auto depname = str::unsafe_from_bytes_ivec(ebmlivec::doc_data(depdoc)); - deps += [tup(crate_num, depname)]; + deps += ~[tup(crate_num, depname)]; crate_num += 1; } ret deps; diff --git a/src/comp/metadata/tydecode.rs b/src/comp/metadata/tydecode.rs index 1c249475868..b4d96d17a3e 100644 --- a/src/comp/metadata/tydecode.rs +++ b/src/comp/metadata/tydecode.rs @@ -2,7 +2,6 @@ import std::ivec; import std::str; -import std::vec; import std::uint; import std::option; import std::option::none; diff --git a/src/comp/middle/alias.rs b/src/comp/middle/alias.rs index e5b42c7f907..5581640251d 100644 --- a/src/comp/middle/alias.rs +++ b/src/comp/middle/alias.rs @@ -7,7 +7,7 @@ import ast::def_id; import syntax::codemap::span; import syntax::visit; import visit::vt; -import std::vec; +import std::ivec; import std::str; import std::option; import std::option::some; @@ -25,14 +25,14 @@ import std::option::is_none; tag valid { valid; overwritten(span, ast::path); val_taken(span, ast::path); } type restrict = - @rec(vec[node_id] root_vars, + @rec(node_id[] root_vars, node_id block_defnum, - vec[node_id] bindings, - vec[ty::t] tys, - vec[uint] depends_on, + node_id[] bindings, + ty::t[] tys, + uint[] depends_on, mutable valid ok); -type scope = vec[restrict]; +type scope = @restrict[]; tag local_info { arg(ast::mode); objfield(ast::mutability); } @@ -50,7 +50,7 @@ fn check_crate(@ty::ctxt tcx, &@ast::crate crate) { visit_expr=bind visit_expr(cx, _, _, _), visit_decl=bind visit_decl(cx, _, _, _) with *visit::default_visitor[scope]()); - visit::visit_crate(*crate, [], visit::mk_vt(v)); + visit::visit_crate(*crate, @~[], visit::mk_vt(v)); tcx.sess.abort_if_errors(); } @@ -60,7 +60,7 @@ fn visit_fn(&@ctx cx, &ast::_fn f, &ast::ty_param[] tp, &span sp, for (ast::arg arg_ in f.decl.inputs) { cx.local_map.insert(arg_.id, arg(arg_.mode)); } - v.visit_block(f.body, [], v); + v.visit_block(f.body, @~[], v); } fn visit_item(&@ctx cx, &@ast::item i, &scope sc, &vt[scope] v) { @@ -148,13 +148,13 @@ fn visit_decl(&@ctx cx, &@ast::decl d, &scope sc, &vt[scope] v) { } fn check_call(&ctx cx, &@ast::expr f, &(@ast::expr)[] args, &scope sc) -> - rec(vec[node_id] root_vars, vec[ty::t] unsafe_ts) { + rec(node_id[] root_vars, ty::t[] unsafe_ts) { auto fty = ty::expr_ty(*cx.tcx, f); auto arg_ts = fty_args(cx, fty); - let vec[node_id] roots = []; - let vec[tup(uint, node_id)] mut_roots = []; - let vec[ty::t] unsafe_ts = []; - let vec[uint] unsafe_t_offsets = []; + let node_id[] roots = ~[]; + let tup(uint, node_id)[] mut_roots = ~[]; + let ty::t[] unsafe_ts = ~[]; + let uint[] unsafe_t_offsets = ~[]; auto i = 0u; for (ty::arg arg_t in arg_ts) { if (arg_t.mode != ty::mo_val) { @@ -162,34 +162,31 @@ fn check_call(&ctx cx, &@ast::expr f, &(@ast::expr)[] args, &scope sc) -> auto root = expr_root(cx, arg, false); if (arg_t.mode == ty::mo_alias(true)) { alt (path_def_id(cx, arg)) { - case (some(?did)) { - vec::push(mut_roots, tup(i, did._1)); - } - case (_) { - if (!mut_field(root.ds)) { - auto m = - "passing a temporary value or \ + some(?did) { mut_roots += ~[tup(i, did._1)]; } + _ { + if (!mut_field(root.ds)) { + auto m = "passing a temporary value or \ immutable field by mutable alias"; - cx.tcx.sess.span_err(arg.span, m); - } + cx.tcx.sess.span_err(arg.span, m); } + } } } alt (path_def_id(cx, root.ex)) { - case (some(?did)) { vec::push(roots, did._1); } - case (_) { } + some(?did) { roots += ~[did._1]; } + _ { } } alt (inner_mut(root.ds)) { - case (some(?t)) { - vec::push(unsafe_ts, t); - vec::push(unsafe_t_offsets, i); - } - case (_) { } + some(?t) { + unsafe_ts += ~[t]; + unsafe_t_offsets += ~[i]; + } + _ { } } } i += 1u; } - if (vec::len(unsafe_ts) > 0u) { + if (ivec::len(unsafe_ts) > 0u) { alt (f.node) { case (ast::expr_path(_)) { if (def_is_local(cx.tcx.def_map.get(f.id), true)) { @@ -223,12 +220,18 @@ fn check_call(&ctx cx, &@ast::expr f, &(@ast::expr)[] args, &scope sc) -> // Ensure we're not passing a root by mutable alias. for (tup(uint, node_id) root in mut_roots) { - auto mut_alias_to_root = vec::count(root._1, roots) > 1u; - for (restrict r in sc) { - if (vec::member(root._1, r.root_vars)) { - mut_alias_to_root = true; + auto mut_alias_to_root = false; + auto mut_alias_to_root_count = 0u; + for (node_id r in roots) { + if root._1 == r { + mut_alias_to_root_count += 1u; + if mut_alias_to_root_count > 1u { + mut_alias_to_root = true; + break; + } } } + if (mut_alias_to_root) { cx.tcx.sess.span_err(args.(root._0).span, "passing a mutable alias to a \ @@ -281,31 +284,31 @@ fn check_alt(&ctx cx, &@ast::expr input, &ast::arm[] arms, &scope sc, visit::visit_expr(input, sc, v); auto root = expr_root(cx, input, true); auto roots = alt (path_def_id(cx, root.ex)) { - some(?did) { [did._1] } - _ { [] } + some(?did) { ~[did._1] } + _ { ~[] } }; - let vec[ty::t] forbidden_tp = - alt (inner_mut(root.ds)) { some(?t) { [t] } _ { [] } }; + let ty::t[] forbidden_tp = + alt (inner_mut(root.ds)) { some(?t) { ~[t] } _ { ~[] } }; for (ast::arm a in arms) { auto dnums = arm_defnums(a); auto new_sc = sc; - if (vec::len(dnums) > 0u) { - new_sc = sc + [@rec(root_vars=roots, - block_defnum=dnums.(0), - bindings=dnums, - tys=forbidden_tp, - depends_on=deps(sc, roots), - mutable ok=valid)]; + if (ivec::len(dnums) > 0u) { + new_sc = @(*sc + ~[@rec(root_vars=roots, + block_defnum=dnums.(0), + bindings=dnums, + tys=forbidden_tp, + depends_on=deps(sc, roots), + mutable ok=valid)]); } visit::visit_arm(a, new_sc, v); } } -fn arm_defnums(&ast::arm arm) -> vec[node_id] { - auto dnums = []; - fn walk_pat(&mutable vec[node_id] found, &@ast::pat p) { +fn arm_defnums(&ast::arm arm) -> node_id[] { + auto dnums = ~[]; + fn walk_pat(&mutable node_id[] found, &@ast::pat p) { alt (p.node) { - case (ast::pat_bind(_)) { vec::push(found, p.id); } + case (ast::pat_bind(_)) { found += ~[p.id]; } case (ast::pat_tag(_, ?children)) { for (@ast::pat child in children) { walk_pat(found, child); } } @@ -330,11 +333,11 @@ fn check_for_each(&ctx cx, &@ast::local local, &@ast::expr call, auto new_sc = @rec(root_vars=data.root_vars, block_defnum=defnum, - bindings=[defnum], + bindings=~[defnum], tys=data.unsafe_ts, depends_on=deps(sc, data.root_vars), mutable ok=valid); - visit::visit_block(block, sc + [new_sc], v); + visit::visit_block(block, @(*sc + ~[new_sc]), v); } } } @@ -345,16 +348,16 @@ fn check_for(&ctx cx, &@ast::local local, &@ast::expr seq, &ast::block block, auto defnum = local.node.id; auto root = expr_root(cx, seq, false); auto root_def = alt (path_def_id(cx, root.ex)) { - some(?did) { [did._1] } - _ { [] } + some(?did) { ~[did._1] } + _ { ~[] } }; - auto unsafe = alt (inner_mut(root.ds)) { some(?t) { [t] } _ { [] } }; + auto unsafe = alt (inner_mut(root.ds)) { some(?t) { ~[t] } _ { ~[] } }; // If this is a mutable vector, don't allow it to be touched. auto seq_t = ty::expr_ty(*cx.tcx, seq); alt (ty::struct(*cx.tcx, seq_t)) { ty::ty_vec(?mt) | ty::ty_ivec(?mt) { - if (mt.mut != ast::imm) { unsafe = [seq_t]; } + if (mt.mut != ast::imm) { unsafe = ~[seq_t]; } } ty::ty_str | ty::ty_istr { /* no-op */ } _ { @@ -365,11 +368,11 @@ fn check_for(&ctx cx, &@ast::local local, &@ast::expr seq, &ast::block block, auto new_sc = @rec(root_vars=root_def, block_defnum=defnum, - bindings=[defnum], + bindings=~[defnum], tys=unsafe, depends_on=deps(sc, root_def), mutable ok=valid); - visit::visit_block(block, sc + [new_sc], v); + visit::visit_block(block, @(*sc + ~[new_sc]), v); } fn check_var(&ctx cx, &@ast::expr ex, &ast::path p, ast::node_id id, @@ -378,7 +381,7 @@ fn check_var(&ctx cx, &@ast::expr ex, &ast::path p, ast::node_id id, if (!def_is_local(def, true)) { ret; } auto my_defnum = ast::def_id_of_def(def)._1; auto var_t = ty::expr_ty(*cx.tcx, ex); - for (restrict r in sc) { + for (restrict r in *sc) { // excludes variables introduced since the alias was made if (my_defnum < r.block_defnum) { for (ty::t t in r.tys) { @@ -386,7 +389,7 @@ fn check_var(&ctx cx, &@ast::expr ex, &ast::path p, ast::node_id id, r.ok = val_taken(ex.span, p); } } - } else if (vec::member(my_defnum, r.bindings)) { + } else if (ivec::member(my_defnum, r.bindings)) { test_scope(cx, sc, r, p); } } @@ -403,15 +406,15 @@ fn check_lval(&@ctx cx, &@ast::expr dest, &scope sc, &vt[scope] v) { cx.tcx.sess.span_err(dest.span, "assigning to immutable obj field"); } - for (restrict r in sc) { - if (vec::member(dnum, r.root_vars)) { + for (restrict r in *sc) { + if (ivec::member(dnum, r.root_vars)) { r.ok = overwritten(dest.span, p); } } } case (_) { auto root = expr_root(*cx, dest, false); - if (vec::len(root.ds) == 0u) { + if (ivec::len(*root.ds) == 0u) { cx.tcx.sess.span_err(dest.span, "assignment to non-lvalue"); } else if (!root.ds.(0).mut) { auto name = @@ -443,7 +446,7 @@ fn check_move_rhs(&@ctx cx, &@ast::expr src, &scope sc, &vt[scope] v) { case (_) { auto root = expr_root(*cx, src, false); // Not a path and no-derefs means this is a temporary. - if (vec::len(root.ds) != 0u) { + if (ivec::len(*root.ds) != 0u) { cx.tcx.sess.span_err (src.span, "moving out of a data structure"); } @@ -463,8 +466,8 @@ fn is_immutable_alias(&@ctx cx, &scope sc, node_id dnum) -> bool { case (some(arg(ast::alias(false)))) { ret true; } case (_) { } } - for (restrict r in sc) { - if (vec::member(dnum, r.bindings)) { ret true; } + for (restrict r in *sc) { + if (ivec::member(dnum, r.bindings)) { ret true; } } ret false; } @@ -495,12 +498,12 @@ fn test_scope(&ctx cx, &scope sc, &restrict r, &ast::path p) { } } -fn deps(&scope sc, vec[node_id] roots) -> vec[uint] { +fn deps(&scope sc, &node_id[] roots) -> uint[] { auto i = 0u; - auto result = []; - for (restrict r in sc) { + auto result = ~[]; + for (restrict r in *sc) { for (node_id dn in roots) { - if (vec::member(dn, r.bindings)) { vec::push(result, i); } + if ivec::member(dn, r.bindings) { result += ~[i]; } } i += 1u; } @@ -509,7 +512,7 @@ fn deps(&scope sc, vec[node_id] roots) -> vec[uint] { tag deref_t { unbox; field; index; } -type deref = rec(bool mut, deref_t kind, ty::t outer_t); +type deref = @rec(bool mut, deref_t kind, ty::t outer_t); // Finds the root (the thing that is dereferenced) for the given expr, and a @@ -517,23 +520,23 @@ type deref = rec(bool mut, deref_t kind, ty::t outer_t); // the inner derefs come in front, so foo.bar.baz becomes rec(ex=foo, // ds=[field(baz),field(bar)]) fn expr_root(&ctx cx, @ast::expr ex, bool autoderef) -> - rec(@ast::expr ex, vec[deref] ds) { + rec(@ast::expr ex, @deref[] ds) { fn maybe_auto_unbox(&ctx cx, &ty::t t) -> rec(ty::t t, option::t[deref] d) { alt (ty::struct(*cx.tcx, t)) { case (ty::ty_box(?mt)) { ret rec(t=mt.ty, - d=some(rec(mut=mt.mut != ast::imm, - kind=unbox, - outer_t=t))); + d=some(@rec(mut=mt.mut != ast::imm, + kind=unbox, + outer_t=t))); } case (_) { ret rec(t=t, d=none); } } } - fn maybe_push_auto_unbox(&option::t[deref] d, &mutable vec[deref] ds) { - alt (d) { case (some(?d)) { vec::push(ds, d); } case (none) { } } + fn maybe_push_auto_unbox(&option::t[deref] d, &mutable deref[] ds) { + alt (d) { case (some(?d)) { ds += ~[d]; } case (none) { } } } - let vec[deref] ds = []; + let deref[] ds = ~[]; while (true) { alt ({ ex.node }) { case (ast::expr_field(?base, ?ident)) { @@ -555,7 +558,7 @@ fn expr_root(&ctx cx, @ast::expr ex, bool autoderef) -> } case (ty::ty_obj(_)) { } } - vec::push(ds, rec(mut=mut, kind=field, outer_t=auto_unbox.t)); + ds += ~[@rec(mut=mut, kind=field, outer_t=auto_unbox.t)]; maybe_push_auto_unbox(auto_unbox.d, ds); ex = base; } @@ -564,14 +567,14 @@ fn expr_root(&ctx cx, @ast::expr ex, bool autoderef) -> maybe_auto_unbox(cx, ty::expr_ty(*cx.tcx, base)); alt (ty::struct(*cx.tcx, auto_unbox.t)) { case (ty::ty_vec(?mt)) { - vec::push(ds, rec(mut=mt.mut != ast::imm, - kind=index, - outer_t=auto_unbox.t)); + ds += ~[@rec(mut=mt.mut != ast::imm, + kind=index, + outer_t=auto_unbox.t)]; } case (ty::ty_ivec(?mt)) { - vec::push(ds, rec(mut=mt.mut != ast::imm, - kind=index, - outer_t=auto_unbox.t)); + ds += ~[@rec(mut=mt.mut != ast::imm, + kind=index, + outer_t=auto_unbox.t)]; } } maybe_push_auto_unbox(auto_unbox.d, ds); @@ -587,7 +590,7 @@ fn expr_root(&ctx cx, @ast::expr ex, bool autoderef) -> case (ty::ty_tag(_, _)) {} case (ty::ty_ptr(?mt)) { mut = mt.mut != ast::imm; } } - vec::push(ds, rec(mut=mut, kind=unbox, outer_t=base_t)); + ds += ~[@rec(mut=mut, kind=unbox, outer_t=base_t)]; ex = base; } else { break; } } @@ -598,16 +601,16 @@ fn expr_root(&ctx cx, @ast::expr ex, bool autoderef) -> auto auto_unbox = maybe_auto_unbox(cx, ty::expr_ty(*cx.tcx, ex)); maybe_push_auto_unbox(auto_unbox.d, ds); } - ret rec(ex=ex, ds=ds); + ret rec(ex=ex, ds=@ds); } -fn mut_field(&vec[deref] ds) -> bool { - for (deref d in ds) { if (d.mut) { ret true; } } +fn mut_field(&@deref[] ds) -> bool { + for (deref d in *ds) { if (d.mut) { ret true; } } ret false; } -fn inner_mut(&vec[deref] ds) -> option::t[ty::t] { - for (deref d in ds) { if (d.mut) { ret some(d.outer_t); } } +fn inner_mut(&@deref[] ds) -> option::t[ty::t] { + for (deref d in *ds) { if (d.mut) { ret some(d.outer_t); } } ret none; } diff --git a/src/comp/middle/resolve.rs b/src/comp/middle/resolve.rs index d32e4b7f4e7..a0fbc6a7061 100644 --- a/src/comp/middle/resolve.rs +++ b/src/comp/middle/resolve.rs @@ -1168,11 +1168,7 @@ fn ns_for_def(def d) -> namespace { fn lookup_external(&env e, int cnum, &ident[] ids, namespace ns) -> option::t[def] { - // FIXME: Remove this ivec->vec conversion. - auto ids_vec = []; - for (ident i in ids) { ids_vec += [i]; } - - for (def d in csearch::lookup_defs(e.sess.get_cstore(), cnum, ids_vec)) { + for (def d in csearch::lookup_defs(e.sess.get_cstore(), cnum, ids)) { e.ext_map.insert(ast::def_id_of_def(d), ids); if (ns == ns_for_def(d)) { ret some(d); } } diff --git a/src/comp/middle/typeck.rs b/src/comp/middle/typeck.rs index 54c662851aa..2ef71234fdd 100644 --- a/src/comp/middle/typeck.rs +++ b/src/comp/middle/typeck.rs @@ -1364,7 +1364,7 @@ fn check_pat(&@fn_ctxt fcx, &ast::pat_id_map map, &@ast::pat pat, fcx.ccx.tcx.sess.span_fatal(pat.span, s); } - // TODO: vec::iter2 + // TODO: ivec::iter2 auto i = 0u; for (@ast::pat subpat in subpats) { diff --git a/src/comp/syntax/codemap.rs b/src/comp/syntax/codemap.rs index 46105f5320e..92639819aa9 100644 --- a/src/comp/syntax/codemap.rs +++ b/src/comp/syntax/codemap.rs @@ -1,6 +1,6 @@ +import std::ivec; import std::uint; import std::str; -import std::vec; import std::termivec; import std::ioivec; import std::option; @@ -14,33 +14,33 @@ type filename = str; * with single-word things, rather than passing records all over the * compiler. */ -type filemap = @rec(filename name, uint start_pos, mutable vec[uint] lines); +type filemap = @rec(filename name, uint start_pos, mutable uint[] lines); -type codemap = @rec(mutable vec[filemap] files); +type codemap = @rec(mutable filemap[] files); type loc = rec(filename filename, uint line, uint col); fn new_codemap() -> codemap { - let vec[filemap] files = []; + let filemap[] files = ~[]; ret @rec(mutable files=files); } fn new_filemap(filename filename, uint start_pos) -> filemap { - ret @rec(name=filename, start_pos=start_pos, mutable lines=[0u]); + ret @rec(name=filename, start_pos=start_pos, mutable lines=~[0u]); } -fn next_line(filemap file, uint pos) { vec::push[uint](file.lines, pos); } +fn next_line(filemap file, uint pos) { file.lines += ~[pos]; } fn lookup_pos(codemap map, uint pos) -> loc { auto a = 0u; - auto b = vec::len[filemap](map.files); + auto b = ivec::len[filemap](map.files); while (b - a > 1u) { auto m = (a + b) / 2u; if (map.files.(m).start_pos > pos) { b = m; } else { a = m; } } auto f = map.files.(a); a = 0u; - b = vec::len[uint](f.lines); + b = ivec::len[uint](f.lines); while (b - a > 1u) { auto m = (a + b) / 2u; if (f.lines.(m) > pos) { b = m; } else { a = m; } @@ -91,8 +91,8 @@ fn emit_diagnostic(&option::t[span] sp, &str msg, &str kind, u8 color, auto max_lines = 6u; auto elided = false; auto display_lines = lines.lines; - if (vec::len(display_lines) > max_lines) { - display_lines = vec::slice(display_lines, 0u, max_lines); + if (ivec::len(display_lines) > max_lines) { + display_lines = ivec::slice(display_lines, 0u, max_lines); elided = true; } // Print the offending lines @@ -106,7 +106,8 @@ fn emit_diagnostic(&option::t[span] sp, &str msg, &str kind, u8 color, ioivec::stdout().write_str(s); } if (elided) { - auto last_line = display_lines.(vec::len(display_lines) - 1u); + auto last_line = display_lines.(ivec::len(display_lines) - + 1u); auto s = #fmt("%s:%u ", fm.name, last_line + 1u); auto indent = str::char_len(s); auto out = ""; @@ -116,7 +117,7 @@ fn emit_diagnostic(&option::t[span] sp, &str msg, &str kind, u8 color, } // If there's one line at fault we can easily point to the problem - if (vec::len(lines.lines) == 1u) { + if (ivec::len(lines.lines) == 1u) { auto lo = codemap::lookup_pos(cm, option::get(sp).lo); auto digits = 0u; auto num = lines.lines.(0) / 10u; @@ -156,21 +157,21 @@ fn emit_note(&option::t[span] sp, &str msg, &codemap cm) { emit_diagnostic(sp, msg, "note", 10u8, cm); } -type file_lines = rec(str name, vec[uint] lines); +type file_lines = rec(str name, uint[] lines); fn span_to_lines(span sp, codemap::codemap cm) -> @file_lines { auto lo = codemap::lookup_pos(cm, sp.lo); auto hi = codemap::lookup_pos(cm, sp.hi); - auto lines = []; + auto lines = ~[]; for each (uint i in uint::range(lo.line - 1u, hi.line as uint)) { - lines += [i]; + lines += ~[i]; } ret @rec(name=lo.filename, lines=lines); } fn get_line(filemap fm, int line, &str file) -> str { let uint end; - if ((line as uint) + 1u >= vec::len(fm.lines)) { + if ((line as uint) + 1u >= ivec::len(fm.lines)) { end = str::byte_len(file); } else { end = fm.lines.(line + 1); diff --git a/src/comp/syntax/parse/eval.rs b/src/comp/syntax/parse/eval.rs index 226d84233e0..5488867dcdd 100644 --- a/src/comp/syntax/parse/eval.rs +++ b/src/comp/syntax/parse/eval.rs @@ -1,5 +1,4 @@ -import std::vec; import std::str; import std::option; import std::option::some; @@ -19,7 +18,7 @@ tag eval_mode { mode_depend; mode_parse; } type ctx = @rec(parser p, eval_mode mode, - mutable vec[str] deps, + mutable str[] deps, parser::parse_sess sess, mutable uint chpos, ast::crate_cfg cfg); @@ -55,7 +54,7 @@ fn eval_crate_directive(ctx cx, @ast::crate_directive cdir, str prefix, } else { prefix + std::fs::path_sep() + file_path }; - if (cx.mode == mode_depend) { cx.deps += [full_path]; ret; } + if (cx.mode == mode_depend) { cx.deps += ~[full_path]; ret; } auto p0 = new_parser_from_file(cx.sess, cx.cfg, full_path, cx.chpos); auto inner_attrs = parse_inner_attrs_and_next(p0); diff --git a/src/comp/syntax/parse/lexer.rs b/src/comp/syntax/parse/lexer.rs index 77bde628014..da7c978ba78 100644 --- a/src/comp/syntax/parse/lexer.rs +++ b/src/comp/syntax/parse/lexer.rs @@ -1,8 +1,8 @@ import std::ioivec; -import std::str; -import std::vec; import std::int; +import std::ivec; +import std::str; import std::map; import std::map::hashmap; import std::option; @@ -40,7 +40,7 @@ fn new_reader(&codemap::codemap cm, str src, codemap::filemap filemap, mutable uint mark_pos, mutable uint mark_chpos, mutable uint chpos, - mutable vec[str] strs, + mutable str[] strs, codemap::filemap fm, @interner::interner[str] itr) { fn is_eof() -> bool { ret ch == -1 as char; } @@ -83,7 +83,7 @@ fn new_reader(&codemap::codemap cm, str src, codemap::filemap filemap, codemap::emit_error(some(rec(lo=chpos, hi=chpos)), m, cm); } } - let vec[str] strs = []; + let str[] strs = ~[]; auto rd = reader(cm, src, str::byte_len(src), 0u, 0u, -1 as char, 0u, filemap.start_pos, filemap.start_pos, strs, filemap, itr); @@ -578,7 +578,7 @@ tag cmnt_style { } -type cmnt = rec(cmnt_style style, vec[str] lines, uint pos); +type cmnt = rec(cmnt_style style, str[] lines, uint pos); fn read_to_eol(&reader rdr) -> str { auto val = ""; @@ -610,7 +610,7 @@ fn consume_whitespace_counting_blank_lines(&reader rdr, while (is_whitespace(rdr.curr()) && !rdr.is_eof()) { if (rdr.curr() == '\n' && rdr.next() == '\n') { log ">>> blank-line comment"; - let vec[str] v = []; + let str[] v = ~[]; comments += ~[rec(style=blank_line, lines=v, pos=rdr.get_chpos())]; } @@ -621,11 +621,11 @@ fn consume_whitespace_counting_blank_lines(&reader rdr, fn read_line_comments(&reader rdr, bool code_to_the_left) -> cmnt { log ">>> line comments"; auto p = rdr.get_chpos(); - let vec[str] lines = []; + let str[] lines = ~[]; while (rdr.curr() == '/' && rdr.next() == '/') { auto line = read_one_line_comment(rdr); log line; - lines += [line]; + lines += ~[line]; consume_non_eol_whitespace(rdr); } log "<<< line comments"; @@ -643,7 +643,7 @@ fn all_whitespace(&str s, uint begin, uint end) -> bool { ret true; } -fn trim_whitespace_prefix_and_push_line(&mutable vec[str] lines, &str s, +fn trim_whitespace_prefix_and_push_line(&mutable str[] lines, &str s, uint col) { auto s1; if (all_whitespace(s, 0u, col)) { @@ -652,13 +652,13 @@ fn trim_whitespace_prefix_and_push_line(&mutable vec[str] lines, &str s, } else { s1 = ""; } } else { s1 = s; } log "pushing line: " + s1; - lines += [s1]; + lines += ~[s1]; } fn read_block_comment(&reader rdr, bool code_to_the_left) -> cmnt { log ">>> block comment"; auto p = rdr.get_chpos(); - let vec[str] lines = []; + let str[] lines = ~[]; let uint col = rdr.get_col(); rdr.bump(); rdr.bump(); @@ -693,7 +693,7 @@ fn read_block_comment(&reader rdr, bool code_to_the_left) -> cmnt { } auto style = if (code_to_the_left) { trailing } else { isolated }; consume_non_eol_whitespace(rdr); - if (!rdr.is_eof() && rdr.curr() != '\n' && vec::len(lines) == 1u) { + if (!rdr.is_eof() && rdr.curr() != '\n' && ivec::len(lines) == 1u) { style = mixed; } log "<<< block comment"; diff --git a/src/comp/syntax/parse/parser.rs b/src/comp/syntax/parse/parser.rs index d238e6eb2e7..2f810f84614 100644 --- a/src/comp/syntax/parse/parser.rs +++ b/src/comp/syntax/parse/parser.rs @@ -1,7 +1,6 @@ import std::ioivec; import std::ivec; -import std::vec; import std::str; import std::option; import std::option::some; @@ -45,7 +44,7 @@ type parser = fn get_lo_pos() -> uint ; fn get_hi_pos() -> uint ; fn get_last_lo_pos() -> uint ; - fn get_prec_table() -> vec[op_spec] ; + fn get_prec_table() -> @op_spec[] ; fn get_str(token::str_num) -> str ; fn get_reader() -> lexer::reader ; fn get_filemap() -> codemap::filemap ; @@ -62,7 +61,7 @@ fn new_parser_from_file(parse_sess sess, ast::crate_cfg cfg, auto srdr = ioivec::file_reader(path); auto src = str::unsafe_from_bytes_ivec(srdr.read_whole_stream()); auto filemap = codemap::new_filemap(path, pos); - vec::push(sess.cm.files, filemap); + sess.cm.files += ~[filemap]; auto itr = @interner::mk(str::hash, str::eq); auto rdr = lexer::new_reader(sess.cm, src, filemap, itr); @@ -80,7 +79,7 @@ fn new_parser(parse_sess sess, ast::crate_cfg cfg, lexer::reader rdr, mutable uint last_lo, mutable restriction restr, lexer::reader rdr, - vec[op_spec] precs, + @op_spec[] precs, hashmap[str, ()] bad_words) { fn peek() -> token::token { ret tok; } fn bump() { @@ -107,7 +106,7 @@ fn new_parser(parse_sess sess, ast::crate_cfg cfg, lexer::reader rdr, fn get_last_lo_pos() -> uint { ret last_lo; } fn get_file_type() -> file_type { ret ftype; } fn get_cfg() -> ast::crate_cfg { ret cfg; } - fn get_prec_table() -> vec[op_spec] { ret precs; } + fn get_prec_table() -> @op_spec[] { ret precs; } fn get_str(token::str_num i) -> str { ret interner::get(*rdr.get_interner(), i); } @@ -258,7 +257,7 @@ fn parse_ty_fn(ast::proto proto, &parser p, uint lo) -> ast::ty_ { } auto lo = p.get_lo_pos(); auto inputs = - parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA), + parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA), parse_fn_input_ty, p); auto constrs = parse_constrs(~[], p); let @ast::ty output; @@ -308,7 +307,7 @@ fn parse_ty_obj(&parser p, &mutable uint hi) -> ast::ty_ { fail; } auto f = parse_method_sig; - auto meths = parse_seq_ivec(token::LBRACE, token::RBRACE, none, f, p); + auto meths = parse_seq(token::LBRACE, token::RBRACE, none, f, p); hi = meths.span.hi; ret ast::ty_obj(meths.node); } @@ -352,7 +351,7 @@ fn parse_ty_constr(&ast::arg[] fn_args, &parser p) -> @ast::constr { auto path = parse_path(p); auto pf = bind parse_constr_arg(fn_args, _); let rec((@ast::constr_arg)[] node, span span) args = - parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA), pf, + parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA), pf, p); // FIXME fix the def_id @@ -409,12 +408,8 @@ fn parse_ty_postfix(@ast::ty orig_t, &parser p) -> @ast::ty { if (mut == ast::imm && p.peek() != token::RBRACKET) { // This is explicit type parameter instantiation. - auto seq = parse_seq_to_end(token::RBRACKET, some(token::COMMA), - parse_ty, p); - - // FIXME: Remove this vec->ivec conversion. - auto seq_ivec = ~[]; - for (@ast::ty typ in seq) { seq_ivec += ~[typ]; } + auto seq = parse_seq_to_end(token::RBRACKET, + some(token::COMMA), parse_ty, p); alt (orig_t.node) { case (ast::ty_path(?pth, ?ann)) { @@ -423,7 +418,7 @@ fn parse_ty_postfix(@ast::ty orig_t, &parser p) -> @ast::ty { ast::ty_path(spanned(lo, hi, rec(global=pth.node.global, idents=pth.node.idents, - types=seq_ivec)), + types=seq)), ann)); } case (_) { @@ -522,13 +517,13 @@ fn parse_ty(&parser p) -> @ast::ty { expect(p, token::RBRACKET); } else if (eat_word(p, "tup")) { auto elems = - parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA), + parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA), parse_mt, p); hi = elems.span.hi; t = ast::ty_tup(elems.node); } else if (eat_word(p, "rec")) { auto elems = - parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA), + parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA), parse_ty_field, p); hi = elems.span.hi; t = ast::ty_rec(elems.node); @@ -577,23 +572,6 @@ fn parse_arg(&parser p) -> ast::arg { } fn parse_seq_to_end[T](token::token ket, option::t[token::token] sep, - fn(&parser) -> T f, &parser p) -> vec[T] { - let bool first = true; - let vec[T] v = []; - while (p.peek() != ket) { - alt (sep) { - case (some(?t)) { - if (first) { first = false; } else { expect(p, t); } - } - case (_) { } - } - v += [f(p)]; - } - expect(p, ket); - ret v; -} - -fn parse_seq_to_end_ivec[T](token::token ket, option::t[token::token] sep, fn(&parser)->T f, &parser p) -> T[] { let bool first = true; let T[] v = ~[]; @@ -612,21 +590,11 @@ fn parse_seq_to_end_ivec[T](token::token ket, option::t[token::token] sep, fn parse_seq[T](token::token bra, token::token ket, - option::t[token::token] sep, fn(&parser) -> T f, &parser p) - -> ast::spanned[vec[T]] { - auto lo = p.get_lo_pos(); - expect(p, bra); - auto result = parse_seq_to_end[T](ket, sep, f, p); - auto hi = p.get_hi_pos(); - ret spanned(lo, hi, result); -} - -fn parse_seq_ivec[T](token::token bra, token::token ket, option::t[token::token] sep, fn(&parser)->T f, &parser p) -> ast::spanned[T[]] { auto lo = p.get_lo_pos(); expect(p, bra); - auto result = parse_seq_to_end_ivec[T](ket, sep, f, p); + auto result = parse_seq_to_end[T](ket, sep, f, p); auto hi = p.get_hi_pos(); ret spanned(lo, hi, result); } @@ -704,15 +672,10 @@ fn parse_path_and_ty_param_substs(&parser p) -> ast::path { if (p.peek() == token::LBRACKET) { auto seq = parse_seq(token::LBRACKET, token::RBRACKET, some(token::COMMA), parse_ty, p); - - // FIXME: Remove this vec->ivec conversion. - auto seq_ivec = ~[]; - for (@ast::ty typ in seq.node) { seq_ivec += ~[typ]; } - auto hi = p.get_hi_pos(); path = spanned(lo, hi, rec(global=path.node.global, idents=path.node.idents, - types=seq_ivec)); + types=seq.node)); } ret path; } @@ -793,7 +756,7 @@ fn parse_bottom_expr(&parser p) -> @ast::expr { ret rec(mut=m, expr=e); } auto es = - parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA), + parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA), parse_elt, p); hi = es.span.hi; ex = ast::expr_tup(es.node); @@ -801,7 +764,7 @@ fn parse_bottom_expr(&parser p) -> @ast::expr { p.bump(); auto mut = parse_mutability(p); auto es = - parse_seq_to_end_ivec(token::RBRACKET, some(token::COMMA), + parse_seq_to_end(token::RBRACKET, some(token::COMMA), parse_expr, p); ex = ast::expr_vec(es, mut, ast::sk_rc); } else if (p.peek() == token::POUND_LT) { @@ -822,7 +785,7 @@ fn parse_bottom_expr(&parser p) -> @ast::expr { p.bump(); auto mut = parse_mutability(p); auto es = - parse_seq_to_end_ivec(token::RBRACKET, some(token::COMMA), + parse_seq_to_end(token::RBRACKET, some(token::COMMA), parse_expr, p); ex = ast::expr_vec(es, mut, ast::sk_unique); } @@ -848,7 +811,7 @@ fn parse_bottom_expr(&parser p) -> @ast::expr { if (p.peek() == token::LPAREN) { p.bump(); fields = - some(parse_seq_to_end_ivec(token::RPAREN, some(token::COMMA), + some(parse_seq_to_end(token::RPAREN, some(token::COMMA), parse_anon_obj_field, p)); } let (@ast::method)[] meths = ~[]; @@ -902,7 +865,7 @@ fn parse_bottom_expr(&parser p) -> @ast::expr { } } auto es = - parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA), + parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA), parse_expr_opt, p); hi = es.span.hi; ex = ast::expr_bind(e, es.node); @@ -1003,7 +966,7 @@ fn parse_bottom_expr(&parser p) -> @ast::expr { let @ast::expr f = parse_self_method(p); auto es = - parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA), + parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA), parse_expr, p); hi = es.span.hi; ex = ast::expr_call(f, es.node); @@ -1033,7 +996,7 @@ fn parse_syntax_ext_naked(&parser p, uint lo) -> @ast::expr { if (ivec::len(pth.node.idents) == 0u) { p.fatal("expected a syntax expander name"); } - auto es = parse_seq_ivec(token::LPAREN, token::RPAREN, + auto es = parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA), parse_expr, p); auto hi = es.span.hi; ret mk_mac_expr(p, lo, hi, ast::mac_invoc(pth, es.node, none)); @@ -1061,7 +1024,7 @@ fn parse_dot_or_call_expr_with(&parser p, @ast::expr e) -> @ast::expr { // Call expr. auto es = - parse_seq_ivec(token::LPAREN, token::RPAREN, + parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA), parse_expr, p); hi = es.span.hi; e = mk_expr(p, lo, hi, ast::expr_call(e, es.node)); @@ -1157,27 +1120,27 @@ type op_spec = rec(token::token tok, ast::binop op, int prec); // FIXME make this a const, don't store it in parser state -fn prec_table() -> vec[op_spec] { - ret [rec(tok=token::BINOP(token::STAR), op=ast::mul, prec=11), - rec(tok=token::BINOP(token::SLASH), op=ast::div, prec=11), - rec(tok=token::BINOP(token::PERCENT), op=ast::rem, prec=11), - rec(tok=token::BINOP(token::PLUS), op=ast::add, prec=10), - rec(tok=token::BINOP(token::MINUS), op=ast::sub, prec=10), - rec(tok=token::BINOP(token::LSL), op=ast::lsl, prec=9), - rec(tok=token::BINOP(token::LSR), op=ast::lsr, prec=9), - rec(tok=token::BINOP(token::ASR), op=ast::asr, prec=9), - rec(tok=token::BINOP(token::AND), op=ast::bitand, prec=8), - rec(tok=token::BINOP(token::CARET), op=ast::bitxor, prec=6), - rec(tok=token::BINOP(token::OR), op=ast::bitor, prec=6), - // 'as' sits between here with 5 - rec(tok=token::LT, op=ast::lt, prec=4), - rec(tok=token::LE, op=ast::le, prec=4), - rec(tok=token::GE, op=ast::ge, prec=4), - rec(tok=token::GT, op=ast::gt, prec=4), - rec(tok=token::EQEQ, op=ast::eq, prec=3), - rec(tok=token::NE, op=ast::ne, prec=3), - rec(tok=token::ANDAND, op=ast::and, prec=2), - rec(tok=token::OROR, op=ast::or, prec=1)]; +fn prec_table() -> @op_spec[] { + ret @~[rec(tok=token::BINOP(token::STAR), op=ast::mul, prec=11), + rec(tok=token::BINOP(token::SLASH), op=ast::div, prec=11), + rec(tok=token::BINOP(token::PERCENT), op=ast::rem, prec=11), + rec(tok=token::BINOP(token::PLUS), op=ast::add, prec=10), + rec(tok=token::BINOP(token::MINUS), op=ast::sub, prec=10), + rec(tok=token::BINOP(token::LSL), op=ast::lsl, prec=9), + rec(tok=token::BINOP(token::LSR), op=ast::lsr, prec=9), + rec(tok=token::BINOP(token::ASR), op=ast::asr, prec=9), + rec(tok=token::BINOP(token::AND), op=ast::bitand, prec=8), + rec(tok=token::BINOP(token::CARET), op=ast::bitxor, prec=6), + rec(tok=token::BINOP(token::OR), op=ast::bitor, prec=6), + // 'as' sits between here with 5 + rec(tok=token::LT, op=ast::lt, prec=4), + rec(tok=token::LE, op=ast::le, prec=4), + rec(tok=token::GE, op=ast::ge, prec=4), + rec(tok=token::GT, op=ast::gt, prec=4), + rec(tok=token::EQEQ, op=ast::eq, prec=3), + rec(tok=token::NE, op=ast::ne, prec=3), + rec(tok=token::ANDAND, op=ast::and, prec=2), + rec(tok=token::OROR, op=ast::or, prec=1)]; } fn parse_binops(&parser p) -> @ast::expr { @@ -1191,7 +1154,7 @@ const int ternary_prec = 0; fn parse_more_binops(&parser p, @ast::expr lhs, int min_prec) -> @ast::expr { auto peeked = p.peek(); - for (op_spec cur in p.get_prec_table()) { + for (op_spec cur in *p.get_prec_table()) { if (cur.prec > min_prec && cur.tok == peeked) { p.bump(); auto rhs = parse_more_binops(p, parse_prefix_expr(p), cur.prec); @@ -1378,7 +1341,7 @@ fn parse_spawn_expr(&parser p) -> @ast::expr { auto fn_expr = parse_bottom_expr(p); auto es = - parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA), + parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA), parse_expr, p); auto hi = es.span.hi; ret mk_expr(p, lo, hi, ast::expr_spawn @@ -1515,7 +1478,7 @@ fn parse_pat(&parser p) -> @ast::pat { case (token::LPAREN) { auto f = parse_pat; auto a = - parse_seq_ivec(token::LPAREN, token::RPAREN, + parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA), f, p); args = a.node; hi = a.span.hi; @@ -1763,7 +1726,7 @@ fn parse_ty_params(&parser p) -> ast::ty_param[] { let ast::ty_param[] ty_params = ~[]; if (p.peek() == token::LBRACKET) { ty_params = - parse_seq_ivec(token::LBRACKET, token::RBRACKET, + parse_seq(token::LBRACKET, token::RBRACKET, some(token::COMMA), parse_ty_param, p).node; } ret ty_params; @@ -1771,7 +1734,7 @@ fn parse_ty_params(&parser p) -> ast::ty_param[] { fn parse_fn_decl(&parser p, ast::purity purity) -> ast::fn_decl { let ast::spanned[ast::arg[]] inputs = - parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA), + parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA), parse_arg, p); let ty_or_bang rslt; auto constrs = parse_constrs(inputs.node, p).node; @@ -1879,7 +1842,7 @@ fn parse_item_obj(&parser p, ast::layer lyr, &ast::attribute[] attrs) -> auto ident = parse_value_ident(p); auto ty_params = parse_ty_params(p); let ast::spanned[ast::obj_field[]] fields = - parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA), + parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA), parse_obj_field, p); let (@ast::method)[] meths = ~[]; let option::t[@ast::method] dtor = none; @@ -2110,7 +2073,7 @@ fn parse_item_tag(&parser p, &ast::attribute[] attrs) -> @ast::item { case (token::LPAREN) { auto arg_tys = parse_seq(token::LPAREN, token::RPAREN, - some(token::COMMA), parse_ty, p); + some(token::COMMA), parse_ty, p); for (@ast::ty ty in arg_tys.node) { args += ~[rec(ty=ty, id=p.get_id())]; } @@ -2284,8 +2247,8 @@ fn parse_meta_item(&parser p) -> @ast::meta_item { } fn parse_meta_seq(&parser p) -> (@ast::meta_item)[] { - ret parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA), - parse_meta_item, p).node; + ret parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA), + parse_meta_item, p).node; } fn parse_optional_meta(&parser p) -> (@ast::meta_item)[] { @@ -2424,7 +2387,7 @@ fn parse_crate_from_source_str(&str name, &str source, &ast::crate_cfg cfg, auto sess = @rec(cm=cm, mutable next_id=0); auto ftype = SOURCE_FILE; auto filemap = codemap::new_filemap(name, 0u); - sess.cm.files += [filemap]; + sess.cm.files += ~[filemap]; auto itr = @interner::mk(str::hash, str::eq); auto rdr = lexer::new_reader(sess.cm, source, filemap, itr); auto p = new_parser(sess, cfg, rdr, ftype); @@ -2548,15 +2511,14 @@ fn parse_crate_from_crate_file(&str input, &ast::crate_cfg cfg, auto crate_attrs = leading_attrs._0; auto first_cdir_attr = leading_attrs._1; auto cdirs = parse_crate_directives(p, token::EOF, first_cdir_attr); - let vec[str] deps = []; + let str[] deps = ~[]; auto cx = @rec(p=p, mode=eval::mode_parse, mutable deps=deps, sess=sess, mutable chpos=p.get_chpos(), cfg = p.get_cfg()); - auto m = - eval::eval_crate_directives_to_mod(cx, cdirs, prefix); + auto m = eval::eval_crate_directives_to_mod(cx, cdirs, prefix); auto hi = p.get_hi_pos(); expect(p, token::EOF); ret @spanned(lo, hi, rec(directives=cdirs, diff --git a/src/comp/syntax/print/pp.rs b/src/comp/syntax/print/pp.rs index 7ac10f6bcf0..21a9bfa6b19 100644 --- a/src/comp/syntax/print/pp.rs +++ b/src/comp/syntax/print/pp.rs @@ -1,6 +1,6 @@ import std::ioivec; -import std::vec; +import std::ivec; import std::str; @@ -74,10 +74,10 @@ fn tok_str(token t) -> str { } } -fn buf_str(vec[mutable token] toks, vec[mutable int] szs, uint left, - uint right, uint lim) -> str { - auto n = vec::len(toks); - assert (n == vec::len(szs)); +fn buf_str(&token[mutable] toks, &int[mutable] szs, uint left, uint right, + uint lim) -> str { + auto n = ivec::len(toks); + assert (n == ivec::len(szs)); auto i = left; auto L = lim; auto s = "["; @@ -104,10 +104,10 @@ fn mk_printer(ioivec::writer out, uint linewidth) -> printer { let uint n = 3u * linewidth; log #fmt("mk_printer %u", linewidth); - let vec[mutable token] token = vec::init_elt_mut(EOF, n); - let vec[mutable int] size = vec::init_elt_mut(0, n); - let vec[mutable uint] scan_stack = vec::init_elt_mut(0u, n); - let vec[print_stack_elt] print_stack = []; + let token[mutable] token = ivec::init_elt_mut(EOF, n); + let int[mutable] size = ivec::init_elt_mut(0, n); + let uint[mutable] scan_stack = ivec::init_elt_mut(0u, n); + let print_stack_elt[] print_stack = ~[]; ret printer(out, n, linewidth as int, // margin linewidth as int, // space 0u, // left @@ -208,9 +208,9 @@ obj printer(ioivec::writer out, mutable uint right, // index of right side of input stream - mutable vec[mutable token] token, + mutable token[mutable] token, // ring-buffr stream goes through - mutable vec[mutable int] size, // ring-buffer of calculated sizes + mutable int[mutable] size, // ring-buffer of calculated sizes mutable int left_total, // running size of stream "...left" @@ -222,7 +222,7 @@ obj printer(ioivec::writer out, // BEGIN (if there is any) on top of it. Stuff is flushed off the // bottom as it becomes irrelevant due to the primary ring-buffer // advancing. - mutable vec[mutable uint] scan_stack, + mutable uint[mutable] scan_stack, mutable bool scan_stack_empty, // top==bottom disambiguator mutable uint top, // index of top of scan_stack @@ -230,7 +230,7 @@ obj printer(ioivec::writer out, mutable uint bottom, // index of bottom of scan_stack // stack of blocks-in-progress being flushed by print - mutable vec[print_stack_elt] print_stack, + mutable print_stack_elt[] print_stack, // buffered indentation to avoid writing trailing whitespace mutable int pending_indentation) { @@ -403,7 +403,7 @@ obj printer(ioivec::writer out, pending_indentation += amount; } fn top() -> print_stack_elt { - auto n = vec::len(print_stack); + auto n = ivec::len(print_stack); let print_stack_elt top = rec(offset=0, pbreak=broken(inconsistent)); if (n != 0u) { top = print_stack.(n - 1u); } ret top; @@ -425,17 +425,17 @@ obj printer(ioivec::writer out, auto col = margin - space + b.offset; log #fmt("print BEGIN -> push broken block at col %d", col); - vec::push(print_stack, - rec(offset=col, pbreak=broken(b.breaks))); + print_stack += ~[rec(offset=col, + pbreak=broken(b.breaks))]; } else { log "print BEGIN -> push fitting block"; - vec::push(print_stack, rec(offset=0, pbreak=fits)); + print_stack += ~[rec(offset=0, pbreak=fits)]; } } case (END) { log "print END -> pop END"; - assert (vec::len(print_stack) != 0u); - vec::pop(print_stack); + assert (ivec::len(print_stack) != 0u); + ivec::pop(print_stack); } case (BREAK(?b)) { auto top = self.top(); diff --git a/src/comp/syntax/print/pprust.rs b/src/comp/syntax/print/pprust.rs index dd3d98fb45b..8ade4ff6a02 100644 --- a/src/comp/syntax/print/pprust.rs +++ b/src/comp/syntax/print/pprust.rs @@ -4,7 +4,6 @@ import std::int; import std::ioivec; import std::str; import std::uint; -import std::vec; import std::option; import parse::lexer; import syntax::codemap::codemap; @@ -1267,7 +1266,7 @@ fn print_view_item(&ps s, &@ast::view_item item) { // FIXME: The fact that this builds up the table anew for every call is // not good. Eventually, table should be a const. fn operator_prec(ast::binop op) -> int { - for (parse::parser::op_spec spec in parse::parser::prec_table()) { + for (parse::parser::op_spec spec in *parse::parser::prec_table()) { if (spec.op == op) { ret spec.prec; } } fail; @@ -1445,7 +1444,7 @@ fn maybe_print_comment(&ps s, uint pos) { fn print_comment(&ps s, lexer::cmnt cmnt) { alt (cmnt.style) { case (lexer::mixed) { - assert (vec::len(cmnt.lines) == 1u); + assert (ivec::len(cmnt.lines) == 1u); zerobreak(s.s); word(s.s, cmnt.lines.(0)); zerobreak(s.s); @@ -1456,7 +1455,7 @@ fn print_comment(&ps s, lexer::cmnt cmnt) { } case (lexer::trailing) { word(s.s, " "); - if (vec::len(cmnt.lines) == 1u) { + if (ivec::len(cmnt.lines) == 1u) { word(s.s, cmnt.lines.(0)); hardbreak(s.s); } else {