user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rewrite everything to use [] instead of vec() in value position.

Browse source
This commit is contained in:
Graydon Hoare 2011-05-16 18:21:22 -07:00
parent ae030c5bf2
commit fbbc1a77d2
87 changed files with 1137 additions and 1134 deletions
Download patch file Download diff file Expand all files Collapse all files

82
src/comp/back/upcall.rs
View file

@ -63,8 +63,8 @@ type upcalls = rec(
fn declare_upcalls(type_names tn, ModuleRef llmod) -> @upcalls {
fn decl(type_names tn, ModuleRef llmod, str name, vec[TypeRef] tys,
TypeRef rv) -> ValueRef {
let vec[TypeRef] arg_tys = vec(T_taskptr(tn));
for (TypeRef t in tys) { arg_tys += vec(t); }
let vec[TypeRef] arg_tys = [T_taskptr(tn)];
for (TypeRef t in tys) { arg_tys += [t]; }
auto fn_ty = T_fn(arg_tys, rv);
ret trans::decl_cdecl_fn(llmod, "upcall_" + name, fn_ty);
}
@ -74,61 +74,61 @@ fn declare_upcalls(type_names tn, ModuleRef llmod) -> @upcalls {
// FIXME: Sigh:.. remove this when I fix the typechecker pushdown.
// --pcwalton
let vec[TypeRef] empty_vec = vec();
let vec[TypeRef] empty_vec = [];
ret @rec(
grow_task=dv("grow_task", vec(T_size_t())),
log_int=dv("log_int", vec(T_i32(), T_i32())),
log_float=dv("log_float", vec(T_i32(), T_f32())),
log_double=dv("log_double", vec(T_i32(), T_ptr(T_f64()))),
log_str=dv("log_str", vec(T_i32(), T_ptr(T_str()))),
trace_word=dv("trace_word", vec(T_int())),
trace_str=dv("trace_str", vec(T_ptr(T_i8()))),
new_port=d("new_port", vec(T_size_t()), T_opaque_port_ptr()),
del_port=dv("del_port", vec(T_opaque_port_ptr())),
new_chan=d("new_chan", vec(T_opaque_port_ptr()), T_opaque_chan_ptr()),
flush_chan=dv("flush_chan", vec(T_opaque_chan_ptr())),
del_chan=dv("del_chan", vec(T_opaque_chan_ptr())),
clone_chan=d("clone_chan", vec(T_taskptr(tn), T_opaque_chan_ptr()),
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", [T_taskptr(tn), T_opaque_chan_ptr()],
T_opaque_chan_ptr()),
_yield=dv("yield", empty_vec),
sleep=dv("sleep", vec(T_size_t())),
_join=dv("join", vec(T_taskptr(tn))),
send=dv("send", vec(T_opaque_chan_ptr(), T_ptr(T_i8()))),
recv=dv("recv", vec(T_ptr(T_ptr(T_i8())), T_opaque_port_ptr())),
_fail=dv("fail", vec(T_ptr(T_i8()), T_ptr(T_i8()), T_size_t())),
kill=dv("kill", vec(T_taskptr(tn))),
sleep=dv("sleep", [T_size_t()]),
_join=dv("join", [T_taskptr(tn)]),
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", [T_taskptr(tn)]),
exit=dv("exit", empty_vec),
malloc=d("malloc", vec(T_size_t(), T_ptr(T_tydesc(tn))),
malloc=d("malloc", [T_size_t(), T_ptr(T_tydesc(tn))],
T_ptr(T_i8())),
free=dv("free", vec(T_ptr(T_i8()), T_int())),
mark=d("mark", vec(T_ptr(T_i8())), T_int()),
new_str=d("new_str", vec(T_ptr(T_i8()), T_size_t()), T_ptr(T_str())),
new_vec=d("new_vec", vec(T_size_t(), T_ptr(T_tydesc(tn))),
free=dv("free", [T_ptr(T_i8()), T_int()]),
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())),
new_vec=d("new_vec", [T_size_t(), T_ptr(T_tydesc(tn))],
T_opaque_vec_ptr()),
vec_grow=d("vec_grow", vec(T_opaque_vec_ptr(), T_size_t(),
T_ptr(T_int()), T_ptr(T_tydesc(tn))),
vec_grow=d("vec_grow", [T_opaque_vec_ptr(), T_size_t(),
T_ptr(T_int()), T_ptr(T_tydesc(tn))],
T_opaque_vec_ptr()),
require_rust_sym=d("require_rust_sym",
vec(T_ptr(T_crate(tn)), T_size_t(), T_size_t(),
[T_ptr(T_crate(tn)), T_size_t(), T_size_t(),
T_size_t(), T_ptr(T_i8()),
T_ptr(T_ptr(T_i8()))),
T_ptr(T_ptr(T_i8()))],
T_int()),
require_c_sym=d("require_c_sym",
vec(T_ptr(T_crate(tn)), T_size_t(), T_size_t(),
T_ptr(T_i8()), T_ptr(T_i8())),
[T_ptr(T_crate(tn)), T_size_t(), T_size_t(),
T_ptr(T_i8()), T_ptr(T_i8())],
T_int()),
get_type_desc=d("get_type_desc",
vec(T_ptr(T_crate(tn)), T_size_t(), T_size_t(),
T_size_t(), T_ptr(T_ptr(T_tydesc(tn)))),
[T_ptr(T_crate(tn)), T_size_t(), T_size_t(),
T_size_t(), T_ptr(T_ptr(T_tydesc(tn)))],
T_ptr(T_tydesc(tn))),
new_task=d("new_task", vec(T_ptr(T_i8())), T_taskptr(tn)),
start_task=d("start_task", vec(T_taskptr(tn), T_int(), T_int(),
T_int(), T_size_t()),
new_task=d("new_task", [T_ptr(T_i8())], T_taskptr(tn)),
start_task=d("start_task", [T_taskptr(tn), T_int(), T_int(),
T_int(), T_size_t()],
T_taskptr(tn)),
new_thread=d("new_thread", vec(T_ptr(T_i8())), T_taskptr(tn)),
start_thread=d("start_thread", vec(T_taskptr(tn), T_int(), T_int(),
T_int(), T_size_t()),
new_thread=d("new_thread", [T_ptr(T_i8())], T_taskptr(tn)),
start_thread=d("start_thread", [T_taskptr(tn), T_int(), T_int(),
T_int(), T_size_t()],
T_taskptr(tn))
);
}

80
src/comp/back/x86.rs
View file

@ -12,78 +12,78 @@ fn wstr(int i) -> str {
}
fn start() -> vec[str] {
ret vec(".cfi_startproc");
ret [".cfi_startproc"];
}
fn end() -> vec[str] {
ret vec(".cfi_endproc");
ret [".cfi_endproc"];
}
fn save_callee_saves() -> vec[str] {
ret vec("pushl %ebp",
ret ["pushl %ebp",
"pushl %edi",
"pushl %esi",
"pushl %ebx");
"pushl %ebx"];
}
fn save_callee_saves_with_cfi() -> vec[str] {
auto offset = 8;
auto t;
t = vec("pushl %ebp");
t += vec(".cfi_def_cfa_offset " + istr(offset));
t += vec(".cfi_offset %ebp, -" + istr(offset));
t = ["pushl %ebp"];
t += [".cfi_def_cfa_offset " + istr(offset)];
t += [".cfi_offset %ebp, -" + istr(offset)];
t += vec("pushl %edi");
t += ["pushl %edi"];
offset += 4;
t += vec(".cfi_def_cfa_offset " + istr(offset));
t += [".cfi_def_cfa_offset " + istr(offset)];
t += vec("pushl %esi");
t += ["pushl %esi"];
offset += 4;
t += vec(".cfi_def_cfa_offset " + istr(offset));
t += [".cfi_def_cfa_offset " + istr(offset)];
t += vec("pushl %ebx");
t += ["pushl %ebx"];
offset += 4;
t += vec(".cfi_def_cfa_offset " + istr(offset));
t += [".cfi_def_cfa_offset " + istr(offset)];
ret t;
}
fn restore_callee_saves() -> vec[str] {
ret vec("popl %ebx",
ret ["popl %ebx",
"popl %esi",
"popl %edi",
"popl %ebp");
"popl %ebp"];
}
fn load_esp_from_rust_sp_first_arg() -> vec[str] {
ret vec("movl " + wstr(abi::task_field_rust_sp) + "(%ecx), %esp");
ret ["movl " + wstr(abi::task_field_rust_sp) + "(%ecx), %esp"];
}
fn load_esp_from_runtime_sp_first_arg() -> vec[str] {
ret vec("movl " + wstr(abi::task_field_runtime_sp) + "(%ecx), %esp");
ret ["movl " + wstr(abi::task_field_runtime_sp) + "(%ecx), %esp"];
}
fn store_esp_to_rust_sp_first_arg() -> vec[str] {
ret vec("movl %esp, " + wstr(abi::task_field_rust_sp) + "(%ecx)");
ret ["movl %esp, " + wstr(abi::task_field_rust_sp) + "(%ecx)"];
}
fn store_esp_to_runtime_sp_first_arg() -> vec[str] {
ret vec("movl %esp, " + wstr(abi::task_field_runtime_sp) + "(%ecx)");
ret ["movl %esp, " + wstr(abi::task_field_runtime_sp) + "(%ecx)"];
}
fn load_esp_from_rust_sp_second_arg() -> vec[str] {
ret vec("movl " + wstr(abi::task_field_rust_sp) + "(%edx), %esp");
ret ["movl " + wstr(abi::task_field_rust_sp) + "(%edx), %esp"];
}
fn load_esp_from_runtime_sp_second_arg() -> vec[str] {
ret vec("movl " + wstr(abi::task_field_runtime_sp) + "(%edx), %esp");
ret ["movl " + wstr(abi::task_field_runtime_sp) + "(%edx), %esp"];
}
fn store_esp_to_rust_sp_second_arg() -> vec[str] {
ret vec("movl %esp, " + wstr(abi::task_field_rust_sp) + "(%edx)");
ret ["movl %esp, " + wstr(abi::task_field_rust_sp) + "(%edx)"];
}
fn store_esp_to_runtime_sp_second_arg() -> vec[str] {
ret vec("movl %esp, " + wstr(abi::task_field_runtime_sp) + "(%edx)");
ret ["movl %esp, " + wstr(abi::task_field_runtime_sp) + "(%edx)"];
}
@ -105,7 +105,7 @@ fn store_esp_to_runtime_sp_second_arg() -> vec[str] {
*/
fn rust_activate_glue() -> vec[str] {
ret vec("movl 4(%esp), %ecx # ecx = rust_task")
ret ["movl 4(%esp), %ecx # ecx = rust_task"]
+ save_callee_saves()
+ store_esp_to_runtime_sp_first_arg()
+ load_esp_from_rust_sp_first_arg()
@ -157,7 +157,7 @@ fn rust_activate_glue() -> vec[str] {
* will be a no-op. Esp won't move, and the task's stack won't
* grow.
*/
+ vec("addl $20, " + wstr(abi::task_field_rust_sp) + "(%ecx)")
+ ["addl $20, " + wstr(abi::task_field_rust_sp) + "(%ecx)"]
/*
@ -167,10 +167,10 @@ fn rust_activate_glue() -> vec[str] {
* activating, the task needs to be in the fastcall 2nd parameter
* expected by the rust main function. That's edx.
*/
+ vec("mov %ecx, %edx")
+ ["mov %ecx, %edx"]
+ restore_callee_saves()
+ vec("ret");
+ ["ret"];
}
/* More glue code, this time the 'bottom half' of yielding.
@ -200,13 +200,13 @@ fn rust_activate_glue() -> vec[str] {
*/
fn rust_yield_glue() -> vec[str] {
ret vec("movl 0(%esp), %ecx # ecx = rust_task")
ret ["movl 0(%esp), %ecx # ecx = rust_task"]
+ load_esp_from_rust_sp_first_arg()
+ save_callee_saves()
+ store_esp_to_rust_sp_first_arg()
+ load_esp_from_runtime_sp_first_arg()
+ restore_callee_saves()
+ vec("ret");
+ ["ret"];
}
fn native_glue(int n_args, abi::native_glue_type ngt) -> vec[str] {
@ -239,8 +239,8 @@ fn native_glue(int n_args, abi::native_glue_type ngt) -> vec[str] {
} else {
src_off = wstr(5 + (i as int));
}
auto m = vec("movl " + src_off + "(%ebp),%eax",
"movl %eax," + dst_off + "(%esp)");
auto m = ["movl " + src_off + "(%ebp),%eax",
"movl %eax," + dst_off + "(%esp)"];
ret _str::connect(m, "\n\t");
}
@ -250,24 +250,24 @@ fn native_glue(int n_args, abi::native_glue_type ngt) -> vec[str] {
start()
+ save_callee_saves_with_cfi()
+ vec("movl %esp, %ebp # ebp = rust_sp")
+ vec(".cfi_def_cfa_register %ebp")
+ ["movl %esp, %ebp # ebp = rust_sp"]
+ [".cfi_def_cfa_register %ebp"]
+ store_esp_to_rust_sp_second_arg()
+ load_esp_from_runtime_sp_second_arg()
+ vec("subl $" + wstr(n_args) + ", %esp # esp -= args",
"andl $~0xf, %esp # align esp down")
+ ["subl $" + wstr(n_args) + ", %esp # esp -= args",
"andl $~0xf, %esp # align esp down"]
+ _vec::init_fn[str](carg, (n_args) as uint)
+ vec("movl %edx, %edi # save task from edx to edi",
+ ["movl %edx, %edi # save task from edx to edi",
"call *%ecx # call *%ecx",
"movl %edi, %edx # restore edi-saved task to edx")
"movl %edi, %edx # restore edi-saved task to edx"]
+ load_esp_from_rust_sp_second_arg()
+ restore_callee_saves()
+ vec("ret")
+ ["ret"]
+ end();
}
@ -305,13 +305,13 @@ fn get_module_asm() -> str {
auto prefix = get_symbol_prefix();
auto glues =
vec(decl_glue(align, prefix,
[decl_glue(align, prefix,
abi::activate_glue_name(),
rust_activate_glue()),
decl_glue(align, prefix,
abi::yield_glue_name(),
rust_yield_glue()))
rust_yield_glue())]
+ _vec::init_fn[str](bind decl_native_glue(align, prefix,
abi::ngt_rust, _), (abi::n_native_glues + 1) as uint)

44
src/comp/driver/rustc.rs
View file

@ -44,7 +44,7 @@ fn default_environment(session::session sess,
}
ret
vec(
[
// Target bindings.
tup("target_os", eval::val_str(std::os::target_os())),
tup("target_arch", eval::val_str("x86")),
@ -53,7 +53,7 @@ fn default_environment(session::session sess,
// Build bindings.
tup("build_compiler", eval::val_str(argv0)),
tup("build_input", eval::val_str(input))
);
];
}
fn parse_input(session::session sess,
@ -205,7 +205,7 @@ fn main(vec[str] args) {
uint_type = common::ty_u32,
float_type = common::ty_f64);
auto opts = vec(optflag("h"), optflag("help"),
auto opts = [optflag("h"), optflag("help"),
optflag("v"), optflag("version"),
optflag("glue"), optflag("emit-llvm"),
optflag("pretty"), optflag("ls"), optflag("parse-only"),
@ -214,7 +214,7 @@ fn main(vec[str] args) {
optflag("save-temps"), optopt("sysroot"),
optflag("stats"),
optflag("time-passes"), optflag("time-llvm-passes"),
optflag("no-typestate"), optflag("noverify"));
optflag("no-typestate"), optflag("noverify")];
auto binary = _vec::shift[str](args);
auto match;
alt (getopts::getopts(args, opts)) {
@ -287,7 +287,7 @@ fn main(vec[str] args) {
auto crate_cache = common::new_int_hash[session::crate_metadata]();
auto target_crate_num = 0;
let vec[@ast::meta_item] md = vec();
let vec[@ast::meta_item] md = [];
auto sess =
session::session(target_crate_num, target_cfg, sopts,
crate_cache, md, front::codemap::new_codemap());
@ -323,13 +323,13 @@ fn main(vec[str] args) {
_vec::pop[str](parts);
saved_out_filename = parts.(0);
alt (output_type) {
case (link::output_type_none) { parts += vec("pp"); }
case (link::output_type_bitcode) { parts += vec("bc"); }
case (link::output_type_assembly) { parts += vec("s"); }
case (link::output_type_none) { parts += ["pp"]; }
case (link::output_type_bitcode) { parts += ["bc"]; }
case (link::output_type_assembly) { parts += ["s"]; }
// Object and exe output both use the '.o' extension here
case (link::output_type_object) { parts += vec("o"); }
case (link::output_type_exe) { parts += vec("o"); }
case (link::output_type_object) { parts += ["o"]; }
case (link::output_type_exe) { parts += ["o"]; }
}
auto ofile = _str::connect(parts, ".");
compile_input(sess, env, ifile, ofile);
@ -353,33 +353,33 @@ fn main(vec[str] args) {
let str exe_suffix = "";
// The invocations of gcc share some flags across platforms
let vec[str] common_cflags = vec("-fno-strict-aliasing", "-fPIC",
"-Wall", "-fno-rtti", "-fno-exceptions", "-g");
let vec[str] common_libs = vec(stage, "-Lrustllvm", "-Lrt",
"-lrustrt", "-lrustllvm", "-lstd", "-lm");
let vec[str] common_cflags = ["-fno-strict-aliasing", "-fPIC",
"-Wall", "-fno-rtti", "-fno-exceptions", "-g"];
let vec[str] common_libs = [stage, "-Lrustllvm", "-Lrt",
"-lrustrt", "-lrustllvm", "-lstd", "-lm"];
alt (sess.get_targ_cfg().os) {
case (session::os_win32) {
exe_suffix = ".exe";
gcc_args = common_cflags + vec(
gcc_args = common_cflags + [
"-march=i686", "-O2",
glu, "-o",
saved_out_filename + exe_suffix,
saved_out_filename + ".o") + common_libs;
saved_out_filename + ".o"] + common_libs;
}
case (session::os_macos) {
gcc_args = common_cflags + vec(
gcc_args = common_cflags + [
"-arch i386", "-O0", "-m32",
glu, "-o",
saved_out_filename + exe_suffix,
saved_out_filename + ".o") + common_libs;
saved_out_filename + ".o"] + common_libs;
}
case (session::os_linux) {
gcc_args = common_cflags + vec(
gcc_args = common_cflags + [
"-march=i686", "-O2", "-m32",
glu, "-o",
saved_out_filename + exe_suffix,
saved_out_filename + ".o") + common_libs;
saved_out_filename + ".o"] + common_libs;
}
}
@ -388,12 +388,12 @@ fn main(vec[str] args) {
// Clean up on Darwin
if (sess.get_targ_cfg().os == session::os_macos) {
run::run_program("dsymutil", vec(saved_out_filename));
run::run_program("dsymutil", [saved_out_filename]);
}
// Remove the temporary object file if we aren't saving temps
if (!save_temps) {
run::run_program("rm", vec(saved_out_filename + ".o"));
run::run_program("rm", [saved_out_filename + ".o"]);
}
}
}

4
src/comp/front/codemap.rs
View file

@ -13,14 +13,14 @@ type codemap = @rec(mutable vec[filemap] files);
type loc = rec(str filename, uint line, uint col);
fn new_codemap() -> codemap {
let vec[filemap] files = vec();
let vec[filemap] files = [];
ret @rec(mutable files=files);
}
fn new_filemap(str filename, uint start_pos) -> filemap {
ret @rec(name=filename,
start_pos=start_pos,
mutable lines=vec(0u));
mutable lines=[0u]);
}
fn next_line(filemap file, uint pos) {

36
src/comp/front/creader.rs
View file

@ -90,9 +90,9 @@ fn parse_ty(@pstate st, str_def sd) -> ty::t {
case ('t') {
assert (next(st) as char == '[');
auto def = parse_def(st, sd);
let vec[ty::t] params = vec();
let vec[ty::t] params = [];
while (peek(st) as char != ']') {
params += vec(parse_ty(st, sd));
params += [parse_ty(st, sd)];
}
st.pos = st.pos + 1u;
ret ty::mk_tag(st.tcx, def, params);
@ -104,23 +104,23 @@ fn parse_ty(@pstate st, str_def sd) -> ty::t {
case ('C') { ret ty::mk_chan(st.tcx, parse_ty(st, sd)); }
case ('T') {
assert (next(st) as char == '[');
let vec[ty::mt] params = vec();
let vec[ty::mt] params = [];
while (peek(st) as char != ']') {
params += vec(parse_mt(st, sd));
params += [parse_mt(st, sd)];
}
st.pos = st.pos + 1u;
ret ty::mk_tup(st.tcx, params);
}
case ('R') {
assert (next(st) as char == '[');
let vec[ty::field] fields = vec();
let vec[ty::field] fields = [];
while (peek(st) as char != ']') {
auto name = "";
while (peek(st) as char != '=') {
name += _str::unsafe_from_byte(next(st));
}
st.pos = st.pos + 1u;
fields += vec(rec(ident=name, mt=parse_mt(st, sd)));
fields += [rec(ident=name, mt=parse_mt(st, sd))];
}
st.pos = st.pos + 1u;
ret ty::mk_rec(st.tcx, fields);
@ -146,7 +146,7 @@ fn parse_ty(@pstate st, str_def sd) -> ty::t {
}
case ('O') {
assert (next(st) as char == '[');
let vec[ty::method] methods = vec();
let vec[ty::method] methods = [];
while (peek(st) as char != ']') {
auto proto;
alt (next(st) as char) {
@ -158,10 +158,10 @@ fn parse_ty(@pstate st, str_def sd) -> ty::t {
name += _str::unsafe_from_byte(next(st));
}
auto func = parse_ty_fn(st, sd);
methods += vec(rec(proto=proto,
methods += [rec(proto=proto,
ident=name,
inputs=func._0,
output=func._1));
output=func._1)];
}
st.pos += 1u;
ret ty::mk_obj(st.tcx, methods);
@ -242,14 +242,14 @@ fn parse_hex(@pstate st) -> uint {
fn parse_ty_fn(@pstate st, str_def sd) -> tup(vec[ty::arg], ty::t) {
assert (next(st) as char == '[');
let vec[ty::arg] inputs = vec();
let vec[ty::arg] inputs = [];
while (peek(st) as char != ']') {
auto mode = ty::mo_val;
if (peek(st) as char == '&') {
mode = ty::mo_alias;
st.pos = st.pos + 1u;
}
inputs += vec(rec(mode=mode, ty=parse_ty(st, sd)));
inputs += [rec(mode=mode, ty=parse_ty(st, sd))];
}
st.pos = st.pos + 1u;
ret tup(inputs, parse_ty(st, sd));
@ -285,7 +285,7 @@ fn lookup_hash(&ebml::doc d, fn(vec[u8]) -> bool eq_fn, uint hash)
auto pos = ebml::be_uint_from_bytes(d.data, hash_pos, 4u);
auto bucket = ebml::doc_at(d.data, pos);
// Awkward logic because we can't ret from foreach yet
let vec[ebml::doc] result = vec();
let vec[ebml::doc] result = [];
auto belt = metadata::tag_index_buckets_bucket_elt;
for each (ebml::doc elt in ebml::tagged_docs(bucket, belt)) {
auto pos = ebml::be_uint_from_bytes(elt.data, elt.start, 4u);
@ -306,7 +306,7 @@ fn resolve_path(vec[ast::ident] path, vec[u8] data) -> vec[ast::def_id] {
auto md = ebml::new_doc(data);
auto paths = ebml::get_doc(md, metadata::tag_paths);
auto eqer = bind eq_item(_, s);
let vec[ast::def_id] result = vec();
let vec[ast::def_id] result = [];
for (ebml::doc doc in lookup_hash(paths, eqer, metadata::hash_path(s))) {
auto did_doc = ebml::get_doc(doc, metadata::tag_def_id);
_vec::push(result, parse_def_id(ebml::doc_data(did_doc)));
@ -380,7 +380,7 @@ fn item_ty_param_count(&ebml::doc item, int this_cnum) -> uint {
}
fn tag_variant_ids(&ebml::doc item, int this_cnum) -> vec[ast::def_id] {
let vec[ast::def_id] ids = vec();
let vec[ast::def_id] ids = [];
auto v = metadata::tag_items_data_item_variant;
for each (ebml::doc p in ebml::tagged_docs(item, v)) {
auto ext = parse_def_id(ebml::doc_data(p));
@ -544,23 +544,23 @@ fn get_tag_variants(session::session sess, ty::ctxt tcx, ast::def_id def)
auto items = ebml::get_doc(ebml::new_doc(data), metadata::tag_items);
auto item = find_item(def._1, items);
let vec[trans::variant_info] infos = vec();
let vec[trans::variant_info] infos = [];
auto variant_ids = tag_variant_ids(item, external_crate_id);
for (ast::def_id did in variant_ids) {
auto item = find_item(did._1, items);
auto ctor_ty = item_type(item, external_crate_id, tcx);
let vec[ty::t] arg_tys = vec();
let vec[ty::t] arg_tys = [];
alt (ty::struct(tcx, ctor_ty)) {
case (ty::ty_fn(_, ?args, _)) {
for (ty::arg a in args) {
arg_tys += vec(a.ty);
arg_tys += [a.ty];
}
}
case (_) {
// Nullary tag variant.
}
}
infos += vec(rec(args=arg_tys, ctor_ty=ctor_ty, id=did));
infos += [rec(args=arg_tys, ctor_ty=ctor_ty, id=did)];
}
ret infos;

10
src/comp/front/eval.rs
View file

@ -38,7 +38,7 @@ type ctx = @rec(parser p,
mutable uint next_ann);
fn mk_env() -> env {
let env e = vec();
let env e = [];
ret e;
}
@ -249,8 +249,8 @@ fn eval_crate_directives(ctx cx,
fn eval_crate_directives_to_mod(ctx cx, env e,
vec[@ast::crate_directive] cdirs,
str prefix) -> ast::_mod {
let vec[@ast::view_item] view_items = vec();
let vec[@ast::item] items = vec();
let vec[@ast::view_item] view_items = [];
let vec[@ast::item] items = [];
eval_crate_directives(cx, e, cdirs, prefix,
view_items, items);
@ -356,7 +356,7 @@ fn eval_crate_directive(ctx cx,
case (ast::cdir_let(?id, ?x, ?cdirs)) {
auto v = eval_expr(cx, e, x);
auto e0 = vec(tup(id, v)) + e;
auto e0 = [tup(id, v)] + e;
eval_crate_directives(cx, e0, cdirs, prefix,
view_items, items);
}
@ -379,7 +379,7 @@ fn eval_crate_directive(ctx cx,
auto full_path = prefix + std::fs::path_sep() + file_path;
if (cx.mode == mode_depend) {
cx.deps += vec(full_path);
cx.deps += [full_path];
ret;
}

22
src/comp/front/extfmt.rs
View file

@ -118,7 +118,7 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast::expr] args)
fn make_path_expr(parser p, common::span sp, vec[ast::ident] idents)
-> @ast::expr {
let vec[@ast::ty] types = vec();
let vec[@ast::ty] types = [];
auto path = rec(idents=idents, types=types);
auto sp_path = rec(node=path, span=sp);
auto pathexpr = ast::expr_path(sp_path, p.get_ann());
@ -143,14 +143,14 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast::expr] args)
fn make_rec_expr(parser p, common::span sp,
vec[tup(ast::ident, @ast::expr)] fields) -> @ast::expr {
let vec[ast::field] astfields = vec();
let vec[ast::field] astfields = [];
for (tup(ast::ident, @ast::expr) field in fields) {
auto ident = field._0;
auto val = field._1;
auto astfield = rec(mut = ast::imm,
ident = ident,
expr = val);
astfields += vec(astfield);
astfields += [astfield];
}
auto recexpr = ast::expr_rec(astfields,
@ -163,7 +163,7 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast::expr] args)
fn make_path_vec(str ident) -> vec[str] {
// FIXME: #fmt can't currently be used from within std
// because we're explicitly referencing the 'std' crate here
ret vec("std", "extfmt", "rt", ident);
ret ["std", "extfmt", "rt", ident];
}
fn make_rt_path_expr(parser p, common::span sp, str ident) -> @ast::expr {
@ -177,7 +177,7 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast::expr] args)
fn make_flags(parser p, common::span sp, vec[flag] flags)
-> @ast::expr {
let vec[@ast::expr] flagexprs = vec();
let vec[@ast::expr] flagexprs = [];
for (flag f in flags) {
auto fstr;
alt (f) {
@ -197,14 +197,14 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast::expr] args)
fstr = "flag_alternate";
}
}
flagexprs += vec(make_rt_path_expr(p, sp, fstr));
flagexprs += [make_rt_path_expr(p, sp, fstr)];
}
// FIXME: 0-length vectors can't have their type inferred
// through the rec that these flags are a member of, so
// this is a hack placeholder flag
if (_vec::len[@ast::expr](flagexprs) == 0u) {
flagexprs += vec(make_rt_path_expr(p, sp, "flag_none"));
flagexprs += [make_rt_path_expr(p, sp, "flag_none")];
}
ret make_vec_expr(p, sp, flagexprs);
@ -218,7 +218,7 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast::expr] args)
case (count_is(?c)) {
auto count_lit = make_new_int(p, sp, c);
auto count_is_path = make_path_vec("count_is");
auto count_is_args = vec(count_lit);
auto count_is_args = [count_lit];
ret make_call(p, sp, count_is_path, count_is_args);
}
case (_) {
@ -261,10 +261,10 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast::expr] args)
@ast::expr width_expr,
@ast::expr precision_expr,
@ast::expr ty_expr) -> @ast::expr {
ret make_rec_expr(p, sp, vec(tup("flags", flags_expr),
ret make_rec_expr(p, sp, [tup("flags", flags_expr),
tup("width", width_expr),
tup("precision", precision_expr),
tup("ty", ty_expr)));
tup("ty", ty_expr)]);
}
auto rt_conv_flags = make_flags(p, sp, cnv.flags);
@ -284,7 +284,7 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast::expr] args)
auto fname = "conv_" + conv_type;
auto path = make_path_vec(fname);
auto cnv_expr = make_rt_conv_expr(p, sp, cnv);
auto args = vec(cnv_expr, arg);
auto args = [cnv_expr, arg];
ret make_call(p, arg.span, path, args);
}

12
src/comp/front/lexer.rs
View file

@ -91,7 +91,7 @@ fn new_reader(session sess, io::reader rdr,
}
}
auto file = _str::unsafe_from_bytes(rdr.read_whole_stream());
let vec[str] strs = vec();
let vec[str] strs = [];
auto rd = reader(sess, file, _str::byte_len(file), 0u, -1 as char,
filemap.start_pos, filemap.start_pos,
strs, filemap, itr);
@ -228,11 +228,11 @@ fn scan_exponent(reader rdr) -> option::t[str] {
auto res = "";
if (c == 'e' || c == 'E') {
res += _str::from_bytes(vec(c as u8));
res += _str::from_bytes([c as u8]);
rdr.bump();
c = rdr.curr();
if (c == '-' || c == '+') {
res += _str::from_bytes(vec(c as u8));
res += _str::from_bytes([c as u8]);
rdr.bump();
}
auto exponent = scan_dec_digits(rdr);
@ -256,7 +256,7 @@ fn scan_dec_digits(reader rdr) -> str {
while (is_dec_digit (c) || c == '_') {
if (c != '_') {
res += _str::from_bytes(vec(c as u8));
res += _str::from_bytes([c as u8]);
}
rdr.bump();
c = rdr.curr();
@ -766,7 +766,7 @@ fn read_block_comment(reader rdr) -> cmnt {
auto p = rdr.get_chpos();
rdr.bump(); rdr.bump();
while (rdr.curr() == ' ') {rdr.bump();}
let vec[str] lines = vec();
let vec[str] lines = [];
auto val = "";
auto level = 1;
while (true) {
@ -802,7 +802,7 @@ fn gather_comments(session sess, str path) -> vec[cmnt] {
auto srdr = io::file_reader(path);
auto itr = @interner::mk_interner[str](_str::hash, _str::eq);
auto rdr = new_reader(sess, srdr, codemap::new_filemap(path, 0u), itr);
let vec[cmnt] comments = vec();
let vec[cmnt] comments = [];
while (!rdr.is_eof()) {
while (true) {
consume_whitespace(rdr);

78
src/comp/front/parser.rs
View file

@ -422,7 +422,7 @@ fn parse_ty_constr(parser p) -> @ast::constr {
fn parse_constrs(parser p) -> common::spanned[vec[@ast::constr]] {
auto lo = p.get_lo_pos();
auto hi = p.get_hi_pos();
let vec[@ast::constr] constrs = vec();
let vec[@ast::constr] constrs = [];
if (p.peek() == token::COLON) {
p.bump();
while (true) {
@ -580,7 +580,7 @@ fn parse_seq_to_end[T](token::token ket,
uint hi,
parser p) -> vec[T] {
let bool first = true;
let vec[T] v = vec();
let vec[T] v = [];
while (p.peek() != ket) {
alt(sep) {
case (some[token::token](?t)) {
@ -595,7 +595,7 @@ fn parse_seq_to_end[T](token::token ket,
}
// FIXME: v += f(p) doesn't work at the moment.
let T t = f(p);
v += vec(t);
v += [t];
}
hi = p.get_hi_pos();
expect(p, ket);
@ -677,7 +677,7 @@ fn parse_ty_args(parser p, uint hi) ->
some(token::COMMA),
pf, p);
}
let vec[@ast::ty] v = vec();
let vec[@ast::ty] v = [];
auto pos = p.get_lo_pos();
ret spanned(hi, hi, v);
}
@ -687,12 +687,12 @@ fn parse_path(parser p) -> ast::path {
auto lo = p.get_lo_pos();
auto hi = lo;
let vec[ast::ident] ids = vec();
let vec[ast::ident] ids = [];
while (true) {
alt (p.peek()) {
case (token::IDENT(?i, _)) {
hi = p.get_hi_pos();
ids += vec(p.get_str(i));
ids += [p.get_str(i)];
p.bump();
if (p.peek() == token::MOD_SEP) {
p.bump();
@ -797,7 +797,7 @@ fn parse_bottom_expr(parser p) -> @ast::expr {
pf, hi, p));
}
let vec[@ast::method] meths = vec();
let vec[@ast::method] meths = [];
let option::t[ast::ident] with_obj = none[ast::ident];
expect(p, token::LBRACE);
@ -830,7 +830,7 @@ fn parse_bottom_expr(parser p) -> @ast::expr {
} else if (eat_word(p, "rec")) {
expect(p, token::LPAREN);
auto fields = vec(parse_field(p));
auto fields = [parse_field(p)];
auto more = true;
auto base = none[@ast::expr];
@ -846,7 +846,7 @@ fn parse_bottom_expr(parser p) -> @ast::expr {
more = false;
} else if (p.peek() == token::COMMA) {
p.bump();
fields += vec(parse_field(p));
fields += [parse_field(p)];
} else {
unexpected(p, p.peek());
}
@ -1151,7 +1151,7 @@ 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 vec(rec(tok=token::BINOP(token::STAR), op=ast::mul, prec=11),
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),
@ -1170,7 +1170,7 @@ fn prec_table() -> vec[op_spec] {
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));
rec(tok=token::OROR, op=ast::or, prec=1)];
}
fn parse_binops(parser p) -> @ast::expr {
@ -1342,14 +1342,14 @@ fn parse_alt_expr(parser p) -> @ast::expr {
expect(p, token::RPAREN);
expect(p, token::LBRACE);
let vec[ast::arm] arms = vec();
let vec[ast::arm] arms = [];
while (p.peek() != token::RBRACE) {
if (eat_word(p, "case")) {
expect(p, token::LPAREN);
auto pat = parse_pat(p);
expect(p, token::RPAREN);
auto block = parse_block(p);
arms += vec(rec(pat=pat, block=block));
arms += [rec(pat=pat, block=block)];
} else if (p.peek() == token::RBRACE) {
/* empty */
} else {
@ -1480,7 +1480,7 @@ fn parse_pat(parser p) -> @ast::pat {
args = a.node;
hi = a.span.hi;
}
case (_) { args = vec(); }
case (_) { args = []; }
}
pat = ast::pat_tag(tag_path, args, p.get_ann());
@ -1630,7 +1630,7 @@ fn stmt_ends_with_semi(@ast::stmt stmt) -> bool {
fn parse_block(parser p) -> ast::block {
auto lo = p.get_lo_pos();
let vec[@ast::stmt] stmts = vec();
let vec[@ast::stmt] stmts = [];
let option::t[@ast::expr] expr = none[@ast::expr];
expect(p, token::LBRACE);
@ -1650,7 +1650,7 @@ fn parse_block(parser p) -> ast::block {
alt (p.peek()) {
case (token::SEMI) {
p.bump();
stmts += vec(stmt);
stmts += [stmt];
}
case (token::RBRACE) { expr = some(e); }
case (?t) {
@ -1660,13 +1660,13 @@ fn parse_block(parser p) -> ast::block {
token::to_str(p.get_reader(), t));
fail;
}
stmts += vec(stmt);
stmts += [stmt];
}
}
}
case (none[@ast::expr]) {
// Not an expression statement.
stmts += vec(stmt);
stmts += [stmt];
// FIXME: crazy differentiation between conditions
// used in branches and binary expressions in rustboot
// means we cannot use && here. I know, right?
@ -1693,7 +1693,7 @@ fn parse_ty_param(parser p) -> ast::ty_param {
}
fn parse_ty_params(parser p) -> vec[ast::ty_param] {
let vec[ast::ty_param] ty_params = vec();
let vec[ast::ty_param] ty_params = [];
if (p.peek() == token::LBRACKET) {
auto f = parse_ty_param; // FIXME: pass as lval directly
ty_params = parse_seq[ast::ty_param](token::LBRACKET, token::RBRACKET,
@ -1775,7 +1775,7 @@ fn parse_method(parser p) -> @ast::method {
fn parse_dtor(parser p) -> @ast::method {
auto lo = p.get_last_lo_pos();
let ast::block b = parse_block(p);
let vec[ast::arg] inputs = vec();
let vec[ast::arg] inputs = [];
let @ast::ty output = @spanned(lo, lo, ast::ty_nil);
let ast::fn_decl d = rec(inputs=inputs,
output=output,
@ -1802,7 +1802,7 @@ fn parse_item_obj(parser p, ast::layer lyr) -> @ast::item {
some(token::COMMA),
pf, p);
let vec[@ast::method] meths = vec();
let vec[@ast::method] meths = [];
let option::t[@ast::method] dtor = none[@ast::method];
expect(p, token::LBRACE);
@ -1829,9 +1829,9 @@ fn parse_item_obj(parser p, ast::layer lyr) -> @ast::item {
fn parse_mod_items(parser p, token::token term) -> ast::_mod {
auto view_items = parse_view(p);
let vec[@ast::item] items = vec();
let vec[@ast::item] items = [];
while (p.peek() != term) {
items += vec(parse_item(p));
items += [parse_item(p)];
}
ret rec(view_items=view_items, items=items);
}
@ -1899,12 +1899,12 @@ fn parse_native_item(parser p) -> @ast::native_item {
fn parse_native_mod_items(parser p,
str native_name,
ast::native_abi abi) -> ast::native_mod {
let vec[@ast::native_item] items = vec();
let vec[@ast::native_item] items = [];
auto view_items = parse_native_view(p);
while (p.peek() != token::RBRACE) {
items += vec(parse_native_item(p));
items += [parse_native_item(p)];
}
ret rec(native_name=native_name, abi=abi,
view_items=view_items,
@ -1982,7 +1982,7 @@ fn parse_item_tag(parser p) -> @ast::item {
auto id = parse_ident(p);
auto ty_params = parse_ty_params(p);
let vec[ast::variant] variants = vec();
let vec[ast::variant] variants = [];
expect(p, token::LBRACE);
while (p.peek() != token::RBRACE) {
auto tok = p.peek();
@ -1992,7 +1992,7 @@ fn parse_item_tag(parser p) -> @ast::item {
auto vlo = p.get_lo_pos();
p.bump();
let vec[ast::variant_arg] args = vec();
let vec[ast::variant_arg] args = [];
alt (p.peek()) {
case (token::LPAREN) {
auto f = parse_ty;
@ -2001,7 +2001,7 @@ fn parse_item_tag(parser p) -> @ast::item {
some(token::COMMA),
f, p);
for (@ast::ty ty in arg_tys.node) {
args += vec(rec(ty=ty, id=p.next_def_id()));
args += [rec(ty=ty, id=p.next_def_id())];
}
}
case (_) { /* empty */ }
@ -2013,7 +2013,7 @@ fn parse_item_tag(parser p) -> @ast::item {
auto id = p.next_def_id();
auto vr = rec(name=p.get_str(name), args=args,
id=id, ann=p.get_ann());
variants += vec(spanned[ast::variant_](vlo, vhi, vr));
variants += [spanned[ast::variant_](vlo, vhi, vr)];
}
case (token::RBRACE) { /* empty */ }
case (_) {
@ -2135,7 +2135,7 @@ fn parse_optional_meta(parser p) -> vec[@ast::meta_item] {
ret parse_meta(p);
}
case (_) {
let vec[@ast::meta_item] v = vec();
let vec[@ast::meta_item] v = [];
ret v;
}
}
@ -2156,11 +2156,11 @@ fn parse_rest_import_name(parser p, ast::ident first,
option::t[ast::ident] def_ident)
-> @ast::view_item {
auto lo = p.get_lo_pos();
let vec[ast::ident] identifiers = vec(first);
let vec[ast::ident] identifiers = [first];
while (p.peek() != token::SEMI) {
expect(p, token::MOD_SEP);
auto i = parse_ident(p);
identifiers += vec(i);
identifiers += [i];
}
auto hi = p.get_hi_pos();
p.bump();
@ -2248,17 +2248,17 @@ fn is_view_item(&parser p) -> bool {
}
fn parse_view(parser p) -> vec[@ast::view_item] {
let vec[@ast::view_item] items = vec();
let vec[@ast::view_item] items = [];
while (is_view_item(p)) {
items += vec(parse_view_item(p));
items += [parse_view_item(p)];
}
ret items;
}
fn parse_native_view(parser p) -> vec[@ast::view_item] {
let vec[@ast::view_item] items = vec();
let vec[@ast::view_item] items = [];
while (is_view_item(p)) {
items += vec(parse_view_item(p));
items += [parse_view_item(p)];
}
ret items;
}
@ -2267,7 +2267,7 @@ fn parse_native_view(parser p) -> vec[@ast::view_item] {
fn parse_crate_from_source_file(parser p) -> @ast::crate {
auto lo = p.get_lo_pos();
auto m = parse_mod_items(p, token::EOF);
let vec[@ast::crate_directive] cdirs = vec();
let vec[@ast::crate_directive] cdirs = [];
ret @spanned(lo, p.get_lo_pos(), rec(directives=cdirs,
module=m));
}
@ -2362,7 +2362,7 @@ fn parse_crate_directive(parser p) -> ast::crate_directive
fn parse_crate_directives(parser p, token::token term)
-> vec[@ast::crate_directive] {
let vec[@ast::crate_directive] cdirs = vec();
let vec[@ast::crate_directive] cdirs = [];
while (p.peek() != term) {
auto cdir = @parse_crate_directive(p);
@ -2376,7 +2376,7 @@ fn parse_crate_from_crate_file(parser p) -> @ast::crate {
auto lo = p.get_lo_pos();
auto prefix = std::fs::dirname(p.get_filemap().name);
auto cdirs = parse_crate_directives(p, token::EOF);
let vec[str] deps = vec();
let vec[str] deps = [];
auto cx = @rec(p=p,
mode=eval::mode_parse,
mutable deps = deps,

6
src/comp/lib/llvm.rs
View file

@ -1395,7 +1395,7 @@ obj builder(BuilderRef B, @mutable bool terminated) {
let ValueRef T = llvm::LLVMGetNamedFunction(M,
_str::buf("llvm.trap"));
assert (T as int != 0);
let vec[ValueRef] Args = vec();
let vec[ValueRef] Args = [];
ret llvm::LLVMBuildCall(B, T,
_vec::buf[ValueRef](Args),
_vec::len[ValueRef](Args),
@ -1467,7 +1467,7 @@ fn mk_type_names() -> type_names {
}
fn type_to_str(type_names names, TypeRef ty) -> str {
let vec[TypeRef] v = vec();
let vec[TypeRef] v = [];
ret type_to_str_inner(names, v, ty);
}
@ -1478,7 +1478,7 @@ fn type_to_str_inner(type_names names,
ret names.get_name(ty);
}
auto outer = outer0 + vec(ty);
auto outer = outer0 + [ty];
let int kind = llvm::LLVMGetTypeKind(ty);

74
src/comp/middle/fold.rs
View file

@ -358,7 +358,7 @@ type ast_fold[ENV] =
//// Fold drivers.
fn fold_path[ENV](&ENV env, &ast_fold[ENV] fld, &path p) -> path {
let vec[@ast::ty] tys_ = vec();
let vec[@ast::ty] tys_ = [];
for (@ast::ty t in p.node.types) {
_vec::push[@ast::ty](tys_, fold_ty(env, fld, t));
}
@ -398,7 +398,7 @@ fn fold_ty[ENV](&ENV env, &ast_fold[ENV] fld, &@ty t) -> @ty {
}
case (ast::ty_tup(?elts)) {
let vec[mt] elts_ = vec();
let vec[mt] elts_ = [];
for (mt elt in elts) {
auto ty_ = fold_ty(env, fld, elt.ty);
_vec::push[mt](elts_, rec(ty=ty_, mut=elt.mut));
@ -407,7 +407,7 @@ fn fold_ty[ENV](&ENV env, &ast_fold[ENV] fld, &@ty t) -> @ty {
}
case (ast::ty_rec(?flds)) {
let vec[ast::ty_field] flds_ = vec();
let vec[ast::ty_field] flds_ = [];
for (ast::ty_field f in flds) {
auto ty_ = fold_ty(env, fld, f.mt.ty);
_vec::push[ast::ty_field]
@ -417,7 +417,7 @@ fn fold_ty[ENV](&ENV env, &ast_fold[ENV] fld, &@ty t) -> @ty {
}
case (ast::ty_obj(?meths)) {
let vec[ast::ty_method] meths_ = vec();
let vec[ast::ty_method] meths_ = [];
for (ast::ty_method m in meths) {
auto tfn = fold_ty_fn(env_, fld, t.span, m.proto,
m.inputs, m.output);
@ -458,11 +458,11 @@ fn fold_ty_fn[ENV](&ENV env, &ast_fold[ENV] fld, &span sp,
&vec[rec(ast::mode mode, @ty ty)] inputs,
&@ty output) -> @ty {
auto output_ = fold_ty(env, fld, output);
let vec[rec(ast::mode mode, @ty ty)] inputs_ = vec();
let vec[rec(ast::mode mode, @ty ty)] inputs_ = [];
for (rec(ast::mode mode, @ty ty) input in inputs) {
auto ty_ = fold_ty(env, fld, input.ty);
auto input_ = rec(ty=ty_ with input);
inputs_ += vec(input_);
inputs_ += [input_];
}
ret fld.fold_ty_fn(env, sp, proto, inputs_, output_);
}
@ -524,9 +524,9 @@ fn fold_pat[ENV](&ENV env, &ast_fold[ENV] fld, &@ast::pat p) -> @ast::pat {
case (ast::pat_tag(?path, ?pats, ?t)) {
auto ppath = fold_path(env, fld, path);
let vec[@ast::pat] ppats = vec();
let vec[@ast::pat] ppats = [];
for (@ast::pat pat in pats) {
ppats += vec(fold_pat(env_, fld, pat));
ppats += [fold_pat(env_, fld, pat)];
}
ret fld.fold_pat_tag(env_, p.span, ppath, ppats, t);
@ -536,7 +536,7 @@ fn fold_pat[ENV](&ENV env, &ast_fold[ENV] fld, &@ast::pat p) -> @ast::pat {
fn fold_exprs[ENV](&ENV env, &ast_fold[ENV] fld,
&vec[@expr] es) -> vec[@expr] {
let vec[@expr] exprs = vec();
let vec[@expr] exprs = [];
for (@expr e in es) {
_vec::push[@expr](exprs, fold_expr(env, fld, e));
}
@ -568,19 +568,19 @@ fn fold_expr[ENV](&ENV env, &ast_fold[ENV] fld, &@expr e) -> @expr {
}
case (ast::expr_tup(?es, ?t)) {
let vec[ast::elt] elts = vec();
let vec[ast::elt] elts = [];
for (ast::elt e in es) {
elts += vec(fold_tup_elt[ENV](env, fld, e));
elts += [fold_tup_elt[ENV](env, fld, e)];
}
auto t2 = fld.fold_ann(env_, t);
ret fld.fold_expr_tup(env_, e.span, elts, t2);
}
case (ast::expr_rec(?fs, ?base, ?t)) {
let vec[ast::field] fields = vec();
let vec[ast::field] fields = [];
let option::t[@expr] b = none[@expr];
for (ast::field f in fs) {
fields += vec(fold_rec_field(env, fld, f));
fields += [fold_rec_field(env, fld, f)];
}
alt (base) {
case (none[@ast::expr]) { }
@ -606,14 +606,14 @@ fn fold_expr[ENV](&ENV env, &ast_fold[ENV] fld, &@expr e) -> @expr {
case (ast::expr_bind(?f, ?args_opt, ?t)) {
auto ff = fold_expr(env_, fld, f);
let vec[option::t[@ast::expr]] aargs_opt = vec();
let vec[option::t[@ast::expr]] aargs_opt = [];
for (option::t[@ast::expr] t_opt in args_opt) {
alt (t_opt) {
case (none[@ast::expr]) {
aargs_opt += vec(none[@ast::expr]);
aargs_opt += [none[@ast::expr]];
}
case (some[@ast::expr](?e)) {
aargs_opt += vec(some(fold_expr(env_, fld, e)));
aargs_opt += [some(fold_expr(env_, fld, e))];
}
case (none[@ast::expr]) { /* empty */ }
}
@ -700,9 +700,9 @@ fn fold_expr[ENV](&ENV env, &ast_fold[ENV] fld, &@expr e) -> @expr {
case (ast::expr_alt(?expr, ?arms, ?t)) {
auto eexpr = fold_expr(env_, fld, expr);
let vec[ast::arm] aarms = vec();
let vec[ast::arm] aarms = [];
for (ast::arm a in arms) {
aarms += vec(fold_arm(env_, fld, a));
aarms += [fold_arm(env_, fld, a)];
}
auto t2 = fld.fold_ann(env_, t);
ret fld.fold_expr_alt(env_, e.span, eexpr, aarms, t2);
@ -887,7 +887,7 @@ fn fold_block[ENV](&ENV env, &ast_fold[ENV] fld, &block blk) -> block {
ret blk;
}
let vec[@ast::stmt] stmts = vec();
let vec[@ast::stmt] stmts = [];
for (@ast::stmt s in blk.node.stmts) {
auto new_stmt = fold_stmt[ENV](env_, fld, s);
_vec::push[@ast::stmt](stmts, new_stmt);
@ -921,9 +921,9 @@ fn fold_arg[ENV](&ENV env, &ast_fold[ENV] fld, &arg a) -> arg {
fn fold_fn_decl[ENV](&ENV env, &ast_fold[ENV] fld,
&ast::fn_decl decl) -> ast::fn_decl {
let vec[ast::arg] inputs = vec();
let vec[ast::arg] inputs = [];
for (ast::arg a in decl.inputs) {
inputs += vec(fold_arg(env, fld, a));
inputs += [fold_arg(env, fld, a)];
}
auto output = fold_ty[ENV](env, fld, decl.output);
ret fld.fold_fn_decl(env, inputs, output, decl.purity);
@ -953,10 +953,10 @@ fn fold_method[ENV](&ENV env, &ast_fold[ENV] fld,
fn fold_obj[ENV](&ENV env, &ast_fold[ENV] fld, &ast::_obj ob) -> ast::_obj {
let vec[ast::obj_field] fields = vec();
let vec[@ast::method] meths = vec();
let vec[ast::obj_field] fields = [];
let vec[@ast::method] meths = [];
for (ast::obj_field f in ob.fields) {
fields += vec(fold_obj_field(env, fld, f));
fields += [fold_obj_field(env, fld, f)];
}
let option::t[@ast::method] dtor = none[@ast::method];
alt (ob.dtor) {
@ -965,7 +965,7 @@ fn fold_obj[ENV](&ENV env, &ast_fold[ENV] fld, &ast::_obj ob) -> ast::_obj {
dtor = some[@ast::method](fold_method[ENV](env, fld, m));
}
}
let vec[ast::ty_param] tp = vec();
let vec[ast::ty_param] tp = [];
for (@ast::method m in ob.methods) {
// Fake-up an ast::item for this method.
// FIXME: this is kinda awful. Maybe we should reformulate
@ -990,9 +990,9 @@ fn fold_anon_obj[ENV](&ENV env, &ast_fold[ENV] fld, &ast::anon_obj ob)
alt (ob.fields) {
case (none[vec[ast::obj_field]]) { }
case (some[vec[ast::obj_field]](?v)) {
let vec[ast::obj_field] fields = vec();
let vec[ast::obj_field] fields = [];
for (ast::obj_field f in v) {
fields += vec(fold_obj_field(env, fld, f));
fields += [fold_obj_field(env, fld, f)];
}
}
}
@ -1007,8 +1007,8 @@ fn fold_anon_obj[ENV](&ENV env, &ast_fold[ENV] fld, &ast::anon_obj ob)
}
// Methods
let vec[@ast::method] meths = vec();
let vec[ast::ty_param] tp = vec();
let vec[@ast::method] meths = [];
let vec[ast::ty_param] tp = [];
for (@ast::method m in ob.methods) {
// Fake-up an ast::item for this method.
// FIXME: this is kinda awful. Maybe we should reformulate
@ -1089,16 +1089,16 @@ fn fold_item[ENV](&ENV env, &ast_fold[ENV] fld, &@item i) -> @item {
}
case (ast::item_tag(?ident, ?variants, ?ty_params, ?id, ?ann)) {
let vec[ast::variant] new_variants = vec();
let vec[ast::variant] new_variants = [];
for (ast::variant v in variants) {
let vec[ast::variant_arg] new_args = vec();
let vec[ast::variant_arg] new_args = [];
for (ast::variant_arg va in v.node.args) {
auto new_ty = fold_ty[ENV](env_, fld, va.ty);
new_args += vec(rec(ty=new_ty, id=va.id));
new_args += [rec(ty=new_ty, id=va.id)];
}
auto new_v = rec(name=v.node.name, args=new_args,
id=v.node.id, ann=v.node.ann);
new_variants += vec(respan[ast::variant_](v.span, new_v));
new_variants += [respan[ast::variant_](v.span, new_v)];
}
ret fld.fold_item_tag(env_, i.span, ident, new_variants,
ty_params, id, ann);
@ -1116,8 +1116,8 @@ fn fold_item[ENV](&ENV env, &ast_fold[ENV] fld, &@item i) -> @item {
fn fold_mod[ENV](&ENV e, &ast_fold[ENV] fld, &ast::_mod m) -> ast::_mod {
let vec[@view_item] view_items = vec();
let vec[@item] items = vec();
let vec[@view_item] view_items = [];
let vec[@item] items = [];
for (@view_item vi in m.view_items) {
auto new_vi = fold_view_item[ENV](e, fld, vi);
@ -1154,8 +1154,8 @@ fn fold_native_item[ENV](&ENV env, &ast_fold[ENV] fld,
fn fold_native_mod[ENV](&ENV e, &ast_fold[ENV] fld,
&ast::native_mod m) -> ast::native_mod {
let vec[@view_item] view_items = vec();
let vec[@native_item] items = vec();
let vec[@view_item] view_items = [];
let vec[@native_item] items = [];
for (@view_item vi in m.view_items) {
auto new_vi = fold_view_item[ENV](e, fld, vi);

40
src/comp/middle/metadata.rs
View file

@ -299,8 +299,8 @@ fn add_to_index(&ebml::writer ebml_w,
&vec[str] path,
&mutable vec[tup(str, uint)] index,
&str name) {
auto full_path = path + vec(name);
index += vec(tup(_str::connect(full_path, "::"), ebml_w.writer.tell()));
auto full_path = path + [name];
index += [tup(_str::connect(full_path, "::"), ebml_w.writer.tell())];
}
fn encode_native_module_item_paths(&ebml::writer ebml_w,
@ -353,7 +353,7 @@ fn encode_module_item_paths(&ebml::writer ebml_w,
ebml::start_tag(ebml_w, tag_paths_data_mod);
encode_name(ebml_w, id);
encode_def_id(ebml_w, did);
encode_module_item_paths(ebml_w, _mod, path + vec(id), index);
encode_module_item_paths(ebml_w, _mod, path + [id], index);
ebml::end_tag(ebml_w);
}
case (ast::item_native_mod(?id, ?nmod, ?did)) {
@ -361,7 +361,7 @@ fn encode_module_item_paths(&ebml::writer ebml_w,
ebml::start_tag(ebml_w, tag_paths_data_mod);
encode_name(ebml_w, id);
encode_def_id(ebml_w, did);
encode_native_module_item_paths(ebml_w, nmod, path + vec(id),
encode_native_module_item_paths(ebml_w, nmod, path + [id],
index);
ebml::end_tag(ebml_w);
}
@ -400,8 +400,8 @@ fn encode_module_item_paths(&ebml::writer ebml_w,
fn encode_item_paths(&ebml::writer ebml_w, &@ast::crate crate)
-> vec[tup(str, uint)] {
let vec[tup(str, uint)] index = vec();
let vec[str] path = vec();
let vec[tup(str, uint)] index = [];
let vec[str] path = [];
ebml::start_tag(ebml_w, tag_paths);
encode_module_item_paths(ebml_w, crate.node.module, path, index);
ebml::end_tag(ebml_w);
@ -413,7 +413,7 @@ fn encode_item_paths(&ebml::writer ebml_w, &@ast::crate crate)
fn encode_kind(&ebml::writer ebml_w, u8 c) {
ebml::start_tag(ebml_w, tag_items_data_item_kind);
ebml_w.writer.write(vec(c));
ebml_w.writer.write([c]);
ebml::end_tag(ebml_w);
}
@ -470,7 +470,7 @@ fn encode_tag_variant_info(&@trans::crate_ctxt cx, &ebml::writer ebml_w,
&mutable vec[tup(int, uint)] index,
&vec[ast::ty_param] ty_params) {
for (ast::variant variant in variants) {
index += vec(tup(variant.node.id._1, ebml_w.writer.tell()));
index += [tup(variant.node.id._1, ebml_w.writer.tell())];
ebml::start_tag(ebml_w, tag_items_data_item);
encode_def_id(ebml_w, variant.node.id);
@ -549,7 +549,7 @@ fn encode_info_for_item(@trans::crate_ctxt cx, &ebml::writer ebml_w,
encode_symbol(cx, ebml_w, odid.ctor);
ebml::end_tag(ebml_w);
index += vec(tup(odid.ty._1, ebml_w.writer.tell()));
index += [tup(odid.ty._1, ebml_w.writer.tell())];
ebml::start_tag(ebml_w, tag_items_data_item);
encode_def_id(ebml_w, odid.ty);
encode_kind(ebml_w, 'y' as u8);
@ -582,16 +582,16 @@ fn encode_info_for_native_item(&@trans::crate_ctxt cx, &ebml::writer ebml_w,
fn encode_info_for_items(&@trans::crate_ctxt cx, &ebml::writer ebml_w)
-> vec[tup(int, uint)] {
let vec[tup(int, uint)] index = vec();
let vec[tup(int, uint)] index = [];
ebml::start_tag(ebml_w, tag_items_data);
for each (@tup(ast::def_id, @ast::item) kvp in cx.items.items()) {
index += vec(tup(kvp._0._1, ebml_w.writer.tell()));
index += [tup(kvp._0._1, ebml_w.writer.tell())];
encode_info_for_item(cx, ebml_w, kvp._1, index);
}
for each (@tup(ast::def_id, @ast::native_item) kvp in
cx.native_items.items()) {
index += vec(tup(kvp._0._1, ebml_w.writer.tell()));
index += [tup(kvp._0._1, ebml_w.writer.tell())];
encode_info_for_native_item(cx, ebml_w, kvp._1);
}
ebml::end_tag(ebml_w);
@ -618,15 +618,15 @@ fn hash_path(&str s) -> uint {
fn create_index[T](&vec[tup(T, uint)] index, fn(&T) -> uint hash_fn)
-> vec[vec[tup(T, uint)]] {
let vec[vec[tup(T, uint)]] buckets = vec();
let vec[vec[tup(T, uint)]] buckets = [];
for each (uint i in _uint::range(0u, 256u)) {
let vec[tup(T, uint)] bucket = vec();
buckets += vec(bucket);
let vec[tup(T, uint)] bucket = [];
buckets += [bucket];
}
for (tup(T, uint) elt in index) {
auto h = hash_fn(elt._0);
buckets.(h % 256u) += vec(elt);
buckets.(h % 256u) += [elt];
}
ret buckets;
@ -638,10 +638,10 @@ fn encode_index[T](&ebml::writer ebml_w, &vec[vec[tup(T, uint)]] buckets,
ebml::start_tag(ebml_w, tag_index);
let vec[uint] bucket_locs = vec();
let vec[uint] bucket_locs = [];
ebml::start_tag(ebml_w, tag_index_buckets);
for (vec[tup(T, uint)] bucket in buckets) {
bucket_locs += vec(ebml_w.writer.tell());
bucket_locs += [ebml_w.writer.tell()];
ebml::start_tag(ebml_w, tag_index_buckets_bucket);
for (tup(T, uint) elt in bucket) {
@ -698,7 +698,7 @@ fn encode_metadata(&@trans::crate_ctxt cx, &@ast::crate crate)
// Pad this, since something (LLVM, presumably) is cutting off the
// remaining % 4 bytes.
buf_w.write(vec(0u8, 0u8, 0u8, 0u8));
buf_w.write([0u8, 0u8, 0u8, 0u8]);
ret C_postr(string_w.get_str());
}
@ -709,7 +709,7 @@ fn write_metadata(&@trans::crate_ctxt cx, &@ast::crate crate) {
llmeta = encode_metadata(cx, crate);
}
auto llconst = trans::C_struct(vec(llmeta));
auto llconst = trans::C_struct([llmeta]);
auto llglobal = llvm::LLVMAddGlobal(cx.llmod, trans::val_ty(llconst),
_str::buf("rust_metadata"));
llvm::LLVMSetInitializer(llglobal, llconst);

4
src/comp/middle/resolve.rs
View file

@ -253,7 +253,7 @@ fn pop_env_for_item(@mutable list[scope] sc, &@ast::item i) {
}
fn push_env_for_method(@mutable list[scope] sc, &@ast::method m) {
let vec[ast::ty_param] tp = vec();
let vec[ast::ty_param] tp = [];
let @ast::item i = @rec(node=ast::item_fn(m.node.ident,
m.node.meth,
tp,
@ -686,7 +686,7 @@ fn lookup_in_mod(&env e, def m, &ident id, namespace ns, dir dr)
if (defid._0 != ast::local_crate) { // Not in this crate
auto cached = e.ext_cache.find(tup(defid,id,ns));
if (!option::is_none(cached)) { ret cached; }
auto path = vec(id);
auto path = [id];
if (defid._1 != -1) {
path = e.ext_map.get(defid) + path;
}

928
src/comp/middle/trans.rs
View file

File diff suppressed because it is too large Load diff

92
src/comp/middle/ty.rs
View file

@ -420,9 +420,9 @@ fn mk_tup(&ctxt cx, &vec[mt] tms) -> t { ret gen_ty(cx, ty_tup(tms)); }
fn mk_imm_tup(&ctxt cx, &vec[t] tys) -> t {
// TODO: map
let vec[ty::mt] mts = vec();
let vec[ty::mt] mts = [];
for (t typ in tys) {
mts += vec(rec(ty=typ, mut=ast::imm));
mts += [rec(ty=typ, mut=ast::imm)];
}
ret mk_tup(cx, mts);
}
@ -625,12 +625,12 @@ fn ty_to_str(ctxt cx, &t typ) -> str {
}
case (ty_param(?id)) {
s += "'" + _str::unsafe_from_bytes(vec(('a' as u8) + (id as u8)));
s += "'" + _str::unsafe_from_bytes([('a' as u8) + (id as u8)]);
}
case (ty_bound_param(?id)) {
s += "''" + _str::unsafe_from_bytes(vec(('a' as u8) +
(id as u8)));
s += "''" + _str::unsafe_from_bytes([('a' as u8) +
(id as u8)]);
}
}
@ -693,7 +693,7 @@ fn walk_ty(ctxt cx, ty_walk walker, t ty) {
walk_ty(cx, walker, ret_ty);
}
case (ty_obj(?methods)) {
let vec[method] new_methods = vec();
let vec[method] new_methods = [];
for (method m in methods) {
for (arg a in m.inputs) {
walk_ty(cx, walker, a.ty);
@ -740,58 +740,58 @@ fn fold_ty(ctxt cx, ty_fold fld, t ty_0) -> t {
ty = copy_cname(cx, mk_chan(cx, fold_ty(cx, fld, subty)), ty);
}
case (ty_tag(?tid, ?subtys)) {
let vec[t] new_subtys = vec();
let vec[t] new_subtys = [];
for (t subty in subtys) {
new_subtys += vec(fold_ty(cx, fld, subty));
new_subtys += [fold_ty(cx, fld, subty)];
}
ty = copy_cname(cx, mk_tag(cx, tid, new_subtys), ty);
}
case (ty_tup(?mts)) {
let vec[mt] new_mts = vec();
let vec[mt] new_mts = [];
for (mt tm in mts) {
auto new_subty = fold_ty(cx, fld, tm.ty);
new_mts += vec(rec(ty=new_subty, mut=tm.mut));
new_mts += [rec(ty=new_subty, mut=tm.mut)];
}
ty = copy_cname(cx, mk_tup(cx, new_mts), ty);
}
case (ty_rec(?fields)) {
let vec[field] new_fields = vec();
let vec[field] new_fields = [];
for (field fl in fields) {
auto new_ty = fold_ty(cx, fld, fl.mt.ty);
auto new_mt = rec(ty=new_ty, mut=fl.mt.mut);
new_fields += vec(rec(ident=fl.ident, mt=new_mt));
new_fields += [rec(ident=fl.ident, mt=new_mt)];
}
ty = copy_cname(cx, mk_rec(cx, new_fields), ty);
}
case (ty_fn(?proto, ?args, ?ret_ty)) {
let vec[arg] new_args = vec();
let vec[arg] new_args = [];
for (arg a in args) {
auto new_ty = fold_ty(cx, fld, a.ty);
new_args += vec(rec(mode=a.mode, ty=new_ty));
new_args += [rec(mode=a.mode, ty=new_ty)];
}
ty = copy_cname(cx, mk_fn(cx, proto, new_args,
fold_ty(cx, fld, ret_ty)), ty);
}
case (ty_native_fn(?abi, ?args, ?ret_ty)) {
let vec[arg] new_args = vec();
let vec[arg] new_args = [];
for (arg a in args) {
auto new_ty = fold_ty(cx, fld, a.ty);
new_args += vec(rec(mode=a.mode, ty=new_ty));
new_args += [rec(mode=a.mode, ty=new_ty)];
}
ty = copy_cname(cx, mk_native_fn(cx, abi, new_args,
fold_ty(cx, fld, ret_ty)), ty);
}
case (ty_obj(?methods)) {
let vec[method] new_methods = vec();
let vec[method] new_methods = [];
for (method m in methods) {
let vec[arg] new_args = vec();
let vec[arg] new_args = [];
for (arg a in m.inputs) {
new_args += vec(rec(mode=a.mode,
ty=fold_ty(cx, fld, a.ty)));
new_args += [rec(mode=a.mode,
ty=fold_ty(cx, fld, a.ty))];
}
new_methods += vec(rec(proto=m.proto, ident=m.ident,
new_methods += [rec(proto=m.proto, ident=m.ident,
inputs=new_args,
output=fold_ty(cx, fld, m.output)));
output=fold_ty(cx, fld, m.output))];
}
ty = copy_cname(cx, mk_obj(cx, new_methods), ty);
}
@ -1443,7 +1443,7 @@ fn ann_to_type(&node_type_table ntt, &ast::ann ann) -> t {
fn ann_to_type_params(&node_type_table ntt, &ast::ann ann) -> vec[t] {
alt (ann_to_ty_param_substs_opt_and_ty(ntt, ann)._0) {
case (none[vec[t]]) {
let vec[t] result = vec();
let vec[t] result = [];
ret result;
}
case (some[vec[t]](?tps)) { ret tps; }
@ -1492,14 +1492,14 @@ fn count_ty_params(ctxt cx, t ty) -> uint {
}
}
if (!seen) {
*param_indices += vec(param_idx);
*param_indices += [param_idx];
}
}
case (_) { /* fall through */ }
}
}
let vec[uint] v = vec(); // FIXME: typechecker botch
let vec[uint] v = []; // FIXME: typechecker botch
let @mutable vec[uint] param_indices = @mutable v;
auto f = bind counter(cx, param_indices, _);
walk_ty(cx, f, ty);
@ -1873,7 +1873,7 @@ mod unify {
}
// TODO: as above, we should have an iter2 iterator.
let vec[arg] result_ins = vec();
let vec[arg] result_ins = [];
auto i = 0u;
while (i < expected_len) {
auto expected_input = expected_inputs.(i);
@ -1897,7 +1897,7 @@ mod unify {
alt (result) {
case (ures_ok(?rty)) {
result_ins += vec(rec(mode=result_mode, ty=rty));
result_ins += [rec(mode=result_mode, ty=rty)];
}
case (_) {
@ -1979,7 +1979,7 @@ mod unify {
&t actual,
&vec[method] expected_meths,
&vec[method] actual_meths) -> result {
let vec[method] result_meths = vec();
let vec[method] result_meths = [];
let uint i = 0u;
let uint expected_len = _vec::len[method](expected_meths);
let uint actual_len = _vec::len[method](actual_meths);
@ -2004,9 +2004,9 @@ mod unify {
case (ures_ok(?tfn)) {
alt (struct(cx.tcx, tfn)) {
case (ty_fn(?proto, ?ins, ?out)) {
result_meths += vec(rec(inputs = ins,
result_meths += [rec(inputs = ins,
output = out
with e_meth));
with e_meth)];
}
}
}
@ -2057,10 +2057,10 @@ mod unify {
// Just bind the type variable to the expected type.
auto vlen = _vec::len[vec[t]](cx.types);
if (actual_n < vlen) {
cx.types.(actual_n) += vec(expected);
cx.types.(actual_n) += [expected];
} else {
assert (actual_n == vlen);
cx.types += vec(mutable vec(expected));
cx.types += [mutable [expected]];
}
}
}
@ -2120,7 +2120,7 @@ mod unify {
// TODO: factor this cruft out, see the TODO in the
// ty::ty_tup case
let vec[t] result_tps = vec();
let vec[t] result_tps = [];
auto i = 0u;
auto expected_len = _vec::len[t](expected_tps);
while (i < expected_len) {
@ -2272,7 +2272,7 @@ mod unify {
// TODO: implement an iterator that can iterate over
// two arrays simultaneously.
let vec[ty::mt] result_elems = vec();
let vec[ty::mt] result_elems = [];
auto i = 0u;
while (i < expected_len) {
auto expected_elem = expected_elems.(i);
@ -2294,7 +2294,7 @@ mod unify {
alt (result) {
case (ures_ok(?rty)) {
auto mt = rec(ty=rty, mut=mut);
result_elems += vec(mt);
result_elems += [mt];
}
case (_) {
ret result;
@ -2326,7 +2326,7 @@ mod unify {
// TODO: implement an iterator that can iterate over
// two arrays simultaneously.
let vec[field] result_fields = vec();
let vec[field] result_fields = [];
auto i = 0u;
while (i < expected_len) {
auto expected_field = expected_fields.(i);
@ -2425,10 +2425,10 @@ mod unify {
auto expected_n = get_or_create_set(cx, expected_id);
auto vlen = _vec::len[vec[t]](cx.types);
if (expected_n < vlen) {
cx.types.(expected_n) += vec(actual);
cx.types.(expected_n) += [actual];
} else {
assert (expected_n == vlen);
cx.types += vec(mutable vec(actual));
cx.types += [mutable [actual]];
}
ret ures_ok(expected);
}
@ -2485,13 +2485,13 @@ mod unify {
}
fn unify_sets(&@ctxt cx) -> vec[t] {
let vec[t] throwaway = vec();
let vec[mutable vec[t]] set_types = vec(mutable throwaway);
let vec[t] throwaway = [];
let vec[mutable vec[t]] set_types = [mutable throwaway];
_vec::pop[vec[t]](set_types); // FIXME: botch
for (ufind::node node in cx.sets.nodes) {
let vec[t] v = vec();
set_types += vec(mutable v);
let vec[t] v = [];
set_types += [mutable v];
}
auto i = 0u;
@ -2501,14 +2501,14 @@ mod unify {
i += 1u;
}
let vec[t] result = vec();
let vec[t] result = [];
for (vec[t] types in set_types) {
if (_vec::len[t](types) > 1u) {
log_err "unification of > 1 types in a type set is " +
"unimplemented";
fail;
}
result += vec(types.(0));
result += [types.(0)];
}
ret result;
@ -2518,8 +2518,8 @@ mod unify {
&t actual,
&unify_handler handler,
&ty_ctxt tcx) -> result {
let vec[t] throwaway = vec();
let vec[mutable vec[t]] types = vec(mutable throwaway);
let vec[t] throwaway = [];
let vec[mutable vec[t]] types = [mutable throwaway];
_vec::pop[vec[t]](types); // FIXME: botch
auto cx = @rec(sets=ufind::make(),

16
src/comp/middle/type_glue.rs
View file

@ -37,17 +37,17 @@ fn rc_shape_of(&ty::ctxt tcx, variant_getter getter, ty::t t) -> rc_shape {
case (ty::ty_char) { ret rs_none; }
case (ty::ty_str) { ret rs_none; }
case (ty::ty_tag(?did, ?params)) {
let vec[vec[@rc_shape]] result = vec();
let vec[vec[@rc_shape]] result = [];
auto vinfos = getter(did);
for (variant_info vinfo in vinfos) {
let vec[@rc_shape] variant_rcs = vec();
let vec[@rc_shape] variant_rcs = [];
for (ty::t typ in vinfo.args) {
auto ty_1 = ty::bind_params_in_type(tcx, typ);
ty_1 = ty::substitute_type_params(tcx, params, ty_1);
variant_rcs += vec(@rc_shape_of(tcx, getter, ty_1));
variant_rcs += [@rc_shape_of(tcx, getter, ty_1)];
}
result += vec(variant_rcs);
result += [variant_rcs];
}
ret rs_tag(result);
@ -58,16 +58,16 @@ fn rc_shape_of(&ty::ctxt tcx, variant_getter getter, ty::t t) -> rc_shape {
case (ty::ty_chan(_)) { ret rs_ref; }
case (ty::ty_task) { ret rs_ref; }
case (ty::ty_tup(?mts)) {
let vec[@rc_shape] result = vec();
let vec[@rc_shape] result = [];
for (ty::mt tm in mts) {
result += vec(@rc_shape_of(tcx, getter, tm.ty));
result += [@rc_shape_of(tcx, getter, tm.ty)];
}
ret rs_tup(result);
}
case (ty::ty_rec(?fields)) {
let vec[@rc_shape] result = vec();
let vec[@rc_shape] result = [];
for (ty::field fld in fields) {
result += vec(@rc_shape_of(tcx, getter, fld.mt.ty));
result += [@rc_shape_of(tcx, getter, fld.mt.ty)];
}
ret rs_tup(result);
}

140
src/comp/middle/typeck.rs
View file

@ -188,10 +188,10 @@ fn instantiate_path(&@fn_ctxt fcx, &ast::path pth, &ty_param_count_and_ty tpt,
auto ty_substs_opt;
auto ty_substs_len = _vec::len[@ast::ty](pth.node.types);
if (ty_substs_len > 0u) {
let vec[ty::t] ty_substs = vec();
let vec[ty::t] ty_substs = [];
auto i = 0u;
while (i < ty_substs_len) {
ty_substs += vec(ast_ty_to_ty_crate(fcx.ccx, pth.node.types.(i)));
ty_substs += [ast_ty_to_ty_crate(fcx.ccx, pth.node.types.(i))];
i += 1u;
}
ty_substs_opt = some[vec[ty::t]](ty_substs);
@ -203,10 +203,10 @@ fn instantiate_path(&@fn_ctxt fcx, &ast::path pth, &ty_param_count_and_ty tpt,
}
} else {
// We will acquire the type parameters through unification.
let vec[ty::t] ty_substs = vec();
let vec[ty::t] ty_substs = [];
auto i = 0u;
while (i < ty_param_count) {
ty_substs += vec(next_ty_var(fcx.ccx));
ty_substs += [next_ty_var(fcx.ccx)];
i += 1u;
}
ty_substs_opt = some[vec[ty::t]](ty_substs);
@ -259,9 +259,9 @@ fn ast_ty_to_ty(&ty::ctxt tcx, &ty_getter getter, &@ast::ty ast_ty) -> ty::t {
// TODO: Make sure the number of supplied bindings matches the number
// of type parameters in the typedef. Emit a friendly error otherwise.
auto bound_ty = bind_params_in_type(tcx, params_opt_and_ty._1);
let vec[ty::t] param_bindings = vec();
let vec[ty::t] param_bindings = [];
for (@ast::ty ast_ty in args) {
param_bindings += vec(ast_ty_to_ty(tcx, getter, ast_ty));
param_bindings += [ast_ty_to_ty(tcx, getter, ast_ty)];
}
ret ty::substitute_type_params(tcx, param_bindings, bound_ty);
}
@ -294,14 +294,14 @@ fn ast_ty_to_ty(&ty::ctxt tcx, &ty_getter getter, &@ast::ty ast_ty) -> ty::t {
}
case (ast::ty_tup(?fields)) {
let vec[ty::mt] flds = vec();
let vec[ty::mt] flds = [];
for (ast::mt field in fields) {
_vec::push[ty::mt](flds, ast_mt_to_mt(tcx, getter, field));
}
typ = ty::mk_tup(tcx, flds);
}
case (ast::ty_rec(?fields)) {
let vec[field] flds = vec();
let vec[field] flds = [];
for (ast::ty_field f in fields) {
auto tm = ast_mt_to_mt(tcx, getter, f.mt);
_vec::push[field](flds, rec(ident=f.ident, mt=tm));
@ -336,7 +336,7 @@ fn ast_ty_to_ty(&ty::ctxt tcx, &ty_getter getter, &@ast::ty ast_ty) -> ty::t {
}
case (ast::ty_obj(?meths)) {
let vec[ty::method] tmeths = vec();
let vec[ty::method] tmeths = [];
auto f = bind ast_arg_to_arg(tcx, getter, _);
for (ast::ty_method m in meths) {
auto ins = _vec::map[ast::ty_arg, arg](f, m.inputs);
@ -502,7 +502,7 @@ mod collect {
-> ty::ty_param_count_and_ty {
auto t_obj = ty_of_obj(cx, id, obj_info, ty_params);
let vec[arg] t_inputs = vec();
let vec[arg] t_inputs = [];
for (ast::obj_field f in obj_info.fields) {
auto g = bind getter(cx, _);
auto t_field = ast_ty_to_ty(cx.tcx, g, f.ty);
@ -561,11 +561,11 @@ mod collect {
case (ast::item_tag(_, _, ?tps, ?def_id, _)) {
// Create a new generic polytype.
let vec[ty::t] subtys = vec();
let vec[ty::t] subtys = [];
auto i = 0u;
for (ast::ty_param tp in tps) {
subtys += vec(ty::mk_param(cx.tcx, i));
subtys += [ty::mk_param(cx.tcx, i)];
i += 1u;
}
@ -613,13 +613,13 @@ mod collect {
&vec[ast::variant] variants,
&vec[ast::ty_param] ty_params)
-> vec[ast::variant] {
let vec[ast::variant] result = vec();
let vec[ast::variant] result = [];
// Create a set of parameter types shared among all the variants.
let vec[ty::t] ty_param_tys = vec();
let vec[ty::t] ty_param_tys = [];
auto i = 0u;
for (ast::ty_param tp in ty_params) {
ty_param_tys += vec(ty::mk_param(cx.tcx, i));
ty_param_tys += [ty::mk_param(cx.tcx, i)];
i += 1u;
}
@ -636,10 +636,10 @@ mod collect {
// should be called to resolve named types.
auto f = bind getter(cx, _);
let vec[arg] args = vec();
let vec[arg] args = [];
for (ast::variant_arg va in variant.node.args) {
auto arg_ty = ast_ty_to_ty(cx.tcx, f, va.ty);
args += vec(rec(mode=ty::mo_alias, ty=arg_ty));
args += [rec(mode=ty::mo_alias, ty=arg_ty)];
}
auto tag_t = ty::mk_tag(cx.tcx, tag_id, ty_param_tys);
result_ty = ty::mk_fn(cx.tcx, ast::proto_fn, args, tag_t);
@ -653,7 +653,7 @@ mod collect {
);
write_type_only(cx.node_types, ast::ann_tag(variant.node.ann),
result_ty);
result += vec(fold::respan(variant.span, variant_t));
result += [fold::respan(variant.span, variant_t)];
}
ret result;
@ -750,7 +750,7 @@ mod collect {
case (none[@ast::method]) { /* nothing to do */ }
case (some[@ast::method](?m)) {
// TODO: typechecker botch
let vec[arg] no_args = vec();
let vec[arg] no_args = [];
auto t = ty::mk_fn(cx.tcx, ast::proto_fn, no_args,
ty::mk_nil(cx.tcx));
write_type_only(cx.node_types,
@ -795,7 +795,7 @@ mod collect {
auto id_to_ty_item = @common::new_def_hash[any_item]();
let vec[mutable option::t[ty::ty_param_substs_opt_and_ty]] ntt_sub =
vec(mutable);
[mutable];
let node_type_table ntt = @mutable ntt_sub;
auto visit = rec(
@ -837,7 +837,7 @@ mod unify {
&ty::t actual) -> ty::unify::result {
// FIXME: horrid botch
let vec[mutable ty::t] param_substs =
vec(mutable ty::mk_nil(fcx.ccx.tcx));
[mutable ty::mk_nil(fcx.ccx.tcx)];
_vec::pop(param_substs);
ret with_params(fcx, expected, actual, param_substs);
}
@ -884,9 +884,9 @@ mod unify {
}
// TODO: "freeze"
let vec[ty::t] param_substs_1 = vec();
let vec[ty::t] param_substs_1 = [];
for (ty::t subst in param_substs) {
param_substs_1 += vec(subst);
param_substs_1 += [subst];
}
unified_type =
@ -968,13 +968,13 @@ type ty_param_substs_and_ty = tup(vec[ty::t], ty::t);
mod Demand {
fn simple(&@fn_ctxt fcx, &span sp, &ty::t expected, &ty::t actual)
-> ty::t {
let vec[ty::t] tps = vec();
let vec[ty::t] tps = [];
ret full(fcx, sp, expected, actual, tps, NO_AUTODEREF)._1;
}
fn autoderef(&@fn_ctxt fcx, &span sp, &ty::t expected, &ty::t actual,
autoderef_kind adk) -> ty::t {
let vec[ty::t] tps = vec();
let vec[ty::t] tps = [];
ret full(fcx, sp, expected, actual, tps, adk)._1;
}
@ -996,18 +996,18 @@ mod Demand {
}
let vec[mutable ty::t] ty_param_substs =
vec(mutable ty::mk_nil(fcx.ccx.tcx));
[mutable ty::mk_nil(fcx.ccx.tcx)];
_vec::pop(ty_param_substs); // FIXME: horrid botch
for (ty::t ty_param_subst in ty_param_substs_0) {
ty_param_substs += vec(mutable ty_param_subst);
ty_param_substs += [mutable ty_param_subst];
}
alt (unify::with_params(fcx, expected_1, actual_1, ty_param_substs)) {
case (ures_ok(?t)) {
// TODO: Use "freeze", when we have it.
let vec[ty::t] result_ty_param_substs = vec();
let vec[ty::t] result_ty_param_substs = [];
for (ty::t ty_param_subst in ty_param_substs) {
result_ty_param_substs += vec(ty_param_subst);
result_ty_param_substs += [ty_param_subst];
}
ret tup(result_ty_param_substs,
@ -1042,7 +1042,7 @@ fn variant_arg_types(&@crate_ctxt ccx, &span sp, &ast::def_id vid,
&vec[ty::t] tag_ty_params) -> vec[ty::t] {
auto ty_param_count = _vec::len[ty::t](tag_ty_params);
let vec[ty::t] result = vec();
let vec[ty::t] result = [];
auto tpt = ty::lookup_item_type(ccx.sess, ccx.tcx, ccx.type_cache, vid);
alt (struct(ccx.tcx, tpt._1)) {
@ -1052,7 +1052,7 @@ fn variant_arg_types(&@crate_ctxt ccx, &span sp, &ast::def_id vid,
auto arg_ty = bind_params_in_type(ccx.tcx, arg.ty);
arg_ty = substitute_ty_params(ccx, arg_ty, ty_param_count,
tag_ty_params, sp);
result += vec(arg_ty);
result += [arg_ty];
}
}
case (_) {
@ -1163,11 +1163,11 @@ mod Pushdown {
auto t = Demand::simple(fcx, e.span, expected,
ann_to_type(fcx.ccx.node_types, ann));
let vec[@ast::expr] es_1 = vec();
let vec[@ast::expr] es_1 = [];
alt (struct(fcx.ccx.tcx, t)) {
case (ty::ty_vec(?mt)) {
for (@ast::expr e_0 in es_0) {
es_1 += vec(pushdown_expr(fcx, mt.ty, e_0));
es_1 += [pushdown_expr(fcx, mt.ty, e_0)];
}
}
case (_) {
@ -1182,14 +1182,14 @@ mod Pushdown {
case (ast::expr_tup(?es_0, ?ann)) {
auto t = Demand::simple(fcx, e.span, expected,
ann_to_type(fcx.ccx.node_types, ann));
let vec[ast::elt] elts_1 = vec();
let vec[ast::elt] elts_1 = [];
alt (struct(fcx.ccx.tcx, t)) {
case (ty::ty_tup(?mts)) {
auto i = 0u;
for (ast::elt elt_0 in es_0) {
auto e_1 = pushdown_expr(fcx, mts.(i).ty,
elt_0.expr);
elts_1 += vec(rec(mut=elt_0.mut, expr=e_1));
elts_1 += [rec(mut=elt_0.mut, expr=e_1)];
i += 1u;
}
}
@ -1207,7 +1207,7 @@ mod Pushdown {
auto t = Demand::simple(fcx, e.span, expected,
ann_to_type(fcx.ccx.node_types, ann));
let vec[ast::field] fields_1 = vec();
let vec[ast::field] fields_1 = [];
alt (struct(fcx.ccx.tcx, t)) {
case (ty::ty_rec(?field_mts)) {
alt (base_0) {
@ -1220,9 +1220,9 @@ mod Pushdown {
pushdown_expr(fcx,
field_mts.(i).mt.ty,
field_0.expr);
fields_1 += vec(rec(mut=field_0.mut,
fields_1 += [rec(mut=field_0.mut,
ident=field_0.ident,
expr=e_1));
expr=e_1)];
i += 1u;
}
}
@ -1231,7 +1231,7 @@ mod Pushdown {
base_1 = some[@ast::expr]
(pushdown_expr(fcx, t, bx));
let vec[field] base_fields = vec();
let vec[field] base_fields = [];
for (ast::field field_0 in fields_0) {
@ -1242,9 +1242,9 @@ mod Pushdown {
pushdown_expr(fcx, ft.mt.ty,
field_0.expr);
fields_1 +=
vec(rec(mut=field_0.mut,
[rec(mut=field_0.mut,
ident=field_0.ident,
expr=e_1));
expr=e_1)];
}
}
}
@ -1479,13 +1479,13 @@ mod Pushdown {
case (ast::expr_alt(?discrim, ?arms_0, ?ann)) {
auto t = expected;
let vec[ast::arm] arms_1 = vec();
let vec[ast::arm] arms_1 = [];
for (ast::arm arm_0 in arms_0) {
auto block_1 = pushdown_block(fcx, expected, arm_0.block);
t = Demand::simple(fcx, e.span, t,
block_ty(fcx.ccx.tcx, fcx.ccx.node_types, block_1));
auto arm_1 = rec(pat=arm_0.pat, block=block_1);
arms_1 += vec(arm_1);
arms_1 += [arm_1];
}
e_1 = ast::expr_alt(discrim, arms_1,
triv_ann(ast::ann_tag(ann), t));
@ -1848,13 +1848,13 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) -> @ast::expr {
auto f_0 = check_expr(fcx, f);
// Check the arguments and generate the argument signature.
let vec[option::t[@ast::expr]] args_0 = vec();
let vec[arg] arg_tys_0 = vec();
let vec[option::t[@ast::expr]] args_0 = [];
let vec[arg] arg_tys_0 = [];
for (option::t[@ast::expr] a_opt in args) {
alt (a_opt) {
case (some[@ast::expr](?a)) {
auto a_0 = check_expr(fcx, a);
args_0 += vec(some[@ast::expr](a_0));
args_0 += [some[@ast::expr](a_0)];
auto arg_ty = rec(mode=mo_either,
ty=expr_ty(fcx.ccx.tcx,
@ -1862,7 +1862,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) -> @ast::expr {
_vec::push[arg](arg_tys_0, arg_ty);
}
case (none[@ast::expr]) {
args_0 += vec(none[@ast::expr]);
args_0 += [none[@ast::expr]];
auto typ = next_ty_var(fcx.ccx);
_vec::push[arg](arg_tys_0, rec(mode=mo_either, ty=typ));
@ -1920,18 +1920,18 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) -> @ast::expr {
fn check_call(&@fn_ctxt fcx, &@ast::expr f, &vec[@ast::expr] args)
-> tup(@ast::expr, vec[@ast::expr]) {
let vec[option::t[@ast::expr]] args_opt_0 = vec();
let vec[option::t[@ast::expr]] args_opt_0 = [];
for (@ast::expr arg in args) {
args_opt_0 += vec(some[@ast::expr](arg));
args_opt_0 += [some[@ast::expr](arg)];
}
// Call the generic checker.
auto result = check_call_or_bind(fcx, f, args_opt_0);
// Pull out the arguments.
let vec[@ast::expr] args_1 = vec();
let vec[@ast::expr] args_1 = [];
for (option::t[@ast::expr] arg in result._1) {
args_1 += vec(option::get[@ast::expr](arg));
args_1 += [option::get[@ast::expr](arg)];
}
ret tup(result._0, args_1);
@ -2397,12 +2397,12 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) -> @ast::expr {
auto pattern_ty = expr_ty(fcx.ccx.tcx, fcx.ccx.node_types,
expr_0);
let vec[@ast::pat] pats = vec();
let vec[@ast::pat] pats = [];
for (ast::arm arm in arms) {
check_pat(fcx, arm.pat);
pattern_ty = Demand::simple(fcx, arm.pat.span, pattern_ty,
pat_ty(fcx.ccx.tcx, fcx.ccx.node_types, arm.pat));
pats += vec(arm.pat);
pats += [arm.pat];
}
for (@ast::pat pat in pats) {
@ -2412,15 +2412,15 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) -> @ast::expr {
// Now typecheck the blocks.
auto result_ty = next_ty_var(fcx.ccx);
let vec[ast::block] blocks_0 = vec();
let vec[ast::block] blocks_0 = [];
for (ast::arm arm in arms) {
auto block_0 = check_block(fcx, arm.block);
result_ty = Demand::simple(fcx, block_0.span, result_ty,
block_ty(fcx.ccx.tcx, fcx.ccx.node_types, block_0));
blocks_0 += vec(block_0);
blocks_0 += [block_0];
}
let vec[ast::arm] arms_1 = vec();
let vec[ast::arm] arms_1 = [];
auto i = 0u;
for (ast::block block_0 in blocks_0) {
auto block_1 = Pushdown::pushdown_block(fcx, result_ty,
@ -2428,7 +2428,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) -> @ast::expr {
auto pat = pats.(i);
auto arm = arms.(i);
auto arm_1 = rec(pat=pat, block=block_1);
arms_1 += vec(arm_1);
arms_1 += [arm_1];
i += 1u;
}
@ -2464,7 +2464,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) -> @ast::expr {
// Pull the argument and return types out.
auto proto_1;
let vec[ty::arg] arg_tys_1 = vec();
let vec[ty::arg] arg_tys_1 = [];
auto rt_1;
alt (struct(fcx.ccx.tcx, expr_ty(fcx.ccx.tcx, fcx.ccx.node_types,
result._0))) {
@ -2479,7 +2479,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) -> @ast::expr {
alt (args.(i)) {
case (some[@ast::expr](_)) { /* no-op */ }
case (none[@ast::expr]) {
arg_tys_1 += vec(arg_tys.(i));
arg_tys_1 += [arg_tys.(i)];
}
}
i += 1u;
@ -2624,7 +2624,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) -> @ast::expr {
}
case (ast::expr_vec(?args, ?mut, ?a)) {
let vec[@ast::expr] args_1 = vec();
let vec[@ast::expr] args_1 = [];
let ty::t t;
if (_vec::len[@ast::expr](args) == 0u) {
@ -2650,15 +2650,15 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) -> @ast::expr {
}
case (ast::expr_tup(?elts, ?a)) {
let vec[ast::elt] elts_1 = vec();
let vec[ty::mt] elts_mt = vec();
let vec[ast::elt] elts_1 = [];
let vec[ty::mt] elts_mt = [];
for (ast::elt e in elts) {
auto expr_1 = check_expr(fcx, e.expr);
auto expr_t = expr_ty(fcx.ccx.tcx, fcx.ccx.node_types,
expr_1);
_vec::push[ast::elt](elts_1, rec(expr=expr_1 with e));
elts_mt += vec(rec(ty=expr_t, mut=e.mut));
elts_mt += [rec(ty=expr_t, mut=e.mut)];
}
auto typ = ty::mk_tup(fcx.ccx.tcx, elts_mt);
@ -2678,8 +2678,8 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) -> @ast::expr {
}
}
let vec[ast::field] fields_1 = vec();
let vec[field] fields_t = vec();
let vec[ast::field] fields_1 = [];
let vec[field] fields_t = [];
for (ast::field f in fields) {
auto expr_1 = check_expr(fcx, f.expr);
@ -2705,7 +2705,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) -> @ast::expr {
auto bexpr_t = expr_ty(fcx.ccx.tcx, fcx.ccx.node_types,
bexpr_1);
let vec[field] base_fields = vec();
let vec[field] base_fields = [];
alt (struct(fcx.ccx.tcx, bexpr_t)) {
case (ty::ty_rec(?flds)) {
@ -3000,7 +3000,7 @@ fn check_stmt(&@fn_ctxt fcx, &@ast::stmt stmt) -> @ast::stmt {
}
fn check_block(&@fn_ctxt fcx, &ast::block block) -> ast::block {
let vec[@ast::stmt] stmts = vec();
let vec[@ast::stmt] stmts = [];
for (@ast::stmt s in block.node.stmts) {
_vec::push[@ast::stmt](stmts, check_stmt(fcx, s));
}
@ -3093,10 +3093,10 @@ fn check_item_fn(&@crate_ctxt ccx, &span sp, &ast::ident ident, &ast::_fn f,
// and return type translated to typeck::ty values. We don't need do to it
// again here, we can extract them.
let vec[arg] inputs = vec();
let vec[arg] inputs = [];
for (ast::arg arg in f.decl.inputs) {
auto input_ty = ast_ty_to_ty_crate(ccx, arg.ty);
inputs += vec(rec(mode=ast_mode_to_mode(arg.mode), ty=input_ty));
inputs += [rec(mode=ast_mode_to_mode(arg.mode), ty=input_ty)];
}
auto output_ty = ast_ty_to_ty_crate(ccx, f.decl.output);
@ -3182,7 +3182,7 @@ fn check_crate(&ty::ctxt tcx, &@ast::crate crate) -> typecheck_result {
auto sess = tcx.sess;
auto result = collect::collect_item_types(sess, tcx, crate);
let vec[ast::obj_field] fields = vec();
let vec[ast::obj_field] fields = [];
auto hasher = hash_unify_cache_entry;
auto eqer = eq_unify_cache_entry;

68
src/comp/middle/typestate_check.rs
View file

@ -797,10 +797,10 @@ fn find_pre_post_loop(&def_map dm, &fn_info_map fm, &fn_info enclosing,
find_pre_post_expr(dm, fm, enclosing, index);
find_pre_post_block(dm, fm, enclosing, body);
auto loop_precond = declare_var(enclosing, decl_lhs(d),
seq_preconds(enclosing, vec(expr_pp(index),
block_pp(body))));
seq_preconds(enclosing, [expr_pp(index),
block_pp(body)]));
auto loop_postcond = intersect_postconds
(vec(expr_postcond(index), block_postcond(body)));
([expr_postcond(index), block_postcond(body)]);
set_pre_and_post(a, rec(precondition=loop_precond,
postcondition=loop_postcond));
}
@ -897,7 +897,7 @@ fn find_pre_post_expr(&def_map dm, &fn_info_map fm, &fn_info enclosing,
}
// doesn't check that lhs is an lval, but
// that's probably ok
find_pre_post_exprs(dm, fm, enclosing, vec(lhs, rhs), a);
find_pre_post_exprs(dm, fm, enclosing, [lhs, rhs], a);
}
case (expr_recv(?lhs, ?rhs, ?a)) {
alt (lhs.node) {
@ -918,12 +918,12 @@ fn find_pre_post_expr(&def_map dm, &fn_info_map fm, &fn_info enclosing,
}
// doesn't check that lhs is an lval, but
// that's probably ok
find_pre_post_exprs(dm, fm, enclosing, vec(lhs, rhs), a);
find_pre_post_exprs(dm, fm, enclosing, [lhs, rhs], a);
}
case (expr_assign_op(_, ?lhs, ?rhs, ?a)) {
/* Different from expr_assign in that the lhs *must*
already be initialized */
find_pre_post_exprs(dm, fm, enclosing, vec(lhs, rhs), a);
find_pre_post_exprs(dm, fm, enclosing, [lhs, rhs], a);
}
case (expr_lit(_,?a)) {
set_pre_and_post(a, empty_pre_post(num_local_vars));
@ -955,8 +955,8 @@ fn find_pre_post_expr(&def_map dm, &fn_info_map fm, &fn_info enclosing,
alt (maybe_alt) {
case (none[@expr]) {
auto precond_res = seq_preconds(enclosing,
vec(expr_pp(antec),
block_pp(conseq)));
[expr_pp(antec),
block_pp(conseq)]);
set_pre_and_post(a, rec(precondition=precond_res,
postcondition=
expr_poststate(antec)));
@ -965,21 +965,21 @@ fn find_pre_post_expr(&def_map dm, &fn_info_map fm, &fn_info enclosing,
find_pre_post_expr(dm, fm, enclosing, altern);
auto precond_true_case =
seq_preconds(enclosing,
vec(expr_pp(antec), block_pp(conseq)));
[expr_pp(antec), block_pp(conseq)]);
auto postcond_true_case = union_postconds
(num_local_vars,
vec(expr_postcond(antec), block_postcond(conseq)));
[expr_postcond(antec), block_postcond(conseq)]);
auto precond_false_case = seq_preconds
(enclosing,
vec(expr_pp(antec), expr_pp(altern)));
[expr_pp(antec), expr_pp(altern)]);
auto postcond_false_case = union_postconds
(num_local_vars,
vec(expr_postcond(antec), expr_postcond(altern)));
[expr_postcond(antec), expr_postcond(altern)]);
auto precond_res = union_postconds
(num_local_vars,
vec(precond_true_case, precond_false_case));
[precond_true_case, precond_false_case]);
auto postcond_res = intersect_postconds
(vec(postcond_true_case, postcond_false_case));
([postcond_true_case, postcond_false_case]);
set_pre_and_post(a, rec(precondition=precond_res,
postcondition=postcond_res));
}
@ -988,10 +988,10 @@ fn find_pre_post_expr(&def_map dm, &fn_info_map fm, &fn_info enclosing,
case (expr_binary(?bop,?l,?r,?a)) {
/* *unless* bop is lazy (e.g. and, or)?
FIXME */
find_pre_post_exprs(dm, fm, enclosing, vec(l, r), a);
find_pre_post_exprs(dm, fm, enclosing, [l, r], a);
}
case (expr_send(?l, ?r, ?a)) {
find_pre_post_exprs(dm, fm, enclosing, vec(l, r), a);
find_pre_post_exprs(dm, fm, enclosing, [l, r], a);
}
case (expr_unary(_,?operand,?a)) {
find_pre_post_expr(dm, fm, enclosing, operand);
@ -1007,18 +1007,18 @@ fn find_pre_post_expr(&def_map dm, &fn_info_map fm, &fn_info enclosing,
set_pre_and_post(a,
rec(precondition=
seq_preconds(enclosing,
vec(expr_pp(test),
block_pp(body))),
[expr_pp(test),
block_pp(body)]),
postcondition=
intersect_postconds(vec(expr_postcond(test),
block_postcond(body)))));
intersect_postconds([expr_postcond(test),
block_postcond(body)])));
}
case (expr_do_while(?body, ?test, ?a)) {
find_pre_post_block(dm, fm, enclosing, body);
find_pre_post_expr(dm, fm, enclosing, test);
auto loop_postcond = union_postconds(num_local_vars,
vec(block_postcond(body), expr_postcond(test)));
[block_postcond(body), expr_postcond(test)]);
/* conservative approximination: if the body
could break or cont, the test may never be executed */
if (has_nonlocal_exits(body)) {
@ -1027,8 +1027,8 @@ fn find_pre_post_expr(&def_map dm, &fn_info_map fm, &fn_info enclosing,
set_pre_and_post(a,
rec(precondition=seq_preconds(enclosing,
vec(block_pp(body),
expr_pp(test))),
[block_pp(body),
expr_pp(test)]),
postcondition=loop_postcond));
}
case (expr_for(?d, ?index, ?body, ?a)) {
@ -1038,7 +1038,7 @@ fn find_pre_post_expr(&def_map dm, &fn_info_map fm, &fn_info enclosing,
find_pre_post_loop(dm, fm, enclosing, d, index, body, a);
}
case (expr_index(?e, ?sub, ?a)) {
find_pre_post_exprs(dm, fm, enclosing, vec(e, sub), a);
find_pre_post_exprs(dm, fm, enclosing, [e, sub], a);
}
case (expr_alt(?e, ?alts, ?a)) {
find_pre_post_expr(dm, fm, enclosing, e);
@ -1053,7 +1053,7 @@ fn find_pre_post_expr(&def_map dm, &fn_info_map fm, &fn_info enclosing,
fn_info enclosing, &pre_and_post pp,
&pre_and_post next) -> pre_and_post {
union(pp.precondition, seq_preconds(enclosing,
vec(antec, next)));
[antec, next]));
intersect(pp.postcondition, next.postcondition);
ret pp;
}
@ -1214,7 +1214,7 @@ fn find_pre_post_block(&def_map dm, &fn_info_map fm, &fn_info enclosing,
auto do_inner = bind do_inner_(dm, fm, enclosing, _);
option::map[@expr, ()](do_inner, b.node.expr);
let vec[pre_and_post] pps = vec();
let vec[pre_and_post] pps = [];
fn get_pp_stmt(&@stmt s) -> pre_and_post {
ret stmt_pp(*s);
@ -1408,8 +1408,8 @@ fn find_pre_post_state_loop(&def_map dm, &fn_info_map fm, &fn_info enclosing,
(poststate of index, poststate of body) */
changed = find_pre_post_state_block(dm, fm, enclosing,
expr_poststate(index), body) || changed;
auto res_p = intersect_postconds(vec(expr_poststate(index),
block_poststate(body)));
auto res_p = intersect_postconds([expr_poststate(index),
block_poststate(body)]);
changed = extend_poststate_ann(a, res_p) || changed;
ret changed;
@ -1603,7 +1603,7 @@ fn find_pre_post_state_expr(&def_map dm, &fn_info_map fm, &fn_info enclosing,
changed = find_pre_post_state_expr(dm, fm, enclosing,
expr_poststate(antec), altern) || changed;
auto poststate_res = intersect_postconds
(vec(block_poststate(conseq), expr_poststate(altern)));
([block_poststate(conseq), expr_poststate(altern)]);
changed = extend_poststate_ann(a, poststate_res) || changed;
}
}
@ -1660,8 +1660,8 @@ fn find_pre_post_state_expr(&def_map dm, &fn_info_map fm, &fn_info enclosing,
changed = find_pre_post_state_block(dm, fm,
enclosing, expr_poststate(test), body) || changed;
changed = extend_poststate_ann(a,
intersect_postconds(vec(expr_poststate(test),
block_poststate(body)))) || changed;
intersect_postconds([expr_poststate(test),
block_poststate(body)])) || changed;
ret changed;
}
case (expr_do_while(?body, ?test, ?a)) {
@ -2335,7 +2335,7 @@ fn annotate_stmt(&fn_info_map fm, &@stmt s) -> @stmt {
}
}
fn annotate_block(&fn_info_map fm, &block b) -> block {
let vec[@stmt] new_stmts = vec();
let vec[@stmt] new_stmts = [];
for (@stmt s in b.node.stmts) {
auto new_s = annotate_stmt(fm, s);
@ -2357,7 +2357,7 @@ fn annotate_fn(&fn_info_map fm, &ast::_fn f) -> ast::_fn {
ret rec(body=annotate_block(fm, f.body) with f);
}
fn annotate_mod(&fn_info_map fm, &ast::_mod m) -> ast::_mod {
let vec[@item] new_items = vec();
let vec[@item] new_items = [];
for (@item i in m.items) {
auto new_i = annotate_item(fm, i);
@ -2470,7 +2470,7 @@ fn annotate_item(&fn_info_map fm, &@ast::item item) -> @ast::item {
}
fn annotate_module(&fn_info_map fm, &ast::_mod module) -> ast::_mod {
let vec[@item] new_items = vec();
let vec[@item] new_items = [];
for (@item i in module.items) {
auto new_item = annotate_item(fm, i);

12
src/comp/pretty/pp.rs
View file

@ -31,9 +31,9 @@ type ps = @rec(mutable vec[context] context,
mutable bool potential_brk);
fn mkstate(io::writer out, uint width) -> ps {
let vec[context] stack = vec(rec(tp=cx_v, indent=0u));
let vec[token] buff = vec();
let vec[boxtype] sd = vec();
let vec[context] stack = [rec(tp=cx_v, indent=0u)];
let vec[token] buff = [];
let vec[boxtype] sd = [];
ret @rec(mutable context=stack,
width=width,
out=out,
@ -81,7 +81,7 @@ fn direct_token(ps p, token tok) {
}
fn buffer_token(ps p, token tok) {
p.buffered += vec(tok);
p.buffered += [tok];
auto col = p.scancol;
p.scancol = col + token_size(tok);
if (p.scancol > p.width) {
@ -140,13 +140,13 @@ fn finish_scan(ps p, bool fits) {
push_context(p, cx_h, base_indent(p) + ind);
}
}
p.scandepth = vec();
p.scandepth = [];
p.scanning = scan_none;
for (token t in buf) { add_token(p, t); }
}
fn start_scan(ps p, token tok, scantype tp) {
p.buffered = vec();
p.buffered = [];
p.scancol = p.col;
p.scanning = tp;
buffer_token(p, tok);

4
src/comp/pretty/pprust.rs
View file

@ -307,7 +307,7 @@ fn print_item(ps s, @ast::item item) {
bopen(s);
for (@ast::method meth in _obj.methods) {
hbox(s);
let vec[ast::ty_param] typarams = vec();
let vec[ast::ty_param] typarams = [];
maybe_print_comment(s, meth.span.lo);
print_fn(s, meth.node.meth.decl, meth.node.ident, typarams);
space(s.s);
@ -360,7 +360,7 @@ fn print_literal(ps s, @ast::lit lit) {
alt (lit.node) {
case (ast::lit_str(?st)) {print_string(s, st);}
case (ast::lit_char(?ch)) {
wrd(s.s, "'" + escape_str(_str::from_bytes(vec(ch as u8)), '\'')
wrd(s.s, "'" + escape_str(_str::from_bytes([ch as u8]), '\'')
+ "'");
}
case (ast::lit_int(?val)) {

4
src/comp/util/interner.rs
View file

@ -20,7 +20,7 @@ type interner[T] = rec(
fn mk_interner[T](hashfn[T] hasher, eqfn[T] eqer) -> interner[T] {
auto m = map::mk_hashmap[T,uint](hasher, eqer);
let vec[T] vect = vec();
let vec[T] vect = [];
ret rec(map=m, mutable vect=vect, hasher=hasher, eqer=eqer);
}
@ -30,7 +30,7 @@ fn intern[T](&interner[T] itr, &T val) -> uint {
case (none[uint]) {
auto new_idx = _vec::len[T](itr.vect);
itr.map.insert(val, new_idx);
itr.vect += vec(val);
itr.vect += [val];
ret new_idx;
}
}