mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

rustc: Remove a bunch of exterior vectors

Browse Source
This commit is contained in:
Patrick Walton 2011-07-14 17:26:10 -07:00
parent a716eb28ec
commit 917afa4cc9
18 changed files with 302 additions and 331 deletions

14
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

80
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:

15
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];

5
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,

9
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)) {

2
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);
}

34
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;
}

27
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;

1
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;

183
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;
}

6
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); }
}

2
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) {

33
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);

5
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);

24
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";

148
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,

38
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();

7
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 {