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

Make vectors uglier ([]/~). Sorry. Should be temporary. Closes #2725.

Browse source
This commit is contained in:
Michael Sullivan 2012-06-25 20:00:46 -07:00
parent c087aaf56b
commit 329eca6044
418 changed files with 4123 additions and 4034 deletions
Download patch file Download diff file Expand all files Collapse all files

52
src/rustc/back/link.rs
View file

@ -292,27 +292,27 @@ fn build_link_meta(sess: session, c: ast::crate, output: str,
type provided_metas =
{name: option<@str>,
vers: option<@str>,
cmh_items: [@ast::meta_item]};
cmh_items: [@ast::meta_item]/~};
fn provided_link_metas(sess: session, c: ast::crate) ->
provided_metas {
let mut name: option<@str> = none;
let mut vers: option<@str> = none;
let mut cmh_items: [@ast::meta_item] = [];
let mut cmh_items: [@ast::meta_item]/~ = []/~;
let linkage_metas = attr::find_linkage_metas(c.node.attrs);
attr::require_unique_names(sess.diagnostic(), linkage_metas);
for linkage_metas.each {|meta|
if *attr::get_meta_item_name(meta) == "name" {
alt attr::get_meta_item_value_str(meta) {
some(v) { name = some(v); }
none { cmh_items += [meta]; }
none { cmh_items += [meta]/~; }
}
} else if *attr::get_meta_item_name(meta) == "vers" {
alt attr::get_meta_item_value_str(meta) {
some(v) { vers = some(v); }
none { cmh_items += [meta]; }
none { cmh_items += [meta]/~; }
}
} else { cmh_items += [meta]; }
} else { cmh_items += [meta]/~; }
}
ret {name: name, vers: vers, cmh_items: cmh_items};
}
@ -320,7 +320,7 @@ fn build_link_meta(sess: session, c: ast::crate, output: str,
// This calculates CMH as defined above
fn crate_meta_extras_hash(sha: sha1, _crate: ast::crate,
metas: provided_metas,
dep_hashes: [@str]) -> str {
dep_hashes: [@str]/~) -> str {
fn len_and_str(s: str) -> str {
ret #fmt["%u_%s", str::len(s), s];
}
@ -490,7 +490,7 @@ fn mangle(ss: path) -> str {
}
fn exported_name(path: path, hash: @str, vers: @str) -> str {
ret mangle(path + [path_name(hash)] + [path_name(vers)]);
ret mangle(path + [path_name(hash)]/~ + [path_name(vers)]/~);
}
fn mangle_exported_name(ccx: @crate_ctxt, path: path, t: ty::t) -> str {
@ -503,12 +503,12 @@ fn mangle_internal_name_by_type_only(ccx: @crate_ctxt,
str {
let s = @util::ppaux::ty_to_short_str(ccx.tcx, t);
let hash = get_symbol_hash(ccx, t);
ret mangle([path_name(name), path_name(s), path_name(@hash)]);
ret mangle([path_name(name), path_name(s), path_name(@hash)]/~);
}
fn mangle_internal_name_by_path_and_seq(ccx: @crate_ctxt, path: path,
flav: @str) -> str {
ret mangle(path + [path_name(@ccx.names(*flav))]);
ret mangle(path + [path_name(@ccx.names(*flav))]/~);
}
fn mangle_internal_name_by_path(_ccx: @crate_ctxt, path: path) -> str {
@ -577,8 +577,8 @@ fn link_binary(sess: session,
// The invocations of cc share some flags across platforms
let mut cc_args =
[stage] + sess.targ_cfg.target_strs.cc_args +
["-o", output, obj_filename];
[stage]/~ + sess.targ_cfg.target_strs.cc_args +
["-o", output, obj_filename]/~;
let mut lib_cmd;
let os = sess.targ_cfg.os;
@ -591,18 +591,18 @@ fn link_binary(sess: session,
let cstore = sess.cstore;
for cstore::get_used_crate_files(cstore).each {|cratepath|
if str::ends_with(cratepath, ".rlib") {
cc_args += [cratepath];
cc_args += [cratepath]/~;
cont;
}
let cratepath = cratepath;
let dir = path::dirname(cratepath);
if dir != "" { cc_args += ["-L" + dir]; }
if dir != "" { cc_args += ["-L" + dir]/~; }
let libarg = unlib(sess.targ_cfg, path::basename(cratepath));
cc_args += ["-l" + libarg];
cc_args += ["-l" + libarg]/~;
}
let ula = cstore::get_used_link_args(cstore);
for ula.each {|arg| cc_args += [arg]; }
for ula.each {|arg| cc_args += [arg]/~; }
// # Native library linking
@ -613,37 +613,37 @@ fn link_binary(sess: session,
// forces to make sure that library can be found at runtime.
let addl_paths = sess.opts.addl_lib_search_paths;
for addl_paths.each {|path| cc_args += ["-L" + path]; }
for addl_paths.each {|path| cc_args += ["-L" + path]/~; }
// The names of the native libraries
let used_libs = cstore::get_used_libraries(cstore);
for used_libs.each {|l| cc_args += ["-l" + l]; }
for used_libs.each {|l| cc_args += ["-l" + l]/~; }
if sess.building_library {
cc_args += [lib_cmd];
cc_args += [lib_cmd]/~;
// On mac we need to tell the linker to let this library
// be rpathed
if sess.targ_cfg.os == session::os_macos {
cc_args += ["-Wl,-install_name,@rpath/"
+ path::basename(output)];
+ path::basename(output)]/~;
}
}
if !sess.debugging_opt(session::no_rt) {
// Always want the runtime linked in
cc_args += ["-lrustrt"];
cc_args += ["-lrustrt"]/~;
}
// On linux librt and libdl are an indirect dependencies via rustrt,
// and binutils 2.22+ won't add them automatically
if sess.targ_cfg.os == session::os_linux {
cc_args += ["-lrt", "-ldl"];
cc_args += ["-lrt", "-ldl"]/~;
// LLVM implements the `frem` instruction as a call to `fmod`,
// which lives in libm. Similar to above, on some linuxes we
// have to be explicit about linking to it. See #2510
cc_args += ["-lm"];
cc_args += ["-lm"]/~;
}
if sess.targ_cfg.os == session::os_freebsd {
@ -653,7 +653,7 @@ fn link_binary(sess: session,
"-L/usr/local/lib/gcc44", "-lstdc++",
"-Wl,-z,origin",
"-Wl,-rpath,/usr/local/lib/gcc46",
"-Wl,-rpath,/usr/local/lib/gcc44"];
"-Wl,-rpath,/usr/local/lib/gcc44"]/~;
}
// OS X 10.6 introduced 'compact unwind info', which is produced by the
@ -661,11 +661,11 @@ fn link_binary(sess: session,
// understand how to unwind our __morestack frame, so we have to turn it
// off. This has impacted some other projects like GHC.
if sess.targ_cfg.os == session::os_macos {
cc_args += ["-Wl,-no_compact_unwind"];
cc_args += ["-Wl,-no_compact_unwind"]/~;
}
// Stack growth requires statically linking a __morestack function
cc_args += ["-lmorestack"];
cc_args += ["-lmorestack"]/~;
// FIXME (#2397): At some point we want to rpath our guesses as to where
// native libraries might live, based on the addl_lib_search_paths
@ -685,7 +685,7 @@ fn link_binary(sess: session,
// Clean up on Darwin
if sess.targ_cfg.os == session::os_macos {
run::run_program("dsymutil", [output]);
run::run_program("dsymutil", [output]/~);
}
// Remove the temporary object file if we aren't saving temps

48
src/rustc/back/rpath.rs
View file

@ -13,12 +13,12 @@ pure fn not_win32(os: session::os) -> bool {
}
}
fn get_rpath_flags(sess: session::session, out_filename: str) -> [str] {
fn get_rpath_flags(sess: session::session, out_filename: str) -> [str]/~ {
let os = sess.targ_cfg.os;
// No rpath on windows
if os == session::os_win32 {
ret [];
ret []/~;
}
#debug("preparing the RPATH!");
@ -29,7 +29,7 @@ fn get_rpath_flags(sess: session::session, out_filename: str) -> [str] {
let libs = cstore::get_used_crate_files(sess.cstore);
// We don't currently rpath native libraries, but we know
// where rustrt is and we know every rust program needs it
let libs = libs + [get_sysroot_absolute_rt_lib(sess)];
let libs = libs + [get_sysroot_absolute_rt_lib(sess)]/~;
let target_triple = sess.opts.target_triple;
let rpaths = get_rpaths(os, cwd, sysroot, output, libs, target_triple);
@ -37,20 +37,20 @@ fn get_rpath_flags(sess: session::session, out_filename: str) -> [str] {
}
fn get_sysroot_absolute_rt_lib(sess: session::session) -> path::path {
let path = [sess.filesearch.sysroot()]
let path = [sess.filesearch.sysroot()]/~
+ filesearch::relative_target_lib_path(
sess.opts.target_triple)
+ [os::dll_filename("rustrt")];
+ [os::dll_filename("rustrt")]/~;
path::connect_many(path)
}
fn rpaths_to_flags(rpaths: [str]) -> [str] {
fn rpaths_to_flags(rpaths: [str]/~) -> [str]/~ {
vec::map(rpaths, { |rpath| #fmt("-Wl,-rpath,%s",rpath)})
}
fn get_rpaths(os: session::os, cwd: path::path, sysroot: path::path,
output: path::path, libs: [path::path],
target_triple: str) -> [str] {
output: path::path, libs: [path::path]/~,
target_triple: str) -> [str]/~ {
#debug("cwd: %s", cwd);
#debug("sysroot: %s", sysroot);
#debug("output: %s", output);
@ -70,9 +70,9 @@ fn get_rpaths(os: session::os, cwd: path::path, sysroot: path::path,
let abs_rpaths = get_absolute_rpaths(cwd, libs);
// And a final backup rpath to the global library location.
let fallback_rpaths = [get_install_prefix_rpath(cwd, target_triple)];
let fallback_rpaths = [get_install_prefix_rpath(cwd, target_triple)]/~;
fn log_rpaths(desc: str, rpaths: [str]) {
fn log_rpaths(desc: str, rpaths: [str]/~) {
#debug("%s rpaths:", desc);
for rpaths.each {|rpath|
#debug(" %s", rpath);
@ -93,7 +93,7 @@ fn get_rpaths(os: session::os, cwd: path::path, sysroot: path::path,
fn get_rpaths_relative_to_output(os: session::os,
cwd: path::path,
output: path::path,
libs: [path::path]) -> [str] {
libs: [path::path]/~) -> [str]/~ {
vec::map(libs, {|a|
check not_win32(os);
get_rpath_relative_to_output(os, cwd, output, a)
@ -139,8 +139,8 @@ fn get_relative_to(abs1: path::path, abs2: path::path) -> path::path {
start_idx += 1u;
}
let mut path = [];
for uint::range(start_idx, len1 - 1u) {|_i| path += [".."]; };
let mut path = []/~;
for uint::range(start_idx, len1 - 1u) {|_i| vec::push(path, ".."); };
path += vec::slice(split2, start_idx, len2 - 1u);
@ -151,7 +151,7 @@ fn get_relative_to(abs1: path::path, abs2: path::path) -> path::path {
}
}
fn get_absolute_rpaths(cwd: path::path, libs: [path::path]) -> [str] {
fn get_absolute_rpaths(cwd: path::path, libs: [path::path]/~) -> [str]/~ {
vec::map(libs, {|a|get_absolute_rpath(cwd, a)})
}
@ -174,17 +174,17 @@ fn get_install_prefix_rpath(cwd: path::path, target_triple: str) -> str {
fail "rustc compiled without CFG_PREFIX environment variable";
}
let path = [install_prefix]
let path = [install_prefix]/~
+ filesearch::relative_target_lib_path(target_triple);
get_absolute(cwd, path::connect_many(path))
}
fn minimize_rpaths(rpaths: [str]) -> [str] {
fn minimize_rpaths(rpaths: [str]/~) -> [str]/~ {
let set = map::str_hash::<()>();
let mut minimized = [];
let mut minimized = []/~;
for rpaths.each {|rpath|
if !set.contains_key(rpath) {
minimized += [rpath];
minimized += [rpath]/~;
set.insert(rpath, ());
}
}
@ -195,8 +195,8 @@ fn minimize_rpaths(rpaths: [str]) -> [str] {
mod test {
#[test]
fn test_rpaths_to_flags() {
let flags = rpaths_to_flags(["path1", "path2"]);
assert flags == ["-Wl,-rpath,path1", "-Wl,-rpath,path2"];
let flags = rpaths_to_flags(["path1", "path2"]/~);
assert flags == ["-Wl,-rpath,path1", "-Wl,-rpath,path2"]/~;
}
#[test]
@ -230,15 +230,15 @@ mod test {
#[test]
fn test_minimize1() {
let res = minimize_rpaths(["rpath1", "rpath2", "rpath1"]);
assert res == ["rpath1", "rpath2"];
let res = minimize_rpaths(["rpath1", "rpath2", "rpath1"]/~);
assert res == ["rpath1", "rpath2"]/~;
}
#[test]
fn test_minimize2() {
let res = minimize_rpaths(["1a", "2", "2", "1a", "4a",
"1a", "2", "3", "4a", "3"]);
assert res == ["1a", "2", "4a", "3"];
"1a", "2", "3", "4a", "3"]/~);
assert res == ["1a", "2", "4a", "3"]/~;
}
#[test]

2
src/rustc/back/target_strs.rs
View file

@ -3,5 +3,5 @@ type t = {
meta_sect_name: str,
data_layout: str,
target_triple: str,
cc_args: [str]
cc_args: [str]/~
};

44
src/rustc/back/upcall.rs
View file

@ -33,10 +33,10 @@ fn declare_upcalls(targ_cfg: @session::config,
tydesc_type: TypeRef,
llmod: ModuleRef) -> @upcalls {
fn decl(llmod: ModuleRef, prefix: str, name: str,
tys: [TypeRef], rv: TypeRef) ->
tys: [TypeRef]/~, rv: TypeRef) ->
ValueRef {
let mut arg_tys: [TypeRef] = [];
for tys.each {|t| arg_tys += [t]; }
let mut arg_tys: [TypeRef]/~ = []/~;
for tys.each {|t| arg_tys += [t]/~; }
let fn_ty = T_fn(arg_tys, rv);
ret base::decl_cdecl_fn(llmod, prefix + name, fn_ty);
}
@ -51,61 +51,61 @@ fn declare_upcalls(targ_cfg: @session::config,
ret @{_fail: dv("fail", [T_ptr(T_i8()),
T_ptr(T_i8()),
size_t]),
size_t]/~),
trace: dv("trace", [T_ptr(T_i8()),
T_ptr(T_i8()),
int_t]),
int_t]/~),
malloc:
nothrow(d("malloc",
[T_ptr(tydesc_type), int_t],
[T_ptr(tydesc_type), int_t]/~,
T_ptr(T_i8()))),
free:
nothrow(dv("free", [T_ptr(T_i8())])),
nothrow(dv("free", [T_ptr(T_i8())]/~)),
exchange_malloc:
nothrow(d("exchange_malloc",
[T_ptr(tydesc_type), int_t],
[T_ptr(tydesc_type), int_t]/~,
T_ptr(T_i8()))),
exchange_free:
nothrow(dv("exchange_free", [T_ptr(T_i8())])),
nothrow(dv("exchange_free", [T_ptr(T_i8())]/~)),
validate_box:
nothrow(dv("validate_box", [T_ptr(T_i8())])),
nothrow(dv("validate_box", [T_ptr(T_i8())]/~)),
mark:
d("mark", [T_ptr(T_i8())], int_t),
d("mark", [T_ptr(T_i8())]/~, int_t),
vec_grow:
nothrow(dv("vec_grow", [T_ptr(T_ptr(T_i8())), int_t])),
nothrow(dv("vec_grow", [T_ptr(T_ptr(T_i8())), int_t]/~)),
str_new_uniq:
nothrow(d("str_new_uniq", [T_ptr(T_i8()), int_t],
nothrow(d("str_new_uniq", [T_ptr(T_i8()), int_t]/~,
T_ptr(T_i8()))),
str_new_shared:
nothrow(d("str_new_shared", [T_ptr(T_i8()), int_t],
nothrow(d("str_new_shared", [T_ptr(T_i8()), int_t]/~,
T_ptr(T_i8()))),
str_concat:
nothrow(d("str_concat", [T_ptr(T_i8()),
T_ptr(T_i8())],
T_ptr(T_i8())]/~,
T_ptr(T_i8()))),
cmp_type:
dv("cmp_type",
[T_ptr(T_i1()), T_ptr(tydesc_type),
T_ptr(T_ptr(tydesc_type)), T_ptr(T_i8()),
T_ptr(T_i8()),
T_i8()]),
T_i8()]/~),
log_type:
dv("log_type", [T_ptr(tydesc_type),
T_ptr(T_i8()), T_i32()]),
T_ptr(T_i8()), T_i32()]/~),
alloc_c_stack:
d("alloc_c_stack", [size_t], T_ptr(T_i8())),
d("alloc_c_stack", [size_t]/~, T_ptr(T_i8())),
call_shim_on_c_stack:
d("call_shim_on_c_stack",
// arguments: void *args, void *fn_ptr
[T_ptr(T_i8()), T_ptr(T_i8())],
[T_ptr(T_i8()), T_ptr(T_i8())]/~,
int_t),
call_shim_on_rust_stack:
d("call_shim_on_rust_stack",
[T_ptr(T_i8()), T_ptr(T_i8())], int_t),
[T_ptr(T_i8()), T_ptr(T_i8())]/~, int_t),
rust_personality:
nothrow(d("rust_personality", [], T_i32())),
nothrow(d("rust_personality", []/~, T_i32())),
reset_stack_limit:
nothrow(dv("reset_stack_limit", []))
nothrow(dv("reset_stack_limit", []/~))
};
}
//

2
src/rustc/back/x86.rs
View file

@ -35,7 +35,7 @@ fn get_target_strs(target_os: session::os) -> target_strs::t {
session::os_freebsd { "i686-unknown-freebsd" }
},
cc_args: ["-m32"]
cc_args: ["-m32"]/~
};
}

2
src/rustc/back/x86_64.rs
View file

@ -42,7 +42,7 @@ fn get_target_strs(target_os: session::os) -> target_strs::t {
session::os_freebsd { "x86_64-unknown-freebsd" }
},
cc_args: ["-m64"]
cc_args: ["-m64"]/~
};
}

20
src/rustc/driver/driver.rs
View file

@ -56,7 +56,7 @@ fn default_configuration(sess: session, argv0: str, input: input) ->
mk(@"target_libc", libc),
// Build bindings.
mk(@"build_compiler", argv0),
mk(@"build_input", source_name(input))];
mk(@"build_input", source_name(input))]/~;
}
fn build_configuration(sess: session, argv0: str, input: input) ->
@ -70,19 +70,19 @@ fn build_configuration(sess: session, argv0: str, input: input) ->
{
if sess.opts.test && !attr::contains_name(user_cfg, "test")
{
[attr::mk_word_item(@"test")]
} else { [] }
[attr::mk_word_item(@"test")]/~
} else { []/~ }
};
ret user_cfg + gen_cfg + default_cfg;
}
// Convert strings provided as --cfg [cfgspec] into a crate_cfg
fn parse_cfgspecs(cfgspecs: [str]) -> ast::crate_cfg {
fn parse_cfgspecs(cfgspecs: [str]/~) -> ast::crate_cfg {
// FIXME (#2399): It would be nice to use the parser to parse all
// varieties of meta_item here. At the moment we just support the
// meta_word variant.
let mut words = [];
for cfgspecs.each {|s| words += [attr::mk_word_item(@s)]; }
let mut words = []/~;
for cfgspecs.each {|s| vec::push(words, attr::mk_word_item(@s)); }
ret words;
}
@ -563,7 +563,7 @@ fn parse_pretty(sess: session, &&name: str) -> pp_mode {
"`identified`");
}
fn opts() -> [getopts::opt] {
fn opts() -> [getopts::opt]/~ {
ret [optflag("h"), optflag("help"), optflag("v"), optflag("version"),
optflag("emit-llvm"), optflagopt("pretty"),
optflag("ls"), optflag("parse-only"), optflag("no-trans"),
@ -577,7 +577,7 @@ fn opts() -> [getopts::opt] {
optmulti("Z"),
optmulti("cfg"), optflag("test"),
optflag("lib"), optflag("bin"), optflag("static"), optflag("gc")];
optflag("lib"), optflag("bin"), optflag("static"), optflag("gc")]/~;
}
type output_filenames = @{out_filename: str, obj_filename:str};
@ -692,7 +692,7 @@ mod test {
#[test]
fn test_switch_implies_cfg_test() {
let match =
alt getopts::getopts(["--test"], opts()) {
alt getopts::getopts(["--test"]/~, opts()) {
ok(m) { m }
err(f) { fail "test_switch_implies_cfg_test: " +
getopts::fail_str(f); }
@ -708,7 +708,7 @@ mod test {
#[test]
fn test_switch_implies_cfg_test_unless_cfg_test() {
let match =
alt getopts::getopts(["--test", "--cfg=test"], opts()) {
alt getopts::getopts(["--test", "--cfg=test"]/~, opts()) {
ok(m) { m }
err(f) { fail "test_switch_implies_cfg_test_unless_cfg_test: " +
getopts::fail_str(f); }

6
src/rustc/driver/rustc.rs
View file

@ -109,7 +109,7 @@ fn describe_debug_flags() {
}
}
fn run_compiler(args: [str], demitter: diagnostic::emitter) {
fn run_compiler(args: [str]/~, demitter: diagnostic::emitter) {
// Don't display log spew by default. Can override with RUST_LOG.
logging::console_off();
@ -250,7 +250,7 @@ fn monitor(+f: fn~(diagnostic::emitter)) {
to get further details and report the results \
to github.com/mozilla/rust/issues"
].each {|note|
]/~.each {|note|
diagnostic::emit(none, note, diagnostic::note)
}
}
@ -260,7 +260,7 @@ fn monitor(+f: fn~(diagnostic::emitter)) {
}
}
fn main(args: [str]) {
fn main(args: [str]/~) {
monitor {|demitter|
run_compiler(args, demitter);
}

28
src/rustc/driver/session.rs
View file

@ -36,7 +36,7 @@ const trace: uint = 128u;
// It should be removed
const no_rt: uint = 256u;
fn debugging_opts_map() -> [(str, str, uint)] {
fn debugging_opts_map() -> [(str, str, uint)]/~ {
[("ppregions", "prettyprint regions with \
internal repr details", ppregions),
("time-passes", "measure time of each rustc pass", time_passes),
@ -48,7 +48,7 @@ fn debugging_opts_map() -> [(str, str, uint)] {
("no-verify", "skip LLVM verification", no_verify),
("trace", "emit trace logs", trace),
("no-rt", "do not link to the runtime", no_rt)
]
]/~
}
type options =
@ -59,10 +59,10 @@ type options =
optimize: uint,
debuginfo: bool,
extra_debuginfo: bool,
lint_opts: [(lint::lint, lint::level)],
lint_opts: [(lint::lint, lint::level)]/~,
save_temps: bool,
output_type: back::link::output_type,
addl_lib_search_paths: [str],
addl_lib_search_paths: [str]/~,
maybe_sysroot: option<str>,
target_triple: str,
cfg: ast::crate_cfg,
@ -72,7 +72,7 @@ type options =
debugging_opts: uint,
};
type crate_metadata = {name: str, data: [u8]};
type crate_metadata = {name: str, data: [u8]/~};
type session = @{targ_cfg: @config,
opts: @options,
@ -172,13 +172,13 @@ fn basic_options() -> @options {
optimize: 0u,
debuginfo: false,
extra_debuginfo: false,
lint_opts: [],
lint_opts: []/~,
save_temps: false,
output_type: link::output_type_exe,
addl_lib_search_paths: [],
addl_lib_search_paths: []/~,
maybe_sysroot: none,
target_triple: driver::host_triple(),
cfg: [],
cfg: []/~,
test: false,
parse_only: false,
no_trans: false,
@ -238,14 +238,14 @@ mod test {
}
fn make_crate(with_bin: bool, with_lib: bool) -> @ast::crate {
let mut attrs = [];
if with_bin { attrs += [make_crate_type_attr("bin")]; }
if with_lib { attrs += [make_crate_type_attr("lib")]; }
let mut attrs = []/~;
if with_bin { attrs += [make_crate_type_attr("bin")]/~; }
if with_lib { attrs += [make_crate_type_attr("lib")]/~; }
@ast_util::respan(ast_util::dummy_sp(), {
directives: [],
module: {view_items: [], items: []},
directives: []/~,
module: {view_items: []/~, items: []/~},
attrs: attrs,
config: []
config: []/~
})
}

6
src/rustc/front/config.rs
View file

@ -4,7 +4,7 @@ export strip_unconfigured_items;
export metas_in_cfg;
export strip_items;
type in_cfg_pred = fn@([ast::attribute]) -> bool;
type in_cfg_pred = fn@([ast::attribute]/~) -> bool;
type ctxt = @{
in_cfg: in_cfg_pred
@ -100,11 +100,11 @@ fn native_item_in_cfg(cx: ctxt, item: @ast::native_item) -> bool {
// Determine if an item should be translated in the current crate
// configuration based on the item's attributes
fn in_cfg(cfg: ast::crate_cfg, attrs: [ast::attribute]) -> bool {
fn in_cfg(cfg: ast::crate_cfg, attrs: [ast::attribute]/~) -> bool {
metas_in_cfg(cfg, attr::attr_metas(attrs))
}
fn metas_in_cfg(cfg: ast::crate_cfg, metas: [@ast::meta_item]) -> bool {
fn metas_in_cfg(cfg: ast::crate_cfg, metas: [@ast::meta_item]/~) -> bool {
// The "cfg" attributes on the item
let cfg_metas = attr::find_meta_items_by_name(metas, "cfg");

10
src/rustc/front/core_inject.rs
View file

@ -30,18 +30,18 @@ fn inject_libcore_ref(sess: session,
let n1 = sess.next_node_id();
let n2 = sess.next_node_id();
let vi1 = @{node: ast::view_item_use(@"core", [], n1),
attrs: [],
let vi1 = @{node: ast::view_item_use(@"core", []/~, n1),
attrs: []/~,
vis: ast::public,
span: dummy_sp()};
let vp = spanned(ast::view_path_glob(ident_to_path(dummy_sp(), @"core"),
n2));
let vi2 = @{node: ast::view_item_import([vp]),
attrs: [],
let vi2 = @{node: ast::view_item_import([vp]/~),
attrs: []/~,
vis: ast::public,
span: dummy_sp()};
let vis = [vi1, vi2] + crate.node.module.view_items;
let vis = [vi1, vi2]/~ + crate.node.module.view_items;
ret @{node: {module: { view_items: vis with crate.node.module }
with crate.node} with *crate }

4
src/rustc/front/intrinsic_inject.rs
View file

@ -12,7 +12,7 @@ fn inject_intrinsic(sess: session,
let item = parse::parse_item_from_source_str("<intrinsic>",
intrinsic_module,
sess.opts.cfg,
[], ast::public,
[]/~, ast::public,
sess.parse_sess);
let item =
alt item {
@ -22,7 +22,7 @@ fn inject_intrinsic(sess: session,
}
};
let items = [item] + crate.node.module.items;
let items = [item]/~ + crate.node.module.items;
ret @{node: {module: { items: items with crate.node.module }
with crate.node} with *crate }

81
src/rustc/front/test.rs
View file

@ -15,12 +15,13 @@ export modify_for_testing;
type node_id_gen = fn@() -> ast::node_id;
type test = {span: span, path: [ast::ident], ignore: bool, should_fail: bool};
type test = {span: span, path: [ast::ident]/~,
ignore: bool, should_fail: bool};
type test_ctxt =
@{sess: session::session,
crate: @ast::crate,
mut path: [ast::ident],
mut path: [ast::ident]/~,
testfns: dvec<test>};
// Traverse the crate, collecting all the test functions, eliding any
@ -40,7 +41,7 @@ fn generate_test_harness(sess: session::session,
let cx: test_ctxt =
@{sess: sess,
crate: crate,
mut path: [],
mut path: []/~,
testfns: dvec()};
let precursor =
@ -97,7 +98,7 @@ fn fold_crate(cx: test_ctxt, c: ast::crate_, fld: fold::ast_fold) ->
fn fold_item(cx: test_ctxt, &&i: @ast::item, fld: fold::ast_fold) ->
@ast::item {
cx.path += [i.ident];
cx.path += [i.ident]/~;
#debug("current path: %s", ast_util::path_name_i(cx.path));
if is_test_fn(i) {
@ -160,7 +161,7 @@ fn should_fail(i: @ast::item) -> bool {
fn add_test_module(cx: test_ctxt, m: ast::_mod) -> ast::_mod {
let testmod = mk_test_module(cx);
ret {items: m.items + [testmod] with m};
ret {items: m.items + [testmod]/~ with m};
}
/*
@ -169,11 +170,11 @@ We're going to be building a module that looks more or less like:
mod __test {
fn main(args: [str]) -> int {
fn main(args: [str]/~) -> int {
std::test::test_main(args, tests())
}
fn tests() -> [std::test::test_desc] {
fn tests() -> [std::test::test_desc]/~ {
... the list of tests in the crate ...
}
}
@ -187,14 +188,14 @@ fn mk_test_module(cx: test_ctxt) -> @ast::item {
// The synthesized main function which will call the console test runner
// with our list of tests
let mainfn = mk_main(cx);
let testmod: ast::_mod = {view_items: [], items: [mainfn, testsfn]};
let testmod: ast::_mod = {view_items: []/~, items: [mainfn, testsfn]/~};
let item_ = ast::item_mod(testmod);
// This attribute tells resolve to let us call unexported functions
let resolve_unexported_attr =
attr::mk_attr(attr::mk_word_item(@"!resolve_unexported"));
let item: ast::item =
{ident: @"__test",
attrs: [resolve_unexported_attr],
attrs: [resolve_unexported_attr]/~,
id: cx.sess.next_node_id(),
node: item_,
vis: ast::public,
@ -209,31 +210,31 @@ fn nospan<T: copy>(t: T) -> ast::spanned<T> {
ret {node: t, span: dummy_sp()};
}
fn path_node(ids: [ast::ident]) -> @ast::path {
@{span: dummy_sp(), global: false, idents: ids, rp: none, types: []}
fn path_node(ids: [ast::ident]/~) -> @ast::path {
@{span: dummy_sp(), global: false, idents: ids, rp: none, types: []/~}
}
fn mk_tests(cx: test_ctxt) -> @ast::item {
let ret_ty = mk_test_desc_vec_ty(cx);
let decl: ast::fn_decl =
{inputs: [],
{inputs: []/~,
output: ret_ty,
purity: ast::impure_fn,
cf: ast::return_val,
constraints: []};
constraints: []/~};
// The vector of test_descs for this crate
let test_descs = mk_test_desc_vec(cx);
let body_: ast::blk_ =
default_block([], option::some(test_descs), cx.sess.next_node_id());
default_block([]/~, option::some(test_descs), cx.sess.next_node_id());
let body = nospan(body_);
let item_ = ast::item_fn(decl, [], body);
let item_ = ast::item_fn(decl, []/~, body);
let item: ast::item =
{ident: @"tests",
attrs: [],
attrs: []/~,
id: cx.sess.next_node_id(),
node: item_,
vis: ast::public,
@ -241,7 +242,7 @@ fn mk_tests(cx: test_ctxt) -> @ast::item {
ret @item;
}
fn mk_path(cx: test_ctxt, path: [ast::ident]) -> [ast::ident] {
fn mk_path(cx: test_ctxt, path: [ast::ident]/~) -> [ast::ident]/~ {
// For tests that are inside of std we don't want to prefix
// the paths with std::
let is_std = {
@ -251,12 +252,12 @@ fn mk_path(cx: test_ctxt, path: [ast::ident]) -> [ast::ident] {
_ { false }
}
};
(if is_std { [] } else { [@"std"] }) + path
(if is_std { []/~ } else { [@"std"]/~ }) + path
}
// The ast::ty of [std::test::test_desc]
// The ast::ty of [std::test::test_desc]/~
fn mk_test_desc_vec_ty(cx: test_ctxt) -> @ast::ty {
let test_desc_ty_path = path_node(mk_path(cx, [@"test", @"test_desc"]));
let test_desc_ty_path = path_node(mk_path(cx, [@"test", @"test_desc"]/~));
let test_desc_ty: ast::ty =
{id: cx.sess.next_node_id(),
@ -275,9 +276,9 @@ fn mk_test_desc_vec_ty(cx: test_ctxt) -> @ast::ty {
fn mk_test_desc_vec(cx: test_ctxt) -> @ast::expr {
#debug("building test vector from %u tests", cx.testfns.len());
let mut descs = [];
let mut descs = []/~;
for cx.testfns.each {|test|
descs += [mk_test_desc_rec(cx, test)];
descs += [mk_test_desc_rec(cx, test)]/~;
}
let inner_expr = @{id: cx.sess.next_node_id(),
@ -337,7 +338,7 @@ fn mk_test_desc_rec(cx: test_ctxt, test: test) -> @ast::expr {
nospan({mutbl: ast::m_imm, ident: @"should_fail", expr: @fail_expr});
let desc_rec_: ast::expr_ =
ast::expr_rec([name_field, fn_field, ignore_field, fail_field],
ast::expr_rec([name_field, fn_field, ignore_field, fail_field]/~,
option::none);
let desc_rec: ast::expr =
{id: cx.sess.next_node_id(), node: desc_rec_, span: span};
@ -352,7 +353,7 @@ fn mk_test_wrapper(cx: test_ctxt,
span: span) -> @ast::expr {
let call_expr: ast::expr = {
id: cx.sess.next_node_id(),
node: ast::expr_call(@fn_path_expr, [], false),
node: ast::expr_call(@fn_path_expr, []/~, false),
span: span
};
@ -360,16 +361,16 @@ fn mk_test_wrapper(cx: test_ctxt,
ast::stmt_semi(@call_expr, cx.sess.next_node_id()));
let wrapper_decl: ast::fn_decl = {
inputs: [],
inputs: []/~,
output: @{id: cx.sess.next_node_id(), node: ast::ty_nil, span: span},
purity: ast::impure_fn,
cf: ast::return_val,
constraints: []
constraints: []/~
};
let wrapper_body: ast::blk = nospan({
view_items: [],
stmts: [@call_stmt],
view_items: []/~,
stmts: [@call_stmt]/~,
expr: option::none,
id: cx.sess.next_node_id(),
rules: ast::default_blk
@ -378,7 +379,7 @@ fn mk_test_wrapper(cx: test_ctxt,
let wrapper_expr: ast::expr = {
id: cx.sess.next_node_id(),
node: ast::expr_fn(ast::proto_bare, wrapper_decl,
wrapper_body, @[]),
wrapper_body, @[]/~),
span: span
};
@ -386,7 +387,7 @@ fn mk_test_wrapper(cx: test_ctxt,
}
fn mk_main(cx: test_ctxt) -> @ast::item {
let str_pt = path_node([@"str"]);
let str_pt = path_node([@"str"]/~);
let str_ty = @{id: cx.sess.next_node_id(),
node: ast::ty_path(str_pt, cx.sess.next_node_id()),
span: dummy_sp()};
@ -410,23 +411,23 @@ fn mk_main(cx: test_ctxt) -> @ast::item {
span: dummy_sp()};
let decl: ast::fn_decl =
{inputs: [args_arg],
{inputs: [args_arg]/~,
output: @ret_ty,
purity: ast::impure_fn,
cf: ast::return_val,
constraints: []};
constraints: []/~};
let test_main_call_expr = mk_test_main_call(cx);
let body_: ast::blk_ =
default_block([], option::some(test_main_call_expr),
default_block([]/~, option::some(test_main_call_expr),
cx.sess.next_node_id());
let body = {node: body_, span: dummy_sp()};
let item_ = ast::item_fn(decl, [], body);
let item_ = ast::item_fn(decl, []/~, body);
let item: ast::item =
{ident: @"main",
attrs: [],
attrs: []/~,
id: cx.sess.next_node_id(),
node: item_,
vis: ast::public,
@ -437,7 +438,7 @@ fn mk_main(cx: test_ctxt) -> @ast::item {
fn mk_test_main_call(cx: test_ctxt) -> @ast::expr {
// Get the args passed to main so we can pass the to test_main
let args_path = path_node([@"args"]);
let args_path = path_node([@"args"]/~);
let args_path_expr_: ast::expr_ = ast::expr_path(args_path);
@ -445,20 +446,20 @@ fn mk_test_main_call(cx: test_ctxt) -> @ast::expr {
{id: cx.sess.next_node_id(), node: args_path_expr_, span: dummy_sp()};
// Call __test::test to generate the vector of test_descs
let test_path = path_node([@"tests"]);
let test_path = path_node([@"tests"]/~);
let test_path_expr_: ast::expr_ = ast::expr_path(test_path);
let test_path_expr: ast::expr =
{id: cx.sess.next_node_id(), node: test_path_expr_, span: dummy_sp()};
let test_call_expr_ = ast::expr_call(@test_path_expr, [], false);
let test_call_expr_ = ast::expr_call(@test_path_expr, []/~, false);
let test_call_expr: ast::expr =
{id: cx.sess.next_node_id(), node: test_call_expr_, span: dummy_sp()};
// Call std::test::test_main
let test_main_path = path_node(mk_path(cx, [@"test", @"test_main"]));
let test_main_path = path_node(mk_path(cx, [@"test", @"test_main"]/~));
let test_main_path_expr_: ast::expr_ = ast::expr_path(test_main_path);
@ -468,7 +469,7 @@ fn mk_test_main_call(cx: test_ctxt) -> @ast::expr {
let test_main_call_expr_: ast::expr_ =
ast::expr_call(@test_main_path_expr,
[@args_path_expr, @test_call_expr], false);
[@args_path_expr, @test_call_expr]/~, false);
let test_main_call_expr: ast::expr =
{id: cx.sess.next_node_id(), node: test_main_call_expr_,

15
src/rustc/lib/llvm.rs
View file

@ -981,21 +981,22 @@ fn mk_type_names() -> type_names {
}
fn type_to_str(names: type_names, ty: TypeRef) -> str {
ret type_to_str_inner(names, [], ty);
ret type_to_str_inner(names, []/~, ty);
}
fn type_to_str_inner(names: type_names, outer0: [TypeRef], ty: TypeRef) ->
fn type_to_str_inner(names: type_names, outer0: [TypeRef]/~, ty: TypeRef) ->
str {
alt type_has_name(names, ty) {
option::some(n) { ret n; }
_ {}
}
let outer = outer0 + [ty];
let outer = outer0 + [ty]/~;
let kind = llvm::LLVMGetTypeKind(ty);
fn tys_str(names: type_names, outer: [TypeRef], tys: [TypeRef]) -> str {
fn tys_str(names: type_names, outer: [TypeRef]/~,
tys: [TypeRef]/~) -> str {
let mut s: str = "";
let mut first: bool = true;
for tys.each {|t|
@ -1021,7 +1022,7 @@ fn type_to_str_inner(names: type_names, outer0: [TypeRef], ty: TypeRef) ->
let mut s = "fn(";
let out_ty: TypeRef = llvm::LLVMGetReturnType(ty);
let n_args = llvm::LLVMCountParamTypes(ty) as uint;
let args: [TypeRef] = vec::from_elem::<TypeRef>(n_args, 0 as TypeRef);
let args = vec::from_elem(n_args, 0 as TypeRef);
unsafe {
llvm::LLVMGetParamTypes(ty, vec::unsafe::to_ptr(args));
}
@ -1033,7 +1034,7 @@ fn type_to_str_inner(names: type_names, outer0: [TypeRef], ty: TypeRef) ->
Struct {
let mut s: str = "{";
let n_elts = llvm::LLVMCountStructElementTypes(ty) as uint;
let elts: [TypeRef] = vec::from_elem::<TypeRef>(n_elts, 0 as TypeRef);
let elts = vec::from_elem(n_elts, 0 as TypeRef);
unsafe {
llvm::LLVMGetStructElementTypes(ty, vec::unsafe::to_ptr(elts));
}
@ -1082,7 +1083,7 @@ fn float_width(llt: TypeRef) -> uint {
};
}
fn fn_ty_param_tys(fn_ty: TypeRef) -> [TypeRef] unsafe {
fn fn_ty_param_tys(fn_ty: TypeRef) -> [TypeRef]/~ unsafe {
let args = vec::from_elem(llvm::LLVMCountParamTypes(fn_ty) as uint,
0 as TypeRef);
llvm::LLVMGetParamTypes(fn_ty, vec::unsafe::to_ptr(args));

22
src/rustc/metadata/astencode.rs
View file

@ -68,7 +68,7 @@ fn encode_inlined_item(ecx: @e::encode_ctxt,
ii: ast::inlined_item) {
#debug["> Encoding inlined item: %s::%s (%u)",
ast_map::path_to_str(path), ii.ident(),
ebml_w.writer.tell()];
ebml_w.writer.tell()]/~;
let id_range = compute_id_range_for_inlined_item(ii);
ebml_w.wr_tag(c::tag_ast as uint) {||
@ -79,7 +79,7 @@ fn encode_inlined_item(ecx: @e::encode_ctxt,
#debug["< Encoded inlined fn: %s::%s (%u)",
ast_map::path_to_str(path), ii.ident(),
ebml_w.writer.tell()];
ebml_w.writer.tell()]/~;
}
fn decode_inlined_item(cdata: cstore::crate_metadata,
@ -103,7 +103,7 @@ fn decode_inlined_item(cdata: cstore::crate_metadata,
#debug["Fn named: %s", ii.ident()];
decode_side_tables(xcx, ast_doc);
#debug["< Decoded inlined fn: %s::%s",
ast_map::path_to_str(path), ii.ident()];
ast_map::path_to_str(path), ii.ident()]/~;
alt ii {
ast::ii_item(i) {
#debug(">>> DECODED ITEM >>>\n%s\n<<< DECODED ITEM <<<",
@ -522,7 +522,7 @@ impl helpers for ebml::writer {
e::write_type(ecx, self, ty)
}
fn emit_tys(ecx: @e::encode_ctxt, tys: [ty::t]) {
fn emit_tys(ecx: @e::encode_ctxt, tys: [ty::t]/~) {
self.emit_from_vec(tys) {|ty|
e::write_type(ecx, self, ty)
}
@ -707,7 +707,7 @@ fn encode_side_tables_for_id(ecx: @e::encode_ctxt,
impl decoder for ebml::doc {
fn as_int() -> int { ebml::doc_as_u64(self) as int }
fn [](tag: c::astencode_tag) -> ebml::doc {
fn []/~(tag: c::astencode_tag) -> ebml::doc {
ebml::get_doc(self, tag as uint)
}
fn opt_child(tag: c::astencode_tag) -> option<ebml::doc> {
@ -727,11 +727,11 @@ impl decoder for ebml::ebml_deserializer {
xcx.tr_def_id(_))
}
fn read_tys(xcx: extended_decode_ctxt) -> [ty::t] {
fn read_tys(xcx: extended_decode_ctxt) -> [ty::t]/~ {
self.read_to_vec {|| self.read_ty(xcx) }
}
fn read_bounds(xcx: extended_decode_ctxt) -> @[ty::param_bound] {
fn read_bounds(xcx: extended_decode_ctxt) -> @[ty::param_bound]/~ {
tydecode::parse_bounds_data(
self.parent.data, self.pos, xcx.dcx.cdata.cnum, xcx.dcx.tcx,
xcx.tr_def_id(_))
@ -765,7 +765,7 @@ fn decode_side_tables(xcx: extended_decode_ctxt,
#debug[">> Side table document with tag 0x%x \
found for id %d (orig %d)",
tag, id, id0];
tag, id, id0]/~;
if tag == (c::tag_table_mutbl as uint) {
dcx.maps.mutbl_map.insert(id, ());
@ -859,7 +859,7 @@ type fake_session = ();
#[cfg(test)]
impl of fake_ext_ctxt for fake_session {
fn cfg() -> ast::crate_cfg { [] }
fn cfg() -> ast::crate_cfg { []/~ }
fn parse_sess() -> parse::parse_sess { new_parse_sess() }
}
@ -922,13 +922,13 @@ fn test_simplification() {
let item_in = ast::ii_item(#ast(item) {
fn new_int_alist<B: copy>() -> alist<int, B> {
fn eq_int(&&a: int, &&b: int) -> bool { a == b }
ret {eq_fn: eq_int, mut data: []};
ret {eq_fn: eq_int, mut data: []/~};
}
});
let item_out = simplify_ast(item_in);
let item_exp = ast::ii_item(#ast(item) {
fn new_int_alist<B: copy>() -> alist<int, B> {
ret {eq_fn: eq_int, mut data: []};
ret {eq_fn: eq_int, mut data: []/~};
}
});
alt (item_out, item_exp) {

22
src/rustc/metadata/creader.rs
View file

@ -43,7 +43,7 @@ type cache_entry = {
cnum: int,
span: span,
hash: @str,
metas: @[@ast::meta_item]
metas: @[@ast::meta_item]/~
};
fn dump_crates(crate_cache: dvec<cache_entry>) {
@ -54,7 +54,7 @@ fn dump_crates(crate_cache: dvec<cache_entry>) {
#debug("hash: %?", entry.hash);
let attrs = [
attr::mk_attr(attr::mk_list_item(@"link", *entry.metas))
];
]/~;
for attr::find_linkage_attrs(attrs).each {|attr|
#debug("meta: %s", pprust::attr_to_str(attr));
}
@ -62,7 +62,7 @@ fn dump_crates(crate_cache: dvec<cache_entry>) {
}
fn warn_if_multiple_versions(diag: span_handler,
crate_cache: [cache_entry]) {
crate_cache: [cache_entry]/~) {
import either::*;
if crate_cache.len() != 0u {
@ -86,7 +86,7 @@ fn warn_if_multiple_versions(diag: span_handler,
diag.span_note(match.span, "used here");
let attrs = [
attr::mk_attr(attr::mk_list_item(@"link", *match.metas))
];
]/~;
loader::note_linkage_attrs(diag, attrs);
}
}
@ -161,21 +161,21 @@ fn visit_item(e: env, i: @ast::item) {
}
fn metas_with(ident: ast::ident, key: ast::ident,
metas: [@ast::meta_item]) -> [@ast::meta_item] {
metas: [@ast::meta_item]/~) -> [@ast::meta_item]/~ {
let name_items = attr::find_meta_items_by_name(metas, *key);
if name_items.is_empty() {
metas + [attr::mk_name_value_item_str(key, *ident)]
metas + [attr::mk_name_value_item_str(key, *ident)]/~
} else {
metas
}
}
fn metas_with_ident(ident: ast::ident,
metas: [@ast::meta_item]) -> [@ast::meta_item] {
metas: [@ast::meta_item]/~) -> [@ast::meta_item]/~ {
metas_with(ident, @"name", metas)
}
fn existing_match(e: env, metas: [@ast::meta_item], hash: str) ->
fn existing_match(e: env, metas: [@ast::meta_item]/~, hash: str) ->
option<int> {
for e.crate_cache.each {|c|
@ -187,7 +187,7 @@ fn existing_match(e: env, metas: [@ast::meta_item], hash: str) ->
ret none;
}
fn resolve_crate(e: env, ident: ast::ident, metas: [@ast::meta_item],
fn resolve_crate(e: env, ident: ast::ident, metas: [@ast::meta_item]/~,
hash: str, span: span) -> ast::crate_num {
let metas = metas_with_ident(ident, metas);
@ -241,7 +241,7 @@ fn resolve_crate(e: env, ident: ast::ident, metas: [@ast::meta_item],
}
// Go through the crate metadata and load any crates that it references
fn resolve_crate_deps(e: env, cdata: @[u8]) -> cstore::cnum_map {
fn resolve_crate_deps(e: env, cdata: @[u8]/~) -> cstore::cnum_map {
#debug("resolving deps of external crate");
// The map from crate numbers in the crate we're resolving to local crate
// numbers
@ -249,7 +249,7 @@ fn resolve_crate_deps(e: env, cdata: @[u8]) -> cstore::cnum_map {
for decoder::get_crate_deps(cdata).each {|dep|
let extrn_cnum = dep.cnum;
let cname = dep.name;
let cmetas = metas_with(dep.vers, @"vers", []);
let cmetas = metas_with(dep.vers, @"vers", []/~);
#debug("resolving dep crate %s ver: %s hash: %s",
*dep.name, *dep.vers, *dep.hash);
alt existing_match(e, metas_with_ident(cname, cmetas), *dep.hash) {

29
src/rustc/metadata/csearch.rs
View file

@ -39,12 +39,12 @@ fn get_type_param_count(cstore: cstore::cstore, def: ast::def_id) -> uint {
}
fn lookup_defs(cstore: cstore::cstore, cnum: ast::crate_num,
path: [ast::ident]) -> [ast::def] {
let mut result = [];
path: [ast::ident]/~) -> [ast::def]/~ {
let mut result = []/~;
#debug("lookup_defs: path = %? cnum = %?", path, cnum);
for resolve_path(cstore, cnum, path).each {|elt|
let (c, data, def) = elt;
result += [decoder::lookup_def(c, data, def)];
result += [decoder::lookup_def(c, data, def)]/~;
}
ret result;
}
@ -60,21 +60,21 @@ fn lookup_method_purity(cstore: cstore::cstore, did: ast::def_id)
/* Returns a vector of possible def IDs for a given path,
in a given crate */
fn resolve_path(cstore: cstore::cstore, cnum: ast::crate_num,
path: [ast::ident]) ->
[(ast::crate_num, @[u8], ast::def_id)] {
path: [ast::ident]/~) ->
[(ast::crate_num, @[u8]/~, ast::def_id)]/~ {
let cm = cstore::get_crate_data(cstore, cnum);
#debug("resolve_path %s in crates[%d]:%s",
ast_util::path_name_i(path), cnum, cm.name);
let mut result = [];
let mut result = []/~;
for decoder::resolve_path(path, cm.data).each {|def|
if def.crate == ast::local_crate {
result += [(cnum, cm.data, def)];
result += [(cnum, cm.data, def)]/~;
} else {
if cm.cnum_map.contains_key(def.crate) {
// This reexport is itself a reexport from another crate
let next_cnum = cm.cnum_map.get(def.crate);
let next_cm_data = cstore::get_crate_data(cstore, next_cnum);
result += [(next_cnum, next_cm_data.data, def)];
result += [(next_cnum, next_cm_data.data, def)]/~;
}
}
}
@ -88,7 +88,7 @@ fn get_item_path(tcx: ty::ctxt, def: ast::def_id) -> ast_map::path {
// FIXME #1920: This path is not always correct if the crate is not linked
// into the root namespace.
[ast_map::path_mod(@cdata.name)] + path
[ast_map::path_mod(@cdata.name)]/~ + path
}
enum found_ast {
@ -109,7 +109,8 @@ fn maybe_get_item_ast(tcx: ty::ctxt, def: ast::def_id,
decode_inlined_item)
}
fn get_enum_variants(tcx: ty::ctxt, def: ast::def_id) -> [ty::variant_info] {
fn get_enum_variants(tcx: ty::ctxt, def: ast::def_id)
-> [ty::variant_info]/~ {
let cstore = tcx.cstore;
let cdata = cstore::get_crate_data(cstore, def.crate);
ret decoder::get_enum_variants(cdata, def.node, tcx)
@ -117,20 +118,20 @@ fn get_enum_variants(tcx: ty::ctxt, def: ast::def_id) -> [ty::variant_info] {
fn get_impls_for_mod(cstore: cstore::cstore, def: ast::def_id,
name: option<ast::ident>)
-> @[@decoder::_impl] {
-> @[@decoder::_impl]/~ {
let cdata = cstore::get_crate_data(cstore, def.crate);
decoder::get_impls_for_mod(cdata, def.node, name) {|cnum|
cstore::get_crate_data(cstore, cnum)
}
}
fn get_iface_methods(tcx: ty::ctxt, def: ast::def_id) -> @[ty::method] {
fn get_iface_methods(tcx: ty::ctxt, def: ast::def_id) -> @[ty::method]/~ {
let cstore = tcx.cstore;
let cdata = cstore::get_crate_data(cstore, def.crate);
decoder::get_iface_methods(cdata, def.node, tcx)
}
fn get_class_fields(tcx: ty::ctxt, def: ast::def_id) -> [ty::field_ty] {
fn get_class_fields(tcx: ty::ctxt, def: ast::def_id) -> [ty::field_ty]/~ {
let cstore = tcx.cstore;
let cdata = cstore::get_crate_data(cstore, def.crate);
decoder::get_class_fields(cdata, def.node)
@ -159,7 +160,7 @@ fn get_field_type(tcx: ty::ctxt, class_id: ast::def_id,
class_id, def)});
#debug("got field data %?", the_field);
let ty = decoder::item_type(def, the_field, tcx, cdata);
ret {bounds: @[], rp: ast::rp_none, ty: ty};
ret {bounds: @[]/~, rp: ast::rp_none, ty: ty};
}
// Given a def_id for an impl or class, return the iface it implements,

34
src/rustc/metadata/cstore.rs
View file

@ -40,7 +40,7 @@ type cnum_map = map::hashmap<ast::crate_num, ast::crate_num>;
type mod_path_map = map::hashmap<ast::def_id, @str>;
type crate_metadata = @{name: str,
data: @[u8],
data: @[u8]/~,
cnum_map: cnum_map,
cnum: ast::crate_num};
@ -55,9 +55,9 @@ type cstore_private =
@{metas: map::hashmap<ast::crate_num, crate_metadata>,
use_crate_map: use_crate_map,
mod_path_map: mod_path_map,
mut used_crate_files: [str],
mut used_libraries: [str],
mut used_link_args: [str]};
mut used_crate_files: [str]/~,
mut used_libraries: [str]/~,
mut used_link_args: [str]/~};
// Map from node_id's of local use statements to crate numbers
type use_crate_map = map::hashmap<ast::node_id, ast::crate_num>;
@ -74,9 +74,9 @@ fn mk_cstore() -> cstore {
ret private(@{metas: meta_cache,
use_crate_map: crate_map,
mod_path_map: mod_path_map,
mut used_crate_files: [],
mut used_libraries: [],
mut used_link_args: []});
mut used_crate_files: []/~,
mut used_libraries: []/~,
mut used_link_args: []/~});
}
fn get_crate_data(cstore: cstore, cnum: ast::crate_num) -> crate_metadata {
@ -113,11 +113,11 @@ fn iter_crate_data(cstore: cstore, i: fn(ast::crate_num, crate_metadata)) {
fn add_used_crate_file(cstore: cstore, lib: str) {
if !vec::contains(p(cstore).used_crate_files, lib) {
p(cstore).used_crate_files += [lib];
p(cstore).used_crate_files += [lib]/~;
}
}
fn get_used_crate_files(cstore: cstore) -> [str] {
fn get_used_crate_files(cstore: cstore) -> [str]/~ {
ret p(cstore).used_crate_files;
}
@ -125,11 +125,11 @@ fn add_used_library(cstore: cstore, lib: str) -> bool {
assert lib != "";
if vec::contains(p(cstore).used_libraries, lib) { ret false; }
p(cstore).used_libraries += [lib];
p(cstore).used_libraries += [lib]/~;
ret true;
}
fn get_used_libraries(cstore: cstore) -> [str] {
fn get_used_libraries(cstore: cstore) -> [str]/~ {
ret p(cstore).used_libraries;
}
@ -137,7 +137,7 @@ fn add_used_link_args(cstore: cstore, args: str) {
p(cstore).used_link_args += str::split_char(args, ' ');
}
fn get_used_link_args(cstore: cstore) -> [str] {
fn get_used_link_args(cstore: cstore) -> [str]/~ {
ret p(cstore).used_link_args;
}
@ -153,15 +153,15 @@ fn find_use_stmt_cnum(cstore: cstore,
// returns hashes of crates directly used by this crate. Hashes are
// sorted by crate name.
fn get_dep_hashes(cstore: cstore) -> [@str] {
fn get_dep_hashes(cstore: cstore) -> [@str]/~ {
type crate_hash = {name: @str, hash: @str};
let mut result = [];
let mut result = []/~;
for p(cstore).use_crate_map.each_value {|cnum|
let cdata = cstore::get_crate_data(cstore, cnum);
let hash = decoder::get_crate_hash(cdata.data);
#debug("Add hash[%s]: %s", cdata.name, *hash);
result += [{name: @cdata.name, hash: hash}];
result += [{name: @cdata.name, hash: hash}]/~;
};
fn lteq(a: crate_hash, b: crate_hash) -> bool {
ret *a.name <= *b.name;
@ -175,9 +175,9 @@ fn get_dep_hashes(cstore: cstore) -> [@str] {
ret vec::map(sorted, mapper);
}
fn get_path(cstore: cstore, d: ast::def_id) -> [ast::ident] {
fn get_path(cstore: cstore, d: ast::def_id) -> [ast::ident]/~ {
// let f = bind str::split_str(_, "::");
option::map_default(p(cstore).mod_path_map.find(d), [],
option::map_default(p(cstore).mod_path_map.find(d), []/~,
{|ds| str::split_str(*ds, "::").map({|x|@x})})
}
// Local Variables:

128
src/rustc/metadata/decoder.rs
View file

@ -53,8 +53,8 @@ export translate_def_id;
// what crate that's in and give us a def_id that makes sense for the current
// build.
fn lookup_hash(d: ebml::doc, eq_fn: fn@([u8]) -> bool, hash: uint) ->
[ebml::doc] {
fn lookup_hash(d: ebml::doc, eq_fn: fn@([u8]/~) -> bool, hash: uint) ->
[ebml::doc]/~ {
let index = ebml::get_doc(d, tag_index);
let table = ebml::get_doc(index, tag_index_table);
let hash_pos = table.start + hash % 256u * 4u;
@ -62,19 +62,19 @@ fn lookup_hash(d: ebml::doc, eq_fn: fn@([u8]) -> bool, hash: uint) ->
let {tag:_, doc:bucket} = ebml::doc_at(d.data, pos);
// Awkward logic because we can't ret from foreach yet
let mut result: [ebml::doc] = [];
let mut result: [ebml::doc]/~ = []/~;
let belt = tag_index_buckets_bucket_elt;
ebml::tagged_docs(bucket, belt) {|elt|
let pos = io::u64_from_be_bytes(*elt.data, elt.start, 4u) as uint;
if eq_fn(vec::slice::<u8>(*elt.data, elt.start + 4u, elt.end)) {
result += [ebml::doc_at(d.data, pos).doc];
result += [ebml::doc_at(d.data, pos).doc]/~;
}
};
ret result;
}
fn maybe_find_item(item_id: int, items: ebml::doc) -> option<ebml::doc> {
fn eq_item(bytes: [u8], item_id: int) -> bool {
fn eq_item(bytes: [u8]/~, item_id: int) -> bool {
ret io::u64_from_be_bytes(bytes, 0u, 4u) as int == item_id;
}
let eqer = {|a|eq_item(a, item_id)};
@ -90,7 +90,7 @@ fn find_item(item_id: int, items: ebml::doc) -> ebml::doc {
// Looks up an item in the given metadata and returns an ebml doc pointing
// to the item data.
fn lookup_item(item_id: int, data: @[u8]) -> ebml::doc {
fn lookup_item(item_id: int, data: @[u8]/~) -> ebml::doc {
let items = ebml::get_doc(ebml::doc(data), tag_items);
alt maybe_find_item(item_id, items) {
none { fail(#fmt("lookup_item: id not found: %d", item_id)); }
@ -164,13 +164,13 @@ fn item_impl_iface(item: ebml::doc, tcx: ty::ctxt, cdata: cmd)
}
fn item_ty_param_bounds(item: ebml::doc, tcx: ty::ctxt, cdata: cmd)
-> @[ty::param_bounds] {
let mut bounds = [];
-> @[ty::param_bounds]/~ {
let mut bounds = []/~;
ebml::tagged_docs(item, tag_items_data_item_ty_param_bounds) {|p|
let bd = parse_bounds_data(p.data, p.start, cdata.cnum, tcx, {|did|
translate_def_id(cdata, did)
});
bounds += [bd];
bounds += [bd]/~;
}
@bounds
}
@ -194,31 +194,31 @@ fn item_ty_param_count(item: ebml::doc) -> uint {
n
}
fn enum_variant_ids(item: ebml::doc, cdata: cmd) -> [ast::def_id] {
let mut ids: [ast::def_id] = [];
fn enum_variant_ids(item: ebml::doc, cdata: cmd) -> [ast::def_id]/~ {
let mut ids: [ast::def_id]/~ = []/~;
let v = tag_items_data_item_variant;
ebml::tagged_docs(item, v) {|p|
let ext = parse_def_id(ebml::doc_data(p));
ids += [{crate: cdata.cnum, node: ext.node}];
ids += [{crate: cdata.cnum, node: ext.node}]/~;
};
ret ids;
}
// Given a path and serialized crate metadata, returns the IDs of the
// definitions the path may refer to.
fn resolve_path(path: [ast::ident], data: @[u8]) -> [ast::def_id] {
fn eq_item(data: [u8], s: str) -> bool {
fn resolve_path(path: [ast::ident]/~, data: @[u8]/~) -> [ast::def_id]/~ {
fn eq_item(data: [u8]/~, s: str) -> bool {
ret str::eq(str::from_bytes(data), s);
}
let s = ast_util::path_name_i(path);
let md = ebml::doc(data);
let paths = ebml::get_doc(md, tag_paths);
let eqer = {|a|eq_item(a, s)};
let mut result: [ast::def_id] = [];
let mut result: [ast::def_id]/~ = []/~;
#debug("resolve_path: looking up %s", s);
for lookup_hash(paths, eqer, hash_path(s)).each {|doc|
let did_doc = ebml::get_doc(doc, tag_def_id);
result += [parse_def_id(ebml::doc_data(did_doc))];
result += [parse_def_id(ebml::doc_data(did_doc))]/~;
}
ret result;
}
@ -229,16 +229,16 @@ fn item_path(item_doc: ebml::doc) -> ast_map::path {
let len_doc = ebml::get_doc(path_doc, tag_path_len);
let len = ebml::doc_as_u32(len_doc) as uint;
let mut result = [];
let mut result = []/~;
vec::reserve(result, len);
ebml::docs(path_doc) {|tag, elt_doc|
if tag == tag_path_elt_mod {
let str = ebml::doc_as_str(elt_doc);
result += [ast_map::path_mod(@str)];
result += [ast_map::path_mod(@str)]/~;
} else if tag == tag_path_elt_name {
let str = ebml::doc_as_str(elt_doc);
result += [ast_map::path_name(@str)];
result += [ast_map::path_name(@str)]/~;
} else {
// ignore tag_path_len element
}
@ -252,11 +252,11 @@ fn item_name(item: ebml::doc) -> ast::ident {
@str::from_bytes(ebml::doc_data(name))
}
fn lookup_item_name(data: @[u8], id: ast::node_id) -> ast::ident {
fn lookup_item_name(data: @[u8]/~, id: ast::node_id) -> ast::ident {
item_name(lookup_item(id, data))
}
fn lookup_def(cnum: ast::crate_num, data: @[u8], did_: ast::def_id) ->
fn lookup_def(cnum: ast::crate_num, data: @[u8]/~, did_: ast::def_id) ->
ast::def {
let item = lookup_item(did_.node, data);
let fam_ch = item_family(item);
@ -288,12 +288,12 @@ fn get_type(cdata: cmd, id: ast::node_id, tcx: ty::ctxt)
let t = item_type({crate: cdata.cnum, node: id}, item, tcx, cdata);
let tp_bounds = if family_has_type_params(item_family(item)) {
item_ty_param_bounds(item, tcx, cdata)
} else { @[] };
} else { @[]/~ };
let rp = item_ty_region_param(item);
ret {bounds: tp_bounds, rp: rp, ty: t};
}
fn get_type_param_count(data: @[u8], id: ast::node_id) -> uint {
fn get_type_param_count(data: @[u8]/~, id: ast::node_id) -> uint {
item_ty_param_count(lookup_item(id, data))
}
@ -351,7 +351,7 @@ fn class_dtor(cdata: cmd, id: ast::node_id) -> option<ast::def_id> {
found
}
fn get_symbol(data: @[u8], id: ast::node_id) -> str {
fn get_symbol(data: @[u8]/~, id: ast::node_id) -> str {
ret item_symbol(lookup_item(id, data));
}
@ -392,11 +392,11 @@ fn maybe_get_item_ast(cdata: cmd, tcx: ty::ctxt,
}
fn get_enum_variants(cdata: cmd, id: ast::node_id, tcx: ty::ctxt)
-> [ty::variant_info] {
-> [ty::variant_info]/~ {
let data = cdata.data;
let items = ebml::get_doc(ebml::doc(data), tag_items);
let item = find_item(id, items);
let mut infos: [ty::variant_info] = [];
let mut infos: [ty::variant_info]/~ = []/~;
let variant_ids = enum_variant_ids(item, cdata);
let mut disr_val = 0;
for variant_ids.each {|did|
@ -404,10 +404,10 @@ fn get_enum_variants(cdata: cmd, id: ast::node_id, tcx: ty::ctxt)
let ctor_ty = item_type({crate: cdata.cnum, node: id}, item,
tcx, cdata);
let name = item_name(item);
let mut arg_tys: [ty::t] = [];
let mut arg_tys: [ty::t]/~ = []/~;
alt ty::get(ctor_ty).struct {
ty::ty_fn(f) {
for f.inputs.each {|a| arg_tys += [a.ty]; }
for f.inputs.each {|a| arg_tys += [a.ty]/~; }
}
_ { /* Nullary enum variant. */ }
}
@ -416,7 +416,7 @@ fn get_enum_variants(cdata: cmd, id: ast::node_id, tcx: ty::ctxt)
_ { /* empty */ }
}
infos += [@{args: arg_tys, ctor_ty: ctor_ty, name: name,
id: did, disr_val: disr_val}];
id: did, disr_val: disr_val}]/~;
disr_val += 1;
}
ret infos;
@ -424,18 +424,18 @@ fn get_enum_variants(cdata: cmd, id: ast::node_id, tcx: ty::ctxt)
// NB: These types are duplicated in resolve.rs
type method_info = {did: ast::def_id, n_tps: uint, ident: ast::ident};
type _impl = {did: ast::def_id, ident: ast::ident, methods: [@method_info]};
type _impl = {did: ast::def_id, ident: ast::ident, methods: [@method_info]/~};
fn item_impl_methods(cdata: cmd, item: ebml::doc, base_tps: uint)
-> [@method_info] {
let mut rslt = [];
-> [@method_info]/~ {
let mut rslt = []/~;
ebml::tagged_docs(item, tag_item_impl_method) {|doc|
let m_did = parse_def_id(ebml::doc_data(doc));
let mth_item = lookup_item(m_did.node, cdata.data);
rslt += [@{did: translate_def_id(cdata, m_did),
/* FIXME (maybe #2323) tjc: take a look at this. */
n_tps: item_ty_param_count(mth_item) - base_tps,
ident: item_name(mth_item)}];
ident: item_name(mth_item)}]/~;
}
rslt
}
@ -443,10 +443,10 @@ fn item_impl_methods(cdata: cmd, item: ebml::doc, base_tps: uint)
fn get_impls_for_mod(cdata: cmd, m_id: ast::node_id,
name: option<ast::ident>,
get_cdata: fn(ast::crate_num) -> cmd)
-> @[@_impl] {
-> @[@_impl]/~ {
let data = cdata.data;
let mod_item = lookup_item(m_id, data);
let mut result = [];
let mut result = []/~;
ebml::tagged_docs(mod_item, tag_mod_impl) {|doc|
let did = parse_def_id(ebml::doc_data(doc));
let local_did = translate_def_id(cdata, did);
@ -461,7 +461,7 @@ fn get_impls_for_mod(cdata: cmd, m_id: ast::node_id,
result += [@{
did: local_did, ident: nm,
methods: item_impl_methods(impl_cdata, item, base_tps)
}];
}]/~;
};
}
@result
@ -469,10 +469,10 @@ fn get_impls_for_mod(cdata: cmd, m_id: ast::node_id,
/* Works for both classes and ifaces */
fn get_iface_methods(cdata: cmd, id: ast::node_id, tcx: ty::ctxt)
-> @[ty::method] {
-> @[ty::method]/~ {
let data = cdata.data;
let item = lookup_item(id, data);
let mut result = [];
let mut result = []/~;
ebml::tagged_docs(item, tag_item_iface_method) {|mth|
let bounds = item_ty_param_bounds(mth, tcx, cdata);
let name = item_name(mth);
@ -487,17 +487,17 @@ fn get_iface_methods(cdata: cmd, id: ast::node_id, tcx: ty::ctxt)
'u' { ast::unsafe_fn }
'f' { ast::impure_fn }
'p' { ast::pure_fn }
}, vis: ast::public}];
}, vis: ast::public}]/~;
}
@result
}
// Helper function that gets either fields or methods
fn get_class_members(cdata: cmd, id: ast::node_id,
p: fn(char) -> bool) -> [ty::field_ty] {
p: fn(char) -> bool) -> [ty::field_ty]/~ {
let data = cdata.data;
let item = lookup_item(id, data);
let mut result = [];
let mut result = []/~;
ebml::tagged_docs(item, tag_item_field) {|an_item|
let f = item_family(an_item);
if p(f) {
@ -505,7 +505,7 @@ fn get_class_members(cdata: cmd, id: ast::node_id,
let did = class_member_id(an_item, cdata);
let mt = field_mutability(an_item);
result += [{ident: name, id: did, vis:
family_to_visibility(f), mutability: mt}];
family_to_visibility(f), mutability: mt}]/~;
}
}
result
@ -519,7 +519,7 @@ pure fn family_to_visibility(family: char) -> ast::visibility {
}
/* 'g' for public field, 'j' for private field */
fn get_class_fields(cdata: cmd, id: ast::node_id) -> [ty::field_ty] {
fn get_class_fields(cdata: cmd, id: ast::node_id) -> [ty::field_ty]/~ {
get_class_members(cdata, id, {|f| f == 'g' || f == 'j'})
}
@ -576,12 +576,12 @@ fn item_family_to_str(fam: char) -> str {
}
}
fn get_meta_items(md: ebml::doc) -> [@ast::meta_item] {
let mut items: [@ast::meta_item] = [];
fn get_meta_items(md: ebml::doc) -> [@ast::meta_item]/~ {
let mut items: [@ast::meta_item]/~ = []/~;
ebml::tagged_docs(md, tag_meta_item_word) {|meta_item_doc|
let nd = ebml::get_doc(meta_item_doc, tag_meta_item_name);
let n = str::from_bytes(ebml::doc_data(nd));
items += [attr::mk_word_item(@n)];
items += [attr::mk_word_item(@n)]/~;
};
ebml::tagged_docs(md, tag_meta_item_name_value) {|meta_item_doc|
let nd = ebml::get_doc(meta_item_doc, tag_meta_item_name);
@ -590,19 +590,19 @@ fn get_meta_items(md: ebml::doc) -> [@ast::meta_item] {
let v = str::from_bytes(ebml::doc_data(vd));
// FIXME (#623): Should be able to decode meta_name_value variants,
// but currently the encoder just drops them
items += [attr::mk_name_value_item_str(@n, v)];
items += [attr::mk_name_value_item_str(@n, v)]/~;
};
ebml::tagged_docs(md, tag_meta_item_list) {|meta_item_doc|
let nd = ebml::get_doc(meta_item_doc, tag_meta_item_name);
let n = str::from_bytes(ebml::doc_data(nd));
let subitems = get_meta_items(meta_item_doc);
items += [attr::mk_list_item(@n, subitems)];
items += [attr::mk_list_item(@n, subitems)]/~;
};
ret items;
}
fn get_attributes(md: ebml::doc) -> [ast::attribute] {
let mut attrs: [ast::attribute] = [];
fn get_attributes(md: ebml::doc) -> [ast::attribute]/~ {
let mut attrs: [ast::attribute]/~ = []/~;
alt ebml::maybe_get_doc(md, tag_attributes) {
option::some(attrs_d) {
ebml::tagged_docs(attrs_d, tag_attribute) {|attr_doc|
@ -613,7 +613,7 @@ fn get_attributes(md: ebml::doc) -> [ast::attribute] {
let meta_item = meta_items[0];
attrs +=
[{node: {style: ast::attr_outer, value: *meta_item},
span: ast_util::dummy_sp()}];
span: ast_util::dummy_sp()}]/~;
};
}
option::none { }
@ -637,15 +637,15 @@ fn list_crate_attributes(md: ebml::doc, hash: @str, out: io::writer) {
out.write_str("\n\n");
}
fn get_crate_attributes(data: @[u8]) -> [ast::attribute] {
fn get_crate_attributes(data: @[u8]/~) -> [ast::attribute]/~ {
ret get_attributes(ebml::doc(data));
}
type crate_dep = {cnum: ast::crate_num, name: ast::ident,
vers: @str, hash: @str};
fn get_crate_deps(data: @[u8]) -> [crate_dep] {
let mut deps: [crate_dep] = [];
fn get_crate_deps(data: @[u8]/~) -> [crate_dep]/~ {
let mut deps: [crate_dep]/~ = []/~;
let cratedoc = ebml::doc(data);
let depsdoc = ebml::get_doc(cratedoc, tag_crate_deps);
let mut crate_num = 1;
@ -656,13 +656,13 @@ fn get_crate_deps(data: @[u8]) -> [crate_dep] {
deps += [{cnum: crate_num,
name: @docstr(depdoc, tag_crate_dep_name),
vers: @docstr(depdoc, tag_crate_dep_vers),
hash: @docstr(depdoc, tag_crate_dep_hash)}];
hash: @docstr(depdoc, tag_crate_dep_hash)}]/~;
crate_num += 1;
};
ret deps;
}
fn list_crate_deps(data: @[u8], out: io::writer) {
fn list_crate_deps(data: @[u8]/~, out: io::writer) {
out.write_str("=External Dependencies=\n");
for get_crate_deps(data).each {|dep|
@ -673,13 +673,13 @@ fn list_crate_deps(data: @[u8], out: io::writer) {
out.write_str("\n");
}
fn get_crate_hash(data: @[u8]) -> @str {
fn get_crate_hash(data: @[u8]/~) -> @str {
let cratedoc = ebml::doc(data);
let hashdoc = ebml::get_doc(cratedoc, tag_crate_hash);
ret @str::from_bytes(ebml::doc_data(hashdoc));
}
fn get_crate_vers(data: @[u8]) -> @str {
fn get_crate_vers(data: @[u8]/~) -> @str {
let attrs = decoder::get_crate_attributes(data);
ret alt attr::last_meta_item_value_str_by_name(
attr::find_linkage_metas(attrs), "vers") {
@ -688,7 +688,7 @@ fn get_crate_vers(data: @[u8]) -> @str {
};
}
fn list_crate_items(bytes: @[u8], md: ebml::doc, out: io::writer) {
fn list_crate_items(bytes: @[u8]/~, md: ebml::doc, out: io::writer) {
out.write_str("=Items=\n");
let items = ebml::get_doc(md, tag_items);
iter_crate_items(bytes) {|path, did|
@ -697,7 +697,7 @@ fn list_crate_items(bytes: @[u8], md: ebml::doc, out: io::writer) {
out.write_str("\n");
}
fn iter_crate_items(bytes: @[u8], proc: fn(str, ast::def_id)) {
fn iter_crate_items(bytes: @[u8]/~, proc: fn(str, ast::def_id)) {
let md = ebml::doc(bytes);
let paths = ebml::get_doc(md, tag_paths);
let index = ebml::get_doc(paths, tag_index);
@ -714,14 +714,14 @@ fn iter_crate_items(bytes: @[u8], proc: fn(str, ast::def_id)) {
};
}
fn get_crate_module_paths(bytes: @[u8]) -> [(ast::def_id, str)] {
fn get_crate_module_paths(bytes: @[u8]/~) -> [(ast::def_id, str)]/~ {
fn mod_of_path(p: str) -> str {
str::connect(vec::init(str::split_str(p, "::")), "::")
}
// find all module (path, def_ids), which are not
// fowarded path due to renamed import or reexport
let mut res = [];
let mut res = []/~;
let mods = map::str_hash();
iter_crate_items(bytes) {|path, did|
let m = mod_of_path(path);
@ -732,7 +732,7 @@ fn get_crate_module_paths(bytes: @[u8]) -> [(ast::def_id, str)] {
// Collect everything by now. There might be multiple
// paths pointing to the same did. Those will be
// unified later by using the mods map
res += [(did, path)];
res += [(did, path)]/~;
}
ret vec::filter(res) {|x|
let (_, xp) = x;
@ -740,7 +740,7 @@ fn get_crate_module_paths(bytes: @[u8]) -> [(ast::def_id, str)] {
}
}
fn list_crate_metadata(bytes: @[u8], out: io::writer) {
fn list_crate_metadata(bytes: @[u8]/~, out: io::writer) {
let hash = get_crate_hash(bytes);
let md = ebml::doc(bytes);
list_crate_attributes(md, hash, out);

152
src/rustc/metadata/encoder.rs
View file

@ -43,8 +43,8 @@ type encode_parms = {
diag: span_handler,
tcx: ty::ctxt,
reachable: hashmap<ast::node_id, ()>,
reexports: [(str, def_id)],
impl_map: fn@(ast::node_id) -> [(ident, def_id)],
reexports: [(str, def_id)]/~,
impl_map: fn@(ast::node_id) -> [(ident, def_id)]/~,
item_symbols: hashmap<ast::node_id, str>,
discrim_symbols: hashmap<ast::node_id, str>,
link_meta: link_meta,
@ -56,8 +56,8 @@ enum encode_ctxt = {
diag: span_handler,
tcx: ty::ctxt,
reachable: hashmap<ast::node_id, ()>,
reexports: [(str, def_id)],
impl_map: fn@(ast::node_id) -> [(ident, def_id)],
reexports: [(str, def_id)]/~,
impl_map: fn@(ast::node_id) -> [(ident, def_id)]/~,
item_symbols: hashmap<ast::node_id, str>,
discrim_symbols: hashmap<ast::node_id, str>,
link_meta: link_meta,
@ -108,8 +108,8 @@ fn encode_mutability(ebml_w: ebml::writer, mt: class_mutability) {
type entry<T> = {val: T, pos: uint};
fn encode_enum_variant_paths(ebml_w: ebml::writer, variants: [variant],
path: [ident], &index: [entry<str>]) {
fn encode_enum_variant_paths(ebml_w: ebml::writer, variants: [variant]/~,
path: [ident]/~, &index: [entry<str>]/~) {
for variants.each {|variant|
add_to_index(ebml_w, path, index, variant.node.name);
ebml_w.wr_tag(tag_paths_data_item) {||
@ -119,15 +119,15 @@ fn encode_enum_variant_paths(ebml_w: ebml::writer, variants: [variant],
}
}
fn add_to_index(ebml_w: ebml::writer, path: [ident], &index: [entry<str>],
fn add_to_index(ebml_w: ebml::writer, path: [ident]/~, &index: [entry<str>]/~,
name: ident) {
let full_path = path + [name];
index +=
[{val: ast_util::path_name_i(full_path), pos: ebml_w.writer.tell()}];
let full_path = path + [name]/~;
vec::push(index, {val: ast_util::path_name_i(full_path),
pos: ebml_w.writer.tell()});
}
fn encode_native_module_item_paths(ebml_w: ebml::writer, nmod: native_mod,
path: [ident], &index: [entry<str>]) {
path: [ident]/~, &index: [entry<str>]/~) {
for nmod.items.each {|nitem|
add_to_index(ebml_w, path, index, nitem.ident);
encode_named_def_id(ebml_w, nitem.ident, local_def(nitem.id));
@ -135,7 +135,7 @@ fn encode_native_module_item_paths(ebml_w: ebml::writer, nmod: native_mod,
}
fn encode_class_item_paths(ebml_w: ebml::writer,
items: [@class_member], path: [ident], &index: [entry<str>]) {
items: [@class_member]/~, path: [ident]/~, &index: [entry<str>]/~) {
for items.each {|it|
alt ast_util::class_member_visibility(it) {
private { cont; }
@ -152,8 +152,8 @@ fn encode_class_item_paths(ebml_w: ebml::writer,
}
fn encode_module_item_paths(ebml_w: ebml::writer, ecx: @encode_ctxt,
module: _mod, path: [ident],
&index: [entry<str>]) {
module: _mod, path: [ident]/~,
&index: [entry<str>]/~) {
for module.items.each {|it|
if !reachable(ecx, it.id) ||
!ast_util::is_exported(it.ident, module) { cont; }
@ -170,7 +170,8 @@ fn encode_module_item_paths(ebml_w: ebml::writer, ecx: @encode_ctxt,
item_mod(_mod) {
ebml_w.wr_tag(tag_paths_data_mod) {||
encode_name_and_def_id(ebml_w, it.ident, it.id);
encode_module_item_paths(ebml_w, ecx, _mod, path + [it.ident],
encode_module_item_paths(ebml_w, ecx, _mod,
path + [it.ident]/~,
index);
}
}
@ -178,7 +179,7 @@ fn encode_module_item_paths(ebml_w: ebml::writer, ecx: @encode_ctxt,
ebml_w.wr_tag(tag_paths_data_mod) {||
encode_name_and_def_id(ebml_w, it.ident, it.id);
encode_native_module_item_paths(ebml_w, nmod,
path + [it.ident], index);
path + [it.ident]/~, index);
}
}
item_ty(_, tps, _) {
@ -196,7 +197,7 @@ fn encode_module_item_paths(ebml_w: ebml::writer, ecx: @encode_ctxt,
add_to_index(ebml_w, path, index, it.ident);
encode_named_def_id(ebml_w, it.ident,
local_def(ctor.node.id));
encode_class_item_paths(ebml_w, items, path + [it.ident],
encode_class_item_paths(ebml_w, items, path + [it.ident]/~,
index);
}
}
@ -223,9 +224,9 @@ fn encode_iface_ref(ebml_w: ebml::writer, ecx: @encode_ctxt, t: @iface_ref) {
}
fn encode_item_paths(ebml_w: ebml::writer, ecx: @encode_ctxt, crate: @crate)
-> [entry<str>] {
let mut index: [entry<str>] = [];
let mut path: [ident] = [];
-> [entry<str>]/~ {
let mut index: [entry<str>]/~ = []/~;
let mut path: [ident]/~ = []/~;
ebml_w.start_tag(tag_paths);
encode_module_item_paths(ebml_w, ecx, crate.node.module, path, index);
encode_reexport_paths(ebml_w, ecx, index);
@ -234,10 +235,10 @@ fn encode_item_paths(ebml_w: ebml::writer, ecx: @encode_ctxt, crate: @crate)
}
fn encode_reexport_paths(ebml_w: ebml::writer,
ecx: @encode_ctxt, &index: [entry<str>]) {
ecx: @encode_ctxt, &index: [entry<str>]/~) {
for ecx.reexports.each {|reexport|
let (path, def_id) = reexport;
index += [{val: path, pos: ebml_w.writer.tell()}];
index += [{val: path, pos: ebml_w.writer.tell()}]/~;
ebml_w.start_tag(tag_paths_data_item);
encode_name(ebml_w, @path);
encode_def_id(ebml_w, def_id);
@ -256,7 +257,7 @@ fn encode_family(ebml_w: ebml::writer, c: char) {
fn def_to_str(did: def_id) -> str { ret #fmt["%d:%d", did.crate, did.node]; }
fn encode_type_param_bounds(ebml_w: ebml::writer, ecx: @encode_ctxt,
params: [ty_param]) {
params: [ty_param]/~) {
let ty_str_ctxt = @{diag: ecx.diag,
ds: def_to_str,
tcx: ecx.tcx,
@ -324,14 +325,14 @@ fn encode_parent_item(ebml_w: ebml::writer, id: def_id) {
}
fn encode_enum_variant_info(ecx: @encode_ctxt, ebml_w: ebml::writer,
id: node_id, variants: [variant],
path: ast_map::path, index: @mut [entry<int>],
ty_params: [ty_param]) {
id: node_id, variants: [variant]/~,
path: ast_map::path, index: @mut [entry<int>]/~,
ty_params: [ty_param]/~) {
let mut disr_val = 0;
let mut i = 0;
let vi = ty::enum_variants(ecx.tcx, {crate: local_crate, node: id});
for variants.each {|variant|
*index += [{val: variant.node.id, pos: ebml_w.writer.tell()}];
*index += [{val: variant.node.id, pos: ebml_w.writer.tell()}]/~;
ebml_w.start_tag(tag_items_data_item);
encode_def_id(ebml_w, local_def(variant.node.id));
encode_family(ebml_w, 'v');
@ -420,20 +421,20 @@ fn encode_visibility(ebml_w: ebml::writer, visibility: visibility) {
/* Returns an index of items in this class */
fn encode_info_for_class(ecx: @encode_ctxt, ebml_w: ebml::writer,
id: node_id, path: ast_map::path,
class_tps: [ty_param],
items: [@class_member],
global_index: @mut[entry<int>]) -> [entry<int>] {
class_tps: [ty_param]/~,
items: [@class_member]/~,
global_index: @mut[entry<int>]/~) -> [entry<int>]/~ {
/* Each class has its own index, since different classes
may have fields with the same name */
let index = @mut [];
let index = @mut []/~;
let tcx = ecx.tcx;
for items.each {|ci|
/* We encode both private and public fields -- need to include
private fields to get the offsets right */
alt ci.node {
instance_var(nm, _, mt, id, vis) {
*index += [{val: id, pos: ebml_w.writer.tell()}];
*global_index += [{val: id, pos: ebml_w.writer.tell()}];
*index += [{val: id, pos: ebml_w.writer.tell()}]/~;
*global_index += [{val: id, pos: ebml_w.writer.tell()}]/~;
ebml_w.start_tag(tag_items_data_item);
#debug("encode_info_for_class: doing %s %d", *nm, id);
encode_visibility(ebml_w, vis);
@ -447,9 +448,9 @@ fn encode_info_for_class(ecx: @encode_ctxt, ebml_w: ebml::writer,
class_method(m) {
alt m.vis {
public {
*index += [{val: m.id, pos: ebml_w.writer.tell()}];
*global_index += [{val: m.id, pos: ebml_w.writer.tell()}];
let impl_path = path + [ast_map::path_name(m.ident)];
*index += [{val: m.id, pos: ebml_w.writer.tell()}]/~;
*global_index += [{val: m.id, pos: ebml_w.writer.tell()}]/~;
let impl_path = path + [ast_map::path_name(m.ident)]/~;
#debug("encode_info_for_class: doing %s %d", *m.ident, m.id);
encode_info_for_method(ecx, ebml_w, impl_path,
should_inline(m.attrs), id, m,
@ -465,7 +466,7 @@ fn encode_info_for_class(ecx: @encode_ctxt, ebml_w: ebml::writer,
fn encode_info_for_fn(ecx: @encode_ctxt, ebml_w: ebml::writer,
id: node_id, ident: ident, path: ast_map::path,
item: option<inlined_item>, tps: [ty_param],
item: option<inlined_item>, tps: [ty_param]/~,
decl: fn_decl) {
ebml_w.start_tag(tag_items_data_item);
encode_name(ebml_w, ident);
@ -491,7 +492,7 @@ fn encode_info_for_fn(ecx: @encode_ctxt, ebml_w: ebml::writer,
fn encode_info_for_method(ecx: @encode_ctxt, ebml_w: ebml::writer,
impl_path: ast_map::path, should_inline: bool,
parent_id: node_id,
m: @method, all_tps: [ty_param]) {
m: @method, all_tps: [ty_param]/~) {
#debug("encode_info_for_method: %d %s %u", m.id, *m.ident, all_tps.len());
ebml_w.start_tag(tag_items_data_item);
encode_def_id(ebml_w, local_def(m.id));
@ -520,7 +521,7 @@ fn purity_fn_family(p: purity) -> char {
}
fn should_inline(attrs: [attribute]) -> bool {
fn should_inline(attrs: [attribute]/~) -> bool {
alt attr::find_inline_attr(attrs) {
attr::ia_none { false }
attr::ia_hint | attr::ia_always { true }
@ -529,7 +530,7 @@ fn should_inline(attrs: [attribute]) -> bool {
fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
index: @mut [entry<int>], path: ast_map::path) {
index: @mut [entry<int>]/~, path: ast_map::path) {
let tcx = ecx.tcx;
let must_write =
@ -537,8 +538,8 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
if !must_write && !reachable(ecx, item.id) { ret; }
fn add_to_index_(item: @item, ebml_w: ebml::writer,
index: @mut [entry<int>]) {
*index += [{val: item.id, pos: ebml_w.writer.tell()}];
index: @mut [entry<int>]/~) {
*index += [{val: item.id, pos: ebml_w.writer.tell()}]/~;
}
let add_to_index = {|copy ebml_w|add_to_index_(item, ebml_w, index)};
@ -620,7 +621,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
items, index);
/* Encode the dtor */
option::iter(m_dtor) {|dtor|
*index += [{val: dtor.node.id, pos: ebml_w.writer.tell()}];
*index += [{val: dtor.node.id, pos: ebml_w.writer.tell()}]/~;
encode_info_for_fn(ecx, ebml_w, dtor.node.id, @(*item.ident
+ "_dtor"), path, if tps.len() > 0u {
some(ii_dtor(dtor, item.ident, tps,
@ -707,9 +708,9 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
encode_path(ebml_w, path, ast_map::path_name(item.ident));
ebml_w.end_tag();
let impl_path = path + [ast_map::path_name(item.ident)];
let impl_path = path + [ast_map::path_name(item.ident)]/~;
for methods.each {|m|
*index += [{val: m.id, pos: ebml_w.writer.tell()}];
*index += [{val: m.id, pos: ebml_w.writer.tell()}]/~;
encode_info_for_method(ecx, ebml_w, impl_path,
should_inline(m.attrs), item.id, m, tps + m.tps);
}
@ -741,10 +742,10 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
fn encode_info_for_native_item(ecx: @encode_ctxt, ebml_w: ebml::writer,
nitem: @native_item,
index: @mut [entry<int>],
index: @mut [entry<int>]/~,
path: ast_map::path, abi: native_abi) {
if !reachable(ecx, nitem.id) { ret; }
*index += [{val: nitem.id, pos: ebml_w.writer.tell()}];
*index += [{val: nitem.id, pos: ebml_w.writer.tell()}]/~;
ebml_w.start_tag(tag_items_data_item);
alt nitem.node {
@ -766,12 +767,12 @@ fn encode_info_for_native_item(ecx: @encode_ctxt, ebml_w: ebml::writer,
}
fn encode_info_for_items(ecx: @encode_ctxt, ebml_w: ebml::writer,
crate: @crate) -> [entry<int>] {
let index = @mut [];
crate: @crate) -> [entry<int>]/~ {
let index = @mut []/~;
ebml_w.start_tag(tag_items_data);
*index += [{val: crate_node_id, pos: ebml_w.writer.tell()}];
*index += [{val: crate_node_id, pos: ebml_w.writer.tell()}]/~;
encode_info_for_mod(ecx, ebml_w, crate.node.module,
crate_node_id, [], @"");
crate_node_id, []/~, @"");
visit::visit_crate(*crate, (), visit::mk_vt(@{
visit_expr: {|_e, _cx, _v|},
visit_item: {|i, cx, v, copy ebml_w|
@ -784,7 +785,8 @@ fn encode_info_for_items(ecx: @encode_ctxt, ebml_w: ebml::writer,
item_class(tps, _, _, ctor, m_dtor, _) {
#debug("encoding info for ctor %s %d", *i.ident,
ctor.node.id);
*index += [{val: ctor.node.id, pos: ebml_w.writer.tell()}];
*index +=
[{val: ctor.node.id, pos: ebml_w.writer.tell()}]/~;
encode_info_for_fn(ecx, ebml_w, ctor.node.id, i.ident,
*pt, if tps.len() > 0u {
some(ii_ctor(ctor, i.ident, tps,
@ -813,30 +815,30 @@ fn encode_info_for_items(ecx: @encode_ctxt, ebml_w: ebml::writer,
// Path and definition ID indexing
fn create_index<T: copy>(index: [entry<T>], hash_fn: fn@(T) -> uint) ->
[@[entry<T>]] {
let mut buckets: [@mut [entry<T>]] = [];
for uint::range(0u, 256u) {|_i| buckets += [@mut []]; };
fn create_index<T: copy>(index: [entry<T>]/~, hash_fn: fn@(T) -> uint) ->
[@[entry<T>]/~]/~ {
let mut buckets: [@mut [entry<T>]/~]/~ = []/~;
for uint::range(0u, 256u) {|_i| buckets += [@mut []/~]/~; };
for index.each {|elt|
let h = hash_fn(elt.val);
*buckets[h % 256u] += [elt];
vec::push(*buckets[h % 256u], elt);
}
let mut buckets_frozen = [];
let mut buckets_frozen = []/~;
for buckets.each {|bucket|
buckets_frozen += [@*bucket];
vec::push(buckets_frozen, @*bucket);
}
ret buckets_frozen;
}
fn encode_index<T>(ebml_w: ebml::writer, buckets: [@[entry<T>]],
fn encode_index<T>(ebml_w: ebml::writer, buckets: [@[entry<T>]/~]/~,
write_fn: fn(io::writer, T)) {
let writer = ebml_w.writer;
ebml_w.start_tag(tag_index);
let mut bucket_locs: [uint] = [];
let mut bucket_locs: [uint]/~ = []/~;
ebml_w.start_tag(tag_index_buckets);
for buckets.each {|bucket|
bucket_locs += [ebml_w.writer.tell()];
bucket_locs += [ebml_w.writer.tell()]/~;
ebml_w.start_tag(tag_index_buckets_bucket);
for vec::each(*bucket) {|elt|
ebml_w.start_tag(tag_index_buckets_bucket_elt);
@ -896,7 +898,7 @@ fn encode_meta_item(ebml_w: ebml::writer, mi: meta_item) {
}
}
fn encode_attributes(ebml_w: ebml::writer, attrs: [attribute]) {
fn encode_attributes(ebml_w: ebml::writer, attrs: [attribute]/~) {
ebml_w.start_tag(tag_attributes);
for attrs.each {|attr|
ebml_w.start_tag(tag_attribute);
@ -910,9 +912,9 @@ fn encode_attributes(ebml_w: ebml::writer, attrs: [attribute]) {
// metadata that Rust cares about for linking crates. This attribute requires
// 'name' and 'vers' items, so if the user didn't provide them we will throw
// them in anyway with default values.
fn synthesize_crate_attrs(ecx: @encode_ctxt, crate: @crate) -> [attribute] {
fn synthesize_crate_attrs(ecx: @encode_ctxt, crate: @crate) -> [attribute]/~ {
fn synthesize_link_attr(ecx: @encode_ctxt, items: [@meta_item]) ->
fn synthesize_link_attr(ecx: @encode_ctxt, items: [@meta_item]/~) ->
attribute {
assert (*ecx.link_meta.name != "");
@ -929,47 +931,47 @@ fn synthesize_crate_attrs(ecx: @encode_ctxt, crate: @crate) -> [attribute] {
attr::remove_meta_items_by_name(tmp, @"vers")
};
let meta_items = [name_item, vers_item] + other_items;
let meta_items = [name_item, vers_item]/~ + other_items;
let link_item = attr::mk_list_item(@"link", meta_items);
ret attr::mk_attr(link_item);
}
let mut attrs: [attribute] = [];
let mut attrs: [attribute]/~ = []/~;
let mut found_link_attr = false;
for crate.node.attrs.each {|attr|
attrs +=
if *attr::get_attr_name(attr) != "link" {
[attr]
[attr]/~
} else {
alt attr.node.value.node {
meta_list(n, l) {
found_link_attr = true;;
[synthesize_link_attr(ecx, l)]
[synthesize_link_attr(ecx, l)]/~
}
_ { [attr] }
_ { [attr]/~ }
}
};
}
if !found_link_attr { attrs += [synthesize_link_attr(ecx, [])]; }
if !found_link_attr { attrs += [synthesize_link_attr(ecx, []/~)]/~; }
ret attrs;
}
fn encode_crate_deps(ebml_w: ebml::writer, cstore: cstore::cstore) {
fn get_ordered_deps(cstore: cstore::cstore) -> [decoder::crate_dep] {
fn get_ordered_deps(cstore: cstore::cstore) -> [decoder::crate_dep]/~ {
type hashkv = @{key: crate_num, val: cstore::crate_metadata};
type numdep = decoder::crate_dep;
// Pull the cnums and name,vers,hash out of cstore
let mut deps: [mut numdep] = [mut];
let mut deps: [mut numdep]/~ = [mut]/~;
cstore::iter_crate_data(cstore) {|key, val|
let dep = {cnum: key, name: @val.name,
vers: decoder::get_crate_vers(val.data),
hash: decoder::get_crate_hash(val.data)};
deps += [mut dep];
deps += [mut dep]/~;
};
// Sort by cnum
@ -1018,7 +1020,7 @@ fn encode_hash(ebml_w: ebml::writer, hash: str) {
ebml_w.end_tag();
}
fn encode_metadata(parms: encode_parms, crate: @crate) -> [u8] {
fn encode_metadata(parms: encode_parms, crate: @crate) -> [u8]/~ {
let ecx: @encode_ctxt = @encode_ctxt({
diag: parms.diag,
tcx: parms.tcx,

26
src/rustc/metadata/filesearch.rs
View file

@ -25,29 +25,29 @@ fn pick_file(file: path, path: path) -> option<path> {
iface filesearch {
fn sysroot() -> path;
fn lib_search_paths() -> [path];
fn lib_search_paths() -> [path]/~;
fn get_target_lib_path() -> path;
fn get_target_lib_file_path(file: path) -> path;
}
fn mk_filesearch(maybe_sysroot: option<path>,
target_triple: str,
addl_lib_search_paths: [path]) -> filesearch {
addl_lib_search_paths: [path]/~) -> filesearch {
type filesearch_impl = {sysroot: path,
addl_lib_search_paths: [path],
addl_lib_search_paths: [path]/~,
target_triple: str};
impl of filesearch for filesearch_impl {
fn sysroot() -> path { self.sysroot }
fn lib_search_paths() -> [path] {
fn lib_search_paths() -> [path]/~ {
self.addl_lib_search_paths
+ [make_target_lib_path(self.sysroot, self.target_triple)]
+ [make_target_lib_path(self.sysroot, self.target_triple)]/~
+ alt get_cargo_lib_path_nearest() {
result::ok(p) { [p] }
result::err(p) { [] }
result::ok(p) { [p]/~ }
result::err(p) { []/~ }
}
+ alt get_cargo_lib_path() {
result::ok(p) { [p] }
result::err(p) { [] }
result::ok(p) { [p]/~ }
result::err(p) { []/~ }
}
}
fn get_target_lib_path() -> path {
@ -85,13 +85,13 @@ fn search<T: copy>(filesearch: filesearch, pick: pick<T>) -> option<T> {
ret rslt;
}
fn relative_target_lib_path(target_triple: str) -> [path] {
[libdir(), "rustc", target_triple, libdir()]
fn relative_target_lib_path(target_triple: str) -> [path]/~ {
[libdir(), "rustc", target_triple, libdir()]/~
}
fn make_target_lib_path(sysroot: path,
target_triple: str) -> path {
let path = [sysroot] + relative_target_lib_path(target_triple);
let path = [sysroot]/~ + relative_target_lib_path(target_triple);
let path = path::connect_many(path);
ret path;
}
@ -113,7 +113,7 @@ fn get_sysroot(maybe_sysroot: option<path>) -> path {
}
fn get_cargo_sysroot() -> result<path, str> {
let path = [get_default_sysroot(), libdir(), "cargo"];
let path = [get_default_sysroot(), libdir(), "cargo"]/~;
result::ok(path::connect_many(path))
}

32
src/rustc/metadata/loader.rs
View file

@ -33,13 +33,13 @@ type ctxt = {
filesearch: filesearch,
span: span,
ident: ast::ident,
metas: [@ast::meta_item],
metas: [@ast::meta_item]/~,
hash: str,
os: os,
static: bool
};
fn load_library_crate(cx: ctxt) -> {ident: str, data: @[u8]} {
fn load_library_crate(cx: ctxt) -> {ident: str, data: @[u8]/~} {
alt find_library_crate(cx) {
some(t) { ret t; }
none {
@ -49,7 +49,7 @@ fn load_library_crate(cx: ctxt) -> {ident: str, data: @[u8]} {
}
}
fn find_library_crate(cx: ctxt) -> option<{ident: str, data: @[u8]}> {
fn find_library_crate(cx: ctxt) -> option<{ident: str, data: @[u8]/~}> {
attr::require_unique_names(cx.diag, cx.metas);
find_library_crate_aux(cx, libname(cx), cx.filesearch)
}
@ -67,12 +67,12 @@ fn libname(cx: ctxt) -> {prefix: str, suffix: str} {
fn find_library_crate_aux(cx: ctxt,
nn: {prefix: str, suffix: str},
filesearch: filesearch::filesearch) ->
option<{ident: str, data: @[u8]}> {
option<{ident: str, data: @[u8]/~}> {
let crate_name = crate_name_from_metas(cx.metas);
let prefix: str = nn.prefix + *crate_name + "-";
let suffix: str = nn.suffix;
let mut matches = [];
let mut matches = []/~;
filesearch::search(filesearch, { |path|
#debug("inspecting file %s", path);
let f: str = path::basename(path);
@ -89,7 +89,7 @@ fn find_library_crate_aux(cx: ctxt,
option::none::<()>
} else {
#debug("found %s with matching metadata", path);
matches += [{ident: path, data: cvec}];
matches += [{ident: path, data: cvec}]/~;
option::none::<()>
}
}
@ -119,7 +119,7 @@ fn find_library_crate_aux(cx: ctxt,
}
}
fn crate_name_from_metas(metas: [@ast::meta_item]) -> @str {
fn crate_name_from_metas(metas: [@ast::meta_item]/~) -> @str {
let name_items = attr::find_meta_items_by_name(metas, "name");
alt vec::last_opt(name_items) {
some(i) {
@ -134,14 +134,14 @@ fn crate_name_from_metas(metas: [@ast::meta_item]) -> @str {
}
}
fn note_linkage_attrs(diag: span_handler, attrs: [ast::attribute]) {
fn note_linkage_attrs(diag: span_handler, attrs: [ast::attribute]/~) {
for attr::find_linkage_attrs(attrs).each {|attr|
diag.handler().note(#fmt("meta: %s", pprust::attr_to_str(attr)));
}
}
fn crate_matches(crate_data: @[u8], metas: [@ast::meta_item], hash: str) ->
bool {
fn crate_matches(crate_data: @[u8]/~, metas: [@ast::meta_item]/~,
hash: str) -> bool {
let attrs = decoder::get_crate_attributes(crate_data);
let linkage_metas = attr::find_linkage_metas(attrs);
if hash.is_not_empty() {
@ -151,8 +151,8 @@ fn crate_matches(crate_data: @[u8], metas: [@ast::meta_item], hash: str) ->
metadata_matches(linkage_metas, metas)
}
fn metadata_matches(extern_metas: [@ast::meta_item],
local_metas: [@ast::meta_item]) -> bool {
fn metadata_matches(extern_metas: [@ast::meta_item]/~,
local_metas: [@ast::meta_item]/~) -> bool {
#debug("matching %u metadata requirements against %u items",
vec::len(local_metas), vec::len(extern_metas));
@ -173,14 +173,14 @@ fn metadata_matches(extern_metas: [@ast::meta_item],
}
fn get_metadata_section(os: os,
filename: str) -> option<@[u8]> unsafe {
filename: str) -> option<@[u8]/~> unsafe {
let mb = str::as_c_str(filename, {|buf|
llvm::LLVMRustCreateMemoryBufferWithContentsOfFile(buf)
});
if mb as int == 0 { ret option::none::<@[u8]>; }
if mb as int == 0 { ret option::none::<@[u8]/~>; }
let of = alt mk_object_file(mb) {
option::some(of) { of }
_ { ret option::none::<@[u8]>; }
_ { ret option::none::<@[u8]/~>; }
};
let si = mk_section_iter(of.llof);
while llvm::LLVMIsSectionIteratorAtEnd(of.llof, si.llsi) == False {
@ -196,7 +196,7 @@ fn get_metadata_section(os: os,
}
llvm::LLVMMoveToNextSection(si.llsi);
}
ret option::none::<@[u8]>;
ret option::none::<@[u8]/~>;
}
fn meta_section_name(os: os) -> str {

60
src/rustc/metadata/tydecode.rs
View file

@ -17,7 +17,7 @@ export parse_bounds_data;
// Callback to translate defs to strs or back:
type conv_did = fn(ast::def_id) -> ast::def_id;
type pstate = {data: @[u8], crate: int, mut pos: uint, tcx: ty::ctxt};
type pstate = {data: @[u8]/~, crate: int, mut pos: uint, tcx: ty::ctxt};
fn peek(st: @pstate) -> char {
st.data[st.pos] as char
@ -50,7 +50,7 @@ fn parse_ident_(st: @pstate, is_last: fn@(char) -> bool) ->
}
fn parse_ty_data(data: @[u8], crate_num: int, pos: uint, tcx: ty::ctxt,
fn parse_ty_data(data: @[u8]/~, crate_num: int, pos: uint, tcx: ty::ctxt,
conv: conv_did) -> ty::t {
let st = @{data: data, crate: crate_num, mut pos: pos, tcx: tcx};
parse_ty(st, conv)
@ -65,13 +65,13 @@ fn parse_ret_ty(st: @pstate, conv: conv_did) -> (ast::ret_style, ty::t) {
fn parse_constrs_gen<T: copy>(st: @pstate, conv: conv_did,
pser: fn(@pstate)
-> ast::constr_arg_general_<T>) -> [@ty::constr_general<T>] {
let mut rslt: [@ty::constr_general<T>] = [];
-> ast::constr_arg_general_<T>) -> [@ty::constr_general<T>]/~ {
let mut rslt: [@ty::constr_general<T>]/~ = []/~;
alt peek(st) {
':' {
loop {
next(st);
rslt += [parse_constr(st, conv, pser)];
rslt += [parse_constr(st, conv, pser)]/~;
if peek(st) != ';' { break; }
}
}
@ -80,18 +80,18 @@ fn parse_constrs_gen<T: copy>(st: @pstate, conv: conv_did,
rslt
}
fn parse_constrs(st: @pstate, conv: conv_did) -> [@ty::constr] {
fn parse_constrs(st: @pstate, conv: conv_did) -> [@ty::constr]/~ {
parse_constrs_gen(st, conv, parse_constr_arg)
}
fn parse_ty_constrs(st: @pstate, conv: conv_did) -> [@ty::type_constr] {
fn parse_ty_constrs(st: @pstate, conv: conv_did) -> [@ty::type_constr]/~ {
parse_constrs_gen(st, conv, parse_ty_constr_arg)
}
fn parse_path(st: @pstate) -> @ast::path {
let mut idents: [ast::ident] = [];
let mut idents: [ast::ident]/~ = []/~;
fn is_last(c: char) -> bool { ret c == '(' || c == ':'; }
idents += [parse_ident_(st, is_last)];
idents += [parse_ident_(st, is_last)]/~;
loop {
alt peek(st) {
':' { next(st); next(st); }
@ -99,8 +99,8 @@ fn parse_path(st: @pstate) -> @ast::path {
if c == '(' {
ret @{span: ast_util::dummy_sp(),
global: false, idents: idents,
rp: none, types: []};
} else { idents += [parse_ident_(st, is_last)]; }
rp: none, types: []/~};
} else { idents += [parse_ident_(st, is_last)]/~; }
}
}
};
@ -124,7 +124,7 @@ fn parse_constr_arg(st: @pstate) -> ast::fn_constr_arg {
/*
else {
auto lit = parse_lit(st, conv, ',');
args += [respan(st.span, ast::carg_lit(lit))];
args += [respan(st.span, ast::carg_lit(lit))]/~;
}
*/
}
@ -143,7 +143,7 @@ fn parse_constr<T: copy>(st: @pstate, conv: conv_did,
-> @ty::constr_general<T> {
// FIXME: use real spans and not a bogus one (#2407)
let sp = ast_util::dummy_sp();
let mut args: [@sp_constr_arg<T>] = [];
let mut args: [@sp_constr_arg<T>]/~ = []/~;
let pth = parse_path(st);
let mut ignore: char = next(st);
assert (ignore == '(');
@ -151,7 +151,7 @@ fn parse_constr<T: copy>(st: @pstate, conv: conv_did,
let mut an_arg: constr_arg_general_<T>;
loop {
an_arg = pser(st);
args += [@respan(sp, an_arg)];
args += [@respan(sp, an_arg)]/~;
ignore = next(st);
if ignore != ';' { break; }
}
@ -197,8 +197,8 @@ fn parse_substs(st: @pstate, conv: conv_did) -> ty::substs {
let self_ty = parse_opt(st) {|| parse_ty(st, conv) };
assert next(st) == '[';
let mut params: [ty::t] = [];
while peek(st) != ']' { params += [parse_ty(st, conv)]; }
let mut params: [ty::t]/~ = []/~;
while peek(st) != ']' { params += [parse_ty(st, conv)]/~; }
st.pos = st.pos + 1u;
ret {self_r: self_r,
@ -320,18 +320,18 @@ fn parse_ty(st: @pstate, conv: conv_did) -> ty::t {
}
'R' {
assert (next(st) == '[');
let mut fields: [ty::field] = [];
let mut fields: [ty::field]/~ = []/~;
while peek(st) != ']' {
let name = @parse_str(st, '=');
fields += [{ident: name, mt: parse_mt(st, conv)}];
fields += [{ident: name, mt: parse_mt(st, conv)}]/~;
}
st.pos = st.pos + 1u;
ret ty::mk_rec(st.tcx, fields);
}
'T' {
assert (next(st) == '[');
let mut params = [];
while peek(st) != ']' { params += [parse_ty(st, conv)]; }
let mut params = []/~;
while peek(st) != ']' { params += [parse_ty(st, conv)]/~; }
st.pos = st.pos + 1u;
ret ty::mk_tup(st.tcx, params);
}
@ -403,8 +403,8 @@ fn parse_mt(st: @pstate, conv: conv_did) -> ty::mt {
}
fn parse_def(st: @pstate, conv: conv_did) -> ast::def_id {
let mut def = [];
while peek(st) != '|' { def += [next_byte(st)]; }
let mut def = []/~;
while peek(st) != '|' { def += [next_byte(st)]/~; }
st.pos = st.pos + 1u;
ret conv(parse_def_id(def));
}
@ -446,7 +446,7 @@ fn parse_ty_fn(st: @pstate, conv: conv_did) -> ty::fn_ty {
let proto = parse_proto(next(st));
let purity = parse_purity(next(st));
assert (next(st) == '[');
let mut inputs: [ty::arg] = [];
let mut inputs: [ty::arg]/~ = []/~;
while peek(st) != ']' {
let mode = alt check peek(st) {
'&' { ast::by_mutbl_ref }
@ -456,7 +456,7 @@ fn parse_ty_fn(st: @pstate, conv: conv_did) -> ty::fn_ty {
'#' { ast::by_val }
};
st.pos += 1u;
inputs += [{mode: ast::expl(mode), ty: parse_ty(st, conv)}];
inputs += [{mode: ast::expl(mode), ty: parse_ty(st, conv)}]/~;
}
st.pos += 1u; // eat the ']'
let cs = parse_constrs(st, conv);
@ -467,7 +467,7 @@ fn parse_ty_fn(st: @pstate, conv: conv_did) -> ty::fn_ty {
// Rust metadata parsing
fn parse_def_id(buf: [u8]) -> ast::def_id {
fn parse_def_id(buf: [u8]/~) -> ast::def_id {
let mut colon_idx = 0u;
let len = vec::len(buf);
while colon_idx < len && buf[colon_idx] != ':' as u8 { colon_idx += 1u; }
@ -491,15 +491,15 @@ fn parse_def_id(buf: [u8]) -> ast::def_id {
ret {crate: crate_num, node: def_num};
}
fn parse_bounds_data(data: @[u8], start: uint,
fn parse_bounds_data(data: @[u8]/~, start: uint,
crate_num: int, tcx: ty::ctxt, conv: conv_did)
-> @[ty::param_bound] {
-> @[ty::param_bound]/~ {
let st = @{data: data, crate: crate_num, mut pos: start, tcx: tcx};
parse_bounds(st, conv)
}
fn parse_bounds(st: @pstate, conv: conv_did) -> @[ty::param_bound] {
let mut bounds = [];
fn parse_bounds(st: @pstate, conv: conv_did) -> @[ty::param_bound]/~ {
let mut bounds = []/~;
loop {
bounds += [alt check next(st) {
'S' { ty::bound_send }
@ -507,7 +507,7 @@ fn parse_bounds(st: @pstate, conv: conv_did) -> @[ty::param_bound] {
'K' { ty::bound_const }
'I' { ty::bound_iface(parse_ty(st, conv)) }
'.' { break; }
}];
}]/~;
}
@bounds
}

2
src/rustc/metadata/tyencode.rs
View file

@ -395,7 +395,7 @@ fn enc_ty_constr(w: io::writer, cx: @ctxt, c: @ty::type_constr) {
});
}
fn enc_bounds(w: io::writer, cx: @ctxt, bs: @[ty::param_bound]) {
fn enc_bounds(w: io::writer, cx: @ctxt, bs: @[ty::param_bound]/~) {
for vec::each(*bs) {|bound|
alt bound {
ty::bound_send { w.write_char('S'); }

12
src/rustc/middle/astencode.rs
View file

@ -540,7 +540,7 @@ impl helpers for ebml::writer {
e::write_type(ecx, self, ty)
}
fn emit_tys(ecx: @e::encode_ctxt, tys: [ty::t]) {
fn emit_tys(ecx: @e::encode_ctxt, tys: [ty::t]/~) {
self.emit_from_vec(tys) {|ty|
e::write_type(ecx, self, ty)
}
@ -741,11 +741,11 @@ impl decoder for ebml::ebml_deserializer {
{|a|xcx.tr_def_id(a)})
}
fn read_tys(xcx: extended_decode_ctxt) -> [ty::t] {
fn read_tys(xcx: extended_decode_ctxt) -> [ty::t]/~ {
self.read_to_vec {|| self.read_ty(xcx) }
}
fn read_bounds(xcx: extended_decode_ctxt) -> @[ty::param_bound] {
fn read_bounds(xcx: extended_decode_ctxt) -> @[ty::param_bound]/~ {
tydecode::parse_bounds_data(
self.parent.data, self.pos, xcx.dcx.cdata.cnum, xcx.dcx.tcx,
{|a|xcx.tr_def_id(a)})
@ -861,7 +861,7 @@ type fake_session = ();
#[cfg(test)]
impl of fake_ext_ctxt for fake_session {
fn cfg() -> ast::crate_cfg { [] }
fn cfg() -> ast::crate_cfg { []/~ }
fn parse_sess() -> parse::parse_sess { parse::new_parse_sess(none) }
}
@ -924,13 +924,13 @@ fn test_simplification() {
let item_in = ast::ii_item(#ast(item) {
fn new_int_alist<B: copy>() -> alist<int, B> {
fn eq_int(&&a: int, &&b: int) -> bool { a == b }
ret {eq_fn: eq_int, mut data: []};
ret {eq_fn: eq_int, mut data: []/~};
}
});
let item_out = simplify_ast(item_in);
let item_exp = ast::ii_item(#ast(item) {
fn new_int_alist<B: copy>() -> alist<int, B> {
ret {eq_fn: eq_int, mut data: []};
ret {eq_fn: eq_int, mut data: []/~};
}
});
alt (item_out, item_exp) {

10
src/rustc/middle/borrowck/check_loans.rs
View file

@ -23,7 +23,7 @@ enum check_loan_ctxt = @{
// we are in a ctor, we track the self id
mut in_ctor: bool,
mut declared_purity: ast::purity,
mut fn_args: @[ast::node_id]
mut fn_args: @[ast::node_id]/~
};
// if we are enforcing purity, why are we doing so?
@ -45,7 +45,7 @@ fn check_loans(bccx: borrowck_ctxt,
reported: int_hash(),
mut in_ctor: false,
mut declared_purity: ast::impure_fn,
mut fn_args: @[]});
mut fn_args: @[]/~});
let vt = visit::mk_vt(@{visit_expr: check_loans_in_expr,
visit_local: check_loans_in_local,
visit_block: check_loans_in_block,
@ -473,7 +473,7 @@ impl methods for check_loan_ctxt {
callee: option<@ast::expr>,
callee_id: ast::node_id,
callee_span: span,
args: [@ast::expr]) {
args: [@ast::expr]/~) {
alt self.purity(expr.id) {
none {}
some(pc) {
@ -618,7 +618,7 @@ fn check_loans_in_expr(expr: @ast::expr,
none,
ast_util::op_expr_callee_id(expr),
expr.span,
[rval]);
[rval]/~);
}
ast::expr_unary(*) | ast::expr_index(*)
if self.bccx.method_map.contains_key(expr.id) {
@ -626,7 +626,7 @@ fn check_loans_in_expr(expr: @ast::expr,
none,
ast_util::op_expr_callee_id(expr),
expr.span,
[]);
[]/~);
}
_ { }
}

5
src/rustc/middle/borrowck/gather_loans.rs
View file

@ -86,12 +86,11 @@ fn req_loans_in_expr(ex: @ast::expr,
// passing the buck onto us to enforce this)
//
// FIXME (#2493): this handling is not really adequate.
// For example, if there is a type like, {f: [int]}, we
// For example, if there is a type like, {f: [int]/~}, we
// will ignore it, but we ought to be requiring it to be
// immutable (whereas something like {f:int} would be
// fine).
//
alt opt_deref_kind(arg_ty.ty) {
some(deref_ptr(region_ptr)) |
some(deref_ptr(unsafe_ptr)) {
@ -281,7 +280,7 @@ impl methods for gather_loan_ctxt {
}
none {
self.req_maps.req_loan_map.insert(
scope_id, @dvec::from_vec([mut loans]));
scope_id, @dvec::from_vec([mut loans]/~));
}
}
}

6
src/rustc/middle/capture.rs
View file

@ -60,7 +60,7 @@ fn check_capture_clause(tcx: ty::ctxt,
fn compute_capture_vars(tcx: ty::ctxt,
fn_expr_id: ast::node_id,
fn_proto: ast::proto,
cap_clause: ast::capture_clause) -> [capture_var] {
cap_clause: ast::capture_clause) -> [capture_var]/~ {
let freevars = freevars::get_freevars(tcx, fn_expr_id);
let cap_map = map::int_hash();
@ -119,7 +119,7 @@ fn compute_capture_vars(tcx: ty::ctxt,
}
}
let mut result = [];
for cap_map.each_value { |cap_var| result += [cap_var]; }
let mut result = []/~;
for cap_map.each_value { |cap_var| result += [cap_var]/~; }
ret result;
}

30
src/rustc/middle/check_alt.rs
View file

@ -36,18 +36,18 @@ fn check_expr(tcx: ty::ctxt, ex: @expr, &&s: (), v: visit::vt<()>) {
}
// Check for unreachable patterns
fn check_arms(tcx: ty::ctxt, arms: [arm]) {
let mut seen = [];
fn check_arms(tcx: ty::ctxt, arms: [arm]/~) {
let mut seen = []/~;
for arms.each {|arm|
for arm.pats.each {|pat|
let v = [pat];
let v = [pat]/~;
alt is_useful(tcx, seen, v) {
not_useful {
tcx.sess.span_err(pat.span, "unreachable pattern");
}
_ {}
}
if option::is_none(arm.guard) { seen += [v]; }
if option::is_none(arm.guard) { seen += [v]/~; }
}
}
}
@ -59,8 +59,8 @@ fn raw_pat(p: @pat) -> @pat {
}
}
fn check_exhaustive(tcx: ty::ctxt, sp: span, pats: [@pat]) {
let ext = alt is_useful(tcx, vec::map(pats, {|p| [p]}), [wild()]) {
fn check_exhaustive(tcx: ty::ctxt, sp: span, pats: [@pat]/~) {
let ext = alt is_useful(tcx, vec::map(pats, {|p| [p]/~}), [wild()]/~) {
not_useful { ret; } // This is good, wildcard pattern isn't reachable
useful_ { none }
useful(ty, ctor) {
@ -89,7 +89,7 @@ fn check_exhaustive(tcx: ty::ctxt, sp: span, pats: [@pat]) {
tcx.sess.span_err(sp, msg);
}
type matrix = [[@pat]];
type matrix = [[@pat]/~]/~;
enum useful { useful(ty::t, ctor), useful_, not_useful }
@ -111,7 +111,7 @@ enum ctor {
// checking (if a wildcard pattern is useful in relation to a matrix, the
// matrix isn't exhaustive).
fn is_useful(tcx: ty::ctxt, m: matrix, v: [@pat]) -> useful {
fn is_useful(tcx: ty::ctxt, m: matrix, v: [@pat]/~) -> useful {
if m.len() == 0u { ret useful_; }
if m[0].len() == 0u { ret not_useful; }
let real_pat = alt vec::find(m, {|r| r[0].id != 0}) {
@ -167,7 +167,7 @@ fn is_useful(tcx: ty::ctxt, m: matrix, v: [@pat]) -> useful {
}
}
fn is_useful_specialized(tcx: ty::ctxt, m: matrix, v: [@pat], ctor: ctor,
fn is_useful_specialized(tcx: ty::ctxt, m: matrix, v: [@pat]/~, ctor: ctor,
arity: uint, lty: ty::t) -> useful {
let ms = vec::filter_map(m, {|r| specialize(tcx, r, ctor, arity, lty)});
alt is_useful(tcx, ms, option::get(specialize(tcx, v, ctor, arity, lty))){
@ -217,10 +217,10 @@ fn missing_ctor(tcx: ty::ctxt, m: matrix, left_ty: ty::t) -> option<ctor> {
ret some(single);
}
ty::ty_enum(eid, _) {
let mut found = [];
let mut found = []/~;
for m.each {|r|
option::iter(pat_ctor_id(tcx, r[0])) {|id|
if !vec::contains(found, id) { found += [id]; }
if !vec::contains(found, id) { found += [id]/~; }
}
}
let variants = ty::enum_variants(tcx, eid);
@ -270,8 +270,8 @@ fn wild() -> @pat {
@{id: 0, node: pat_wild, span: syntax::ast_util::dummy_sp()}
}
fn specialize(tcx: ty::ctxt, r: [@pat], ctor_id: ctor, arity: uint,
left_ty: ty::t) -> option<[@pat]> {
fn specialize(tcx: ty::ctxt, r: [@pat]/~, ctor_id: ctor, arity: uint,
left_ty: ty::t) -> option<[@pat]/~> {
let r0 = raw_pat(r[0]);
alt r0.node {
pat_wild { some(vec::from_elem(arity, wild()) + vec::tail(r)) }
@ -308,7 +308,7 @@ fn specialize(tcx: ty::ctxt, r: [@pat], ctor_id: ctor, arity: uint,
some(args + vec::tail(r))
}
pat_tup(args) { some(args + vec::tail(r)) }
pat_box(a) | pat_uniq(a) { some([a] + vec::tail(r)) }
pat_box(a) | pat_uniq(a) { some([a]/~ + vec::tail(r)) }
pat_lit(expr) {
let e_v = eval_const_expr(tcx, expr);
let match = alt check ctor_id {
@ -334,7 +334,7 @@ fn specialize(tcx: ty::ctxt, r: [@pat], ctor_id: ctor, arity: uint,
}
}
fn default(tcx: ty::ctxt, r: [@pat]) -> option<[@pat]> {
fn default(tcx: ty::ctxt, r: [@pat]/~) -> option<[@pat]/~> {
if is_wild(tcx, r[0]) { some(vec::tail(r)) }
else { none }
}

6
src/rustc/middle/freevars.rs
View file

@ -23,7 +23,7 @@ type freevar_entry = {
def: ast::def, //< The variable being accessed free.
span: span //< First span where it is accessed (there can be multiple)
};
type freevar_info = @[@freevar_entry];
type freevar_info = @[@freevar_entry]/~;
type freevar_map = hashmap<ast::node_id, freevar_info>;
// Searches through part of the AST for all references to locals or
@ -34,7 +34,7 @@ type freevar_map = hashmap<ast::node_id, freevar_info>;
fn collect_freevars(def_map: resolve::def_map, blk: ast::blk)
-> freevar_info {
let seen = int_hash();
let refs = @mut [];
let refs = @mut []/~;
fn ignore_item(_i: @ast::item, &&_depth: int, _v: visit::vt<int>) { }
@ -64,7 +64,7 @@ fn collect_freevars(def_map: resolve::def_map, blk: ast::blk)
if i == depth { // Made it to end of loop
let dnum = ast_util::def_id_of_def(def).node;
if !seen.contains_key(dnum) {
*refs += [@{def:def, span:expr.span}];
*refs += [@{def:def, span:expr.span}]/~;
seen.insert(dnum, ());
}
}

10
src/rustc/middle/kind.rs
View file

@ -40,15 +40,15 @@ import lint::{non_implicitly_copyable_typarams,implicit_copies};
// types.
fn kind_to_str(k: kind) -> str {
let mut kinds = [];
let mut kinds = []/~;
if ty::kind_lteq(kind_const(), k) {
kinds += ["const"];
vec::push(kinds, "const");
}
if ty::kind_can_be_copied(k) {
kinds += ["copy"];
vec::push(kinds, "copy");
}
if ty::kind_can_be_sent(k) {
kinds += ["send"];
vec::push(kinds, "send");
}
str::connect(kinds, " ")
}
@ -160,7 +160,7 @@ fn check_fn(fk: visit::fn_kind, decl: fn_decl, body: blk, sp: span,
let cap_clause = alt fk {
visit::fk_anon(_, cc) | visit::fk_fn_block(cc) { cc }
visit::fk_item_fn(*) | visit::fk_method(*) |
visit::fk_ctor(*) | visit::fk_dtor(*) { @[] }
visit::fk_ctor(*) | visit::fk_dtor(*) { @[]/~ }
};
let captured_vars = (*cap_clause).map { |cap_item|
let cap_def = cx.tcx.def_map.get(cap_item.id);

8
src/rustc/middle/lint.rs
View file

@ -134,7 +134,7 @@ fn get_lint_dict() -> lint_dict {
desc: "implicit copies of non implicitly copyable data",
default: warn})
];
]/~;
hash_from_strs(v)
}
@ -206,7 +206,7 @@ impl methods for ctxt {
current lint context, call the provided function, then reset the
warnings in effect to their previous state.
"]
fn with_warn_attrs(attrs: [ast::attribute], f: fn(ctxt)) {
fn with_warn_attrs(attrs: [ast::attribute]/~, f: fn(ctxt)) {
let mut new_ctxt = self;
@ -358,7 +358,7 @@ fn check_item_ctypes(cx: ty::ctxt, it: @ast::item) {
fn check_native_fn(cx: ty::ctxt, fn_id: ast::node_id,
decl: ast::fn_decl) {
let tys = vec::map(decl.inputs) {|a| a.ty };
for vec::each(tys + [decl.output]) {|ty|
for vec::each(tys + [decl.output]/~) {|ty|
alt ty.node {
ast::ty_path(_, id) {
alt cx.def_map.get(id) {
@ -456,7 +456,7 @@ fn check_item_old_vecs(cx: ty::ctxt, it: @ast::item) {
}
ast::ty_path(@{span: _, global: _, idents: ids,
rp: none, types: _}, _)
if ids == [@"str"] && (! uses_vstore.contains_key(t.id)) {
if ids == [@"str"]/~ && (! uses_vstore.contains_key(t.id)) {
cx.sess.span_lint(
old_strs, t.id, it.id,
t.span, "deprecated str type");

31
src/rustc/middle/liveness.rs
View file

@ -220,9 +220,9 @@ class ir_maps {
let live_node_map: hashmap<node_id, live_node>;
let variable_map: hashmap<node_id, variable>;
let field_map: hashmap<ident, variable>;
let capture_map: hashmap<node_id, @[capture_info]>;
let mut var_kinds: [var_kind];
let mut lnks: [live_node_kind];
let capture_map: hashmap<node_id, @[capture_info]/~>;
let mut var_kinds: [var_kind]/~;
let mut lnks: [live_node_kind]/~;
new(tcx: ty::ctxt, method_map: typeck::method_map,
last_use_map: last_use_map) {
@ -236,13 +236,13 @@ class ir_maps {
self.variable_map = int_hash();
self.capture_map = int_hash();
self.field_map = box_str_hash();
self.var_kinds = [];
self.lnks = [];
self.var_kinds = []/~;
self.lnks = []/~;
}
fn add_live_node(lnk: live_node_kind) -> live_node {
let ln = live_node(self.num_live_nodes);
self.lnks += [lnk];
self.lnks += [lnk]/~;
self.num_live_nodes += 1u;
#debug["%s is of kind %?", ln.to_str(), lnk];
@ -259,7 +259,7 @@ class ir_maps {
fn add_variable(vk: var_kind) -> variable {
let v = variable(self.num_vars);
self.var_kinds += [vk];
self.var_kinds += [vk]/~;
self.num_vars += 1u;
alt vk {
@ -297,11 +297,11 @@ class ir_maps {
}
}
fn set_captures(node_id: node_id, +cs: [capture_info]) {
fn set_captures(node_id: node_id, +cs: [capture_info]/~) {
self.capture_map.insert(node_id, @cs);
}
fn captures(expr: @expr) -> @[capture_info] {
fn captures(expr: @expr) -> @[capture_info]/~ {
alt self.capture_map.find(expr.id) {
some(caps) {caps}
none {
@ -435,7 +435,7 @@ fn visit_expr(expr: @expr, &&self: @ir_maps, vt: vt<@ir_maps>) {
let proto = ty::ty_fn_proto(ty::expr_ty(self.tcx, expr));
let cvs = capture::compute_capture_vars(self.tcx, expr.id,
proto, cap_clause);
let mut call_caps = [];
let mut call_caps = []/~;
for cvs.each { |cv|
alt relevant_def(cv.def) {
some(rv) {
@ -444,7 +444,7 @@ fn visit_expr(expr: @expr, &&self: @ir_maps, vt: vt<@ir_maps>) {
cap_move | cap_drop {true} // var must be dead afterwards
cap_copy | cap_ref {false} // var can still be used
};
call_caps += [{ln: cv_ln, is_move: is_move, rv: rv}];
call_caps += [{ln: cv_ln, is_move: is_move, rv: rv}]/~;
}
none {}
}
@ -511,8 +511,8 @@ class liveness {
let tcx: ty::ctxt;
let ir: @ir_maps;
let s: specials;
let successors: [mut live_node];
let users: [mut users];
let successors: [mut live_node]/~;
let users: [mut users]/~;
let mut break_ln: live_node;
let mut cont_ln: live_node;
@ -887,7 +887,8 @@ class liveness {
succ
}
fn propagate_through_exprs(exprs: [@expr], succ: live_node) -> live_node {
fn propagate_through_exprs(exprs: [@expr]/~,
succ: live_node) -> live_node {
exprs.foldr(succ) { |expr, succ|
self.propagate_through_expr(expr, succ)
}
@ -1095,7 +1096,7 @@ class liveness {
expr_log(_, l, r) |
expr_index(l, r) |
expr_binary(_, l, r) {
self.propagate_through_exprs([l, r], succ)
self.propagate_through_exprs([l, r]/~, succ)
}
expr_assert(e) |

6
src/rustc/middle/pat_util.rs
View file

@ -49,8 +49,8 @@ fn pat_bindings(dm: resolve::def_map, pat: @pat,
}
}
fn pat_binding_ids(dm: resolve::def_map, pat: @pat) -> [node_id] {
let mut found = [];
pat_bindings(dm, pat) {|b_id, _sp, _pt| found += [b_id]; };
fn pat_binding_ids(dm: resolve::def_map, pat: @pat) -> [node_id]/~ {
let mut found = []/~;
pat_bindings(dm, pat) {|b_id, _sp, _pt| found += [b_id]/~; };
ret found;
}

8
src/rustc/middle/region.rs
View file

@ -214,14 +214,14 @@ fn nearest_common_ancestor(region_map: region_map, scope_a: ast::node_id,
scope_b: ast::node_id) -> option<ast::node_id> {
fn ancestors_of(region_map: region_map, scope: ast::node_id)
-> [ast::node_id] {
let mut result = [scope];
-> [ast::node_id]/~ {
let mut result = [scope]/~;
let mut scope = scope;
loop {
alt region_map.find(scope) {
none { ret result; }
some(superscope) {
result += [superscope];
result += [superscope]/~;
scope = superscope;
}
}
@ -235,7 +235,7 @@ fn nearest_common_ancestor(region_map: region_map, scope_a: ast::node_id,
let mut a_index = vec::len(a_ancestors) - 1u;
let mut b_index = vec::len(b_ancestors) - 1u;
// Here, [ab]_ancestors is a vector going from narrow to broad.
// Here, [ab]/~_ancestors is a vector going from narrow to broad.
// The end of each vector will be the item where the scope is
// defined; if there are any common ancestors, then the tails of
// the vector will be the same. So basically we want to walk

148
src/rustc/middle/resolve.rs
View file

@ -34,13 +34,13 @@ enum scope {
scope_toplevel,
scope_crate,
scope_item(@ast::item),
scope_bare_fn(ast::fn_decl, node_id, [ast::ty_param]),
scope_fn_expr(ast::fn_decl, node_id, [ast::ty_param]),
scope_bare_fn(ast::fn_decl, node_id, [ast::ty_param]/~),
scope_fn_expr(ast::fn_decl, node_id, [ast::ty_param]/~),
scope_native_item(@ast::native_item),
scope_loop(@ast::local), // there's only 1 decl per loop.
scope_block(ast::blk, @mut uint, @mut uint),
scope_arm(ast::arm),
scope_method(node_id, [ast::ty_param]),
scope_method(node_id, [ast::ty_param]/~),
}
type scopes = @list<scope>;
@ -50,13 +50,13 @@ fn top_scope() -> scopes {
}
enum import_state {
todo(ast::ident, @[ast::ident], span, scopes),
is_glob(@[ast::ident], scopes, span),
todo(ast::ident, @[ast::ident]/~, span, scopes),
is_glob(@[ast::ident]/~, scopes, span),
resolving(span),
resolved(option<def>, /* value */
option<def>, /* type */
option<def>, /* module */
@[@_impl], /* impls */
@[@_impl]/~, /* impls */
/* used for reporting unused import warning */
ast::ident, span),
}
@ -88,7 +88,7 @@ enum mod_index_entry {
mie_item(@ast::item),
mie_native_item(@ast::native_item),
mie_enum_variant(/* variant index */uint,
/*parts of enum item*/ [variant],
/*parts of enum item*/ [variant]/~,
node_id, span),
}
@ -101,7 +101,7 @@ type indexed_mod = {
m: option<ast::_mod>,
index: mod_index,
glob_imports: dvec<glob_imp_def>,
mut globbed_exports: [ident],
mut globbed_exports: [ident]/~,
glob_imported_names: hashmap<ident, glob_import_state>,
path: str
};
@ -111,12 +111,12 @@ type indexed_mod = {
control.*/
type def_map = hashmap<node_id, def>;
type ext_map = hashmap<def_id, [ident]>;
type ext_map = hashmap<def_id, [ident]/~>;
type impl_map = hashmap<node_id, iscopes>;
type impl_cache = hashmap<def_id, option<@[@_impl]>>;
type impl_cache = hashmap<def_id, option<@[@_impl]/~>>;
type exp = {reexp: bool, id: def_id};
type exp_map = hashmap<node_id, [exp]>;
type exp_map = hashmap<node_id, [exp]/~>;
type env =
{cstore: cstore::cstore,
@ -125,15 +125,15 @@ type env =
imports: hashmap<node_id, import_state>,
exp_map: exp_map,
mod_map: hashmap<node_id, @indexed_mod>,
block_map: hashmap<node_id, [glob_imp_def]>,
block_map: hashmap<node_id, [glob_imp_def]/~>,
ext_map: ext_map,
impl_map: impl_map,
impl_cache: impl_cache,
ext_cache: ext_hash,
used_imports: {mut track: bool,
mut data: [node_id]},
mut data: [node_id]/~},
reported: dvec<{ident: ast::ident, sc: scope}>,
mut ignored_imports: [node_id],
mut ignored_imports: [node_id]/~,
mut current_tp: option<uint>,
mut resolve_unexported: bool,
sess: session};
@ -181,9 +181,9 @@ fn create_env(sess: session, amap: ast_map::map) -> @env {
impl_map: int_hash(),
impl_cache: new_def_hash(),
ext_cache: new_ext_hash(),
used_imports: {mut track: false, mut data: []},
used_imports: {mut track: false, mut data: []/~},
reported: dvec(),
mut ignored_imports: [],
mut ignored_imports: []/~,
mut current_tp: none,
mut resolve_unexported: false,
sess: sess}
@ -243,7 +243,7 @@ fn map_crate(e: @env, c: @ast::crate) {
ast::view_path_list(mod_path, idents, _) {
for idents.each {|ident|
let t = todo(ident.node.name,
@(mod_path.idents + [ident.node.name]),
@(mod_path.idents + [ident.node.name]/~),
ident.span, sc);
e.imports.insert(ident.node.id, t);
}
@ -271,7 +271,7 @@ fn map_crate(e: @env, c: @ast::crate) {
@{m: some(md),
index: index_mod(md),
glob_imports: dvec(),
mut globbed_exports: [],
mut globbed_exports: []/~,
glob_imported_names: box_str_hash(),
path: path_from_scope(sc, *i.ident)});
}
@ -280,7 +280,7 @@ fn map_crate(e: @env, c: @ast::crate) {
@{m: none::<ast::_mod>,
index: index_nmod(nmd),
glob_imports: dvec(),
mut globbed_exports: [],
mut globbed_exports: []/~,
glob_imported_names: box_str_hash(),
path: path_from_scope(sc, *i.ident)});
}
@ -305,8 +305,8 @@ fn map_crate(e: @env, c: @ast::crate) {
}
scope_block(b, _, _) {
let globs = alt e.block_map.find(b.node.id) {
some(globs) { globs + [glob] }
none { [glob] }
some(globs) { globs + [glob]/~ }
none { [glob]/~ }
};
e.block_map.insert(b.node.id, globs);
}
@ -339,7 +339,7 @@ fn map_crate(e: @env, c: @ast::crate) {
@{m: some(c.node.module),
index: index_mod(c.node.module),
glob_imports: dvec(),
mut globbed_exports: [],
mut globbed_exports: []/~,
glob_imported_names: box_str_hash(),
path: ""});
@ -476,7 +476,8 @@ fn resolve_names(e: @env, c: @ast::crate) {
_ { }
}
}
fn walk_tps(e: @env, tps: [ast::ty_param], &&sc: scopes, v: vt<scopes>) {
fn walk_tps(e: @env, tps: [ast::ty_param]/~,
&&sc: scopes, v: vt<scopes>) {
let outer_current_tp = e.current_tp;
let mut current = 0u;
for tps.each {|tp|
@ -557,7 +558,7 @@ fn visit_item_with_scope(e: @env, i: @ast::item,
for methods.each {|m|
v.visit_ty_params(m.tps, sc, v);
let msc = @cons(scope_method(m.self_id, tps + m.tps), sc);
v.visit_fn(visit::fk_method(m.ident, [], m),
v.visit_fn(visit::fk_method(m.ident, []/~, m),
m.decl, m.body, m.span, m.id, msc, v);
}
}
@ -625,7 +626,7 @@ fn visit_fn_with_scope(e: @env, fk: visit::fn_kind, decl: ast::fn_decl,
// is this a main fn declaration?
alt fk {
visit::fk_item_fn(nm, _) {
if is_main_name([ast_map::path_name(nm)]) &&
if is_main_name([ast_map::path_name(nm)]/~) &&
!e.sess.building_library {
// This is a main function -- set it in the session
// as the main ID
@ -643,9 +644,9 @@ fn visit_fn_with_scope(e: @env, fk: visit::fn_kind, decl: ast::fn_decl,
| visit::fk_ctor(_, tps, _, _) | visit::fk_dtor(tps, _, _) {
scope_bare_fn(decl, id, tps) }
visit::fk_anon(ast::proto_bare, _) {
scope_bare_fn(decl, id, []) }
scope_bare_fn(decl, id, []/~) }
visit::fk_anon(_, _) | visit::fk_fn_block(_) {
scope_fn_expr(decl, id, []) }
scope_fn_expr(decl, id, []/~) }
};
visit::visit_fn(fk, decl, body, sp, id, @cons(scope, sc), v);
@ -713,7 +714,7 @@ fn visit_local_with_scope(e: @env, loc: @local, &&sc: scopes, v:vt<scopes>) {
}
fn follow_import(e: env, &&sc: scopes, path: [ident], sp: span) ->
fn follow_import(e: env, &&sc: scopes, path: [ident]/~, sp: span) ->
option<def> {
let path_len = vec::len(path);
let mut dcur = lookup_in_scope_strict(e, sc, sp, path[0], ns_module);
@ -757,10 +758,10 @@ fn resolve_constr(e: @env, c: @ast::constr, &&sc: scopes, _v: vt<scopes>) {
// Import resolution
fn resolve_import(e: env, n_id: node_id, name: ast::ident,
ids: [ast::ident], sp: codemap::span, &&sc: scopes) {
ids: [ast::ident]/~, sp: codemap::span, &&sc: scopes) {
fn register(e: env, id: node_id, cx: ctxt, sp: codemap::span,
name: ast::ident, lookup: fn(namespace) -> option<def>,
impls: [@_impl]) {
impls: [@_impl]/~) {
let val = lookup(ns_val), typ = lookup(ns_type),
md = lookup(ns_module);
if is_none(val) && is_none(typ) && is_none(md) &&
@ -772,21 +773,21 @@ fn resolve_import(e: env, n_id: node_id, name: ast::ident,
}
// Temporarily disable this import and the imports coming after during
// resolution of this import.
fn find_imports_after(e: env, id: node_id, &&sc: scopes) -> [node_id] {
fn lst(my_id: node_id, vis: [@view_item]) -> [node_id] {
let mut imports = [], found = false;
fn find_imports_after(e: env, id: node_id, &&sc: scopes) -> [node_id]/~ {
fn lst(my_id: node_id, vis: [@view_item]/~) -> [node_id]/~ {
let mut imports = []/~, found = false;
for vis.each {|vi|
iter_effective_import_paths(*vi) {|vp|
alt vp.node {
view_path_simple(_, _, id)
| view_path_glob(_, id) {
if id == my_id { found = true; }
if found { imports += [id]; }
if found { imports += [id]/~; }
}
view_path_list(_, ids, _) {
for ids.each {|id|
if id.node.id == my_id { found = true; }
if found { imports += [id.node.id]; }
if found { imports += [id.node.id]/~; }
}
}
}
@ -822,7 +823,7 @@ fn resolve_import(e: env, n_id: node_id, name: ast::ident,
let end_id = ids[n_idents - 1u];
if n_idents == 1u {
register(e, n_id, in_scope(sc), sp, name,
{|ns| lookup_in_scope(e, sc, sp, end_id, ns, true) }, []);
{|ns| lookup_in_scope(e, sc, sp, end_id, ns, true) }, []/~);
} else {
alt lookup_in_scope(e, sc, sp, ids[0], ns_module, true) {
none {
@ -832,7 +833,7 @@ fn resolve_import(e: env, n_id: node_id, name: ast::ident,
let mut dcur = dcur_, i = 1u;
loop {
if i == n_idents - 1u {
let mut impls = [];
let mut impls = []/~;
find_impls_in_mod(e, dcur, impls, some(end_id));
register(e, n_id, in_mod(dcur), sp, name, {|ns|
lookup_in_mod(e, dcur, sp, end_id, ns, outside)
@ -860,7 +861,7 @@ fn resolve_import(e: env, n_id: node_id, name: ast::ident,
// import
alt e.imports.find(n_id) {
some(resolving(sp)) {
e.imports.insert(n_id, resolved(none, none, none, @[], @"", sp));
e.imports.insert(n_id, resolved(none, none, none, @[]/~, @"", sp));
}
_ { }
}
@ -910,7 +911,7 @@ fn unresolved_err(e: env, cx: ctxt, sp: span, name: ident, kind: str) {
path = @(e.mod_map.get(did.node).path + *path);
} else if did.node != ast::crate_node_id {
let paths = e.ext_map.get(did);
path = @str::connect((paths + [path]).map({|x|*x}), "::");
path = @str::connect((paths + [path]/~).map({|x|*x}), "::");
}
}
}
@ -1110,7 +1111,7 @@ fn lookup_in_scope(e: env, &&sc: scopes, sp: span, name: ident, ns: namespace,
ret none;
}
let mut left_fn = false;
let mut closing = [];
let mut closing = []/~;
// Used to determine whether self is in scope
let mut left_fn_level2 = false;
let mut sc = sc;
@ -1150,7 +1151,7 @@ fn lookup_in_scope(e: env, &&sc: scopes, sp: span, name: ident, ns: namespace,
} else if ns != ns_module {
left_fn = scope_is_fn(hd);
alt scope_closes(hd) {
some(node_id) { closing += [node_id]; }
some(node_id) { closing += [node_id]/~; }
_ { }
}
}
@ -1160,7 +1161,7 @@ fn lookup_in_scope(e: env, &&sc: scopes, sp: span, name: ident, ns: namespace,
};
}
fn lookup_in_ty_params(e: env, name: ident, ty_params: [ast::ty_param])
fn lookup_in_ty_params(e: env, name: ident, ty_params: [ast::ty_param]/~)
-> option<def> {
let mut n = 0u;
for ty_params.each {|tp|
@ -1183,7 +1184,7 @@ fn lookup_in_pat(e: env, name: ident, pat: @ast::pat) -> option<node_id> {
}
fn lookup_in_fn(e: env, name: ident, decl: ast::fn_decl,
ty_params: [ast::ty_param],
ty_params: [ast::ty_param]/~,
ns: namespace) -> option<def> {
alt ns {
ns_val {
@ -1367,7 +1368,7 @@ fn lookup_in_mod(e: env, m: def, sp: span, name: ident, ns: namespace,
// examining a module in an external crate
let cached = e.ext_cache.find({did: defid, ident: name, ns: ns});
if !is_none(cached) { ret cached; }
let mut path = [name];
let mut path = [name]/~;
if defid.node != ast::crate_node_id {
path = cstore::get_path(e.cstore, defid) + path;
}
@ -1420,7 +1421,7 @@ fn lookup_import(e: env, n_id: node_id, ns: namespace) -> option<def> {
}
resolved(val, typ, md, _, _, _) {
if e.used_imports.track {
e.used_imports.data += [n_id];
e.used_imports.data += [n_id]/~;
}
ret alt ns { ns_val { val } ns_type { typ } ns_module { md } };
}
@ -1490,7 +1491,7 @@ fn lookup_in_local_mod(e: env, node_id: node_id, sp: span, id: ident,
ret lookup_glob_in_mod(e, inf, sp, id, ns, outside);
}
fn lookup_in_globs(e: env, globs: [glob_imp_def], sp: span, id: ident,
fn lookup_in_globs(e: env, globs: [glob_imp_def]/~, sp: span, id: ident,
ns: namespace, dr: dir) -> option<def> {
fn lookup_in_mod_(e: env, def: glob_imp_def, sp: span, name: ident,
ns: namespace, dr: dir) -> option<glob_imp_def> {
@ -1595,7 +1596,7 @@ fn add_to_index(index: hashmap<ident, @list<mod_index_entry>>, id: ident,
}
}
fn index_view_items(view_items: [@ast::view_item],
fn index_view_items(view_items: [@ast::view_item]/~,
index: hashmap<ident, @list<mod_index_entry>>) {
for view_items.each {|vi|
alt vi.node {
@ -1684,7 +1685,7 @@ fn ns_for_def(d: def) -> namespace {
}
}
fn lookup_external(e: env, cnum: int, ids: [ident], ns: namespace) ->
fn lookup_external(e: env, cnum: int, ids: [ident]/~, ns: namespace) ->
option<def> {
let mut result = none;
for csearch::lookup_defs(e.sess.cstore, cnum, ids).each {|d|
@ -1757,9 +1758,9 @@ fn mie_span(mie: mod_index_entry) -> span {
}
fn check_item(e: @env, i: @ast::item, &&x: (), v: vt<()>) {
fn typaram_names(tps: [ast::ty_param]) -> [ident] {
let mut x: [ast::ident] = [];
for tps.each {|tp| x += [tp.ident]; }
fn typaram_names(tps: [ast::ty_param]/~) -> [ident]/~ {
let mut x: [ast::ident]/~ = []/~;
for tps.each {|tp| x += [tp.ident]/~; }
ret x;
}
visit::visit_item(i, x, v);
@ -1914,7 +1915,7 @@ fn add_name(ch: checker, sp: span, name: ident) {
ch.seen.push(name);
}
fn ensure_unique<T>(e: env, sp: span, elts: [T], id: fn(T) -> ident,
fn ensure_unique<T>(e: env, sp: span, elts: [T]/~, id: fn(T) -> ident,
kind: str) {
let ch = checker(e, kind);
for elts.each {|elt| add_name(ch, sp, id(elt)); }
@ -1942,7 +1943,7 @@ fn check_exports(e: @env) {
let defs =
[ found_def_item(item, ns_val),
found_def_item(item, ns_type),
found_def_item(item, ns_module) ];
found_def_item(item, ns_module) ]/~;
for defs.each {|d|
alt d {
some(def) {
@ -1984,9 +1985,10 @@ fn check_exports(e: @env) {
fn add_export(e: @env, export_id: node_id, target_id: def_id,
reexp: bool) {
let found = alt e.exp_map.find(export_id) {
some(f) { f } none { [] }
some(f) { f } none { []/~ }
};
e.exp_map.insert(export_id, found + [{reexp: reexp, id: target_id}]);
e.exp_map.insert(export_id,
found + [{reexp: reexp, id: target_id}]/~);
}
fn check_export(e: @env, ident: ident, _mod: @indexed_mod,
@ -2053,7 +2055,7 @@ fn check_exports(e: @env) {
fn check_export_enum_list(e: @env, export_id: node_id, _mod: @indexed_mod,
span: codemap::span, id: ast::ident,
ids: [ast::path_list_ident]) {
ids: [ast::path_list_ident]/~) {
let parent_id = check_enum_ok(e, span, id, _mod);
add_export(e, export_id, local_def(parent_id), false);
for ids.each {|variant_id|
@ -2119,7 +2121,7 @@ fn check_exports(e: @env) {
if ! glob_is_re_exported.contains_key(id) { cont; }
iter_mod(*e, glob.def,
glob.path.span, outside) {|ident, def|
_mod.globbed_exports += [ident];
_mod.globbed_exports += [ident]/~;
maybe_add_reexport(e, id, some(def));
}
}
@ -2140,8 +2142,8 @@ type method_info = {did: def_id, n_tps: uint, ident: ast::ident};
is the ident of the iface that's being implemented
* methods: the item's methods
*/
type _impl = {did: def_id, ident: ast::ident, methods: [@method_info]};
type iscopes = @list<@[@_impl]>;
type _impl = {did: def_id, ident: ast::ident, methods: [@method_info]/~};
type iscopes = @list<@[@_impl]/~>;
fn resolve_impls(e: @env, c: @ast::crate) {
visit::visit_crate(*c, @nil, visit::mk_vt(@{
@ -2153,9 +2155,9 @@ fn resolve_impls(e: @env, c: @ast::crate) {
}
fn find_impls_in_view_item(e: env, vi: @ast::view_item,
&impls: [@_impl], sc: option<iscopes>) {
&impls: [@_impl]/~, sc: option<iscopes>) {
fn lookup_imported_impls(e: env, id: node_id,
act: fn(@[@_impl])) {
act: fn(@[@_impl]/~)) {
alt e.imports.get(id) {
resolved(_, _, _, is, _, _) { act(is); }
todo(name, path, span, scopes) {
@ -2171,14 +2173,14 @@ fn find_impls_in_view_item(e: env, vi: @ast::view_item,
iter_effective_import_paths(*vi) { |vp|
alt vp.node {
ast::view_path_simple(name, pt, id) {
let mut found = [];
let mut found = []/~;
if vec::len(pt.idents) == 1u {
option::iter(sc) {|sc|
list::iter(sc) {|level|
if vec::len(found) == 0u {
for vec::each(*level) {|imp|
if imp.ident == pt.idents[0] {
found += [@{ident: name with *imp}];
found += [@{ident: name with *imp}]/~;
}
}
if vec::len(found) > 0u { impls += found; }
@ -2188,7 +2190,7 @@ fn find_impls_in_view_item(e: env, vi: @ast::view_item,
} else {
lookup_imported_impls(e, id) {|is|
for vec::each(*is) {|i|
impls += [@{ident: name with *i}];
impls += [@{ident: name with *i}]/~;
}
}
}
@ -2220,7 +2222,7 @@ fn find_impls_in_view_item(e: env, vi: @ast::view_item,
item is a class; and none otherwise. Each record describes
one interface implemented by i.
*/
fn find_impls_in_item(e: env, i: @ast::item, &impls: [@_impl],
fn find_impls_in_item(e: env, i: @ast::item, &impls: [@_impl]/~,
name: option<ident>,
ck_exports: option<@indexed_mod>) {
alt i.node {
@ -2236,7 +2238,7 @@ fn find_impls_in_item(e: env, i: @ast::item, &impls: [@_impl],
@{did: local_def(m.id),
n_tps: vec::len(m.tps),
ident: m.ident}
})}];
})}]/~;
}
}
ast::item_class(tps, ifces, items, _, _, _) {
@ -2250,14 +2252,14 @@ fn find_impls_in_item(e: env, i: @ast::item, &impls: [@_impl],
methods: vec::map(mthds, {|m|
@{did: local_def(m.id),
n_tps: n_tps + m.tps.len(),
ident: m.ident}})}];
ident: m.ident}})}]/~;
}
}
_ {}
}
}
fn find_impls_in_mod_by_id(e: env, defid: def_id, &impls: [@_impl],
fn find_impls_in_mod_by_id(e: env, defid: def_id, &impls: [@_impl]/~,
name: option<ident>) {
let mut cached;
alt e.impl_cache.find(defid) {
@ -2266,7 +2268,7 @@ fn find_impls_in_mod_by_id(e: env, defid: def_id, &impls: [@_impl],
none {
e.impl_cache.insert(defid, none);
cached = if defid.crate == ast::local_crate {
let mut tmp = [];
let mut tmp = []/~;
let mi = e.mod_map.get(defid.node);
let md = option::get(mi.m);
for md.view_items.each {|vi|
@ -2285,14 +2287,14 @@ fn find_impls_in_mod_by_id(e: env, defid: def_id, &impls: [@_impl],
alt name {
some(n) {
for vec::each(*cached) {|im|
if n == im.ident { impls += [im]; }
if n == im.ident { impls += [im]/~; }
}
}
_ { impls += *cached; }
}
}
fn find_impls_in_mod(e: env, m: def, &impls: [@_impl],
fn find_impls_in_mod(e: env, m: def, &impls: [@_impl]/~,
name: option<ident>) {
alt m {
ast::def_mod(defid) {
@ -2304,7 +2306,7 @@ fn find_impls_in_mod(e: env, m: def, &impls: [@_impl],
fn visit_block_with_impl_scope(e: @env, b: ast::blk, &&sc: iscopes,
v: vt<iscopes>) {
let mut impls = [];
let mut impls = []/~;
for b.node.view_items.each {|vi|
find_impls_in_view_item(*e, vi, impls, some(sc));
}
@ -2322,7 +2324,7 @@ fn visit_block_with_impl_scope(e: @env, b: ast::blk, &&sc: iscopes,
fn visit_mod_with_impl_scope(e: @env, m: ast::_mod, s: span, id: node_id,
&&sc: iscopes, v: vt<iscopes>) {
let mut impls = [];
let mut impls = []/~;
for m.view_items.each {|vi|
find_impls_in_view_item(*e, vi, impls, some(sc));
}

128
src/rustc/middle/trans/alt.rs
View file

@ -77,7 +77,7 @@ fn variant_opt(tcx: ty::ctxt, pat_id: ast::node_id) -> opt {
core::unreachable();
}
type bind_map = [{ident: ast::ident, val: ValueRef}];
type bind_map = [{ident: ast::ident, val: ValueRef}]/~;
fn assoc(key: ast::ident, list: bind_map) -> option<ValueRef> {
for vec::each(list) {|elt|
if str::eq(*elt.ident, *key) { ret some(elt.val); }
@ -86,12 +86,12 @@ fn assoc(key: ast::ident, list: bind_map) -> option<ValueRef> {
}
type match_branch =
@{pats: [@ast::pat],
@{pats: [@ast::pat]/~,
bound: bind_map,
data: @{bodycx: block,
guard: option<@ast::expr>,
id_map: pat_id_map}};
type match = [match_branch];
type match = [match_branch]/~;
fn has_nested_bindings(m: match, col: uint) -> bool {
for vec::each(m) {|br|
@ -104,28 +104,28 @@ fn has_nested_bindings(m: match, col: uint) -> bool {
}
fn expand_nested_bindings(m: match, col: uint, val: ValueRef) -> match {
let mut result = [];
let mut result = []/~;
for vec::each(m) {|br|
alt br.pats[col].node {
ast::pat_ident(name, some(inner)) {
let pats = vec::slice(br.pats, 0u, col) + [inner] +
let pats = vec::slice(br.pats, 0u, col) + [inner]/~ +
vec::slice(br.pats, col + 1u, br.pats.len());
result += [@{pats: pats,
bound: br.bound + [{ident: path_to_ident(name),
val: val}]
with *br}];
val: val}]/~
with *br}]/~;
}
_ { result += [br]; }
_ { result += [br]/~; }
}
}
result
}
type enter_pat = fn(@ast::pat) -> option<[@ast::pat]>;
type enter_pat = fn(@ast::pat) -> option<[@ast::pat]/~>;
fn enter_match(dm: def_map, m: match, col: uint, val: ValueRef,
e: enter_pat) -> match {
let mut result = [];
let mut result = []/~;
for vec::each(m) {|br|
alt e(br.pats[col]) {
some(sub) {
@ -134,11 +134,11 @@ fn enter_match(dm: def_map, m: match, col: uint, val: ValueRef,
let self = br.pats[col];
let bound = alt self.node {
ast::pat_ident(name, none) if !pat_is_variant(dm, self) {
br.bound + [{ident: path_to_ident(name), val: val}]
br.bound + [{ident: path_to_ident(name), val: val}]/~
}
_ { br.bound }
};
result += [@{pats: pats, bound: bound with *br}];
result += [@{pats: pats, bound: bound with *br}]/~;
}
none { }
}
@ -149,9 +149,9 @@ fn enter_match(dm: def_map, m: match, col: uint, val: ValueRef,
fn enter_default(dm: def_map, m: match, col: uint, val: ValueRef) -> match {
enter_match(dm, m, col, val) {|p|
alt p.node {
ast::pat_wild | ast::pat_rec(_, _) | ast::pat_tup(_) { some([]) }
ast::pat_wild | ast::pat_rec(_, _) | ast::pat_tup(_) { some([]/~) }
ast::pat_ident(_, none) if !pat_is_variant(dm, p) {
some([])
some([]/~)
}
_ { none }
}
@ -170,33 +170,33 @@ fn enter_opt(tcx: ty::ctxt, m: match, opt: opt, col: uint,
else { none }
}
ast::pat_ident(_, none) if pat_is_variant(tcx.def_map, p) {
if opt_eq(tcx, variant_opt(tcx, p.id), opt) { some([]) }
if opt_eq(tcx, variant_opt(tcx, p.id), opt) { some([]/~) }
else { none }
}
ast::pat_lit(l) {
if opt_eq(tcx, lit(l), opt) { some([]) } else { none }
if opt_eq(tcx, lit(l), opt) { some([]/~) } else { none }
}
ast::pat_range(l1, l2) {
if opt_eq(tcx, range(l1, l2), opt) { some([]) } else { none }
if opt_eq(tcx, range(l1, l2), opt) { some([]/~) } else { none }
}
_ { some(vec::from_elem(variant_size, dummy)) }
}
}
}
fn enter_rec(dm: def_map, m: match, col: uint, fields: [ast::ident],
fn enter_rec(dm: def_map, m: match, col: uint, fields: [ast::ident]/~,
val: ValueRef) -> match {
let dummy = @{id: 0, node: ast::pat_wild, span: dummy_sp()};
enter_match(dm, m, col, val) {|p|
alt p.node {
ast::pat_rec(fpats, _) {
let mut pats = [];
let mut pats = []/~;
for vec::each(fields) {|fname|
let mut pat = dummy;
for vec::each(fpats) {|fpat|
if str::eq(*fpat.ident, *fname) { pat = fpat.pat; break; }
}
pats += [pat];
pats += [pat]/~;
}
some(pats)
}
@ -220,8 +220,8 @@ fn enter_box(dm: def_map, m: match, col: uint, val: ValueRef) -> match {
let dummy = @{id: 0, node: ast::pat_wild, span: dummy_sp()};
enter_match(dm, m, col, val) {|p|
alt p.node {
ast::pat_box(sub) { some([sub]) }
_ { some([dummy]) }
ast::pat_box(sub) { some([sub]/~) }
_ { some([dummy]/~) }
}
}
}
@ -230,13 +230,13 @@ fn enter_uniq(dm: def_map, m: match, col: uint, val: ValueRef) -> match {
let dummy = @{id: 0, node: ast::pat_wild, span: dummy_sp()};
enter_match(dm, m, col, val) {|p|
alt p.node {
ast::pat_uniq(sub) { some([sub]) }
_ { some([dummy]) }
ast::pat_uniq(sub) { some([sub]/~) }
_ { some([dummy]/~) }
}
}
}
fn get_options(ccx: @crate_ctxt, m: match, col: uint) -> [opt] {
fn get_options(ccx: @crate_ctxt, m: match, col: uint) -> [opt]/~ {
fn add_to_set(tcx: ty::ctxt, &&set: dvec<opt>, val: opt) {
if set.any({|l| opt_eq(tcx, l, val)}) {ret;}
set.push(val);
@ -262,7 +262,7 @@ fn get_options(ccx: @crate_ctxt, m: match, col: uint) -> [opt] {
fn extract_variant_args(bcx: block, pat_id: ast::node_id,
vdefs: {enm: def_id, var: def_id}, val: ValueRef) ->
{vals: [ValueRef], bcx: block} {
{vals: [ValueRef]/~, bcx: block} {
let _icx = bcx.insn_ctxt("alt::extract_variant_args");
let ccx = bcx.fcx.ccx;
let enum_ty_substs = alt check ty::get(node_id_type(bcx, pat_id)).struct {
@ -275,7 +275,7 @@ fn extract_variant_args(bcx: block, pat_id: ast::node_id,
if size > 0u && (*variants).len() != 1u {
let enumptr =
PointerCast(bcx, val, T_opaque_enum_ptr(ccx));
blobptr = GEPi(bcx, enumptr, [0u, 1u]);
blobptr = GEPi(bcx, enumptr, [0u, 1u]/~);
}
let vdefs_tg = vdefs.enm;
let vdefs_var = vdefs.var;
@ -286,14 +286,14 @@ fn extract_variant_args(bcx: block, pat_id: ast::node_id,
ret {vals: args, bcx: bcx};
}
fn collect_record_fields(m: match, col: uint) -> [ast::ident] {
let mut fields: [ast::ident] = [];
fn collect_record_fields(m: match, col: uint) -> [ast::ident]/~ {
let mut fields: [ast::ident]/~ = []/~;
for vec::each(m) {|br|
alt br.pats[col].node {
ast::pat_rec(fs, _) {
for vec::each(fs) {|f|
if !vec::any(fields, {|x| str::eq(*f.ident, *x)}) {
fields += [f.ident];
fields += [f.ident]/~;
}
}
}
@ -375,8 +375,8 @@ fn pick_col(m: match) -> uint {
ret best_col;
}
fn compile_submatch(bcx: block, m: match, vals: [ValueRef],
chk: option<mk_fail>, &exits: [exit_node]) {
fn compile_submatch(bcx: block, m: match, vals: [ValueRef]/~,
chk: option<mk_fail>, &exits: [exit_node]/~) {
let _icx = bcx.insn_ctxt("alt::compile_submatch");
let mut bcx = bcx;
let tcx = bcx.tcx(), dm = tcx.def_map;
@ -405,7 +405,7 @@ fn compile_submatch(bcx: block, m: match, vals: [ValueRef],
}
if !bcx.unreachable {
exits += [{bound: m[0].bound, from: bcx.llbb,
to: data.bodycx.llbb}];
to: data.bodycx.llbb}]/~;
}
Br(bcx, data.bodycx.llbb);
ret;
@ -433,10 +433,10 @@ fn compile_submatch(bcx: block, m: match, vals: [ValueRef],
// Separate path for extracting and binding record fields
if rec_fields.len() > 0u {
let fields = ty::get_fields(node_id_type(bcx, pat_id));
let mut rec_vals = [];
let mut rec_vals = []/~;
for vec::each(rec_fields) {|field_name|
let ix = option::get(ty::field_idx(field_name, fields));
rec_vals += [GEPi(bcx, val, [0u, ix])];
rec_vals += [GEPi(bcx, val, [0u, ix]/~)]/~;
}
compile_submatch(bcx, enter_rec(dm, m, col, rec_fields, val),
rec_vals + vals_left, chk, exits);
@ -449,9 +449,9 @@ fn compile_submatch(bcx: block, m: match, vals: [ValueRef],
ty::ty_tup(elts) { elts.len() }
_ { ccx.sess.bug("non-tuple type in tuple pattern"); }
};
let mut tup_vals = [], i = 0u;
let mut tup_vals = []/~, i = 0u;
while i < n_tup_elts {
tup_vals += [GEPi(bcx, val, [0u, i])];
tup_vals += [GEPi(bcx, val, [0u, i]/~)]/~;
i += 1u;
}
compile_submatch(bcx, enter_tup(dm, m, col, val, n_tup_elts),
@ -463,8 +463,9 @@ fn compile_submatch(bcx: block, m: match, vals: [ValueRef],
if any_box_pat(m, col) {
let box = Load(bcx, val);
let box_no_addrspace = non_gc_box_cast(bcx, box);
let unboxed = GEPi(bcx, box_no_addrspace, [0u, abi::box_field_body]);
compile_submatch(bcx, enter_box(dm, m, col, val), [unboxed]
let unboxed =
GEPi(bcx, box_no_addrspace, [0u, abi::box_field_body]/~);
compile_submatch(bcx, enter_box(dm, m, col, val), [unboxed]/~
+ vals_left, chk, exits);
ret;
}
@ -472,9 +473,10 @@ fn compile_submatch(bcx: block, m: match, vals: [ValueRef],
if any_uniq_pat(m, col) {
let box = Load(bcx, val);
let box_no_addrspace = non_gc_box_cast(bcx, box);
let unboxed = GEPi(bcx, box_no_addrspace, [0u, abi::box_field_body]);
let unboxed =
GEPi(bcx, box_no_addrspace, [0u, abi::box_field_body]/~);
compile_submatch(bcx, enter_uniq(dm, m, col, val),
[unboxed] + vals_left, chk, exits);
[unboxed]/~ + vals_left, chk, exits);
ret;
}
@ -491,7 +493,7 @@ fn compile_submatch(bcx: block, m: match, vals: [ValueRef],
} else {
let enumptr =
PointerCast(bcx, val, T_opaque_enum_ptr(ccx));
let discrimptr = GEPi(bcx, enumptr, [0u, 0u]);
let discrimptr = GEPi(bcx, enumptr, [0u, 0u]/~);
test_val = Load(bcx, discrimptr);
kind = switch;
}
@ -567,7 +569,7 @@ fn compile_submatch(bcx: block, m: match, vals: [ValueRef],
}
} else if kind == compare { Br(bcx, else_cx.llbb); }
let mut size = 0u;
let mut unpacked = [];
let mut unpacked = []/~;
alt opt {
var(_, vdef) {
let args = extract_variant_args(opt_cx, pat_id, vdef, val);
@ -591,18 +593,18 @@ fn compile_submatch(bcx: block, m: match, vals: [ValueRef],
}
// Returns false for unreachable blocks
fn make_phi_bindings(bcx: block, map: [exit_node],
fn make_phi_bindings(bcx: block, map: [exit_node]/~,
ids: pat_util::pat_id_map) -> bool {
let _icx = bcx.insn_ctxt("alt::make_phi_bindings");
let our_block = bcx.llbb as uint;
let mut success = true, bcx = bcx;
for ids.each {|name, node_id|
let mut llbbs = [];
let mut vals = [];
let mut llbbs = []/~;
let mut vals = []/~;
for vec::each(map) {|ex|
if ex.to as uint == our_block {
alt assoc(name, ex.bound) {
some(val) { llbbs += [ex.from]; vals += [val]; }
some(val) { llbbs += [ex.from]/~; vals += [val]/~; }
none { }
}
}
@ -621,7 +623,7 @@ fn make_phi_bindings(bcx: block, map: [exit_node],
fn trans_alt(bcx: block,
alt_expr: @ast::expr,
expr: @ast::expr,
arms: [ast::arm],
arms: [ast::arm]/~,
mode: ast::alt_mode,
dest: dest) -> block {
let _icx = bcx.insn_ctxt("alt::trans_alt");
@ -630,11 +632,11 @@ fn trans_alt(bcx: block,
}
}
fn trans_alt_inner(scope_cx: block, expr: @ast::expr, arms: [ast::arm],
fn trans_alt_inner(scope_cx: block, expr: @ast::expr, arms: [ast::arm]/~,
mode: ast::alt_mode, dest: dest) -> block {
let _icx = scope_cx.insn_ctxt("alt::trans_alt_inner");
let bcx = scope_cx, tcx = bcx.tcx();
let mut bodies = [], match = [];
let mut bodies = []/~, match = []/~;
let {bcx, val, _} = trans_temp_expr(bcx, expr);
if bcx.unreachable { ret bcx; }
@ -642,12 +644,12 @@ fn trans_alt_inner(scope_cx: block, expr: @ast::expr, arms: [ast::arm],
for vec::each(arms) {|a|
let body = scope_block(bcx, a.body.info(), "case_body");
let id_map = pat_util::pat_id_map(tcx.def_map, a.pats[0]);
bodies += [body];
bodies += [body]/~;
for vec::each(a.pats) {|p|
match += [@{pats: [p],
bound: [],
match += [@{pats: [p]/~,
bound: []/~,
data: @{bodycx: body, guard: a.guard,
id_map: id_map}}];
id_map: id_map}}]/~;
}
}
@ -667,21 +669,21 @@ fn trans_alt_inner(scope_cx: block, expr: @ast::expr, arms: [ast::arm],
}
ast::alt_exhaustive { none }
};
let mut exit_map = [];
let mut exit_map = []/~;
let t = node_id_type(bcx, expr.id);
let spilled = spill_if_immediate(bcx, val, t);
compile_submatch(bcx, match, [spilled], mk_fail, exit_map);
compile_submatch(bcx, match, [spilled]/~, mk_fail, exit_map);
let mut arm_cxs = [], arm_dests = [], i = 0u;
let mut arm_cxs = []/~, arm_dests = []/~, i = 0u;
for vec::each(arms) {|a|
let body_cx = bodies[i];
let id_map = pat_util::pat_id_map(tcx.def_map, a.pats[0]);
if make_phi_bindings(body_cx, exit_map, id_map) {
let arm_dest = dup_for_join(dest);
arm_dests += [arm_dest];
arm_dests += [arm_dest]/~;
let mut arm_cx = trans_block(body_cx, a.body, arm_dest);
arm_cx = trans_block_cleanups(arm_cx, body_cx);
arm_cxs += [arm_cx];
arm_cxs += [arm_cx]/~;
}
i += 1u;
}
@ -726,14 +728,14 @@ fn bind_irrefutable_pat(bcx: block, pat: @ast::pat, val: ValueRef,
let rec_fields = ty::get_fields(node_id_type(bcx, pat.id));
for vec::each(fields) {|f|
let ix = option::get(ty::field_idx(f.ident, rec_fields));
let fldptr = GEPi(bcx, val, [0u, ix]);
let fldptr = GEPi(bcx, val, [0u, ix]/~);
bcx = bind_irrefutable_pat(bcx, f.pat, fldptr, make_copy);
}
}
ast::pat_tup(elems) {
let mut i = 0u;
for vec::each(elems) {|elem|
let fldptr = GEPi(bcx, val, [0u, i]);
let fldptr = GEPi(bcx, val, [0u, i]/~);
bcx = bind_irrefutable_pat(bcx, elem, fldptr, make_copy);
i += 1u;
}
@ -741,13 +743,13 @@ fn bind_irrefutable_pat(bcx: block, pat: @ast::pat, val: ValueRef,
ast::pat_box(inner) {
let box = Load(bcx, val);
let unboxed =
GEPi(bcx, box, [0u, abi::box_field_body]);
GEPi(bcx, box, [0u, abi::box_field_body]/~);
bcx = bind_irrefutable_pat(bcx, inner, unboxed, true);
}
ast::pat_uniq(inner) {
let box = Load(bcx, val);
let unboxed =
GEPi(bcx, box, [0u, abi::box_field_body]);
GEPi(bcx, box, [0u, abi::box_field_body]/~);
bcx = bind_irrefutable_pat(bcx, inner, unboxed, true);
}
ast::pat_wild | ast::pat_lit(_) | ast::pat_range(_, _) { }

379
src/rustc/middle/trans/base.rs
View file

File diff suppressed because it is too large Load diff

30
src/rustc/middle/trans/build.rs
View file

@ -79,7 +79,7 @@ fn Ret(cx: block, V: ValueRef) {
llvm::LLVMBuildRet(B(cx), V);
}
fn AggregateRet(cx: block, RetVals: [ValueRef]) {
fn AggregateRet(cx: block, RetVals: [ValueRef]/~) {
if cx.unreachable { ret; }
assert (!cx.terminated);
cx.terminated = true;
@ -134,7 +134,7 @@ fn noname() -> *libc::c_char unsafe {
ret unsafe::reinterpret_cast(ptr::addr_of(cnull));
}
fn Invoke(cx: block, Fn: ValueRef, Args: [ValueRef],
fn Invoke(cx: block, Fn: ValueRef, Args: [ValueRef]/~,
Then: BasicBlockRef, Catch: BasicBlockRef) {
if cx.unreachable { ret; }
assert (!cx.terminated);
@ -151,7 +151,7 @@ fn Invoke(cx: block, Fn: ValueRef, Args: [ValueRef],
}
}
fn FastInvoke(cx: block, Fn: ValueRef, Args: [ValueRef],
fn FastInvoke(cx: block, Fn: ValueRef, Args: [ValueRef]/~,
Then: BasicBlockRef, Catch: BasicBlockRef) {
if cx.unreachable { ret; }
assert (!cx.terminated);
@ -417,7 +417,7 @@ fn Store(cx: block, Val: ValueRef, Ptr: ValueRef) {
llvm::LLVMBuildStore(B(cx), Val, Ptr);
}
fn GEP(cx: block, Pointer: ValueRef, Indices: [ValueRef]) -> ValueRef {
fn GEP(cx: block, Pointer: ValueRef, Indices: [ValueRef]/~) -> ValueRef {
if cx.unreachable { ret llvm::LLVMGetUndef(T_ptr(T_nil())); }
unsafe {
count_insn(cx, "gep");
@ -428,14 +428,14 @@ fn GEP(cx: block, Pointer: ValueRef, Indices: [ValueRef]) -> ValueRef {
// Simple wrapper around GEP that takes an array of ints and wraps them
// in C_i32()
fn GEPi(cx: block, base: ValueRef, ixs: [uint]) -> ValueRef {
let mut v: [ValueRef] = [];
for vec::each(ixs) {|i| v += [C_i32(i as i32)]; }
fn GEPi(cx: block, base: ValueRef, ixs: [uint]/~) -> ValueRef {
let mut v: [ValueRef]/~ = []/~;
for vec::each(ixs) {|i| v += [C_i32(i as i32)]/~; }
count_insn(cx, "gepi");
ret InBoundsGEP(cx, base, v);
}
fn InBoundsGEP(cx: block, Pointer: ValueRef, Indices: [ValueRef]) ->
fn InBoundsGEP(cx: block, Pointer: ValueRef, Indices: [ValueRef]/~) ->
ValueRef {
if cx.unreachable { ret llvm::LLVMGetUndef(T_ptr(T_nil())); }
unsafe {
@ -607,7 +607,7 @@ fn EmptyPhi(cx: block, Ty: TypeRef) -> ValueRef {
ret llvm::LLVMBuildPhi(B(cx), Ty, noname());
}
fn Phi(cx: block, Ty: TypeRef, vals: [ValueRef], bbs: [BasicBlockRef])
fn Phi(cx: block, Ty: TypeRef, vals: [ValueRef]/~, bbs: [BasicBlockRef]/~)
-> ValueRef {
if cx.unreachable { ret llvm::LLVMGetUndef(Ty); }
assert vals.len() == bbs.len();
@ -657,15 +657,15 @@ fn add_comment(bcx: block, text: str) {
let asm = str::as_c_str(comment_text, {|c|
str::as_c_str("", {|e|
count_insn(bcx, "inlineasm");
llvm::LLVMConstInlineAsm(T_fn([], T_void()), c, e,
llvm::LLVMConstInlineAsm(T_fn([]/~, T_void()), c, e,
False, False)
})
});
Call(bcx, asm, []);
Call(bcx, asm, []/~);
}
}
fn Call(cx: block, Fn: ValueRef, Args: [ValueRef]) -> ValueRef {
fn Call(cx: block, Fn: ValueRef, Args: [ValueRef]/~) -> ValueRef {
if cx.unreachable { ret _UndefReturn(cx, Fn); }
unsafe {
count_insn(cx, "call");
@ -679,7 +679,7 @@ fn Call(cx: block, Fn: ValueRef, Args: [ValueRef]) -> ValueRef {
}
}
fn FastCall(cx: block, Fn: ValueRef, Args: [ValueRef]) -> ValueRef {
fn FastCall(cx: block, Fn: ValueRef, Args: [ValueRef]/~) -> ValueRef {
if cx.unreachable { ret _UndefReturn(cx, Fn); }
unsafe {
count_insn(cx, "fastcall");
@ -690,7 +690,7 @@ fn FastCall(cx: block, Fn: ValueRef, Args: [ValueRef]) -> ValueRef {
}
}
fn CallWithConv(cx: block, Fn: ValueRef, Args: [ValueRef],
fn CallWithConv(cx: block, Fn: ValueRef, Args: [ValueRef]/~,
Conv: CallConv) -> ValueRef {
if cx.unreachable { ret _UndefReturn(cx, Fn); }
unsafe {
@ -779,7 +779,7 @@ fn Trap(cx: block) {
llvm::LLVMGetNamedFunction(M, buf)
});
assert (T as int != 0);
let Args: [ValueRef] = [];
let Args: [ValueRef]/~ = []/~;
unsafe {
count_insn(cx, "trap");
llvm::LLVMBuildCall(b, T, vec::unsafe::to_ptr(Args),

114
src/rustc/middle/trans/closure.rs
View file

@ -122,9 +122,9 @@ fn mk_tuplified_uniq_cbox_ty(tcx: ty::ctxt, cdata_ty: ty::t) -> ty::t {
// Given a closure ty, emits a corresponding tuple ty
fn mk_closure_tys(tcx: ty::ctxt,
bound_values: [environment_value])
-> (ty::t, [ty::t]) {
let mut bound_tys = [];
bound_values: [environment_value]/~)
-> (ty::t, [ty::t]/~) {
let mut bound_tys = []/~;
// Compute the closed over data
for vec::each(bound_values) {|bv|
@ -133,12 +133,12 @@ fn mk_closure_tys(tcx: ty::ctxt,
env_move(_, t, _) { t }
env_ref(_, t, _) { t }
env_expr(_, t) { t }
}];
}]/~;
}
let bound_data_ty = ty::mk_tup(tcx, bound_tys);
// FIXME[mono] remove tuple of tydescs from closure types (#2531)
let cdata_ty = ty::mk_tup(tcx, [ty::mk_tup(tcx, []),
bound_data_ty]);
// FIXME[mono]/~ remove tuple of tydescs from closure types (#2531)
let cdata_ty = ty::mk_tup(tcx, [ty::mk_tup(tcx, []/~),
bound_data_ty]/~);
#debug["cdata_ty=%s", ty_to_str(tcx, cdata_ty)];
ret (cdata_ty, bound_tys);
}
@ -146,7 +146,7 @@ fn mk_closure_tys(tcx: ty::ctxt,
fn allocate_cbox(bcx: block,
ck: ty::closure_kind,
cdata_ty: ty::t)
-> (block, ValueRef, [ValueRef]) {
-> (block, ValueRef, [ValueRef]/~) {
let _icx = bcx.insn_ctxt("closure::allocate_cbox");
let ccx = bcx.ccx(), tcx = ccx.tcx;
@ -155,7 +155,7 @@ fn allocate_cbox(bcx: block,
// Initialize ref count to arbitrary value for debugging:
let ccx = bcx.ccx();
let box = PointerCast(bcx, box, T_opaque_box_ptr(ccx));
let ref_cnt = GEPi(bcx, box, [0u, abi::box_field_refcnt]);
let ref_cnt = GEPi(bcx, box, [0u, abi::box_field_refcnt]/~);
let rc = C_int(ccx, 0x12345678);
Store(bcx, rc, ref_cnt);
}
@ -164,7 +164,7 @@ fn allocate_cbox(bcx: block,
cdata_ty: ty::t,
box: ValueRef,
&ti: option<@tydesc_info>) -> block {
let bound_tydesc = GEPi(bcx, box, [0u, abi::box_field_tydesc]);
let bound_tydesc = GEPi(bcx, box, [0u, abi::box_field_tydesc]/~);
let td = base::get_tydesc(bcx.ccx(), cdata_ty, ti);
Store(bcx, td, bound_tydesc);
bcx
@ -172,7 +172,7 @@ fn allocate_cbox(bcx: block,
// Allocate and initialize the box:
let mut ti = none;
let mut temp_cleanups = [];
let mut temp_cleanups = []/~;
let (bcx, box) = alt ck {
ty::ck_box {
get_tydesc(ccx, cdata_ty, ti);
@ -209,7 +209,7 @@ type closure_result = {
// heap allocated closure that copies the upvars into environment.
// Otherwise, it is stack allocated and copies pointers to the upvars.
fn store_environment(bcx: block,
bound_values: [environment_value],
bound_values: [environment_value]/~,
ck: ty::closure_kind) -> closure_result {
let _icx = bcx.insn_ctxt("closure::store_environment");
let ccx = bcx.ccx(), tcx = ccx.tcx;
@ -242,12 +242,12 @@ fn store_environment(bcx: block,
}
let bound_data = GEPi(bcx, llbox,
[0u, abi::box_field_body, abi::closure_body_bindings, i]);
[0u, abi::box_field_body, abi::closure_body_bindings, i]/~);
alt bv {
env_expr(e, _) {
bcx = base::trans_expr_save_in(bcx, e, bound_data);
add_clean_temp_mem(bcx, bound_data, bound_tys[i]);
temp_cleanups += [bound_data];
temp_cleanups += [bound_data]/~;
}
env_copy(val, ty, owned) {
let val1 = load_if_immediate(bcx, val, ty);
@ -283,13 +283,13 @@ fn store_environment(bcx: block,
// Given a context and a list of upvars, build a closure. This just
// collects the upvars and packages them up for store_environment.
fn build_closure(bcx0: block,
cap_vars: [capture::capture_var],
cap_vars: [capture::capture_var]/~,
ck: ty::closure_kind,
id: ast::node_id,
include_ret_handle: option<ValueRef>) -> closure_result {
let _icx = bcx0.insn_ctxt("closure::build_closure");
// If we need to, package up the iterator body to call
let mut env_vals = [];
let mut env_vals = []/~;
let mut bcx = bcx0;
let ccx = bcx.ccx(), tcx = ccx.tcx;
@ -303,18 +303,18 @@ fn build_closure(bcx0: block,
capture::cap_ref {
assert ck == ty::ck_block;
ty = ty::mk_mut_ptr(tcx, ty);
env_vals += [env_ref(lv.val, ty, lv.kind)];
env_vals += [env_ref(lv.val, ty, lv.kind)]/~;
}
capture::cap_copy {
let mv = alt check ccx.maps.last_use_map.find(id) {
none { false }
some(vars) { (*vars).contains(nid) }
};
if mv { env_vals += [env_move(lv.val, ty, lv.kind)]; }
else { env_vals += [env_copy(lv.val, ty, lv.kind)]; }
if mv { env_vals += [env_move(lv.val, ty, lv.kind)]/~; }
else { env_vals += [env_copy(lv.val, ty, lv.kind)]/~; }
}
capture::cap_move {
env_vals += [env_move(lv.val, ty, lv.kind)];
env_vals += [env_move(lv.val, ty, lv.kind)]/~;
}
capture::cap_drop {
assert lv.kind == owned;
@ -331,7 +331,7 @@ fn build_closure(bcx0: block,
let nil_ret = PointerCast(bcx, our_ret, T_ptr(T_nil()));
env_vals +=
[env_ref(flagptr, ty::mk_mut_ptr(tcx, ty::mk_bool(tcx)), owned),
env_ref(nil_ret, ty::mk_nil_ptr(tcx), owned)];
env_ref(nil_ret, ty::mk_nil_ptr(tcx), owned)]/~;
}
ret store_environment(bcx, env_vals, ck);
}
@ -341,7 +341,7 @@ fn build_closure(bcx0: block,
// with the upvars and type descriptors.
fn load_environment(fcx: fn_ctxt,
cdata_ty: ty::t,
cap_vars: [capture::capture_var],
cap_vars: [capture::capture_var]/~,
load_ret_handle: bool,
ck: ty::closure_kind) {
let _icx = fcx.insn_ctxt("closure::load_environment");
@ -357,7 +357,7 @@ fn load_environment(fcx: fn_ctxt,
capture::cap_drop { /* ignore */ }
_ {
let mut upvarptr =
GEPi(bcx, llcdata, [0u, abi::closure_body_bindings, i]);
GEPi(bcx, llcdata, [0u, abi::closure_body_bindings, i]/~);
alt ck {
ty::ck_block { upvarptr = Load(bcx, upvarptr); }
ty::ck_uniq | ty::ck_box { }
@ -370,9 +370,10 @@ fn load_environment(fcx: fn_ctxt,
}
if load_ret_handle {
let flagptr = Load(bcx, GEPi(bcx, llcdata,
[0u, abi::closure_body_bindings, i]));
let retptr = Load(bcx, GEPi(bcx, llcdata,
[0u, abi::closure_body_bindings, i+1u]));
[0u, abi::closure_body_bindings, i]/~));
let retptr = Load(bcx,
GEPi(bcx, llcdata,
[0u, abi::closure_body_bindings, i+1u]/~));
fcx.loop_ret = some({flagptr: flagptr, retptr: retptr});
}
}
@ -390,7 +391,7 @@ fn trans_expr_fn(bcx: block,
let ccx = bcx.ccx(), bcx = bcx;
let fty = node_id_type(bcx, id);
let llfnty = type_of_fn_from_ty(ccx, fty);
let sub_path = bcx.fcx.path + [path_name(@"anon")];
let sub_path = bcx.fcx.path + [path_name(@"anon")]/~;
let s = mangle_internal_name_by_path(ccx, sub_path);
let llfn = decl_internal_cdecl_fn(ccx.llmod, s, llfnty);
@ -428,13 +429,13 @@ fn trans_expr_fn(bcx: block,
fn trans_bind_1(cx: block, outgoing_fty: ty::t,
f_res: lval_maybe_callee,
args: [option<@ast::expr>], pair_ty: ty::t,
args: [option<@ast::expr>]/~, pair_ty: ty::t,
dest: dest) -> block {
let _icx = cx.insn_ctxt("closure::trans_bind1");
let ccx = cx.ccx();
let mut bound: [@ast::expr] = [];
let mut bound: [@ast::expr]/~ = []/~;
for vec::each(args) {|argopt|
alt argopt { none { } some(e) { bound += [e]; } }
alt argopt { none { } some(e) { bound += [e]/~; } }
}
let mut bcx = f_res.bcx;
if dest == ignore {
@ -453,22 +454,22 @@ fn trans_bind_1(cx: block, outgoing_fty: ty::t,
// Arrange for the bound function to live in the first binding spot
// if the function is not statically known.
let (env_vals, target_info) = alt f_res.env {
null_env { ([], target_static(f_res.val)) }
null_env { ([]/~, target_static(f_res.val)) }
is_closure {
// Cast the function we are binding to be the type that the
// closure will expect it to have. The type the closure knows
// about has the type parameters substituted with the real types.
let llclosurety = T_ptr(type_of(ccx, outgoing_fty));
let src_loc = PointerCast(bcx, f_res.val, llclosurety);
([env_copy(src_loc, pair_ty, owned)], target_closure)
([env_copy(src_loc, pair_ty, owned)]/~, target_closure)
}
self_env(slf, slf_t, none) {
([env_copy(slf, slf_t, owned)], target_static_self(f_res.val))
([env_copy(slf, slf_t, owned)]/~, target_static_self(f_res.val))
}
self_env(_, slf_t, some(slf)) {
let cast = PointerCast(bcx, f_res.val, T_ptr(T_nil()));
([env_copy(cast, ty::mk_nil_ptr(ccx.tcx), owned_imm),
env_copy(slf, slf_t, owned_imm)], target_self)
env_copy(slf, slf_t, owned_imm)]/~, target_self)
}
};
@ -498,7 +499,7 @@ fn make_fn_glue(
let tcx = cx.tcx();
let fn_env = fn@(ck: ty::closure_kind) -> block {
let box_cell_v = GEPi(cx, v, [0u, abi::fn_field_box]);
let box_cell_v = GEPi(cx, v, [0u, abi::fn_field_box]/~);
let box_ptr_v = Load(cx, box_cell_v);
with_cond(cx, IsNotNull(cx, box_ptr_v)) {|bcx|
let closure_ty = ty::mk_opaque_closure_ptr(tcx, ck);
@ -536,28 +537,28 @@ fn make_opaque_cbox_take_glue(
with_cond(bcx, IsNotNull(bcx, cbox_in)) {|bcx|
// Load the size from the type descr found in the cbox
let cbox_in = PointerCast(bcx, cbox_in, llopaquecboxty);
let tydescptr = GEPi(bcx, cbox_in, [0u, abi::box_field_tydesc]);
let tydescptr = GEPi(bcx, cbox_in, [0u, abi::box_field_tydesc]/~);
let tydesc = Load(bcx, tydescptr);
let tydesc = PointerCast(bcx, tydesc, T_ptr(ccx.tydesc_type));
let sz = Load(bcx, GEPi(bcx, tydesc, [0u, abi::tydesc_field_size]));
let sz = Load(bcx, GEPi(bcx, tydesc, [0u, abi::tydesc_field_size]/~));
// Adjust sz to account for the rust_opaque_box header fields
let sz = Add(bcx, sz, shape::llsize_of(ccx, T_box_header(ccx)));
// Allocate memory, update original ptr, and copy existing data
let malloc = ccx.upcalls.exchange_malloc;
let cbox_out = Call(bcx, malloc, [tydesc, sz]);
let cbox_out = Call(bcx, malloc, [tydesc, sz]/~);
let cbox_out = PointerCast(bcx, cbox_out, llopaquecboxty);
call_memmove(bcx, cbox_out, cbox_in, sz);
Store(bcx, cbox_out, cboxptr);
// Take the (deeply cloned) type descriptor
let tydesc_out = GEPi(bcx, cbox_out, [0u, abi::box_field_tydesc]);
let tydesc_out = GEPi(bcx, cbox_out, [0u, abi::box_field_tydesc]/~);
let bcx = take_ty(bcx, tydesc_out, ty::mk_type(tcx));
// Take the data in the tuple
let ti = none;
let cdata_out = GEPi(bcx, cbox_out, [0u, abi::box_field_body]);
let cdata_out = GEPi(bcx, cbox_out, [0u, abi::box_field_body]/~);
call_tydesc_glue_full(bcx, cdata_out, tydesc,
abi::tydesc_field_take_glue, ti);
bcx
@ -599,13 +600,13 @@ fn make_opaque_cbox_free_glue(
// Load the type descr found in the cbox
let lltydescty = T_ptr(ccx.tydesc_type);
let cbox = PointerCast(bcx, cbox, T_opaque_cbox_ptr(ccx));
let tydescptr = GEPi(bcx, cbox, [0u, abi::box_field_tydesc]);
let tydescptr = GEPi(bcx, cbox, [0u, abi::box_field_tydesc]/~);
let tydesc = Load(bcx, tydescptr);
let tydesc = PointerCast(bcx, tydesc, lltydescty);
// Drop the tuple data then free the descriptor
let ti = none;
let cdata = GEPi(bcx, cbox, [0u, abi::box_field_body]);
let cdata = GEPi(bcx, cbox, [0u, abi::box_field_body]/~);
call_tydesc_glue_full(bcx, cdata, tydesc,
abi::tydesc_field_drop_glue, ti);
@ -634,14 +635,14 @@ fn trans_bind_thunk(ccx: @crate_ctxt,
path: path,
incoming_fty: ty::t,
outgoing_fty: ty::t,
args: [option<@ast::expr>],
args: [option<@ast::expr>]/~,
cdata_ty: ty::t,
target_info: target_info)
-> {val: ValueRef, ty: TypeRef} {
let _icx = ccx.insn_ctxt("closure::trans_bind_thunk");
let tcx = ccx.tcx;
#debug["trans_bind_thunk[incoming_fty=%s,outgoing_fty=%s,\
cdata_ty=%s]",
cdata_ty=%s]/~",
ty_to_str(tcx, incoming_fty),
ty_to_str(tcx, outgoing_fty),
ty_to_str(tcx, cdata_ty)];
@ -701,22 +702,25 @@ fn trans_bind_thunk(ccx: @crate_ctxt,
(fptr, llvm::LLVMGetUndef(T_opaque_cbox_ptr(ccx)), 0u)
}
target_closure {
let pair = GEPi(bcx, llcdata, [0u, abi::closure_body_bindings, 0u]);
let pair = GEPi(bcx, llcdata, [0u, abi::closure_body_bindings, 0u]/~);
let lltargetenv =
Load(bcx, GEPi(bcx, pair, [0u, abi::fn_field_box]));
Load(bcx, GEPi(bcx, pair, [0u, abi::fn_field_box]/~));
let lltargetfn = Load
(bcx, GEPi(bcx, pair, [0u, abi::fn_field_code]));
(bcx, GEPi(bcx, pair, [0u, abi::fn_field_code]/~));
(lltargetfn, lltargetenv, 1u)
}
target_self {
let fptr = Load(bcx, GEPi(bcx, llcdata,
[0u, abi::closure_body_bindings, 0u]));
let slfbox = GEPi(bcx, llcdata, [0u, abi::closure_body_bindings, 1u]);
let selfptr = GEPi(bcx, Load(bcx, slfbox), [0u, abi::box_field_body]);
[0u, abi::closure_body_bindings, 0u]/~));
let slfbox =
GEPi(bcx, llcdata, [0u, abi::closure_body_bindings, 1u]/~);
let selfptr =
GEPi(bcx, Load(bcx, slfbox), [0u, abi::box_field_body]/~);
(fptr, PointerCast(bcx, selfptr, T_opaque_cbox_ptr(ccx)), 2u)
}
target_static_self(fptr) {
let slfptr = GEPi(bcx, llcdata, [0u, abi::closure_body_bindings, 0u]);
let slfptr =
GEPi(bcx, llcdata, [0u, abi::closure_body_bindings, 0u]/~);
(fptr, PointerCast(bcx, slfptr, T_opaque_cbox_ptr(ccx)), 1u)
}
};
@ -728,7 +732,7 @@ fn trans_bind_thunk(ccx: @crate_ctxt,
let outgoing_args = ty::ty_fn_args(outgoing_fty);
// Set up the three implicit arguments to the thunk.
let mut llargs: [ValueRef] = [fcx.llretptr, lltargetenv];
let mut llargs: [ValueRef]/~ = [fcx.llretptr, lltargetenv]/~;
let mut a: uint = first_real_arg; // retptr, env come first
let mut b: uint = starting_idx;
@ -740,7 +744,7 @@ fn trans_bind_thunk(ccx: @crate_ctxt,
// closure.
some(e) {
let mut val =
GEPi(bcx, llcdata, [0u, abi::closure_body_bindings, b]);
GEPi(bcx, llcdata, [0u, abi::closure_body_bindings, b]/~);
alt ty::resolved_mode(tcx, out_arg.mode) {
ast::by_val {
@ -754,13 +758,13 @@ fn trans_bind_thunk(ccx: @crate_ctxt,
}
ast::by_ref | ast::by_mutbl_ref | ast::by_move { }
}
llargs += [val];
llargs += [val]/~;
b += 1u;
}
// Arg will be provided when the thunk is invoked.
none {
llargs += [llvm::LLVMGetParam(llthunk, a as c_uint)];
llargs += [llvm::LLVMGetParam(llthunk, a as c_uint)]/~;
a += 1u;
}
}

88
src/rustc/middle/trans/common.rs
View file

@ -58,9 +58,9 @@ type stats =
mut n_glues_created: uint,
mut n_null_glues: uint,
mut n_real_glues: uint,
llvm_insn_ctxt: @mut [str],
llvm_insn_ctxt: @mut [str]/~,
llvm_insns: hashmap<str, uint>,
fn_times: @mut [{ident: str, time: int}]};
fn_times: @mut [{ident: str, time: int}]/~};
class BuilderRef_res {
let B: BuilderRef;
@ -92,7 +92,7 @@ type crate_ctxt = {
monomorphized: hashmap<mono_id, ValueRef>,
monomorphizing: hashmap<ast::def_id, uint>,
// Cache computed type parameter uses (see type_use.rs)
type_use_cache: hashmap<ast::def_id, [type_use::type_uses]>,
type_use_cache: hashmap<ast::def_id, [type_use::type_uses]/~>,
// Cache generated vtables
vtables: hashmap<mono_id, ValueRef>,
// Cache of constant strings,
@ -129,9 +129,9 @@ type val_self_pair = {v: ValueRef, t: ty::t};
enum local_val { local_mem(ValueRef), local_imm(ValueRef), }
type param_substs = {tys: [ty::t],
type param_substs = {tys: [ty::t]/~,
vtables: option<typeck::vtable_res>,
bounds: @[ty::param_bounds]};
bounds: @[ty::param_bounds]/~};
// Function context. Every LLVM function we create will have one of
// these.
@ -217,7 +217,7 @@ type cleanup_path = {target: option<BasicBlockRef>,
dest: BasicBlockRef};
fn scope_clean_changed(info: scope_info) {
if info.cleanup_paths.len() > 0u { info.cleanup_paths = []; }
if info.cleanup_paths.len() > 0u { info.cleanup_paths = []/~; }
info.landing_pad = none;
}
@ -237,7 +237,7 @@ fn add_clean(cx: block, val: ValueRef, ty: ty::t) {
let cleanup_type = cleanup_type(cx.tcx(), ty);
in_scope_cx(cx) {|info|
info.cleanups += [clean({|a|base::drop_ty(a, val, ty)},
cleanup_type)];
cleanup_type)]/~;
scope_clean_changed(info);
}
}
@ -257,7 +257,7 @@ fn add_clean_temp(cx: block, val: ValueRef, ty: ty::t) {
}
in_scope_cx(cx) {|info|
info.cleanups += [clean_temp(val, {|a|do_drop(a, val, ty)},
cleanup_type)];
cleanup_type)]/~;
scope_clean_changed(info);
}
}
@ -269,7 +269,7 @@ fn add_clean_temp_mem(cx: block, val: ValueRef, ty: ty::t) {
let cleanup_type = cleanup_type(cx.tcx(), ty);
in_scope_cx(cx) {|info|
info.cleanups += [clean_temp(val, {|a|base::drop_ty(a, val, ty)},
cleanup_type)];
cleanup_type)]/~;
scope_clean_changed(info);
}
}
@ -278,7 +278,7 @@ fn add_clean_free(cx: block, ptr: ValueRef, shared: bool) {
else { {|a|base::trans_free(a, ptr)} };
in_scope_cx(cx) {|info|
info.cleanups += [clean_temp(ptr, free_fn,
normal_exit_and_unwind)];
normal_exit_and_unwind)]/~;
scope_clean_changed(info);
}
}
@ -318,10 +318,10 @@ type scope_info = {
// A list of functions that must be run at when leaving this
// block, cleaning up any variables that were introduced in the
// block.
mut cleanups: [cleanup],
mut cleanups: [cleanup]/~,
// Existing cleanup paths that may be reused, indexed by destination and
// cleared when the set of cleanups changes.
mut cleanup_paths: [cleanup_path],
mut cleanup_paths: [cleanup_path]/~,
// Unwinding landing pad. Also cleared when cleanups change.
mut landing_pad: option<BasicBlockRef>,
};
@ -551,21 +551,21 @@ fn T_size_t(targ_cfg: @session::config) -> TypeRef {
ret T_int(targ_cfg);
}
fn T_fn(inputs: [TypeRef], output: TypeRef) -> TypeRef unsafe {
fn T_fn(inputs: [TypeRef]/~, output: TypeRef) -> TypeRef unsafe {
ret llvm::LLVMFunctionType(output, to_ptr(inputs),
inputs.len() as c_uint,
False);
}
fn T_fn_pair(cx: @crate_ctxt, tfn: TypeRef) -> TypeRef {
ret T_struct([T_ptr(tfn), T_opaque_cbox_ptr(cx)]);
ret T_struct([T_ptr(tfn), T_opaque_cbox_ptr(cx)]/~);
}
fn T_ptr(t: TypeRef) -> TypeRef {
ret llvm::LLVMPointerType(t, 0u as c_uint);
}
fn T_struct(elts: [TypeRef]) -> TypeRef unsafe {
fn T_struct(elts: [TypeRef]/~) -> TypeRef unsafe {
ret llvm::LLVMStructType(to_ptr(elts), elts.len() as c_uint, False);
}
@ -574,12 +574,12 @@ fn T_named_struct(name: str) -> TypeRef {
ret str::as_c_str(name, {|buf| llvm::LLVMStructCreateNamed(c, buf) });
}
fn set_struct_body(t: TypeRef, elts: [TypeRef]) unsafe {
fn set_struct_body(t: TypeRef, elts: [TypeRef]/~) unsafe {
llvm::LLVMStructSetBody(t, to_ptr(elts),
elts.len() as c_uint, False);
}
fn T_empty_struct() -> TypeRef { ret T_struct([]); }
fn T_empty_struct() -> TypeRef { ret T_struct([]/~); }
// A vtable is, in reality, a vtable pointer followed by zero or more pointers
// to tydescs and other vtables that it closes over. But the types and number
@ -604,7 +604,7 @@ fn T_task(targ_cfg: @session::config) -> TypeRef {
let t_int = T_int(targ_cfg);
let elems =
[t_int, t_int, t_int, t_int,
t_int, t_int, t_int, t_int];
t_int, t_int, t_int, t_int]/~;
set_struct_body(t, elems);
ret t;
}
@ -612,7 +612,7 @@ fn T_task(targ_cfg: @session::config) -> TypeRef {
fn T_tydesc_field(cx: @crate_ctxt, field: uint) -> TypeRef unsafe {
// Bit of a kludge: pick the fn typeref out of the tydesc..
let tydesc_elts: [TypeRef] =
let tydesc_elts: [TypeRef]/~ =
vec::from_elem::<TypeRef>(abi::n_tydesc_fields,
T_nil());
llvm::LLVMGetStructElementTypes(cx.tydesc_type,
@ -635,14 +635,14 @@ fn T_tydesc(targ_cfg: @session::config) -> TypeRef {
let pvoid = T_ptr(T_i8());
let glue_fn_ty =
T_ptr(T_fn([T_ptr(T_nil()), T_ptr(T_nil()), tydescpp,
pvoid], T_void()));
pvoid]/~, T_void()));
let int_type = T_int(targ_cfg);
let elems =
[tydescpp, int_type, int_type,
glue_fn_ty, glue_fn_ty, glue_fn_ty, glue_fn_ty,
int_type, int_type, int_type, int_type,
T_ptr(T_i8()), T_ptr(T_i8()), int_type, int_type];
T_ptr(T_i8()), T_ptr(T_i8()), int_type, int_type]/~;
set_struct_body(tydesc, elems);
ret tydesc;
}
@ -655,7 +655,7 @@ fn T_array(t: TypeRef, n: uint) -> TypeRef {
fn T_vec2(targ_cfg: @session::config, t: TypeRef) -> TypeRef {
ret T_struct([T_int(targ_cfg), // fill
T_int(targ_cfg), // alloc
T_array(t, 0u)]); // elements
T_array(t, 0u)]/~); // elements
}
fn T_vec(ccx: @crate_ctxt, t: TypeRef) -> TypeRef {
@ -674,12 +674,12 @@ fn tuplify_box_ty(tcx: ty::ctxt, t: ty::t) -> ty::t {
let ptr = ty::mk_ptr(tcx, {ty: ty::mk_nil(tcx), mutbl: ast::m_imm});
ret ty::mk_tup(tcx, [ty::mk_uint(tcx), ty::mk_type(tcx),
ptr, ptr,
t]);
t]/~);
}
fn T_box_header_fields(cx: @crate_ctxt) -> [TypeRef] {
fn T_box_header_fields(cx: @crate_ctxt) -> [TypeRef]/~ {
let ptr = T_ptr(T_i8());
ret [cx.int_type, T_ptr(cx.tydesc_type), ptr, ptr];
ret [cx.int_type, T_ptr(cx.tydesc_type), ptr, ptr]/~;
}
fn T_box_header(cx: @crate_ctxt) -> TypeRef {
@ -687,7 +687,7 @@ fn T_box_header(cx: @crate_ctxt) -> TypeRef {
}
fn T_box(cx: @crate_ctxt, t: TypeRef) -> TypeRef {
ret T_struct(T_box_header_fields(cx) + [t]);
ret T_struct(T_box_header_fields(cx) + [t]/~);
}
fn T_box_ptr(t: TypeRef) -> TypeRef {
@ -704,7 +704,7 @@ fn T_opaque_box_ptr(cx: @crate_ctxt) -> TypeRef {
}
fn T_unique(cx: @crate_ctxt, t: TypeRef) -> TypeRef {
ret T_struct(T_box_header_fields(cx) + [t]);
ret T_struct(T_box_header_fields(cx) + [t]/~);
}
fn T_unique_ptr(t: TypeRef) -> TypeRef {
@ -713,12 +713,12 @@ fn T_unique_ptr(t: TypeRef) -> TypeRef {
}
fn T_port(cx: @crate_ctxt, _t: TypeRef) -> TypeRef {
ret T_struct([cx.int_type]); // Refcount
ret T_struct([cx.int_type]/~); // Refcount
}
fn T_chan(cx: @crate_ctxt, _t: TypeRef) -> TypeRef {
ret T_struct([cx.int_type]); // Refcount
ret T_struct([cx.int_type]/~); // Refcount
}
@ -749,7 +749,7 @@ fn T_enum_discrim(cx: @crate_ctxt) -> TypeRef {
fn T_opaque_enum(cx: @crate_ctxt) -> TypeRef {
let s = "opaque_enum";
alt name_has_type(cx.tn, s) { some(t) { ret t; } _ {} }
let t = T_struct([T_enum_discrim(cx), T_i8()]);
let t = T_struct([T_enum_discrim(cx), T_i8()]/~);
associate_type(cx.tn, s, t);
ret t;
}
@ -763,7 +763,7 @@ fn T_captured_tydescs(cx: @crate_ctxt, n: uint) -> TypeRef {
}
fn T_opaque_iface(cx: @crate_ctxt) -> TypeRef {
T_struct([T_ptr(cx.tydesc_type), T_opaque_box_ptr(cx)])
T_struct([T_ptr(cx.tydesc_type), T_opaque_box_ptr(cx)]/~)
}
fn T_opaque_port_ptr() -> TypeRef { ret T_ptr(T_i8()); }
@ -836,7 +836,7 @@ fn C_cstr(cx: @crate_ctxt, s: str) -> ValueRef {
fn C_estr_slice(cx: @crate_ctxt, s: str) -> ValueRef {
let cs = llvm::LLVMConstPointerCast(C_cstr(cx, s), T_ptr(T_i8()));
C_struct([cs, C_uint(cx, str::len(s) + 1u /* +1 for null */)])
C_struct([cs, C_uint(cx, str::len(s) + 1u /* +1 for null */)]/~)
}
// Returns a Plain Old LLVM String:
@ -848,34 +848,34 @@ fn C_postr(s: str) -> ValueRef {
fn C_zero_byte_arr(size: uint) -> ValueRef unsafe {
let mut i = 0u;
let mut elts: [ValueRef] = [];
while i < size { elts += [C_u8(0u)]; i += 1u; }
let mut elts: [ValueRef]/~ = []/~;
while i < size { elts += [C_u8(0u)]/~; i += 1u; }
ret llvm::LLVMConstArray(T_i8(), vec::unsafe::to_ptr(elts),
elts.len() as c_uint);
}
fn C_struct(elts: [ValueRef]) -> ValueRef unsafe {
fn C_struct(elts: [ValueRef]/~) -> ValueRef unsafe {
ret llvm::LLVMConstStruct(vec::unsafe::to_ptr(elts),
elts.len() as c_uint, False);
}
fn C_named_struct(T: TypeRef, elts: [ValueRef]) -> ValueRef unsafe {
fn C_named_struct(T: TypeRef, elts: [ValueRef]/~) -> ValueRef unsafe {
ret llvm::LLVMConstNamedStruct(T, vec::unsafe::to_ptr(elts),
elts.len() as c_uint);
}
fn C_array(ty: TypeRef, elts: [ValueRef]) -> ValueRef unsafe {
fn C_array(ty: TypeRef, elts: [ValueRef]/~) -> ValueRef unsafe {
ret llvm::LLVMConstArray(ty, vec::unsafe::to_ptr(elts),
elts.len() as c_uint);
}
fn C_bytes(bytes: [u8]) -> ValueRef unsafe {
fn C_bytes(bytes: [u8]/~) -> ValueRef unsafe {
ret llvm::LLVMConstString(
unsafe::reinterpret_cast(vec::unsafe::to_ptr(bytes)),
bytes.len() as c_uint, False);
}
fn C_shape(ccx: @crate_ctxt, bytes: [u8]) -> ValueRef {
fn C_shape(ccx: @crate_ctxt, bytes: [u8]/~) -> ValueRef {
let llshape = C_bytes(bytes);
let llglobal = str::as_c_str(ccx.names("shape"), {|buf|
llvm::LLVMAddGlobal(ccx.llmod, val_ty(llshape), buf)
@ -892,11 +892,11 @@ fn get_param(fndecl: ValueRef, param: uint) -> ValueRef {
// Used to identify cached monomorphized functions and vtables
enum mono_param_id {
mono_precise(ty::t, option<[mono_id]>),
mono_precise(ty::t, option<[mono_id]/~>),
mono_any,
mono_repr(uint /* size */, uint /* align */),
}
type mono_id = @{def: ast::def_id, params: [mono_param_id]};
type mono_id = @{def: ast::def_id, params: [mono_param_id]/~};
fn hash_mono_id(&&mi: mono_id) -> uint {
let mut h = syntax::ast_util::hash_def(mi.def);
for vec::each(mi.params) {|param|
@ -954,7 +954,7 @@ fn node_id_type(bcx: block, id: ast::node_id) -> ty::t {
fn expr_ty(bcx: block, ex: @ast::expr) -> ty::t {
node_id_type(bcx, ex.id)
}
fn node_id_type_params(bcx: block, id: ast::node_id) -> [ty::t] {
fn node_id_type_params(bcx: block, id: ast::node_id) -> [ty::t]/~ {
let tcx = bcx.tcx();
let params = ty::node_id_to_type_params(tcx, id);
alt bcx.fcx.param_substs {
@ -966,7 +966,7 @@ fn node_id_type_params(bcx: block, id: ast::node_id) -> [ty::t] {
}
fn field_idx_strict(cx: ty::ctxt, sp: span, ident: ast::ident,
fields: [ty::field])
fields: [ty::field]/~)
-> uint {
alt ty::field_idx(ident, fields) {
none { cx.sess.span_bug(sp, #fmt("base expr doesn't appear to \
@ -975,7 +975,7 @@ fn field_idx_strict(cx: ty::ctxt, sp: span, ident: ast::ident,
}
}
fn dummy_substs(tps: [ty::t]) -> ty::substs {
fn dummy_substs(tps: [ty::t]/~) -> ty::substs {
{self_r: some(ty::re_bound(ty::br_self)),
self_ty: none,
tps: tps}

50
src/rustc/middle/trans/debuginfo.rs
View file

@ -64,7 +64,7 @@ fn lli64(val: int) -> ValueRef {
fn lli1(bval: bool) -> ValueRef {
C_bool(bval)
}
fn llmdnode(elems: [ValueRef]) -> ValueRef unsafe {
fn llmdnode(elems: [ValueRef]/~) -> ValueRef unsafe {
llvm::LLVMMDNode(vec::unsafe::to_ptr(elems),
vec::len(elems) as libc::c_uint)
}
@ -99,9 +99,9 @@ fn update_cache(cache: metadata_cache, mdtag: int, val: debug_metadata) {
let existing = if cache.contains_key(mdtag) {
cache.get(mdtag)
} else {
[]
[]/~
};
cache.insert(mdtag, existing + [val]);
cache.insert(mdtag, existing + [val]/~);
}
type metadata<T> = {node: ValueRef, data: T};
@ -115,7 +115,7 @@ type block_md = {start: codemap::loc, end: codemap::loc};
type argument_md = {id: ast::node_id};
type retval_md = {id: ast::node_id};
type metadata_cache = hashmap<int, [debug_metadata]>;
type metadata_cache = hashmap<int, [debug_metadata]/~>;
enum debug_metadata {
file_metadata(@metadata<file_md>),
@ -183,7 +183,7 @@ fn create_compile_unit(cx: @crate_ctxt)
lli1(cx.sess.opts.optimize != 0u),
llstr(""), // flags (???)
lli32(0) // runtime version (???)
];
]/~;
let unit_node = llmdnode(unit_metadata);
add_named_metadata(cx, "llvm.dbg.cu", unit_node);
let mdval = @{node: unit_node, data: {name: crate_name}};
@ -220,7 +220,7 @@ fn create_file(cx: @crate_ctxt, full_path: str) -> @metadata<file_md> {
let file_md = [lltag(tg),
llstr(file_path),
llstr(work_dir),
unit_node];
unit_node]/~;
let val = llmdnode(file_md);
let mdval = @{node: val, data: {path: full_path}};
update_cache(cache, tg, file_metadata(mdval));
@ -268,7 +268,7 @@ fn create_block(cx: block) -> @metadata<block_md> {
lli32(start.col as int),
file_node.node,
lli32(unique_id)
];
]/~;
let val = llmdnode(lldata);
let mdval = @{node: val, data: {start: start, end: end}};
//update_cache(cache, tg, block_metadata(mdval));
@ -328,7 +328,7 @@ fn create_basic_type(cx: @crate_ctxt, t: ty::t, ty: ast::prim_ty, span: span)
lli64(align * 8), // alignment in bits
lli64(0), //XXX offset?
lli32(0), //XXX flags?
lli32(encoding)];
lli32(encoding)]/~;
let llnode = llmdnode(lldata);
let mdval = @{node: llnode, data: {hash: ty::type_id(t)}};
update_cache(cache, tg, tydesc_metadata(mdval));
@ -362,7 +362,7 @@ type struct_ctxt = {
file: ValueRef,
name: str,
line: int,
mut members: [ValueRef],
mut members: [ValueRef]/~,
mut total_size: int,
align: int
};
@ -378,7 +378,7 @@ fn create_structure(file: @metadata<file_md>, name: str, line: int)
let cx = @{file: file.node,
name: name,
line: line,
mut members: [],
mut members: []/~,
mut total_size: 0,
align: 64 //XXX different alignment per arch?
};
@ -397,7 +397,7 @@ fn create_derived_type(type_tag: int, file: ValueRef, name: str, line: int,
lli64(align),
lli64(offset),
lli32(0),
ty];
ty]/~;
ret llmdnode(lldata);
}
@ -405,11 +405,11 @@ fn add_member(cx: @struct_ctxt, name: str, line: int, size: int, align: int,
ty: ValueRef) {
cx.members += [create_derived_type(MemberTag, cx.file, name, line,
size * 8, align * 8, cx.total_size,
ty)];
ty)]/~;
cx.total_size += size * 8;
}
fn create_record(cx: @crate_ctxt, t: ty::t, fields: [ast::ty_field],
fn create_record(cx: @crate_ctxt, t: ty::t, fields: [ast::ty_field]/~,
span: span) -> @metadata<tydesc_md> {
let fname = filename_from_span(cx, span);
let file_node = create_file(cx, fname);
@ -461,7 +461,7 @@ fn create_boxed_type(cx: @crate_ctxt, outer: ty::t, _inner: ty::t,
fn create_composite_type(type_tag: int, name: str, file: ValueRef, line: int,
size: int, align: int, offset: int,
derived: option<ValueRef>,
members: option<[ValueRef]>)
members: option<[ValueRef]/~>)
-> ValueRef {
let lldata = [lltag(type_tag),
file,
@ -484,7 +484,7 @@ fn create_composite_type(type_tag: int, name: str, file: ValueRef, line: int,
},
lli32(0), // runtime language
llnull()
];
]/~;
ret llmdnode(lldata);
}
@ -501,12 +501,12 @@ fn create_vec(cx: @crate_ctxt, vec_t: ty::t, elem_t: ty::t,
sys::min_align_of::<libc::size_t>() as int, size_t_type.node);
add_member(scx, "alloc", 0, sys::size_of::<libc::size_t>() as int,
sys::min_align_of::<libc::size_t>() as int, size_t_type.node);
let subrange = llmdnode([lltag(SubrangeTag), lli64(0), lli64(0)]);
let subrange = llmdnode([lltag(SubrangeTag), lli64(0), lli64(0)]/~);
let (arr_size, arr_align) = size_and_align_of(cx, elem_t);
let data_ptr = create_composite_type(ArrayTypeTag, "", file_node.node, 0,
arr_size, arr_align, 0,
option::some(elem_ty_md.node),
option::some([subrange]));
option::some([subrange]/~));
add_member(scx, "data", 0, 0, // clang says the size should be 0
sys::min_align_of::<u8>() as int, data_ptr);
let llnode = finish_structure(scx);
@ -548,12 +548,12 @@ fn create_ty(_cx: @crate_ctxt, _t: ty::t, _ty: @ast::ty)
ty::ty_uniq(mt) { ast::ty_uniq({ty: t_to_ty(cx, mt.ty, span),
mutbl: mt.mutbl}) }
ty::ty_rec(fields) {
let fs = [];
let fs = []/~;
for field in fields {
fs += [{node: {ident: field.ident,
mt: {ty: t_to_ty(cx, field.mt.ty, span),
mutbl: field.mt.mutbl}},
span: span}];
span: span}]/~;
}
ast::ty_rec(fs)
}
@ -630,7 +630,7 @@ fn create_var(type_tag: int, context: ValueRef, name: str, file: ValueRef,
lli32(line),
ret_ty,
lli32(0)
];
]/~;
ret llmdnode(lldata);
}
@ -678,7 +678,7 @@ fn create_local_var(bcx: block, local: @ast::local)
}
}
};
let declargs = [llmdnode([llptr]), mdnode];
let declargs = [llmdnode([llptr]/~), mdnode]/~;
trans::build::Call(bcx, cx.intrinsics.get("llvm.dbg.declare"),
declargs);
ret mdval;
@ -709,7 +709,7 @@ fn create_arg(bcx: block, arg: ast::arg, sp: span)
let llptr = alt fcx.llargs.get(arg.id) {
local_mem(v) | local_imm(v) { v }
};
let declargs = [llmdnode([llptr]), mdnode];
let declargs = [llmdnode([llptr]/~), mdnode]/~;
trans::build::Call(bcx, cx.intrinsics.get("llvm.dbg.declare"),
declargs);
ret mdval;
@ -725,7 +725,7 @@ fn update_source_pos(cx: block, s: span) {
let scopedata = [lli32(loc.line as int),
lli32(loc.col as int),
blockmd.node,
llnull()];
llnull()]/~;
let dbgscope = llmdnode(scopedata);
llvm::LLVMSetCurrentDebugLocation(trans::build::B(cx), dbgscope);
}
@ -796,7 +796,7 @@ fn create_function(fcx: fn_ctxt) -> @metadata<subprogram_md> {
};
let sub_node = create_composite_type(SubroutineTag, "", file_node, 0, 0,
0, 0, option::none,
option::some([ty_node]));
option::some([ty_node]/~));
let fn_metadata = [lltag(SubprogramTag),
llunused(),
@ -818,7 +818,7 @@ fn create_function(fcx: fn_ctxt) -> @metadata<subprogram_md> {
//list of template params
//func decl descriptor
//list of func vars
];
]/~;
let val = llmdnode(fn_metadata);
add_named_metadata(cx, "llvm.dbg.sp", val);
let mdval = @{node: val, data: {id: id}};

31
src/rustc/middle/trans/impl.rs
View file

@ -16,14 +16,14 @@ import lib::llvm::llvm::LLVMGetParam;
import std::map::hashmap;
fn trans_impl(ccx: @crate_ctxt, path: path, name: ast::ident,
methods: [@ast::method], tps: [ast::ty_param]) {
methods: [@ast::method]/~, tps: [ast::ty_param]/~) {
let _icx = ccx.insn_ctxt("impl::trans_impl");
if tps.len() > 0u { ret; }
let sub_path = path + [path_name(name)];
let sub_path = path + [path_name(name)]/~;
for vec::each(methods) {|m|
if m.tps.len() == 0u {
let llfn = get_item_val(ccx, m.id);
trans_fn(ccx, sub_path + [path_name(m.ident)], m.decl, m.body,
trans_fn(ccx, sub_path + [path_name(m.ident)]/~, m.decl, m.body,
llfn, impl_self(ty::node_id_to_type(ccx.tcx, m.self_id)),
none, m.id);
}
@ -34,14 +34,14 @@ fn trans_self_arg(bcx: block, base: @ast::expr, derefs: uint) -> result {
let _icx = bcx.insn_ctxt("impl::trans_self_arg");
let basety = expr_ty(bcx, base);
let m_by_ref = ast::expl(ast::by_ref);
let mut temp_cleanups = [];
let mut temp_cleanups = []/~;
let result = trans_arg_expr(bcx, {mode: m_by_ref, ty: basety},
T_ptr(type_of::type_of(bcx.ccx(), basety)),
base, temp_cleanups, none, derefs);
// by-ref self argument should not require cleanup in the case of
// other arguments failing:
assert temp_cleanups == [];
assert temp_cleanups == []/~;
ret result;
}
@ -73,7 +73,8 @@ fn trans_method_callee(bcx: block, callee_id: ast::node_id,
}
}
fn method_from_methods(ms: [@ast::method], name: ast::ident) -> ast::def_id {
fn method_from_methods(ms: [@ast::method]/~, name: ast::ident)
-> ast::def_id {
local_def(option::get(vec::find(ms, {|m| m.ident == name})).id)
}
@ -147,16 +148,16 @@ fn trans_iface_callee(bcx: block, val: ValueRef,
-> lval_maybe_callee {
let _icx = bcx.insn_ctxt("impl::trans_iface_callee");
let ccx = bcx.ccx();
let vtable = Load(bcx, PointerCast(bcx, GEPi(bcx, val, [0u, 0u]),
let vtable = Load(bcx, PointerCast(bcx, GEPi(bcx, val, [0u, 0u]/~),
T_ptr(T_ptr(T_vtable()))));
let box = Load(bcx, GEPi(bcx, val, [0u, 1u]));
// FIXME[impl] I doubt this is alignment-safe (#2534)
let self = GEPi(bcx, box, [0u, abi::box_field_body]);
let box = Load(bcx, GEPi(bcx, val, [0u, 1u]/~));
// FIXME[impl]/~ I doubt this is alignment-safe (#2534)
let self = GEPi(bcx, box, [0u, abi::box_field_body]/~);
let env = self_env(self, ty::mk_opaque_box(bcx.tcx()), some(box));
let llfty = type_of::type_of_fn_from_ty(ccx, callee_ty);
let vtable = PointerCast(bcx, vtable,
T_ptr(T_array(T_ptr(llfty), n_method + 1u)));
let mptr = Load(bcx, GEPi(bcx, vtable, [0u, n_method]));
let mptr = Load(bcx, GEPi(bcx, vtable, [0u, n_method]/~));
{bcx: bcx, val: mptr, kind: owned, env: env}
}
@ -234,7 +235,7 @@ fn get_vtable(ccx: @crate_ctxt, origin: typeck::vtable_origin)
}
}
fn make_vtable(ccx: @crate_ctxt, ptrs: [ValueRef]) -> ValueRef {
fn make_vtable(ccx: @crate_ctxt, ptrs: [ValueRef]/~) -> ValueRef {
let _icx = ccx.insn_ctxt("impl::make_vtable");
let tbl = C_struct(ptrs);
let vt_gvar = str::as_c_str(ccx.names("vtable"), {|buf|
@ -246,7 +247,7 @@ fn make_vtable(ccx: @crate_ctxt, ptrs: [ValueRef]) -> ValueRef {
vt_gvar
}
fn make_impl_vtable(ccx: @crate_ctxt, impl_id: ast::def_id, substs: [ty::t],
fn make_impl_vtable(ccx: @crate_ctxt, impl_id: ast::def_id, substs: [ty::t]/~,
vtables: typeck::vtable_res) -> ValueRef {
let _icx = ccx.insn_ctxt("impl::make_impl_vtable");
let tcx = ccx.tcx;
@ -288,12 +289,12 @@ fn trans_cast(bcx: block, val: @ast::expr, id: ast::node_id, dest: dest)
let bcx = trans_expr_save_in(bcx, val, body);
revoke_clean(bcx, box);
let result = get_dest_addr(dest);
Store(bcx, box, PointerCast(bcx, GEPi(bcx, result, [0u, 1u]),
Store(bcx, box, PointerCast(bcx, GEPi(bcx, result, [0u, 1u]/~),
T_ptr(val_ty(box))));
let orig = ccx.maps.vtable_map.get(id)[0];
let orig = resolve_vtable_in_fn_ctxt(bcx.fcx, orig);
let vtable = get_vtable(bcx.ccx(), orig);
Store(bcx, vtable, PointerCast(bcx, GEPi(bcx, result, [0u, 0u]),
Store(bcx, vtable, PointerCast(bcx, GEPi(bcx, result, [0u, 0u]/~),
T_ptr(val_ty(vtable))));
bcx
}

150
src/rustc/middle/trans/native.rs
View file

@ -44,7 +44,7 @@ fn is_sse(++c: x86_64_reg_class) -> bool {
};
}
fn is_ymm(cls: [x86_64_reg_class]) -> bool {
fn is_ymm(cls: [x86_64_reg_class]/~) -> bool {
let len = vec::len(cls);
ret (len > 2u &&
is_sse(cls[0]) &&
@ -56,13 +56,13 @@ fn is_ymm(cls: [x86_64_reg_class]) -> bool {
cls[3] == sseup_class);
}
fn classify_ty(ty: TypeRef) -> [x86_64_reg_class] {
fn classify_ty(ty: TypeRef) -> [x86_64_reg_class]/~ {
fn align(off: uint, ty: TypeRef) -> uint {
let a = ty_align(ty);
ret (off + a - 1u) / a * a;
}
fn struct_tys(ty: TypeRef) -> [TypeRef] {
fn struct_tys(ty: TypeRef) -> [TypeRef]/~ {
let n = llvm::LLVMCountStructElementTypes(ty);
let elts = vec::from_elem(n as uint, ptr::null());
vec::as_buf(elts) {|buf|
@ -119,13 +119,13 @@ fn classify_ty(ty: TypeRef) -> [x86_64_reg_class] {
};
}
fn all_mem(cls: [mut x86_64_reg_class]) {
fn all_mem(cls: [mut x86_64_reg_class]/~) {
for uint::range(0u, cls.len()) { |i|
cls[i] = memory_class;
}
}
fn unify(cls: [mut x86_64_reg_class],
fn unify(cls: [mut x86_64_reg_class]/~,
i: uint,
newv: x86_64_reg_class) {
if cls[i] == newv {
@ -150,8 +150,8 @@ fn classify_ty(ty: TypeRef) -> [x86_64_reg_class] {
}
}
fn classify_struct(tys: [TypeRef],
cls: [mut x86_64_reg_class], i: uint,
fn classify_struct(tys: [TypeRef]/~,
cls: [mut x86_64_reg_class]/~, i: uint,
off: uint) {
if vec::is_empty(tys) {
classify(T_i64(), cls, i, off);
@ -166,7 +166,7 @@ fn classify_ty(ty: TypeRef) -> [x86_64_reg_class] {
}
fn classify(ty: TypeRef,
cls: [mut x86_64_reg_class], ix: uint,
cls: [mut x86_64_reg_class]/~, ix: uint,
off: uint) {
let t_align = ty_align(ty);
let t_size = ty_size(ty);
@ -216,7 +216,7 @@ fn classify_ty(ty: TypeRef) -> [x86_64_reg_class] {
}
}
fn fixup(ty: TypeRef, cls: [mut x86_64_reg_class]) {
fn fixup(ty: TypeRef, cls: [mut x86_64_reg_class]/~) {
let mut i = 0u;
let llty = llvm::LLVMGetTypeKind(ty) as int;
let e = vec::len(cls);
@ -274,8 +274,8 @@ fn classify_ty(ty: TypeRef) -> [x86_64_reg_class] {
ret vec::from_mut(cls);
}
fn llreg_ty(cls: [x86_64_reg_class]) -> TypeRef {
fn llvec_len(cls: [x86_64_reg_class]) -> uint {
fn llreg_ty(cls: [x86_64_reg_class]/~) -> TypeRef {
fn llvec_len(cls: [x86_64_reg_class]/~) -> uint {
let mut len = 1u;
for vec::each(cls) {|c|
if c != sseup_class {
@ -286,27 +286,27 @@ fn llreg_ty(cls: [x86_64_reg_class]) -> TypeRef {
ret len;
}
let mut tys = [];
let mut tys = []/~;
let mut i = 0u;
let e = vec::len(cls);
while i < e {
alt cls[i] {
integer_class {
tys += [T_i64()];
tys += [T_i64()]/~;
}
sse_fv_class {
let vec_len = llvec_len(vec::tailn(cls, i + 1u)) * 2u;
let vec_ty = llvm::LLVMVectorType(T_f32(),
vec_len as c_uint);
tys += [vec_ty];
tys += [vec_ty]/~;
i += vec_len;
cont;
}
sse_fs_class {
tys += [T_f32()];
tys += [T_f32()]/~;
}
sse_ds_class {
tys += [T_f64()];
tys += [T_f64()]/~;
}
_ {
fail "llregtype: unhandled class";
@ -323,13 +323,13 @@ type x86_64_llty = {
};
type x86_64_tys = {
arg_tys: [x86_64_llty],
arg_tys: [x86_64_llty]/~,
ret_ty: x86_64_llty,
attrs: [option<Attribute>],
attrs: [option<Attribute>]/~,
sret: bool
};
fn x86_64_tys(atys: [TypeRef],
fn x86_64_tys(atys: [TypeRef]/~,
rty: TypeRef,
ret_def: bool) -> x86_64_tys {
fn is_reg_ty(ty: TypeRef) -> bool {
@ -342,18 +342,18 @@ fn x86_64_tys(atys: [TypeRef],
};
}
fn is_pass_byval(cls: [x86_64_reg_class]) -> bool {
fn is_pass_byval(cls: [x86_64_reg_class]/~) -> bool {
ret cls[0] == memory_class ||
cls[0] == x87_class ||
cls[0] == complex_x87_class;
}
fn is_ret_bysret(cls: [x86_64_reg_class]) -> bool {
fn is_ret_bysret(cls: [x86_64_reg_class]/~) -> bool {
ret cls[0] == memory_class;
}
fn x86_64_ty(ty: TypeRef,
is_mem_cls: fn(cls: [x86_64_reg_class]) -> bool,
is_mem_cls: fn(cls: [x86_64_reg_class]/~) -> bool,
attr: Attribute) -> (x86_64_llty, option<Attribute>) {
let mut cast = false;
let mut ty_attr = option::none;
@ -371,22 +371,22 @@ fn x86_64_tys(atys: [TypeRef],
ret ({ cast: cast, ty: llty }, ty_attr);
}
let mut arg_tys = [];
let mut attrs = [];
let mut arg_tys = []/~;
let mut attrs = []/~;
for vec::each(atys) {|t|
let (ty, attr) = x86_64_ty(t, is_pass_byval, ByValAttribute);
arg_tys += [ty];
attrs += [attr];
arg_tys += [ty]/~;
attrs += [attr]/~;
}
let mut (ret_ty, ret_attr) = x86_64_ty(rty, is_ret_bysret,
StructRetAttribute);
let sret = option::is_some(ret_attr);
if sret {
arg_tys = [ret_ty] + arg_tys;
arg_tys = [ret_ty]/~ + arg_tys;
ret_ty = { cast: false,
ty: T_void()
};
attrs = [ret_attr] + attrs;
attrs = [ret_attr]/~ + attrs;
} else if !ret_def {
ret_ty = { cast: false,
ty: T_void()
@ -427,7 +427,7 @@ fn link_name(i: @ast::native_item) -> str {
}
type c_stack_tys = {
arg_tys: [TypeRef],
arg_tys: [TypeRef]/~,
ret_ty: TypeRef,
ret_def: bool,
bundle_ty: TypeRef,
@ -436,7 +436,7 @@ type c_stack_tys = {
};
fn c_arg_and_ret_lltys(ccx: @crate_ctxt,
id: ast::node_id) -> ([TypeRef], TypeRef, ty::t) {
id: ast::node_id) -> ([TypeRef]/~, TypeRef, ty::t) {
alt ty::get(ty::node_id_to_type(ccx.tcx, id)).struct {
ty::ty_fn({inputs: arg_tys, output: ret_ty, _}) {
let llargtys = type_of_explicit_args(ccx, arg_tys);
@ -450,7 +450,7 @@ fn c_arg_and_ret_lltys(ccx: @crate_ctxt,
fn c_stack_tys(ccx: @crate_ctxt,
id: ast::node_id) -> @c_stack_tys {
let (llargtys, llretty, ret_ty) = c_arg_and_ret_lltys(ccx, id);
let bundle_ty = T_struct(llargtys + [T_ptr(llretty)]);
let bundle_ty = T_struct(llargtys + [T_ptr(llretty)]/~);
let ret_def = !ty::type_is_bot(ret_ty) && !ty::type_is_nil(ret_ty);
let x86_64 = if ccx.sess.targ_cfg.arch == arch_x86_64 {
option::some(x86_64_tys(llargtys, llretty, ret_def))
@ -462,13 +462,13 @@ fn c_stack_tys(ccx: @crate_ctxt,
ret_ty: llretty,
ret_def: ret_def,
bundle_ty: bundle_ty,
shim_fn_ty: T_fn([T_ptr(bundle_ty)], T_void()),
shim_fn_ty: T_fn([T_ptr(bundle_ty)]/~, T_void()),
x86_64_tys: x86_64
};
}
type shim_arg_builder = fn(bcx: block, tys: @c_stack_tys,
llargbundle: ValueRef) -> [ValueRef];
llargbundle: ValueRef) -> [ValueRef]/~;
type shim_ret_builder = fn(bcx: block, tys: @c_stack_tys,
llargbundle: ValueRef, llretval: ValueRef);
@ -485,7 +485,7 @@ fn build_shim_fn_(ccx: @crate_ctxt,
ccx.llmod, shim_name, tys.shim_fn_ty);
// Declare the body of the shim function:
let fcx = new_fn_ctxt(ccx, [], llshimfn, none);
let fcx = new_fn_ctxt(ccx, []/~, llshimfn, none);
let bcx = top_scope_block(fcx, none);
let lltop = bcx.llbb;
let llargbundle = get_param(llshimfn, 0u);
@ -519,7 +519,7 @@ fn build_wrap_fn_(ccx: @crate_ctxt,
ret_builder: wrap_ret_builder) {
let _icx = ccx.insn_ctxt("native::build_wrap_fn_");
let fcx = new_fn_ctxt(ccx, [], llwrapfn, none);
let fcx = new_fn_ctxt(ccx, []/~, llwrapfn, none);
let bcx = top_scope_block(fcx, none);
let lltop = bcx.llbb;
@ -530,7 +530,7 @@ fn build_wrap_fn_(ccx: @crate_ctxt,
// Create call itself.
let llshimfnptr = PointerCast(bcx, llshimfn, T_ptr(T_i8()));
let llrawargbundle = PointerCast(bcx, llargbundle, T_ptr(T_i8()));
Call(bcx, shim_upcall, [llrawargbundle, llshimfnptr]);
Call(bcx, shim_upcall, [llrawargbundle, llshimfnptr]/~);
ret_builder(bcx, tys, llargbundle);
tie_up_header_blocks(fcx, lltop);
@ -588,9 +588,9 @@ fn trans_native_mod(ccx: @crate_ctxt,
let _icx = ccx.insn_ctxt("native::build_shim_fn");
fn build_args(bcx: block, tys: @c_stack_tys,
llargbundle: ValueRef) -> [ValueRef] {
llargbundle: ValueRef) -> [ValueRef]/~ {
let _icx = bcx.insn_ctxt("native::shim::build_args");
let mut llargvals = [];
let mut llargvals = []/~;
let mut i = 0u;
let n = vec::len(tys.arg_tys);
@ -599,33 +599,33 @@ fn trans_native_mod(ccx: @crate_ctxt,
let mut atys = x86_64.arg_tys;
let mut attrs = x86_64.attrs;
if x86_64.sret {
let llretptr = GEPi(bcx, llargbundle, [0u, n]);
let llretptr = GEPi(bcx, llargbundle, [0u, n]/~);
let llretloc = Load(bcx, llretptr);
llargvals = [llretloc];
llargvals = [llretloc]/~;
atys = vec::tail(atys);
attrs = vec::tail(attrs);
}
while i < n {
let llargval = if atys[i].cast {
let arg_ptr = GEPi(bcx, llargbundle,
[0u, i]);
[0u, i]/~);
let arg_ptr = BitCast(bcx, arg_ptr,
T_ptr(atys[i].ty));
Load(bcx, arg_ptr)
} else if option::is_some(attrs[i]) {
GEPi(bcx, llargbundle, [0u, i])
GEPi(bcx, llargbundle, [0u, i]/~)
} else {
load_inbounds(bcx, llargbundle, [0u, i])
load_inbounds(bcx, llargbundle, [0u, i]/~)
};
llargvals += [llargval];
llargvals += [llargval]/~;
i += 1u;
}
}
_ {
while i < n {
let llargval = load_inbounds(bcx, llargbundle,
[0u, i]);
llargvals += [llargval];
[0u, i]/~);
llargvals += [llargval]/~;
i += 1u;
}
}
@ -652,7 +652,7 @@ fn trans_native_mod(ccx: @crate_ctxt,
ret;
}
let n = vec::len(tys.arg_tys);
let llretptr = GEPi(bcx, llargbundle, [0u, n]);
let llretptr = GEPi(bcx, llargbundle, [0u, n]/~);
let llretloc = Load(bcx, llretptr);
if x86_64.ret_ty.cast {
let tmp_ptr = BitCast(bcx, llretloc,
@ -666,7 +666,7 @@ fn trans_native_mod(ccx: @crate_ctxt,
if tys.ret_def {
let n = vec::len(tys.arg_tys);
// R** llretptr = &args->r;
let llretptr = GEPi(bcx, llargbundle, [0u, n]);
let llretptr = GEPi(bcx, llargbundle, [0u, n]/~);
// R* llretloc = *llretptr; /* (args->r) */
let llretloc = Load(bcx, llretptr);
// *args->r = r;
@ -705,7 +705,7 @@ fn trans_native_mod(ccx: @crate_ctxt,
fn build_direct_fn(ccx: @crate_ctxt, decl: ValueRef,
item: @ast::native_item, tys: @c_stack_tys,
cc: lib::llvm::CallConv) {
let fcx = new_fn_ctxt(ccx, [], decl, none);
let fcx = new_fn_ctxt(ccx, []/~, decl, none);
let bcx = top_scope_block(fcx, none), lltop = bcx.llbb;
let llbasefn = base_fn(ccx, link_name(item), tys, cc);
let ty = ty::lookup_item_type(ccx.tcx,
@ -736,11 +736,11 @@ fn trans_native_mod(ccx: @crate_ctxt,
let implicit_args = first_real_arg; // ret + env
while i < n {
let llargval = get_param(llwrapfn, i + implicit_args);
store_inbounds(bcx, llargval, llargbundle, [0u, i]);
store_inbounds(bcx, llargval, llargbundle, [0u, i]/~);
i += 1u;
}
let llretptr = get_param(llwrapfn, 0u);
store_inbounds(bcx, llretptr, llargbundle, [0u, n]);
store_inbounds(bcx, llretptr, llargbundle, [0u, n]/~);
}
fn build_ret(bcx: block, _tys: @c_stack_tys,
@ -786,9 +786,9 @@ fn trans_native_mod(ccx: @crate_ctxt,
}
};
let psubsts = {
tys: [],
tys: []/~,
vtables: none,
bounds: @[]
bounds: @[]/~
};
trans_intrinsic(ccx, llwrapfn, native_item,
*path, psubsts, none);
@ -894,7 +894,7 @@ fn trans_intrinsic(ccx: @crate_ctxt, decl: ValueRef, item: @ast::native_item,
}
"frame_address" {
let frameaddress = ccx.intrinsics.get("llvm.frameaddress");
let frameaddress_val = Call(bcx, frameaddress, [C_i32(0i32)]);
let frameaddress_val = Call(bcx, frameaddress, [C_i32(0i32)]/~);
let fty = ty::mk_fn(bcx.tcx(), {
purity: ast::impure_fn,
proto: ast::proto_any,
@ -903,10 +903,10 @@ fn trans_intrinsic(ccx: @crate_ctxt, decl: ValueRef, item: @ast::native_item,
ty: ty::mk_imm_ptr(
bcx.tcx(),
ty::mk_mach_uint(bcx.tcx(), ast::ty_u8))
}],
}]/~,
output: ty::mk_nil(bcx.tcx()),
ret_style: ast::return_val,
constraints: []
constraints: []/~
});
bcx = trans_call_inner(bcx, none, fty, ty::mk_nil(bcx.tcx()),
{ |bcx|
@ -915,7 +915,7 @@ fn trans_intrinsic(ccx: @crate_ctxt, decl: ValueRef, item: @ast::native_item,
get_param(decl, first_real_arg),
temporary)
},
arg_vals([frameaddress_val]), ignore);
arg_vals([frameaddress_val]/~), ignore);
}
}
build_return(bcx);
@ -933,7 +933,7 @@ fn trans_crust_fn(ccx: @crate_ctxt, path: ast_map::path, decl: ast::fn_decl,
let _icx = ccx.insn_ctxt("native::crust::build_rust_fn");
let t = ty::node_id_to_type(ccx.tcx, id);
let ps = link::mangle_internal_name_by_path(
ccx, path + [ast_map::path_name(@"__rust_abi")]);
ccx, path + [ast_map::path_name(@"__rust_abi")]/~);
let llty = type_of_fn_from_ty(ccx, t);
let llfndecl = decl_internal_cdecl_fn(ccx.llmod, ps, llty);
trans_fn(ccx, path, decl, body, llfndecl, no_self, none, id);
@ -946,18 +946,18 @@ fn trans_crust_fn(ccx: @crate_ctxt, path: ast_map::path, decl: ast::fn_decl,
let _icx = ccx.insn_ctxt("native::crust::build_shim_fn");
fn build_args(bcx: block, tys: @c_stack_tys,
llargbundle: ValueRef) -> [ValueRef] {
llargbundle: ValueRef) -> [ValueRef]/~ {
let _icx = bcx.insn_ctxt("native::crust::shim::build_args");
let mut llargvals = [];
let mut llargvals = []/~;
let mut i = 0u;
let n = vec::len(tys.arg_tys);
let llretptr = load_inbounds(bcx, llargbundle, [0u, n]);
llargvals += [llretptr];
let llretptr = load_inbounds(bcx, llargbundle, [0u, n]/~);
llargvals += [llretptr]/~;
let llenvptr = C_null(T_opaque_box_ptr(bcx.ccx()));
llargvals += [llenvptr];
llargvals += [llenvptr]/~;
while i < n {
let llargval = load_inbounds(bcx, llargbundle, [0u, i]);
llargvals += [llargval];
let llargval = load_inbounds(bcx, llargbundle, [0u, i]/~);
llargvals += [llargval]/~;
i += 1u;
}
ret llargvals;
@ -970,7 +970,7 @@ fn trans_crust_fn(ccx: @crate_ctxt, path: ast_map::path, decl: ast::fn_decl,
}
let shim_name = link::mangle_internal_name_by_path(
ccx, path + [ast_map::path_name(@"__rust_stack_shim")]);
ccx, path + [ast_map::path_name(@"__rust_stack_shim")]/~);
ret build_shim_fn_(ccx, shim_name, llrustfn, tys,
lib::llvm::CCallConv,
build_args, build_ret);
@ -1007,18 +1007,20 @@ fn trans_crust_fn(ccx: @crate_ctxt, path: ast_map::path, decl: ast::fn_decl,
let mut argval = get_param(llwrapfn, i + j);
if option::is_some(attrs[i]) {
argval = Load(bcx, argval);
store_inbounds(bcx, argval, llargbundle, [0u, i]);
store_inbounds(bcx, argval, llargbundle,
[0u, i]/~);
} else if atys[i].cast {
let argptr = GEPi(bcx, llargbundle, [0u, i]);
let argptr = GEPi(bcx, llargbundle, [0u, i]/~);
let argptr = BitCast(bcx, argptr,
T_ptr(atys[i].ty));
Store(bcx, argval, argptr);
} else {
store_inbounds(bcx, argval, llargbundle, [0u, i]);
store_inbounds(bcx, argval, llargbundle,
[0u, i]/~);
}
i += 1u;
}
store_inbounds(bcx, llretptr, llargbundle, [0u, n]);
store_inbounds(bcx, llretptr, llargbundle, [0u, n]/~);
}
_ {
let llretptr = alloca(bcx, tys.ret_ty);
@ -1026,9 +1028,9 @@ fn trans_crust_fn(ccx: @crate_ctxt, path: ast_map::path, decl: ast::fn_decl,
for uint::range(0u, n) {|i|
let llargval = get_param(llwrapfn, i);
store_inbounds(bcx, llargval, llargbundle,
[0u, i]);
[0u, i]/~);
};
store_inbounds(bcx, llretptr, llargbundle, [0u, n]);
store_inbounds(bcx, llretptr, llargbundle, [0u, n]/~);
}
}
}
@ -1043,7 +1045,7 @@ fn trans_crust_fn(ccx: @crate_ctxt, path: ast_map::path, decl: ast::fn_decl,
ret;
}
let n = vec::len(tys.arg_tys);
let llretval = load_inbounds(bcx, llargbundle, [0u, n]);
let llretval = load_inbounds(bcx, llargbundle, [0u, n]/~);
let llretval = if x86_64.ret_ty.cast {
let retptr = BitCast(bcx, llretval,
T_ptr(x86_64.ret_ty.ty));
@ -1055,7 +1057,7 @@ fn trans_crust_fn(ccx: @crate_ctxt, path: ast_map::path, decl: ast::fn_decl,
}
_ {
let n = vec::len(tys.arg_tys);
let llretval = load_inbounds(bcx, llargbundle, [0u, n]);
let llretval = load_inbounds(bcx, llargbundle, [0u, n]/~);
let llretval = Load(bcx, llretval);
Ret(bcx, llretval);
}

2
src/rustc/middle/trans/reachable.rs
View file

@ -31,7 +31,7 @@ fn find_reachable(crate_mod: _mod, exp_map: resolve::exp_map,
rmap
}
fn traverse_exports(cx: ctx, vis: [@view_item]) -> bool {
fn traverse_exports(cx: ctx, vis: [@view_item]/~) -> bool {
let mut found_export = false;
for vec::each(vis) {|vi|
alt vi.node {

68
src/rustc/middle/trans/reflect.rs
View file

@ -12,7 +12,7 @@ import util::ppaux::ty_to_str;
enum reflector = {
visitor_val: ValueRef,
visitor_methods: @[ty::method],
visitor_methods: @[ty::method]/~,
mut bcx: block
};
@ -31,15 +31,15 @@ impl methods for reflector {
do_spill_noroot(self.bcx, ss)
}
fn c_size_and_align(t: ty::t) -> [ValueRef] {
fn c_size_and_align(t: ty::t) -> [ValueRef]/~ {
let tr = type_of::type_of(self.bcx.ccx(), t);
let s = shape::llsize_of_real(self.bcx.ccx(), tr);
let a = shape::llalign_of_min(self.bcx.ccx(), tr);
ret [self.c_uint(s),
self.c_uint(a)];
self.c_uint(a)]/~;
}
fn visit(ty_name: str, args: [ValueRef]) {
fn visit(ty_name: str, args: [ValueRef]/~) {
let tcx = self.bcx.tcx();
let mth_idx = option::get(ty::method_idx(@("visit_" + ty_name),
*self.visitor_methods));
@ -69,33 +69,33 @@ impl methods for reflector {
abi::tydesc_field_visit_glue);
}
fn bracketed_t(bracket_name: str, t: ty::t, extra: [ValueRef]) {
fn bracketed_t(bracket_name: str, t: ty::t, extra: [ValueRef]/~) {
self.visit("enter_" + bracket_name, extra);
self.visit_tydesc(t);
self.visit("leave_" + bracket_name, extra);
}
fn bracketed_mt(bracket_name: str, mt: ty::mt, extra: [ValueRef]) {
fn bracketed_mt(bracket_name: str, mt: ty::mt, extra: [ValueRef]/~) {
self.bracketed_t(bracket_name, mt.ty,
[self.c_uint(mt.mutbl as uint)] + extra);
[self.c_uint(mt.mutbl as uint)]/~ + extra);
}
fn vstore_name_and_extra(t: ty::t,
vstore: ty::vstore,
f: fn(str,[ValueRef])) {
f: fn(str,[ValueRef]/~)) {
alt vstore {
ty::vstore_fixed(n) {
let extra = [self.c_uint(n)] + self.c_size_and_align(t);
let extra = [self.c_uint(n)]/~ + self.c_size_and_align(t);
f("fixed", extra)
}
ty::vstore_slice(_) { f("slice", []) }
ty::vstore_uniq { f("uniq", []);}
ty::vstore_box { f("box", []); }
ty::vstore_slice(_) { f("slice", []/~) }
ty::vstore_uniq { f("uniq", []/~);}
ty::vstore_box { f("box", []/~); }
}
}
fn leaf(name: str) {
self.visit(name, []);
self.visit(name, []/~);
}
// Entrypoint
@ -125,7 +125,7 @@ impl methods for reflector {
ty::ty_float(ast::ty_f64) { self.leaf("f64") }
ty::ty_str { self.leaf("str") }
ty::ty_vec(mt) { self.bracketed_mt("vec", mt, []) }
ty::ty_vec(mt) { self.bracketed_mt("vec", mt, []/~) }
ty::ty_estr(vst) {
self.vstore_name_and_extra(t, vst) {|name, extra|
self.visit("estr_" + name, extra)
@ -136,29 +136,29 @@ impl methods for reflector {
self.bracketed_mt("evec_" + name, mt, extra)
}
}
ty::ty_box(mt) { self.bracketed_mt("box", mt, []) }
ty::ty_uniq(mt) { self.bracketed_mt("uniq", mt, []) }
ty::ty_ptr(mt) { self.bracketed_mt("ptr", mt, []) }
ty::ty_rptr(_, mt) { self.bracketed_mt("rptr", mt, []) }
ty::ty_box(mt) { self.bracketed_mt("box", mt, []/~) }
ty::ty_uniq(mt) { self.bracketed_mt("uniq", mt, []/~) }
ty::ty_ptr(mt) { self.bracketed_mt("ptr", mt, []/~) }
ty::ty_rptr(_, mt) { self.bracketed_mt("rptr", mt, []/~) }
ty::ty_rec(fields) {
let extra = ([self.c_uint(vec::len(fields))]
let extra = ([self.c_uint(vec::len(fields))]/~
+ self.c_size_and_align(t));
self.visit("enter_rec", extra);
for fields.eachi {|i, field|
self.bracketed_mt("rec_field", field.mt,
[self.c_uint(i),
self.c_slice(*field.ident)]);
self.c_slice(*field.ident)]/~);
}
self.visit("leave_rec", extra);
}
ty::ty_tup(tys) {
let extra = ([self.c_uint(vec::len(tys))]
let extra = ([self.c_uint(vec::len(tys))]/~
+ self.c_size_and_align(t));
self.visit("enter_tup", extra);
for tys.eachi {|i, t|
self.bracketed_t("tup_field", t, [self.c_uint(i)]);
self.bracketed_t("tup_field", t, [self.c_uint(i)]/~);
}
self.visit("leave_tup", extra);
}
@ -186,7 +186,7 @@ impl methods for reflector {
let extra = [self.c_uint(pureval),
self.c_uint(protoval),
self.c_uint(vec::len(fty.inputs)),
self.c_uint(retval)];
self.c_uint(retval)]/~;
self.visit("enter_fn", extra);
for fty.inputs.eachi {|i, arg|
let modeval = alt arg.mode {
@ -203,10 +203,10 @@ impl methods for reflector {
};
self.bracketed_t("fn_input", arg.ty,
[self.c_uint(i),
self.c_uint(modeval)]);
self.c_uint(modeval)]/~);
}
self.bracketed_t("fn_output", fty.output,
[self.c_uint(retval)]);
[self.c_uint(retval)]/~);
self.visit("leave_fn", extra);
}
@ -214,14 +214,14 @@ impl methods for reflector {
let bcx = self.bcx;
let tcx = bcx.ccx().tcx;
let fields = ty::class_items_as_fields(tcx, did, substs);
let extra = ([self.c_uint(vec::len(fields))]
let extra = ([self.c_uint(vec::len(fields))]/~
+ self.c_size_and_align(t));
self.visit("enter_class", extra);
for fields.eachi {|i, field|
self.bracketed_mt("class_field", field.mt,
[self.c_uint(i),
self.c_slice(*field.ident)]);
self.c_slice(*field.ident)]/~);
}
self.visit("leave_class", extra);
}
@ -234,7 +234,7 @@ impl methods for reflector {
let bcx = self.bcx;
let tcx = bcx.ccx().tcx;
let variants = ty::substd_enum_variants(tcx, did, substs);
let extra = ([self.c_uint(vec::len(variants))]
let extra = ([self.c_uint(vec::len(variants))]/~
+ self.c_size_and_align(t));
self.visit("enter_enum", extra);
@ -242,11 +242,11 @@ impl methods for reflector {
let extra = [self.c_uint(i),
self.c_int(v.disr_val),
self.c_uint(vec::len(v.args)),
self.c_slice(*v.name)];
self.c_slice(*v.name)]/~;
self.visit("enter_enum_variant", extra);
for v.args.eachi {|j, a|
self.bracketed_t("enum_variant_field", a,
[self.c_uint(j)]);
[self.c_uint(j)]/~);
}
self.visit("leave_enum_variant", extra);
}
@ -257,20 +257,20 @@ impl methods for reflector {
ty::ty_iface(_, _) { self.leaf("iface") }
ty::ty_var(_) { self.leaf("var") }
ty::ty_var_integral(_) { self.leaf("var_integral") }
ty::ty_param(n, _) { self.visit("param", [self.c_uint(n)]) }
ty::ty_param(n, _) { self.visit("param", [self.c_uint(n)]/~) }
ty::ty_self { self.leaf("self") }
ty::ty_type { self.leaf("type") }
ty::ty_opaque_box { self.leaf("opaque_box") }
ty::ty_constr(t, _) { self.bracketed_t("constr", t, []) }
ty::ty_constr(t, _) { self.bracketed_t("constr", t, []/~) }
ty::ty_opaque_closure_ptr(ck) {
let ckval = alt ck {
ty::ck_block { 0u }
ty::ck_box { 1u }
ty::ck_uniq { 2u }
};
self.visit("closure_ptr", [self.c_uint(ckval)])
self.visit("closure_ptr", [self.c_uint(ckval)]/~)
}
ty::ty_unboxed_vec(mt) { self.bracketed_mt("vec", mt, []) }
ty::ty_unboxed_vec(mt) { self.bracketed_mt("vec", mt, []/~) }
}
}
}

149
src/rustc/middle/trans/shape.rs
View file

@ -22,11 +22,11 @@ import std::map::hashmap;
import ty_ctxt = middle::ty::ctxt;
type nominal_id = @{did: ast::def_id, parent_id: option<ast::def_id>,
tps: [ty::t]};
tps: [ty::t]/~};
fn mk_nominal_id(tcx: ty::ctxt, did: ast::def_id,
parent_id: option<ast::def_id>,
tps: [ty::t]) -> nominal_id {
tps: [ty::t]/~) -> nominal_id {
let tps_norm = tps.map { |t| ty::normalize_ty(tcx, t) };
@{did: did, parent_id: parent_id, tps: tps_norm}
}
@ -197,44 +197,46 @@ fn mk_ctxt(llmod: ModuleRef) -> ctxt {
llshapetables: llshapetables};
}
fn add_bool(&dest: [u8], val: bool) { dest += [if val { 1u8 } else { 0u8 }]; }
fn add_u16(&dest: [u8], val: u16) {
dest += [(val & 0xffu16) as u8, (val >> 8u16) as u8];
fn add_bool(&dest: [u8]/~, val: bool) {
dest += [if val { 1u8 } else { 0u8 }]/~;
}
fn add_substr(&dest: [u8], src: [u8]) {
fn add_u16(&dest: [u8]/~, val: u16) {
dest += [(val & 0xffu16) as u8, (val >> 8u16) as u8]/~;
}
fn add_substr(&dest: [u8]/~, src: [u8]/~) {
add_u16(dest, vec::len(src) as u16);
dest += src;
}
fn shape_of(ccx: @crate_ctxt, t: ty::t) -> [u8] {
fn shape_of(ccx: @crate_ctxt, t: ty::t) -> [u8]/~ {
alt ty::get(t).struct {
ty::ty_nil | ty::ty_bool | ty::ty_uint(ast::ty_u8) |
ty::ty_bot { [shape_u8] }
ty::ty_int(ast::ty_i) { [s_int(ccx.tcx)] }
ty::ty_float(ast::ty_f) { [s_float(ccx.tcx)] }
ty::ty_uint(ast::ty_u) | ty::ty_ptr(_) { [s_uint(ccx.tcx)] }
ty::ty_type { [s_tydesc(ccx.tcx)] }
ty::ty_int(ast::ty_i8) { [shape_i8] }
ty::ty_uint(ast::ty_u16) { [shape_u16] }
ty::ty_int(ast::ty_i16) { [shape_i16] }
ty::ty_uint(ast::ty_u32) { [shape_u32] }
ty::ty_int(ast::ty_i32) | ty::ty_int(ast::ty_char) { [shape_i32] }
ty::ty_uint(ast::ty_u64) { [shape_u64] }
ty::ty_int(ast::ty_i64) { [shape_i64] }
ty::ty_float(ast::ty_f32) { [shape_f32] }
ty::ty_float(ast::ty_f64) { [shape_f64] }
ty::ty_bot { [shape_u8]/~ }
ty::ty_int(ast::ty_i) { [s_int(ccx.tcx)]/~ }
ty::ty_float(ast::ty_f) { [s_float(ccx.tcx)]/~ }
ty::ty_uint(ast::ty_u) | ty::ty_ptr(_) { [s_uint(ccx.tcx)]/~ }
ty::ty_type { [s_tydesc(ccx.tcx)]/~ }
ty::ty_int(ast::ty_i8) { [shape_i8]/~ }
ty::ty_uint(ast::ty_u16) { [shape_u16]/~ }
ty::ty_int(ast::ty_i16) { [shape_i16]/~ }
ty::ty_uint(ast::ty_u32) { [shape_u32]/~ }
ty::ty_int(ast::ty_i32) | ty::ty_int(ast::ty_char) { [shape_i32]/~ }
ty::ty_uint(ast::ty_u64) { [shape_u64]/~ }
ty::ty_int(ast::ty_i64) { [shape_i64]/~ }
ty::ty_float(ast::ty_f32) { [shape_f32]/~ }
ty::ty_float(ast::ty_f64) { [shape_f64]/~ }
ty::ty_estr(ty::vstore_uniq) |
ty::ty_str {
shape_of(ccx, tvec::expand_boxed_vec_ty(ccx.tcx, t))
}
ty::ty_enum(did, substs) {
alt enum_kind(ccx, did) {
tk_unit { [s_variant_enum_t(ccx.tcx)] }
tk_enum { [s_variant_enum_t(ccx.tcx)] }
tk_unit { [s_variant_enum_t(ccx.tcx)]/~ }
tk_enum { [s_variant_enum_t(ccx.tcx)]/~ }
tk_newtype | tk_complex {
let mut s = [shape_enum], id;
let mut s = [shape_enum]/~, id;
let nom_id = mk_nominal_id(ccx.tcx, did, none, substs.tps);
alt ccx.shape_cx.tag_id_to_index.find(nom_id) {
none {
@ -257,14 +259,14 @@ fn shape_of(ccx: @crate_ctxt, t: ty::t) -> [u8] {
}
ty::ty_estr(ty::vstore_box) |
ty::ty_evec(_, ty::vstore_box) |
ty::ty_box(_) | ty::ty_opaque_box { [shape_box] }
ty::ty_box(_) | ty::ty_opaque_box { [shape_box]/~ }
ty::ty_uniq(mt) {
let mut s = [shape_uniq];
let mut s = [shape_uniq]/~;
add_substr(s, shape_of(ccx, mt.ty));
s
}
ty::ty_unboxed_vec(mt) {
let mut s = [shape_unboxed_vec];
let mut s = [shape_unboxed_vec]/~;
add_bool(s, ty::type_is_pod(ccx.tcx, mt.ty));
add_substr(s, shape_of(ccx, mt.ty));
s
@ -275,7 +277,7 @@ fn shape_of(ccx: @crate_ctxt, t: ty::t) -> [u8] {
}
ty::ty_estr(ty::vstore_fixed(n)) {
let mut s = [shape_fixedvec];
let mut s = [shape_fixedvec]/~;
let u8_t = ty::mk_mach_uint(ccx.tcx, ast::ty_u8);
assert (n + 1u) <= 0xffffu;
add_u16(s, (n + 1u) as u16);
@ -285,7 +287,7 @@ fn shape_of(ccx: @crate_ctxt, t: ty::t) -> [u8] {
}
ty::ty_evec(mt, ty::vstore_fixed(n)) {
let mut s = [shape_fixedvec];
let mut s = [shape_fixedvec]/~;
assert n <= 0xffffu;
add_u16(s, n as u16);
add_bool(s, ty::type_is_pod(ccx.tcx, mt.ty));
@ -294,7 +296,7 @@ fn shape_of(ccx: @crate_ctxt, t: ty::t) -> [u8] {
}
ty::ty_estr(ty::vstore_slice(r)) {
let mut s = [shape_slice];
let mut s = [shape_slice]/~;
let u8_t = ty::mk_mach_uint(ccx.tcx, ast::ty_u8);
add_bool(s, true); // is_pod
add_bool(s, true); // is_str
@ -303,7 +305,7 @@ fn shape_of(ccx: @crate_ctxt, t: ty::t) -> [u8] {
}
ty::ty_evec(mt, ty::vstore_slice(r)) {
let mut s = [shape_slice];
let mut s = [shape_slice]/~;
add_bool(s, ty::type_is_pod(ccx.tcx, mt.ty));
add_bool(s, false); // is_str
add_substr(s, shape_of(ccx, mt.ty));
@ -311,7 +313,7 @@ fn shape_of(ccx: @crate_ctxt, t: ty::t) -> [u8] {
}
ty::ty_rec(fields) {
let mut s = [shape_struct], sub = [];
let mut s = [shape_struct]/~, sub = []/~;
for vec::each(fields) {|f|
sub += shape_of(ccx, f.mt.ty);
}
@ -319,22 +321,22 @@ fn shape_of(ccx: @crate_ctxt, t: ty::t) -> [u8] {
s
}
ty::ty_tup(elts) {
let mut s = [shape_struct], sub = [];
let mut s = [shape_struct]/~, sub = []/~;
for vec::each(elts) {|elt|
sub += shape_of(ccx, elt);
}
add_substr(s, sub);
s
}
ty::ty_iface(_, _) { [shape_box_fn] }
ty::ty_iface(_, _) { [shape_box_fn]/~ }
ty::ty_class(did, substs) {
// same as records, unless there's a dtor
let tps = substs.tps;
let m_dtor_did = ty::ty_dtor(ccx.tcx, did);
let mut s = if option::is_some(m_dtor_did) {
[shape_res]
[shape_res]/~
}
else { [shape_struct] }, sub = [];
else { [shape_struct]/~ }, sub = []/~;
option::iter(m_dtor_did) {|dtor_did|
let ri = @{did: dtor_did, parent_id: some(did), tps: tps};
let id = interner::intern(ccx.shape_cx.resources, ri);
@ -351,19 +353,19 @@ fn shape_of(ccx: @crate_ctxt, t: ty::t) -> [u8] {
s
}
ty::ty_rptr(_, mt) {
let mut s = [shape_rptr];
let mut s = [shape_rptr]/~;
add_substr(s, shape_of(ccx, mt.ty));
s
}
ty::ty_param(*) {
ccx.tcx.sess.bug("non-monomorphized type parameter");
}
ty::ty_fn({proto: ast::proto_box, _}) { [shape_box_fn] }
ty::ty_fn({proto: ast::proto_uniq, _}) { [shape_uniq_fn] }
ty::ty_fn({proto: ast::proto_box, _}) { [shape_box_fn]/~ }
ty::ty_fn({proto: ast::proto_uniq, _}) { [shape_uniq_fn]/~ }
ty::ty_fn({proto: ast::proto_block, _}) |
ty::ty_fn({proto: ast::proto_any, _}) { [shape_stack_fn] }
ty::ty_fn({proto: ast::proto_bare, _}) { [shape_bare_fn] }
ty::ty_opaque_closure_ptr(_) { [shape_opaque_closure_ptr] }
ty::ty_fn({proto: ast::proto_any, _}) { [shape_stack_fn]/~ }
ty::ty_fn({proto: ast::proto_bare, _}) { [shape_bare_fn]/~ }
ty::ty_opaque_closure_ptr(_) { [shape_opaque_closure_ptr]/~ }
ty::ty_constr(inner_t, _) { shape_of(ccx, inner_t) }
ty::ty_var(_) | ty::ty_var_integral(_) | ty::ty_self {
ccx.sess.bug("shape_of: unexpected type struct found");
@ -371,8 +373,8 @@ fn shape_of(ccx: @crate_ctxt, t: ty::t) -> [u8] {
}
}
fn shape_of_variant(ccx: @crate_ctxt, v: ty::variant_info) -> [u8] {
let mut s = [];
fn shape_of_variant(ccx: @crate_ctxt, v: ty::variant_info) -> [u8]/~ {
let mut s = []/~;
for vec::each(v.args) {|t| s += shape_of(ccx, t); }
ret s;
}
@ -381,23 +383,23 @@ fn gen_enum_shapes(ccx: @crate_ctxt) -> ValueRef {
// Loop over all the enum variants and write their shapes into a
// data buffer. As we do this, it's possible for us to discover
// new enums, so we must do this first.
let mut data = [];
let mut offsets = [];
let mut data = []/~;
let mut offsets = []/~;
let mut i = 0u;
let mut enum_variants = [];
let mut enum_variants = []/~;
while i < ccx.shape_cx.tag_order.len() {
let {did, substs} = ccx.shape_cx.tag_order[i];
let variants = @ty::substd_enum_variants(ccx.tcx, did, substs);
vec::iter(*variants) {|v|
offsets += [vec::len(data) as u16];
offsets += [vec::len(data) as u16]/~;
let variant_shape = shape_of_variant(ccx, v);
add_substr(data, variant_shape);
let zname = str::bytes(*v.name) + [0u8];
let zname = str::bytes(*v.name) + [0u8]/~;
add_substr(data, zname);
}
enum_variants += [variants];
enum_variants += [variants]/~;
i += 1u;
}
@ -405,8 +407,8 @@ fn gen_enum_shapes(ccx: @crate_ctxt) -> ValueRef {
// info records for each enum) and the info space (which contains offsets
// to each variant shape). As we do so, build up the header.
let mut header = [];
let mut inf = [];
let mut header = []/~;
let mut inf = []/~;
let header_sz = 2u16 * ccx.shape_cx.next_tag_id;
let data_sz = vec::len(data) as u16;
@ -421,7 +423,7 @@ fn gen_enum_shapes(ccx: @crate_ctxt) -> ValueRef {
// variant. Also construct the largest-variant table for each enum, which
// contains the variants that the size-of operation needs to look at.
let mut lv_table = [];
let mut lv_table = []/~;
let mut i = 0u;
for enum_variants.each { |variants|
add_u16(inf, vec::len(*variants) as u16);
@ -445,7 +447,7 @@ fn gen_enum_shapes(ccx: @crate_ctxt) -> ValueRef {
// Write in the static size and alignment of the enum.
add_u16(inf, size_align.size);
inf += [size_align.align];
inf += [size_align.align]/~;
// Now write in the offset of each variant.
for vec::each(*variants) {|_v|
@ -467,14 +469,14 @@ fn gen_enum_shapes(ccx: @crate_ctxt) -> ValueRef {
/* tjc: Not annotating FIXMEs in this module because of #1498 */
fn largest_variants(ccx: @crate_ctxt,
variants: @[ty::variant_info]) -> [uint] {
variants: @[ty::variant_info]/~) -> [uint]/~ {
// Compute the minimum and maximum size and alignment for each
// variant.
//
// NB: We could do better here; e.g. we know that any
// variant that contains (T,T) must be as least as large as
// any variant that contains just T.
let mut ranges = [];
let mut ranges = []/~;
for vec::each(*variants) {|variant|
let mut bounded = true;
let mut min_size = 0u, min_align = 0u;
@ -493,12 +495,12 @@ fn gen_enum_shapes(ccx: @crate_ctxt) -> ValueRef {
ranges +=
[{size: {min: min_size, bounded: bounded},
align: {min: min_align, bounded: bounded}}];
align: {min: min_align, bounded: bounded}}]/~;
}
// Initialize the candidate set to contain all variants.
let mut candidates = [mut];
for vec::each(*variants) {|_v| candidates += [mut true]; }
let mut candidates = [mut]/~;
for vec::each(*variants) {|_v| candidates += [mut true]/~; }
// Do a pairwise comparison among all variants still in the
// candidate set. Throw out any variant that we know has size
@ -531,24 +533,25 @@ fn gen_enum_shapes(ccx: @crate_ctxt) -> ValueRef {
}
// Return the resulting set.
let mut result = [];
let mut result = []/~;
let mut i = 0u;
while i < vec::len(candidates) {
if candidates[i] { result += [i]; }
if candidates[i] { vec::push(result, i); }
i += 1u;
}
ret result;
}
fn compute_static_enum_size(ccx: @crate_ctxt, largest_variants: [uint],
variants: @[ty::variant_info]) -> size_align {
fn compute_static_enum_size(ccx: @crate_ctxt, largest_variants: [uint]/~,
variants: @[ty::variant_info]/~)
-> size_align {
let mut max_size = 0u16;
let mut max_align = 1u8;
for vec::each(largest_variants) {|vid|
// We increment a "virtual data pointer" to compute the size.
let mut lltys = [];
let mut lltys = []/~;
for vec::each(variants[vid].args) {|typ|
lltys += [type_of::type_of(ccx, typ)];
lltys += [type_of::type_of(ccx, typ)]/~;
}
let llty = trans::common::T_struct(lltys);
@ -574,13 +577,13 @@ fn gen_enum_shapes(ccx: @crate_ctxt) -> ValueRef {
}
fn gen_resource_shapes(ccx: @crate_ctxt) -> ValueRef {
let mut dtors = [];
let mut dtors = []/~;
let len = interner::len(ccx.shape_cx.resources);
for uint::range(0u, len) {|i|
let ri = interner::get(ccx.shape_cx.resources, i);
for ri.tps.each() {|s| assert !ty::type_has_params(s); }
option::iter(ri.parent_id) {|id|
dtors += [trans::base::get_res_dtor(ccx, ri.did, id, ri.tps)];
dtors += [trans::base::get_res_dtor(ccx, ri.did, id, ri.tps)]/~;
}
}
ret mk_global(ccx, "resource_shapes", C_struct(dtors), true);
@ -591,11 +594,11 @@ fn gen_shape_tables(ccx: @crate_ctxt) {
let llresourcestable = gen_resource_shapes(ccx);
trans::common::set_struct_body(ccx.shape_cx.llshapetablesty,
[val_ty(lltagstable),
val_ty(llresourcestable)]);
val_ty(llresourcestable)]/~);
let lltables =
C_named_struct(ccx.shape_cx.llshapetablesty,
[lltagstable, llresourcestable]);
[lltagstable, llresourcestable]/~);
lib::llvm::llvm::LLVMSetInitializer(ccx.shape_cx.llshapetables, lltables);
lib::llvm::llvm::LLVMSetGlobalConstant(ccx.shape_cx.llshapetables, True);
lib::llvm::SetLinkage(ccx.shape_cx.llshapetables,
@ -724,10 +727,10 @@ fn simplify_type(tcx: ty::ctxt, typ: ty::t) -> ty::t {
ty::ty_evec(_, ty::vstore_uniq) | ty::ty_evec(_, ty::vstore_box) |
ty::ty_estr(ty::vstore_uniq) | ty::ty_estr(ty::vstore_box) |
ty::ty_ptr(_) | ty::ty_rptr(_,_) { nilptr(tcx) }
ty::ty_fn(_) { ty::mk_tup(tcx, [nilptr(tcx), nilptr(tcx)]) }
ty::ty_fn(_) { ty::mk_tup(tcx, [nilptr(tcx), nilptr(tcx)]/~) }
ty::ty_evec(_, ty::vstore_slice(_)) |
ty::ty_estr(ty::vstore_slice(_)) {
ty::mk_tup(tcx, [nilptr(tcx), ty::mk_int(tcx)])
ty::mk_tup(tcx, [nilptr(tcx), ty::mk_int(tcx)]/~)
}
_ { typ }
}
@ -736,7 +739,7 @@ fn simplify_type(tcx: ty::ctxt, typ: ty::t) -> ty::t {
}
// Given a tag type `ty`, returns the offset of the payload.
//fn tag_payload_offs(bcx: block, tag_id: ast::def_id, tps: [ty::t])
//fn tag_payload_offs(bcx: block, tag_id: ast::def_id, tps: [ty::t]/~)
// -> ValueRef {
// alt tag_kind(tag_id) {
// tk_unit | tk_enum | tk_newtype { C_int(bcx.ccx(), 0) }

57
src/rustc/middle/trans/tvec.rs
View file

@ -36,30 +36,30 @@ fn expand_boxed_vec_ty(tcx: ty::ctxt, t: ty::t) -> ty::t {
fn get_fill(bcx: block, vptr: ValueRef) -> ValueRef {
let _icx = bcx.insn_ctxt("tvec::get_fill");
Load(bcx, GEPi(bcx, vptr, [0u, abi::vec_elt_fill]))
Load(bcx, GEPi(bcx, vptr, [0u, abi::vec_elt_fill]/~))
}
fn set_fill(bcx: block, vptr: ValueRef, fill: ValueRef) {
Store(bcx, fill, GEPi(bcx, vptr, [0u, abi::vec_elt_fill]));
Store(bcx, fill, GEPi(bcx, vptr, [0u, abi::vec_elt_fill]/~));
}
fn get_alloc(bcx: block, vptr: ValueRef) -> ValueRef {
Load(bcx, GEPi(bcx, vptr, [0u, abi::vec_elt_alloc]))
Load(bcx, GEPi(bcx, vptr, [0u, abi::vec_elt_alloc]/~))
}
fn get_bodyptr(bcx: block, vptr: ValueRef) -> ValueRef {
non_gc_box_cast(bcx, GEPi(bcx, vptr, [0u, abi::box_field_body]))
non_gc_box_cast(bcx, GEPi(bcx, vptr, [0u, abi::box_field_body]/~))
}
fn get_dataptr(bcx: block, vptr: ValueRef)
-> ValueRef {
let _icx = bcx.insn_ctxt("tvec::get_dataptr");
GEPi(bcx, vptr, [0u, abi::vec_elt_elems, 0u])
GEPi(bcx, vptr, [0u, abi::vec_elt_elems, 0u]/~)
}
fn pointer_add(bcx: block, ptr: ValueRef, bytes: ValueRef) -> ValueRef {
let _icx = bcx.insn_ctxt("tvec::pointer_add");
let old_ty = val_ty(ptr);
let bptr = PointerCast(bcx, ptr, T_ptr(T_i8()));
ret PointerCast(bcx, InBoundsGEP(bcx, bptr, [bytes]), old_ty);
ret PointerCast(bcx, InBoundsGEP(bcx, bptr, [bytes]/~), old_ty);
}
fn alloc_raw(bcx: block, unit_ty: ty::t,
@ -71,8 +71,8 @@ fn alloc_raw(bcx: block, unit_ty: ty::t,
let vecsize = Add(bcx, alloc, llsize_of(ccx, ccx.opaque_vec_type));
let {box, body} = base::malloc_general_dyn(bcx, vecbodyty, heap, vecsize);
Store(bcx, fill, GEPi(bcx, body, [0u, abi::vec_elt_fill]));
Store(bcx, alloc, GEPi(bcx, body, [0u, abi::vec_elt_alloc]));
Store(bcx, fill, GEPi(bcx, body, [0u, abi::vec_elt_fill]/~));
Store(bcx, alloc, GEPi(bcx, body, [0u, abi::vec_elt_alloc]/~));
ret {bcx: bcx, val: box};
}
fn alloc_uniq_raw(bcx: block, unit_ty: ty::t,
@ -119,7 +119,7 @@ fn make_drop_glue_unboxed(bcx: block, vptr: ValueRef, vec_ty: ty::t) ->
} else { bcx }
}
fn trans_evec(bcx: block, args: [@ast::expr],
fn trans_evec(bcx: block, args: [@ast::expr]/~,
vst: ast::vstore, id: ast::node_id, dest: dest) -> block {
let _icx = bcx.insn_ctxt("tvec::trans_evec");
let ccx = bcx.ccx();
@ -158,9 +158,9 @@ fn trans_evec(bcx: block, args: [@ast::expr],
let len = Mul(bcx, n, unit_sz);
let p = base::alloca(bcx, T_struct([T_ptr(llunitty),
ccx.int_type]));
Store(bcx, vp, GEPi(bcx, p, [0u, abi::slice_elt_base]));
Store(bcx, len, GEPi(bcx, p, [0u, abi::slice_elt_len]));
ccx.int_type]/~));
Store(bcx, vp, GEPi(bcx, p, [0u, abi::slice_elt_base]/~));
Store(bcx, len, GEPi(bcx, p, [0u, abi::slice_elt_len]/~));
{bcx: bcx, val: p, dataptr: vp}
}
@ -182,12 +182,12 @@ fn trans_evec(bcx: block, args: [@ast::expr],
// Store the individual elements.
let mut i = 0u, temp_cleanups = [val];
let mut i = 0u, temp_cleanups = [val]/~;
#debug("trans_evec: v: %s, dataptr: %s",
val_str(ccx.tn, val),
val_str(ccx.tn, dataptr));
for vec::each(args) {|e|
let lleltptr = InBoundsGEP(bcx, dataptr, [C_uint(ccx, i)]);
let lleltptr = InBoundsGEP(bcx, dataptr, [C_uint(ccx, i)]/~);
bcx = base::trans_expr_save_in(bcx, e, lleltptr);
add_clean_temp_mem(bcx, lleltptr, unit_ty);
vec::push(temp_cleanups, lleltptr);
@ -242,14 +242,14 @@ fn get_base_and_len(cx: block, v: ValueRef, e_ty: ty::t)
alt vstore {
ty::vstore_fixed(n) {
let base = GEPi(cx, v, [0u, 0u]);
let base = GEPi(cx, v, [0u, 0u]/~);
let n = if ty::type_is_str(e_ty) { n + 1u } else { n };
let len = Mul(cx, C_uint(ccx, n), unit_sz);
(base, len)
}
ty::vstore_slice(_) {
let base = Load(cx, GEPi(cx, v, [0u, abi::slice_elt_base]));
let len = Load(cx, GEPi(cx, v, [0u, abi::slice_elt_len]));
let base = Load(cx, GEPi(cx, v, [0u, abi::slice_elt_base]/~));
let len = Load(cx, GEPi(cx, v, [0u, abi::slice_elt_len]/~));
(base, len)
}
ty::vstore_uniq | ty::vstore_box {
@ -268,7 +268,7 @@ fn trans_estr(bcx: block, s: @str, vstore: ast::vstore,
let c = alt vstore {
ast::vstore_fixed(_)
{
// "hello"/_ => "hello"/5 => [i8 x 6] in llvm
// "hello"/_ => "hello"/5 => [i8 x 6]/~ in llvm
#debug("trans_estr: fixed: %s", *s);
C_postr(*s)
}
@ -282,7 +282,7 @@ fn trans_estr(bcx: block, s: @str, vstore: ast::vstore,
ast::vstore_uniq {
let cs = PointerCast(bcx, C_cstr(ccx, *s), T_ptr(T_i8()));
let len = C_uint(ccx, str::len(*s));
let c = Call(bcx, ccx.upcalls.str_new_uniq, [cs, len]);
let c = Call(bcx, ccx.upcalls.str_new_uniq, [cs, len]/~);
PointerCast(bcx, c,
T_unique_ptr(T_unique(ccx, T_vec(ccx, T_i8()))))
}
@ -290,7 +290,7 @@ fn trans_estr(bcx: block, s: @str, vstore: ast::vstore,
ast::vstore_box {
let cs = PointerCast(bcx, C_cstr(ccx, *s), T_ptr(T_i8()));
let len = C_uint(ccx, str::len(*s));
let c = Call(bcx, ccx.upcalls.str_new_shared, [cs, len]);
let c = Call(bcx, ccx.upcalls.str_new_shared, [cs, len]/~);
PointerCast(bcx, c,
T_box_ptr(T_box(ccx, T_vec(ccx, T_i8()))))
}
@ -317,7 +317,7 @@ fn trans_append(bcx: block, vec_ty: ty::t, lhsptr: ValueRef,
let opaque_lhs = PointerCast(bcx, lhsptr,
T_ptr(T_ptr(T_i8())));
Call(bcx, ccx.upcalls.vec_grow,
[opaque_lhs, new_fill]);
[opaque_lhs, new_fill]/~);
// Was overwritten if we resized
let lhs = Load(bcx, lhsptr);
let rhs = Select(bcx, self_append, lhs, rhs);
@ -333,14 +333,14 @@ fn trans_append(bcx: block, vec_ty: ty::t, lhsptr: ValueRef,
let write_ptr = Load(bcx, write_ptr_ptr);
let bcx = copy_val(bcx, INIT, write_ptr,
load_if_immediate(bcx, addr, unit_ty), unit_ty);
Store(bcx, InBoundsGEP(bcx, write_ptr, [C_int(ccx, 1)]),
Store(bcx, InBoundsGEP(bcx, write_ptr, [C_int(ccx, 1)]/~),
write_ptr_ptr);
bcx
})
}
fn trans_append_literal(bcx: block, vptrptr: ValueRef, vec_ty: ty::t,
vals: [@ast::expr]) -> block {
vals: [@ast::expr]/~) -> block {
let _icx = bcx.insn_ctxt("tvec::trans_append_literal");
let mut bcx = bcx, ccx = bcx.ccx();
let elt_ty = ty::sequence_element_type(bcx.tcx(), vec_ty);
@ -357,7 +357,7 @@ fn trans_append_literal(bcx: block, vptrptr: ValueRef, vec_ty: ty::t,
bcx = base::with_cond(bcx, do_grow) {|bcx|
let pt = PointerCast(bcx, vptrptr,
T_ptr(T_ptr(T_i8())));
Call(bcx, ccx.upcalls.vec_grow, [pt, new_fill]);
Call(bcx, ccx.upcalls.vec_grow, [pt, new_fill]/~);
bcx
};
let vptr = get_bodyptr(bcx, Load(bcx, vptrptr));
@ -380,7 +380,7 @@ fn trans_add(bcx: block, vec_ty: ty::t, lhs: ValueRef,
if ty::get(vec_ty).struct == ty::ty_str {
let lhs = PointerCast(bcx, lhs, T_ptr(T_i8()));
let rhs = PointerCast(bcx, rhs, T_ptr(T_i8()));
let n = Call(bcx, ccx.upcalls.str_concat, [lhs, rhs]);
let n = Call(bcx, ccx.upcalls.str_concat, [lhs, rhs]/~);
let n = PointerCast(
bcx, n, T_unique_ptr(T_unique(ccx, T_vec(ccx, llunitty))));
ret base::store_in_dest(bcx, n, dest);
@ -401,7 +401,7 @@ fn trans_add(bcx: block, vec_ty: ty::t, lhs: ValueRef,
let write_ptr = Load(bcx, write_ptr_ptr);
let bcx = copy_val(bcx, INIT, write_ptr,
load_if_immediate(bcx, addr, unit_ty), unit_ty);
Store(bcx, InBoundsGEP(bcx, write_ptr, [C_int(ccx, 1)]),
Store(bcx, InBoundsGEP(bcx, write_ptr, [C_int(ccx, 1)]/~),
write_ptr_ptr);
ret bcx;
};
@ -430,7 +430,8 @@ fn iter_vec_raw(bcx: block, data_ptr: ValueRef, vec_ty: ty::t,
// Now perform the iteration.
let header_cx = sub_block(bcx, "iter_vec_loop_header");
Br(bcx, header_cx.llbb);
let data_ptr = Phi(header_cx, val_ty(data_ptr), [data_ptr], [bcx.llbb]);
let data_ptr =
Phi(header_cx, val_ty(data_ptr), [data_ptr]/~, [bcx.llbb]/~);
let not_yet_at_end =
ICmp(header_cx, lib::llvm::IntULT, data_ptr, data_end_ptr);
let body_cx = sub_block(header_cx, "iter_vec_loop_body");
@ -438,7 +439,7 @@ fn iter_vec_raw(bcx: block, data_ptr: ValueRef, vec_ty: ty::t,
CondBr(header_cx, not_yet_at_end, body_cx.llbb, next_cx.llbb);
let body_cx = f(body_cx, data_ptr, unit_ty);
AddIncomingToPhi(data_ptr, InBoundsGEP(body_cx, data_ptr,
[C_int(bcx.ccx(), 1)]),
[C_int(bcx.ccx(), 1)]/~),
body_cx.llbb);
Br(body_cx, header_cx.llbb);
ret next_cx;

34
src/rustc/middle/trans/type_of.rs
View file

@ -14,7 +14,8 @@ export type_of_fn_from_ty;
export type_of_fn;
export type_of_non_gc_box;
fn type_of_explicit_args(cx: @crate_ctxt, inputs: [ty::arg]) -> [TypeRef] {
fn type_of_explicit_args(cx: @crate_ctxt,
inputs: [ty::arg]/~) -> [TypeRef]/~ {
vec::map(inputs) {|arg|
let arg_ty = arg.ty;
let llty = type_of(cx, arg_ty);
@ -25,14 +26,15 @@ fn type_of_explicit_args(cx: @crate_ctxt, inputs: [ty::arg]) -> [TypeRef] {
}
}
fn type_of_fn(cx: @crate_ctxt, inputs: [ty::arg], output: ty::t) -> TypeRef {
let mut atys: [TypeRef] = [];
fn type_of_fn(cx: @crate_ctxt, inputs: [ty::arg]/~,
output: ty::t) -> TypeRef {
let mut atys: [TypeRef]/~ = []/~;
// Arg 0: Output pointer.
atys += [T_ptr(type_of(cx, output))];
atys += [T_ptr(type_of(cx, output))]/~;
// Arg 1: Environment
atys += [T_opaque_box_ptr(cx)];
atys += [T_opaque_box_ptr(cx)]/~;
// ... then explicit args.
atys += type_of_explicit_args(cx, inputs);
@ -115,12 +117,12 @@ fn type_of(cx: @crate_ctxt, t: ty::t) -> TypeRef {
ty::ty_evec(mt, ty::vstore_slice(_)) {
T_struct([T_ptr(type_of(cx, mt.ty)),
T_uint_ty(cx, ast::ty_u)])
T_uint_ty(cx, ast::ty_u)]/~)
}
ty::ty_estr(ty::vstore_slice(_)) {
T_struct([T_ptr(T_i8()),
T_uint_ty(cx, ast::ty_u)])
T_uint_ty(cx, ast::ty_u)]/~)
}
ty::ty_estr(ty::vstore_fixed(n)) {
@ -132,10 +134,10 @@ fn type_of(cx: @crate_ctxt, t: ty::t) -> TypeRef {
}
ty::ty_rec(fields) {
let mut tys: [TypeRef] = [];
let mut tys: [TypeRef]/~ = []/~;
for vec::each(fields) {|f|
let mt_ty = f.mt.ty;
tys += [type_of(cx, mt_ty)];
tys += [type_of(cx, mt_ty)]/~;
}
T_struct(tys)
}
@ -143,9 +145,9 @@ fn type_of(cx: @crate_ctxt, t: ty::t) -> TypeRef {
ty::ty_iface(_, _) { T_opaque_iface(cx) }
ty::ty_type { T_ptr(cx.tydesc_type) }
ty::ty_tup(elts) {
let mut tys = [];
let mut tys = []/~;
for vec::each(elts) {|elt|
tys += [type_of(cx, elt)];
tys += [type_of(cx, elt)]/~;
}
T_struct(tys)
}
@ -180,7 +182,7 @@ fn type_of(cx: @crate_ctxt, t: ty::t) -> TypeRef {
if ty::ty_dtor(cx.tcx, did) != none {
// resource type
tys = [T_i8(), T_struct(tys)];
tys = [T_i8(), T_struct(tys)]/~;
}
common::set_struct_body(llty, tys);
@ -213,13 +215,13 @@ fn type_of_enum(cx: @crate_ctxt, did: ast::def_id, t: ty::t)
let degen = (*ty::enum_variants(cx.tcx, did)).len() == 1u;
let size = shape::static_size_of_enum(cx, t);
if !degen {
[T_enum_discrim(cx), T_array(T_i8(), size)]
[T_enum_discrim(cx), T_array(T_i8(), size)]/~
}
else if size == 0u {
[T_enum_discrim(cx)]
[T_enum_discrim(cx)]/~
}
else {
[T_array(T_i8(), size)]
[T_array(T_i8(), size)]/~
}
};
@ -250,7 +252,7 @@ fn llvm_type_name(cx: @crate_ctxt, t: ty::t) -> str {
fn type_of_dtor(ccx: @crate_ctxt, self_ty: ty::t) -> TypeRef {
T_fn([T_ptr(type_of(ccx, ty::mk_nil(ccx.tcx))),
T_ptr(type_of(ccx, self_ty))],
T_ptr(type_of(ccx, self_ty))]/~,
llvm::LLVMVoidType())
}

4
src/rustc/middle/trans/type_use.rs
View file

@ -31,10 +31,10 @@ const use_repr: uint = 1u; // Dependency on size/alignment and take/drop glue
const use_tydesc: uint = 2u; // Takes the tydesc, or compares
type ctx = {ccx: @crate_ctxt,
uses: [mut type_uses]};
uses: [mut type_uses]/~};
fn type_uses_for(ccx: @crate_ctxt, fn_id: def_id, n_tps: uint)
-> [type_uses] {
-> [type_uses]/~ {
alt ccx.type_use_cache.find(fn_id) {
some(uses) { ret uses; }
none {}

4
src/rustc/middle/trans/uniq.rs
View file

@ -56,9 +56,9 @@ fn duplicate(bcx: block, v: ValueRef, t: ty::t) -> result {
let bcx = copy_val(bcx, INIT, dst_body, src_body, content_ty);
let src_tydesc_ptr = GEPi(bcx, src_box,
[0u, back::abi::box_field_tydesc]);
[0u, back::abi::box_field_tydesc]/~);
let dst_tydesc_ptr = GEPi(bcx, dst_box,
[0u, back::abi::box_field_tydesc]);
[0u, back::abi::box_field_tydesc]/~);
let td = Load(bcx, src_tydesc_ptr);
Store(bcx, td, dst_tydesc_ptr);

14
src/rustc/middle/tstate/annotate.rs
View file

@ -7,13 +7,13 @@ import aux::{num_constraints, get_fn_info, crate_ctxt, add_node};
import ann::empty_ann;
import pat_util::pat_binding_ids;
fn collect_ids_expr(e: @expr, rs: @mut [node_id]) { vec::push(*rs, e.id); }
fn collect_ids_expr(e: @expr, rs: @mut [node_id]/~) { vec::push(*rs, e.id); }
fn collect_ids_block(b: blk, rs: @mut [node_id]) {
fn collect_ids_block(b: blk, rs: @mut [node_id]/~) {
vec::push(*rs, b.node.id);
}
fn collect_ids_stmt(s: @stmt, rs: @mut [node_id]) {
fn collect_ids_stmt(s: @stmt, rs: @mut [node_id]/~) {
alt s.node {
stmt_decl(_, id) | stmt_expr(_, id) | stmt_semi(_, id) {
#debug["node_id %s", int::str(id)];
@ -23,11 +23,11 @@ fn collect_ids_stmt(s: @stmt, rs: @mut [node_id]) {
}
}
fn collect_ids_local(tcx: ty::ctxt, l: @local, rs: @mut [node_id]) {
fn collect_ids_local(tcx: ty::ctxt, l: @local, rs: @mut [node_id]/~) {
*rs += pat_binding_ids(tcx.def_map, l.node.pat);
}
fn node_ids_in_fn(tcx: ty::ctxt, body: blk, rs: @mut [node_id]) {
fn node_ids_in_fn(tcx: ty::ctxt, body: blk, rs: @mut [node_id]/~) {
let collect_ids =
visit::mk_simple_visitor(@{visit_expr: {|a|collect_ids_expr(a, rs)},
visit_block: {|a|collect_ids_block(a, rs)},
@ -38,7 +38,7 @@ fn node_ids_in_fn(tcx: ty::ctxt, body: blk, rs: @mut [node_id]) {
collect_ids.visit_block(body, (), collect_ids);
}
fn init_vecs(ccx: crate_ctxt, node_ids: [node_id], len: uint) {
fn init_vecs(ccx: crate_ctxt, node_ids: [node_id]/~, len: uint) {
for node_ids.each {|i|
log(debug, int::str(i) + " |-> " + uint::str(len));
add_node(ccx, i, empty_ann(len));
@ -46,7 +46,7 @@ fn init_vecs(ccx: crate_ctxt, node_ids: [node_id], len: uint) {
}
fn visit_fn(ccx: crate_ctxt, num_constraints: uint, body: blk) {
let node_ids: @mut [node_id] = @mut [];
let node_ids: @mut [node_id]/~ = @mut []/~;
node_ids_in_fn(ccx.tcx, body, node_ids);
let node_id_vec = *node_ids;
init_vecs(ccx, node_id_vec, num_constraints);

137
src/rustc/middle/tstate/auxiliary.rs
View file

@ -34,7 +34,7 @@ fn def_id_to_str(d: def_id) -> str {
ret int::str(d.crate) + "," + int::str(d.node);
}
fn comma_str(args: [@constr_arg_use]) -> str {
fn comma_str(args: [@constr_arg_use]/~) -> str {
let mut rslt = "";
let mut comma = false;
for args.each {|a|
@ -93,7 +93,7 @@ fn log_tritv_err(fcx: fn_ctxt, v: tritv::t) {
log(error, tritv_to_str(fcx, v));
}
fn tos(v: [uint]) -> str {
fn tos(v: [uint]/~) -> str {
let mut rslt = "";
for v.each {|i|
if i == 0u {
@ -103,9 +103,9 @@ fn tos(v: [uint]) -> str {
ret rslt;
}
fn log_cond(v: [uint]) { log(debug, tos(v)); }
fn log_cond(v: [uint]/~) { log(debug, tos(v)); }
fn log_cond_err(v: [uint]) { log(error, tos(v)); }
fn log_cond_err(v: [uint]/~) { log(error, tos(v)); }
fn log_pp(pp: pre_and_post) {
let p1 = tritv::to_vec(pp.precondition);
@ -145,7 +145,7 @@ fn log_states_err(pp: pre_and_post_state) {
fn print_ident(i: ident) { log(debug, " " + *i + " "); }
fn print_idents(&idents: [ident]) {
fn print_idents(&idents: [ident]/~) {
if vec::len::<ident>(idents) == 0u { ret; }
log(debug, "an ident: " + *vec::pop::<ident>(idents));
print_idents(idents);
@ -180,7 +180,7 @@ to represent predicate *arguments* however. This type
Both types store an ident and span, for error-logging purposes.
*/
type pred_args_ = {args: [@constr_arg_use], bit_num: uint};
type pred_args_ = {args: [@constr_arg_use]/~, bit_num: uint};
type pred_args = spanned<pred_args_>;
@ -203,7 +203,7 @@ type constraint = {
type tsconstr = {
path: @path,
def_id: def_id,
args: [@constr_arg_use]
args: [@constr_arg_use]/~
};
type sp_constr = spanned<tsconstr>;
@ -224,11 +224,11 @@ type fn_info =
{constrs: constr_map,
num_constraints: uint,
cf: ret_style,
used_vars: @mut [node_id],
used_vars: @mut [node_id]/~,
ignore: bool};
/* mapping from node ID to typestate annotation */
type node_ann_table = @mut [mut ts_ann];
type node_ann_table = @mut [mut ts_ann]/~;
/* mapping from function name to fn_info map */
@ -436,7 +436,7 @@ fn pure_exp(ccx: crate_ctxt, id: node_id, p: prestate) -> bool {
fn num_constraints(m: fn_info) -> uint { ret m.num_constraints; }
fn new_crate_ctxt(cx: ty::ctxt) -> crate_ctxt {
let na: [mut ts_ann] = [mut];
let na: [mut ts_ann]/~ = [mut]/~;
ret {tcx: cx, node_anns: @mut na, fm: int_hash::<fn_info>()};
}
@ -450,10 +450,10 @@ fn controlflow_expr(ccx: crate_ctxt, e: @expr) -> ret_style {
}
}
fn constraints_expr(cx: ty::ctxt, e: @expr) -> [@ty::constr] {
fn constraints_expr(cx: ty::ctxt, e: @expr) -> [@ty::constr]/~ {
alt ty::get(ty::node_id_to_type(cx, e.id)).struct {
ty::ty_fn(f) { ret f.constraints; }
_ { ret []; }
_ { ret []/~; }
}
}
@ -471,14 +471,14 @@ fn node_id_to_def(ccx: crate_ctxt, id: node_id) -> option<def> {
ret ccx.tcx.def_map.find(id);
}
fn norm_a_constraint(id: def_id, c: constraint) -> [norm_constraint] {
let mut rslt: [norm_constraint] = [];
fn norm_a_constraint(id: def_id, c: constraint) -> [norm_constraint]/~ {
let mut rslt: [norm_constraint]/~ = []/~;
for (*c.descs).each {|pd|
rslt +=
[{bit_num: pd.node.bit_num,
c: respan(pd.span, {path: c.path,
def_id: id,
args: pd.node.args})}];
args: pd.node.args})}]/~;
}
ret rslt;
}
@ -486,8 +486,8 @@ fn norm_a_constraint(id: def_id, c: constraint) -> [norm_constraint] {
// Tried to write this as an iterator, but I got a
// non-exhaustive match in trans.
fn constraints(fcx: fn_ctxt) -> [norm_constraint] {
let mut rslt: [norm_constraint] = [];
fn constraints(fcx: fn_ctxt) -> [norm_constraint]/~ {
let mut rslt: [norm_constraint]/~ = []/~;
for fcx.enclosing.constrs.each {|key, val|
rslt += norm_a_constraint(key, val);
};
@ -497,7 +497,7 @@ fn constraints(fcx: fn_ctxt) -> [norm_constraint] {
// FIXME (#2539): Would rather take an immutable vec as an argument,
// should freeze it at some earlier point.
fn match_args(fcx: fn_ctxt, occs: @dvec<pred_args>,
occ: [@constr_arg_use]) -> uint {
occ: [@constr_arg_use]/~) -> uint {
#debug("match_args: looking at %s",
constr_args_to_str(fn@(i: inst) -> str { ret *i.ident; }, occ));
for (*occs).each {|pd|
@ -549,10 +549,11 @@ fn expr_to_constr_arg(tcx: ty::ctxt, e: @expr) -> @constr_arg_use {
}
}
fn exprs_to_constr_args(tcx: ty::ctxt, args: [@expr]) -> [@constr_arg_use] {
fn exprs_to_constr_args(tcx: ty::ctxt,
args: [@expr]/~) -> [@constr_arg_use]/~ {
let f = {|a|expr_to_constr_arg(tcx, a)};
let mut rslt: [@constr_arg_use] = [];
for args.each {|e| rslt += [f(e)]; }
let mut rslt: [@constr_arg_use]/~ = []/~;
for args.each {|e| rslt += [f(e)]/~; }
rslt
}
@ -584,18 +585,18 @@ fn pred_args_to_str(p: pred_args) -> str {
+ ">"
}
fn substitute_constr_args(cx: ty::ctxt, actuals: [@expr], c: @ty::constr) ->
fn substitute_constr_args(cx: ty::ctxt, actuals: [@expr]/~, c: @ty::constr) ->
tsconstr {
let mut rslt: [@constr_arg_use] = [];
let mut rslt: [@constr_arg_use]/~ = []/~;
for c.node.args.each {|a|
rslt += [substitute_arg(cx, actuals, a)];
rslt += [substitute_arg(cx, actuals, a)]/~;
}
ret {path: c.node.path,
def_id: c.node.id,
args: rslt};
}
fn substitute_arg(cx: ty::ctxt, actuals: [@expr], a: @constr_arg) ->
fn substitute_arg(cx: ty::ctxt, actuals: [@expr]/~, a: @constr_arg) ->
@constr_arg_use {
let num_actuals = vec::len(actuals);
alt a.node {
@ -611,7 +612,7 @@ fn substitute_arg(cx: ty::ctxt, actuals: [@expr], a: @constr_arg) ->
}
}
fn pred_args_matches(pattern: [constr_arg_general_<inst>],
fn pred_args_matches(pattern: [constr_arg_general_<inst>]/~,
desc: pred_args) ->
bool {
let mut i = 0u;
@ -637,8 +638,8 @@ fn pred_args_matches(pattern: [constr_arg_general_<inst>],
ret true;
}
fn find_instance_(pattern: [constr_arg_general_<inst>],
descs: [pred_args]) ->
fn find_instance_(pattern: [constr_arg_general_<inst>]/~,
descs: [pred_args]/~) ->
option<uint> {
for descs.each {|d|
if pred_args_matches(pattern, d) { ret some(d.node.bit_num); }
@ -653,13 +654,13 @@ enum dest {
call // RHS is passed to a function
}
type subst = [{from: inst, to: inst}];
type subst = [{from: inst, to: inst}]/~;
fn find_instances(_fcx: fn_ctxt, subst: subst,
c: constraint) -> [{from: uint, to: uint}] {
c: constraint) -> [{from: uint, to: uint}]/~ {
if vec::len(subst) == 0u { ret []; }
let mut res = [];
if vec::len(subst) == 0u { ret []/~; }
let mut res = []/~;
(*c.descs).swap { |v|
let v <- vec::from_mut(v);
for v.each { |d|
@ -667,7 +668,7 @@ fn find_instances(_fcx: fn_ctxt, subst: subst,
let old_bit_num = d.node.bit_num;
let newv = replace(subst, d);
alt find_instance_(newv, v) {
some(d1) {res += [{from: old_bit_num, to: d1}]}
some(d1) {res += [{from: old_bit_num, to: d1}]/~}
_ {}
}
} else {}
@ -688,7 +689,7 @@ fn find_in_subst_bool(s: subst, id: node_id) -> bool {
is_some(find_in_subst(id, s))
}
fn insts_to_str(stuff: [constr_arg_general_<inst>]) -> str {
fn insts_to_str(stuff: [constr_arg_general_<inst>]/~) -> str {
let mut rslt = "<";
for stuff.each {|i|
rslt +=
@ -696,25 +697,25 @@ fn insts_to_str(stuff: [constr_arg_general_<inst>]) -> str {
alt i {
carg_ident(p) { *p.ident }
carg_base { "*" }
carg_lit(_) { "[lit]" }
carg_lit(_) { "[lit]/~" }
} + " ";
}
rslt += ">";
rslt
}
fn replace(subst: subst, d: pred_args) -> [constr_arg_general_<inst>] {
let mut rslt: [constr_arg_general_<inst>] = [];
fn replace(subst: subst, d: pred_args) -> [constr_arg_general_<inst>]/~ {
let mut rslt: [constr_arg_general_<inst>]/~ = []/~;
for d.node.args.each {|c|
alt c.node {
carg_ident(p) {
alt find_in_subst(p.node, subst) {
some(newv) { rslt += [carg_ident(newv)]; }
_ { rslt += [c.node]; }
some(newv) { rslt += [carg_ident(newv)]/~; }
_ { rslt += [c.node]/~; }
}
}
_ {
rslt += [c.node];
rslt += [c.node]/~;
}
}
}
@ -796,11 +797,11 @@ fn copy_in_poststate_two(fcx: fn_ctxt, src_post: poststate,
ty: oper_type) {
let mut subst;
alt ty {
oper_swap { subst = [{from: dest, to: src}, {from: src, to: dest}]; }
oper_swap { subst = [{from: dest, to: src}, {from: src, to: dest}]/~; }
oper_assign_op {
ret; // Don't do any propagation
}
_ { subst = [{from: src, to: dest}]; }
_ { subst = [{from: src, to: dest}]/~; }
}
@ -845,19 +846,19 @@ fn forget_in_poststate(fcx: fn_ctxt, p: poststate, dead_v: node_id) -> bool {
ret changed;
}
fn any_eq(v: [node_id], d: node_id) -> bool {
fn any_eq(v: [node_id]/~, d: node_id) -> bool {
for v.each {|i| if i == d { ret true; } }
false
}
fn constraint_mentions(_fcx: fn_ctxt, c: norm_constraint, v: node_id) ->
bool {
ret args_mention(c.c.node.args, any_eq, [v]);
ret args_mention(c.c.node.args, any_eq, [v]/~);
}
fn args_mention<T>(args: [@constr_arg_use],
q: fn([T], node_id) -> bool,
s: [T]) -> bool {
fn args_mention<T>(args: [@constr_arg_use]/~,
q: fn([T]/~, node_id) -> bool,
s: [T]/~) -> bool {
for args.each {|a|
alt a.node { carg_ident(p1) { if q(s, p1.node) { ret true; } } _ { } }
@ -865,7 +866,7 @@ fn args_mention<T>(args: [@constr_arg_use],
ret false;
}
fn use_var(fcx: fn_ctxt, v: node_id) { *fcx.enclosing.used_vars += [v]; }
fn use_var(fcx: fn_ctxt, v: node_id) { *fcx.enclosing.used_vars += [v]/~; }
fn op_to_oper_ty(io: init_op) -> oper_type {
alt io { init_move { oper_move } _ { oper_assign } }
@ -878,9 +879,10 @@ fn do_nothing<T>(_fk: visit::fn_kind, _decl: fn_decl, _body: blk,
}
fn args_to_constr_args(tcx: ty::ctxt, args: [arg],
indices: [@sp_constr_arg<uint>]) -> [@constr_arg_use] {
let mut actuals: [@constr_arg_use] = [];
fn args_to_constr_args(tcx: ty::ctxt, args: [arg]/~,
indices: [@sp_constr_arg<uint>]/~)
-> [@constr_arg_use]/~ {
let mut actuals: [@constr_arg_use]/~ = []/~;
let num_args = vec::len(args);
for indices.each {|a|
actuals +=
@ -898,12 +900,12 @@ fn args_to_constr_args(tcx: ty::ctxt, args: [arg],
}
}
carg_lit(l) { carg_lit(l) }
})];
})]/~;
}
ret actuals;
}
fn ast_constr_to_ts_constr(tcx: ty::ctxt, args: [arg], c: @constr) ->
fn ast_constr_to_ts_constr(tcx: ty::ctxt, args: [arg]/~, c: @constr) ->
tsconstr {
let tconstr = ty::ast_constr_to_constr(tcx, c);
ret {path: tconstr.node.path,
@ -911,35 +913,35 @@ fn ast_constr_to_ts_constr(tcx: ty::ctxt, args: [arg], c: @constr) ->
args: args_to_constr_args(tcx, args, tconstr.node.args)};
}
fn ast_constr_to_sp_constr(tcx: ty::ctxt, args: [arg], c: @constr) ->
fn ast_constr_to_sp_constr(tcx: ty::ctxt, args: [arg]/~, c: @constr) ->
sp_constr {
let tconstr = ast_constr_to_ts_constr(tcx, args, c);
ret respan(c.span, tconstr);
}
type binding = {lhs: [dest], rhs: option<initializer>};
type binding = {lhs: [dest]/~, rhs: option<initializer>};
fn local_to_bindings(tcx: ty::ctxt, loc: @local) -> binding {
let mut lhs = [];
let mut lhs = []/~;
pat_bindings(tcx.def_map, loc.node.pat) {|p_id, _s, name|
lhs += [local_dest({ident: path_to_ident(name), node: p_id})];
lhs += [local_dest({ident: path_to_ident(name), node: p_id})]/~;
};
{lhs: lhs, rhs: loc.node.init}
}
fn locals_to_bindings(tcx: ty::ctxt, locals: [@local]) -> [binding] {
let mut rslt = [];
for locals.each {|loc| rslt += [local_to_bindings(tcx, loc)]; }
fn locals_to_bindings(tcx: ty::ctxt, locals: [@local]/~) -> [binding]/~ {
let mut rslt = []/~;
for locals.each {|loc| rslt += [local_to_bindings(tcx, loc)]/~; }
ret rslt;
}
fn callee_modes(fcx: fn_ctxt, callee: node_id) -> [mode] {
fn callee_modes(fcx: fn_ctxt, callee: node_id) -> [mode]/~ {
let ty = ty::type_autoderef(fcx.ccx.tcx,
ty::node_id_to_type(fcx.ccx.tcx, callee));
alt ty::get(ty).struct {
ty::ty_fn({inputs: args, _}) {
let mut modes = [];
for args.each {|arg| modes += [arg.mode]; }
let mut modes = []/~;
for args.each {|arg| modes += [arg.mode]/~; }
ret modes;
}
_ {
@ -950,7 +952,7 @@ fn callee_modes(fcx: fn_ctxt, callee: node_id) -> [mode] {
}
}
fn callee_arg_init_ops(fcx: fn_ctxt, callee: node_id) -> [init_op] {
fn callee_arg_init_ops(fcx: fn_ctxt, callee: node_id) -> [init_op]/~ {
vec::map(callee_modes(fcx, callee)) {|m|
alt ty::resolved_mode(fcx.ccx.tcx, m) {
by_move { init_move }
@ -959,11 +961,12 @@ fn callee_arg_init_ops(fcx: fn_ctxt, callee: node_id) -> [init_op] {
}
}
fn arg_bindings(ops: [init_op], es: [@expr]) -> [binding] {
let mut bindings: [binding] = [];
fn arg_bindings(ops: [init_op]/~, es: [@expr]/~) -> [binding]/~ {
let mut bindings: [binding]/~ = []/~;
let mut i = 0u;
for ops.each {|op|
bindings += [{lhs: [call], rhs: some({op: op, expr: es[i]})}];
vec::push(bindings,
{lhs: [call]/~, rhs: some({op: op, expr: es[i]})});
i += 1u;
}
ret bindings;

6
src/rustc/middle/tstate/bitvectors.rs
View file

@ -45,7 +45,7 @@ fn seq_tritv(p: postcond, q: postcond) {
}
}
fn seq_postconds(fcx: fn_ctxt, ps: [postcond]) -> postcond {
fn seq_postconds(fcx: fn_ctxt, ps: [postcond]/~) -> postcond {
let sz = vec::len(ps);
if sz >= 1u {
let prev = tritv_clone(ps[0]);
@ -58,11 +58,11 @@ fn seq_postconds(fcx: fn_ctxt, ps: [postcond]) -> postcond {
// return the precondition for evaluating each expr in order.
// So, if e0's post is {x} and e1's pre is {x, y, z}, the entire
// precondition shouldn't include x.
fn seq_preconds(fcx: fn_ctxt, pps: [pre_and_post]) -> precond {
fn seq_preconds(fcx: fn_ctxt, pps: [pre_and_post]/~) -> precond {
let sz: uint = vec::len(pps);
let num_vars: uint = num_constraints(fcx.enclosing);
fn seq_preconds_go(fcx: fn_ctxt, pps: [pre_and_post],
fn seq_preconds_go(fcx: fn_ctxt, pps: [pre_and_post]/~,
idx: uint, first: pre_and_post)
-> precond {
let mut idx = idx;

12
src/rustc/middle/tstate/collect_locals.rs
View file

@ -10,12 +10,12 @@ import aux::*;
import std::map::hashmap;
import dvec::{dvec, extensions};
type ctxt = {cs: @mut [sp_constr], tcx: ty::ctxt};
type ctxt = {cs: @mut [sp_constr]/~, tcx: ty::ctxt};
fn collect_pred(e: @expr, cx: ctxt, v: visit::vt<ctxt>) {
alt e.node {
expr_check(_, ch) { *cx.cs += [expr_to_constr(cx.tcx, ch)]; }
expr_if_check(ex, _, _) { *cx.cs += [expr_to_constr(cx.tcx, ex)]; }
expr_check(_, ch) { *cx.cs += [expr_to_constr(cx.tcx, ch)]/~; }
expr_if_check(ex, _, _) { *cx.cs += [expr_to_constr(cx.tcx, ex)]/~; }
// If it's a call, generate appropriate instances of the
// call's constraints.
@ -24,7 +24,7 @@ fn collect_pred(e: @expr, cx: ctxt, v: visit::vt<ctxt>) {
let ct: sp_constr =
respan(c.span,
aux::substitute_constr_args(cx.tcx, operands, c));
*cx.cs += [ct];
*cx.cs += [ct]/~;
}
}
_ { }
@ -39,7 +39,7 @@ fn find_locals(tcx: ty::ctxt,
f_body: blk,
sp: span,
id: node_id) -> ctxt {
let cx: ctxt = {cs: @mut [], tcx: tcx};
let cx: ctxt = {cs: @mut []/~, tcx: tcx};
let visitor = visit::default_visitor::<ctxt>();
let visitor =
@{visit_expr: collect_pred,
@ -130,7 +130,7 @@ fn mk_fn_info(ccx: crate_ctxt,
}
}
let v: @mut [node_id] = @mut [];
let v: @mut [node_id]/~ = @mut []/~;
let rslt =
{constrs: res_map,
num_constraints: next,

65
src/rustc/middle/tstate/pre_post_conditions.rs
View file

@ -63,7 +63,7 @@ fn find_pre_post_item(ccx: crate_ctxt, i: item) {
sets the precondition in a to be the result of combining
the preconditions for <args>, and the postcondition in a to
be the union of all postconditions for <args> */
fn find_pre_post_exprs(fcx: fn_ctxt, args: [@expr], id: node_id) {
fn find_pre_post_exprs(fcx: fn_ctxt, args: [@expr]/~, id: node_id) {
if vec::len::<@expr>(args) > 0u {
#debug["find_pre_post_exprs: oper = %s", expr_to_str(args[0])];
}
@ -84,7 +84,8 @@ fn find_pre_post_loop(fcx: fn_ctxt, index: @expr, body: blk, id: node_id) {
find_pre_post_block(fcx, body);
let loop_precond =
seq_preconds(fcx, [expr_pp(fcx.ccx, index), block_pp(fcx.ccx, body)]);
seq_preconds(fcx, [expr_pp(fcx.ccx, index),
block_pp(fcx.ccx, body)]/~);
let loop_postcond =
intersect_states(expr_postcond(fcx.ccx, index),
block_postcond(fcx.ccx, body));
@ -111,7 +112,7 @@ fn join_then_else(fcx: fn_ctxt, antec: @expr, conseq: blk,
let precond_res =
seq_preconds(fcx,
[expr_pp(fcx.ccx, antec),
block_pp(fcx.ccx, conseq)]);
block_pp(fcx.ccx, conseq)]/~);
set_pre_and_post(fcx.ccx, id, precond_res,
expr_poststate(fcx.ccx, antec));
}
@ -124,11 +125,12 @@ fn join_then_else(fcx: fn_ctxt, antec: @expr, conseq: blk,
find_pre_post_expr(fcx, altern);
let precond_false_case =
seq_preconds(fcx,
[expr_pp(fcx.ccx, antec), expr_pp(fcx.ccx, altern)]);
[expr_pp(fcx.ccx, antec),
expr_pp(fcx.ccx, altern)]/~);
let postcond_false_case =
seq_postconds(fcx,
[expr_postcond(fcx.ccx, antec),
expr_postcond(fcx.ccx, altern)]);
expr_postcond(fcx.ccx, altern)]/~);
/* Be sure to set the bit for the check condition here,
so that it's *not* set in the alternative. */
@ -142,14 +144,14 @@ fn join_then_else(fcx: fn_ctxt, antec: @expr, conseq: blk,
let precond_true_case =
seq_preconds(fcx,
[expr_pp(fcx.ccx, antec),
block_pp(fcx.ccx, conseq)]);
block_pp(fcx.ccx, conseq)]/~);
let postcond_true_case =
seq_postconds(fcx,
[expr_postcond(fcx.ccx, antec),
block_postcond(fcx.ccx, conseq)]);
block_postcond(fcx.ccx, conseq)]/~);
let precond_res =
seq_postconds(fcx, [precond_true_case, precond_false_case]);
seq_postconds(fcx, [precond_true_case, precond_false_case]/~);
let postcond_res =
intersect_states(postcond_true_case, postcond_false_case);
set_pre_and_post(fcx.ccx, id, precond_res, postcond_res);
@ -168,10 +170,10 @@ fn gen_if_local(fcx: fn_ctxt, lhs: @expr, rhs: @expr, larger_id: node_id,
set_pre_and_post(fcx.ccx, larger_id, p.precondition,
p.postcondition);
}
_ { find_pre_post_exprs(fcx, [lhs, rhs], larger_id); }
_ { find_pre_post_exprs(fcx, [lhs, rhs]/~, larger_id); }
}
}
_ { find_pre_post_exprs(fcx, [lhs, rhs], larger_id); }
_ { find_pre_post_exprs(fcx, [lhs, rhs]/~, larger_id); }
}
}
@ -226,8 +228,8 @@ fn handle_update(fcx: fn_ctxt, parent: @expr, lhs: @expr, rhs: @expr,
}
}
fn forget_args_moved_in(fcx: fn_ctxt, parent: @expr, modes: [mode],
operands: [@expr]) {
fn forget_args_moved_in(fcx: fn_ctxt, parent: @expr, modes: [mode]/~,
operands: [@expr]/~) {
vec::iteri(modes) {|i,mode|
alt ty::resolved_mode(fcx.ccx.tcx, mode) {
by_move { forget_in_postcond(fcx, parent.id, operands[i].id); }
@ -253,7 +255,7 @@ fn find_pre_post_expr(fcx: fn_ctxt, e: @expr) {
/* copy */
let mut args = operands;
args += [operator];
args += [operator]/~;
find_pre_post_exprs(fcx, args, e.id);
/* see if the call has any constraints on its type */
@ -285,10 +287,10 @@ fn find_pre_post_expr(fcx: fn_ctxt, e: @expr) {
clear_pp(rslt);
}
expr_new(p, _, v) {
find_pre_post_exprs(fcx, [p, v], e.id);
find_pre_post_exprs(fcx, [p, v]/~, e.id);
}
expr_log(_, lvl, arg) {
find_pre_post_exprs(fcx, [lvl, arg], e.id);
find_pre_post_exprs(fcx, [lvl, arg]/~, e.id);
}
expr_fn(_, _, _, cap_clause) | expr_fn_block(_, _, cap_clause) {
find_pre_post_expr_fn_upvars(fcx, e);
@ -312,7 +314,7 @@ fn find_pre_post_expr(fcx: fn_ctxt, e: @expr) {
}
expr_rec(fields, maybe_base) {
let mut es = field_exprs(fields);
alt maybe_base { none {/* no-op */ } some(b) { es += [b]; } }
alt maybe_base { none {/* no-op */ } some(b) { es += [b]/~; } }
find_pre_post_exprs(fcx, es, e.id);
}
expr_tup(elts) { find_pre_post_exprs(fcx, elts, e.id); }
@ -323,7 +325,7 @@ fn find_pre_post_expr(fcx: fn_ctxt, e: @expr) {
/* Different from expr_assign in that the lhs *must*
already be initialized */
find_pre_post_exprs(fcx, [lhs, rhs], e.id);
find_pre_post_exprs(fcx, [lhs, rhs]/~, e.id);
forget_in_postcond(fcx, e.id, lhs.id);
}
expr_lit(_) { clear_pp(expr_pp(fcx.ccx, e)); }
@ -349,11 +351,12 @@ fn find_pre_post_expr(fcx: fn_ctxt, e: @expr) {
find_pre_post_expr(fcx, l);
find_pre_post_expr(fcx, r);
let overall_pre =
seq_preconds(fcx, [expr_pp(fcx.ccx, l), expr_pp(fcx.ccx, r)]);
seq_preconds(fcx,
[expr_pp(fcx.ccx, l), expr_pp(fcx.ccx, r)]/~);
set_precondition(node_id_to_ts_ann(fcx.ccx, e.id), overall_pre);
set_postcondition(node_id_to_ts_ann(fcx.ccx, e.id),
expr_postcond(fcx.ccx, l));
} else { find_pre_post_exprs(fcx, [l, r], e.id); }
} else { find_pre_post_exprs(fcx, [l, r]/~, e.id); }
}
expr_addr_of(_, x) | expr_cast(x, _) | expr_unary(_, x) |
expr_loop_body(x) | expr_do_body(x) | expr_assert(x) | expr_copy(x) {
@ -366,7 +369,7 @@ fn find_pre_post_expr(fcx: fn_ctxt, e: @expr) {
set_pre_and_post(fcx.ccx, e.id,
seq_preconds(fcx,
[expr_pp(fcx.ccx, test),
block_pp(fcx.ccx, body)]),
block_pp(fcx.ccx, body)]/~),
intersect_states(expr_postcond(fcx.ccx, test),
block_postcond(fcx.ccx, body)));
}
@ -383,7 +386,7 @@ fn find_pre_post_expr(fcx: fn_ctxt, e: @expr) {
set_pre_and_post(fcx.ccx, e.id, block_precond(fcx.ccx, body),
loop_postcond);
}
expr_index(val, sub) { find_pre_post_exprs(fcx, [val, sub], e.id); }
expr_index(val, sub) { find_pre_post_exprs(fcx, [val, sub]/~, e.id); }
expr_alt(ex, alts, _) {
find_pre_post_expr(fcx, ex);
fn do_an_alt(fcx: fn_ctxt, an_alt: arm) -> pre_and_post {
@ -394,11 +397,11 @@ fn find_pre_post_expr(fcx: fn_ctxt, e: @expr) {
find_pre_post_block(fcx, an_alt.body);
ret block_pp(fcx.ccx, an_alt.body);
}
let mut alt_pps = [];
for alts.each {|a| alt_pps += [do_an_alt(fcx, a)]; }
let mut alt_pps = []/~;
for alts.each {|a| alt_pps += [do_an_alt(fcx, a)]/~; }
fn combine_pp(antec: pre_and_post, fcx: fn_ctxt, &&pp: pre_and_post,
&&next: pre_and_post) -> pre_and_post {
union(pp.precondition, seq_preconds(fcx, [antec, next]));
union(pp.precondition, seq_preconds(fcx, [antec, next]/~));
intersect(pp.postcondition, next.postcondition);
ret pp;
}
@ -494,7 +497,7 @@ fn find_pre_post_stmt(fcx: fn_ctxt, s: stmt) {
guaranteed */
let e_pp = expr_pp(fcx.ccx, an_init.expr);
tritv_copy(prev_pp.precondition,
seq_preconds(fcx, [prev_pp, e_pp]));
seq_preconds(fcx, [prev_pp, e_pp]/~));
/* Include the LHSs too, since those aren't in the
postconds of the RHSs themselves */
@ -551,21 +554,21 @@ fn find_pre_post_block(fcx: fn_ctxt, b: blk) {
let do_inner = {|a|do_inner_(fcx, a)};
option::map::<@expr, ()>(b.node.expr, do_inner);
let mut pps: [pre_and_post] = [];
for b.node.stmts.each {|s| pps += [stmt_pp(fcx.ccx, *s)]; }
let mut pps: [pre_and_post]/~ = []/~;
for b.node.stmts.each {|s| pps += [stmt_pp(fcx.ccx, *s)]/~; }
alt b.node.expr {
none {/* no-op */ }
some(e) { pps += [expr_pp(fcx.ccx, e)]; }
some(e) { pps += [expr_pp(fcx.ccx, e)]/~; }
}
let block_precond = seq_preconds(fcx, pps);
let mut postconds = [];
for pps.each {|pp| postconds += [get_post(pp)]; }
let mut postconds = []/~;
for pps.each {|pp| postconds += [get_post(pp)]/~; }
/* A block may be empty, so this next line ensures that the postconds
vector is non-empty. */
postconds += [block_precond];
postconds += [block_precond]/~;
let mut block_postcond = empty_poststate(nv);
/* conservative approximation */

12
src/rustc/middle/tstate/states.rs
View file

@ -54,7 +54,7 @@ fn handle_move_or_copy(fcx: fn_ctxt, post: poststate, rhs_path: @path,
}
}
fn seq_states(fcx: fn_ctxt, pres: prestate, bindings: [binding]) ->
fn seq_states(fcx: fn_ctxt, pres: prestate, bindings: [binding]/~) ->
{changed: bool, post: poststate} {
let mut changed = false;
let mut post = tritv_clone(pres);
@ -166,7 +166,7 @@ fn find_pre_post_state_two(fcx: fn_ctxt, pres: prestate, lhs: @expr,
}
fn find_pre_post_state_call(fcx: fn_ctxt, pres: prestate, a: @expr,
id: node_id, ops: [init_op], bs: [@expr],
id: node_id, ops: [init_op]/~, bs: [@expr]/~,
cf: ret_style) -> bool {
let mut changed = find_pre_post_state_expr(fcx, pres, a);
// FIXME (#2178): This could be a typestate constraint (except we're
@ -183,8 +183,8 @@ fn find_pre_post_state_call(fcx: fn_ctxt, pres: prestate, a: @expr,
}
fn find_pre_post_state_exprs(fcx: fn_ctxt, pres: prestate, id: node_id,
ops: [init_op], es: [@expr], cf: ret_style) ->
bool {
ops: [init_op]/~, es: [@expr]/~,
cf: ret_style) -> bool {
let rs = seq_states(fcx, pres, arg_bindings(ops, es));
let mut changed = rs.changed | set_prestate_ann(fcx.ccx, id, pres);
/* if this is a failing call, it sets everything as initialized */
@ -404,7 +404,7 @@ fn find_pre_post_state_expr(fcx: fn_ctxt, pres: prestate, e: @expr) -> bool {
/* conservative approximation: if a loop contains a break
or cont, we assume nothing about the poststate */
/* which is still unsound -- see [Break-unsound] */
/* which is still unsound -- see [Break-unsound]/~ */
if has_nonlocal_exits(body) {
ret changed | set_poststate_ann(fcx.ccx, e.id, pres);
} else {
@ -423,7 +423,7 @@ fn find_pre_post_state_expr(fcx: fn_ctxt, pres: prestate, e: @expr) -> bool {
/* conservative approximation: if a loop contains a break
or cont, we assume nothing about the poststate (so, we
set all predicates to "don't know" */
/* which is still unsound -- see [Break-unsound] */
/* which is still unsound -- see [Break-unsound]/~ */
if may_break(body) {
/* Only do this if there are *breaks* not conts.
An infinite loop with conts is still an infinite loop.

6
src/rustc/middle/tstate/tritv.rs
View file

@ -249,16 +249,16 @@ fn tritv_doesntcare(v: t) -> bool {
ret true;
}
fn to_vec(v: t) -> [uint] {
fn to_vec(v: t) -> [uint]/~ {
let mut i: uint = 0u;
let mut rslt: [uint] = [];
let mut rslt: [uint]/~ = []/~;
while i < v.nbits {
rslt +=
[alt tritv_get(v, i) {
dont_care { 2u }
ttrue { 1u }
tfalse { 0u }
}];
}]/~;
i += 1u;
}
ret rslt;

137
src/rustc/middle/ty.rs
View file

@ -172,15 +172,15 @@ type arg = {mode: ast::mode, ty: t};
type field = {ident: ast::ident, mt: mt};
type param_bounds = @[param_bound];
type param_bounds = @[param_bound]/~;
type method = {ident: ast::ident,
tps: @[param_bounds],
tps: @[param_bounds]/~,
fty: fn_ty,
purity: ast::purity,
vis: ast::visibility};
type constr_table = hashmap<ast::node_id, [constr]>;
type constr_table = hashmap<ast::node_id, [constr]/~>;
type mt = {ty: t, mutbl: ast::mutability};
@ -234,7 +234,7 @@ type ctxt =
// of this node. This only applies to nodes that refer to entities
// parameterized by type parameters, such as generic fns, types, or
// other items.
node_type_substs: hashmap<node_id, [t]>,
node_type_substs: hashmap<node_id, [t]/~>,
items: ast_map::map,
intrinsic_ifaces: hashmap<ast::ident, (ast::def_id, t)>,
@ -246,8 +246,8 @@ type ctxt =
needs_unwind_cleanup_cache: hashmap<t, bool>,
kind_cache: hashmap<t, kind>,
ast_ty_to_ty_cache: hashmap<@ast::ty, ast_ty_to_ty_cache_entry>,
enum_var_cache: hashmap<def_id, @[variant_info]>,
iface_method_cache: hashmap<def_id, @[method]>,
enum_var_cache: hashmap<def_id, @[variant_info]/~>,
iface_method_cache: hashmap<def_id, @[method]/~>,
ty_param_bounds: hashmap<ast::node_id, param_bounds>,
inferred_modes: hashmap<ast::node_id, ast::mode>,
// maps the id of borrowed expr to scope of borrowed ptr
@ -305,10 +305,10 @@ enum closure_kind {
type fn_ty = {purity: ast::purity,
proto: ast::proto,
inputs: [arg],
inputs: [arg]/~,
output: t,
ret_style: ret_style,
constraints: [@constr]};
constraints: [@constr]/~};
// See discussion at head of region.rs
enum region {
@ -340,7 +340,7 @@ type opt_region = option<region>;
type substs = {
self_r: opt_region,
self_ty: option<ty::t>,
tps: [t]
tps: [t]/~
};
// NB: If you change this, you'll probably want to change the corresponding
@ -361,18 +361,18 @@ enum sty {
ty_evec(mt, vstore),
ty_ptr(mt),
ty_rptr(region, mt),
ty_rec([field]),
ty_rec([field]/~),
ty_fn(fn_ty),
ty_iface(def_id, substs),
ty_class(def_id, substs),
ty_tup([t]),
ty_tup([t]/~),
ty_var(tv_vid), // type variable during typechecking
ty_var_integral(tvi_vid), // type variable during typechecking, for
// integral types only
ty_param(uint, def_id), // type parameter
ty_self, // special, implicit `self` type parameter
ty_constr(t, [@type_constr]),
ty_constr(t, [@type_constr]/~),
// "Fake" types, used for trans purposes
ty_type, // type_desc*
@ -471,7 +471,7 @@ fn param_bounds_to_kind(bounds: param_bounds) -> kind {
kind
}
type ty_param_bounds_and_ty = {bounds: @[param_bounds],
type ty_param_bounds_and_ty = {bounds: @[param_bounds]/~,
rp: ast::region_param,
ty: t};
@ -691,13 +691,13 @@ fn mk_mut_unboxed_vec(cx: ctxt, ty: t) -> t {
}
fn mk_rec(cx: ctxt, fs: [field]) -> t { mk_t(cx, ty_rec(fs)) }
fn mk_rec(cx: ctxt, fs: [field]/~) -> t { mk_t(cx, ty_rec(fs)) }
fn mk_constr(cx: ctxt, t: t, cs: [@type_constr]) -> t {
fn mk_constr(cx: ctxt, t: t, cs: [@type_constr]/~) -> t {
mk_t(cx, ty_constr(t, cs))
}
fn mk_tup(cx: ctxt, ts: [t]) -> t { mk_t(cx, ty_tup(ts)) }
fn mk_tup(cx: ctxt, ts: [t]/~) -> t { mk_t(cx, ty_tup(ts)) }
fn mk_fn(cx: ctxt, fty: fn_ty) -> t { mk_t(cx, ty_fn(fty)) }
@ -992,7 +992,7 @@ fn fold_region(cx: ctxt, t0: t, fldop: fn(region, bool) -> region) -> t {
}
// Substitute *only* type parameters. Used in trans where regions are erased.
fn subst_tps(cx: ctxt, tps: [t], typ: t) -> t {
fn subst_tps(cx: ctxt, tps: [t]/~, typ: t) -> t {
if tps.len() == 0u { ret typ; }
let tb = ty::get(typ);
if !tbox_has_flag(tb, has_params) { ret typ; }
@ -1598,7 +1598,7 @@ fn type_kind(cx: ctxt, ty: t) -> kind {
// True if instantiating an instance of `ty` requires an instance of `r_ty`.
fn is_instantiable(cx: ctxt, r_ty: t) -> bool {
fn type_requires(cx: ctxt, seen: @mut [def_id],
fn type_requires(cx: ctxt, seen: @mut [def_id]/~,
r_ty: t, ty: t) -> bool {
#debug["type_requires(%s, %s)?",
ty_to_str(cx, r_ty),
@ -1616,7 +1616,7 @@ fn is_instantiable(cx: ctxt, r_ty: t) -> bool {
ret r;
}
fn subtypes_require(cx: ctxt, seen: @mut [def_id],
fn subtypes_require(cx: ctxt, seen: @mut [def_id]/~,
r_ty: t, ty: t) -> bool {
#debug["subtypes_require(%s, %s)?",
ty_to_str(cx, r_ty),
@ -1713,7 +1713,7 @@ fn is_instantiable(cx: ctxt, r_ty: t) -> bool {
ret r;
}
let seen = @mut [];
let seen = @mut []/~;
!subtypes_require(cx, seen, r_ty, r_ty)
}
@ -1973,7 +1973,7 @@ fn hash_type_structure(st: sty) -> uint {
(h << 2u) + (did.node as uint)
}
fn hash_subty(id: uint, subty: t) -> uint { (id << 2u) + type_id(subty) }
fn hash_subtys(id: uint, subtys: [t]) -> uint {
fn hash_subtys(id: uint, subtys: [t]/~) -> uint {
let mut h = id;
for subtys.each {|s| h = (h << 2u) + type_id(s) }
h
@ -2094,8 +2094,8 @@ fn arg_eq<T>(eq: fn(T, T) -> bool,
}
fn args_eq<T>(eq: fn(T, T) -> bool,
a: [@sp_constr_arg<T>],
b: [@sp_constr_arg<T>]) -> bool {
a: [@sp_constr_arg<T>]/~,
b: [@sp_constr_arg<T>]/~) -> bool {
let mut i: uint = 0u;
for a.each {|arg|
if !arg_eq(eq, arg, b[i]) { ret false; }
@ -2110,7 +2110,7 @@ fn constr_eq(c: @constr, d: @constr) -> bool {
args_eq(eq_int, c.node.args, d.node.args);
}
fn constrs_eq(cs: [@constr], ds: [@constr]) -> bool {
fn constrs_eq(cs: [@constr]/~, ds: [@constr]/~) -> bool {
if vec::len(cs) != vec::len(ds) { ret false; }
let mut i = 0u;
for cs.each {|c| if !constr_eq(c, ds[i]) { ret false; } i += 1u; }
@ -2125,9 +2125,9 @@ fn node_id_to_type(cx: ctxt, id: ast::node_id) -> t {
}
}
fn node_id_to_type_params(cx: ctxt, id: ast::node_id) -> [t] {
fn node_id_to_type_params(cx: ctxt, id: ast::node_id) -> [t]/~ {
alt cx.node_type_substs.find(id) {
none { ret []; }
none { ret []/~; }
some(ts) { ret ts; }
}
}
@ -2137,7 +2137,7 @@ fn node_id_has_type_params(cx: ctxt, id: ast::node_id) -> bool {
}
// Type accessors for substructures of types
fn ty_fn_args(fty: t) -> [arg] {
fn ty_fn_args(fty: t) -> [arg]/~ {
alt get(fty).struct {
ty_fn(f) { f.inputs }
_ { fail "ty_fn_args() called on non-fn type"; }
@ -2173,8 +2173,8 @@ fn is_fn_ty(fty: t) -> bool {
}
// Returns a vec of all the input and output types of fty.
fn tys_in_fn_ty(fty: fn_ty) -> [t] {
fty.inputs.map({|a| a.ty}) + [fty.output]
fn tys_in_fn_ty(fty: fn_ty) -> [t]/~ {
fty.inputs.map({|a| a.ty}) + [fty.output]/~
}
// Just checks whether it's a fn that returns bool,
@ -2222,7 +2222,8 @@ fn expr_ty(cx: ctxt, expr: @ast::expr) -> t {
ret node_id_to_type(cx, expr.id);
}
fn expr_ty_params_and_ty(cx: ctxt, expr: @ast::expr) -> {params: [t], ty: t} {
fn expr_ty_params_and_ty(cx: ctxt,
expr: @ast::expr) -> {params: [t]/~, ty: t} {
ret {params: node_id_to_type_params(cx, expr.id),
ty: node_id_to_type(cx, expr.id)};
}
@ -2249,7 +2250,7 @@ fn stmt_node_id(s: @ast::stmt) -> ast::node_id {
}
}
fn field_idx(id: ast::ident, fields: [field]) -> option<uint> {
fn field_idx(id: ast::ident, fields: [field]/~) -> option<uint> {
let mut i = 0u;
for fields.each {|f| if f.ident == id { ret some(i); } i += 1u; }
ret none;
@ -2261,13 +2262,13 @@ fn get_field(rec_ty: t, id: ast::ident) -> field {
}
}
fn get_fields(rec_ty:t) -> [field] {
fn get_fields(rec_ty:t) -> [field]/~ {
alt check get(rec_ty).struct {
ty_rec(fields) { fields }
}
}
fn method_idx(id: ast::ident, meths: [method]) -> option<uint> {
fn method_idx(id: ast::ident, meths: [method]/~) -> option<uint> {
let mut i = 0u;
for meths.each {|m| if m.ident == id { ret some(i); } i += 1u; }
ret none;
@ -2277,10 +2278,10 @@ fn occurs_check(tcx: ctxt, sp: span, vid: tv_vid, rt: t) {
// Returns a vec of all the type variables occurring in `ty`. It may
// contain duplicates. (Integral type vars aren't counted.)
fn vars_in_type(ty: t) -> [tv_vid] {
let mut rslt = [];
fn vars_in_type(ty: t) -> [tv_vid]/~ {
let mut rslt = []/~;
walk_ty(ty) {|ty|
alt get(ty).struct { ty_var(v) { rslt += [v]; } _ { } }
alt get(ty).struct { ty_var(v) { rslt += [v]/~; } _ { } }
}
rslt
}
@ -2501,11 +2502,11 @@ fn def_has_ty_params(def: ast::def) -> bool {
}
}
fn store_iface_methods(cx: ctxt, id: ast::node_id, ms: @[method]) {
fn store_iface_methods(cx: ctxt, id: ast::node_id, ms: @[method]/~) {
cx.iface_method_cache.insert(ast_util::local_def(id), ms);
}
fn iface_methods(cx: ctxt, id: ast::def_id) -> @[method] {
fn iface_methods(cx: ctxt, id: ast::def_id) -> @[method]/~ {
alt cx.iface_method_cache.find(id) {
some(ms) { ret ms; }
_ {}
@ -2553,12 +2554,12 @@ fn ty_to_def_id(ty: t) -> option<ast::def_id> {
}
// Enum information
type variant_info = @{args: [t], ctor_ty: t, name: ast::ident,
type variant_info = @{args: [t]/~, ctor_ty: t, name: ast::ident,
id: ast::def_id, disr_val: int};
fn substd_enum_variants(cx: ctxt,
id: ast::def_id,
substs: substs) -> [variant_info] {
substs: substs) -> [variant_info]/~ {
vec::map(*enum_variants(cx, id)) { |variant_info|
let substd_args = vec::map(variant_info.args) {|aty|
subst(cx, substs, aty)
@ -2609,26 +2610,26 @@ fn item_path(cx: ctxt, id: ast::def_id) -> ast_map::path {
ast_map::path_name(item.ident)
}
};
*path + [item_elt]
*path + [item_elt]/~
}
ast_map::node_native_item(nitem, _, path) {
*path + [ast_map::path_name(nitem.ident)]
*path + [ast_map::path_name(nitem.ident)]/~
}
ast_map::node_method(method, _, path) {
*path + [ast_map::path_name(method.ident)]
*path + [ast_map::path_name(method.ident)]/~
}
ast_map::node_variant(variant, _, path) {
vec::init(*path) + [ast_map::path_name(variant.node.name)]
vec::init(*path) + [ast_map::path_name(variant.node.name)]/~
}
ast_map::node_ctor(nm, _, _, _, path) {
*path + [ast_map::path_name(nm)]
*path + [ast_map::path_name(nm)]/~
}
ast_map::node_dtor(_, _, _, path) {
*path + [ast_map::path_name(@"dtor")]
*path + [ast_map::path_name(@"dtor")]/~
}
@ -2645,7 +2646,7 @@ fn enum_is_univariant(cx: ctxt, id: ast::def_id) -> bool {
vec::len(*enum_variants(cx, id)) == 1u
}
fn enum_variants(cx: ctxt, id: ast::def_id) -> @[variant_info] {
fn enum_variants(cx: ctxt, id: ast::def_id) -> @[variant_info]/~ {
alt cx.enum_var_cache.find(id) {
some(variants) { ret variants; }
_ { /* fallthrough */ }
@ -2667,7 +2668,7 @@ fn enum_variants(cx: ctxt, id: ast::def_id) -> @[variant_info] {
let arg_tys = {
if vec::len(variant.node.args) > 0u {
ty_fn_args(ctor_ty).map { |a| a.ty }
} else { [] }
} else { []/~ }
};
alt variant.node.disr_expr {
some (ex) {
@ -2751,7 +2752,7 @@ fn lookup_field_type(tcx: ctxt, class_id: def_id, id: def_id,
// Look up the list of field names and IDs for a given class
// Fails if the id is not bound to a class.
fn lookup_class_fields(cx: ctxt, did: ast::def_id) -> [field_ty] {
fn lookup_class_fields(cx: ctxt, did: ast::def_id) -> [field_ty]/~ {
if did.crate == ast::local_crate {
alt cx.items.find(did.node) {
some(ast_map::node_item(i,_)) {
@ -2782,7 +2783,7 @@ fn lookup_class_field(cx: ctxt, parent: ast::def_id, field_id: ast::def_id)
}
}
fn lookup_public_fields(cx: ctxt, did: ast::def_id) -> [field_ty] {
fn lookup_public_fields(cx: ctxt, did: ast::def_id) -> [field_ty]/~ {
vec::filter(lookup_class_fields(cx, did), is_public)
}
@ -2796,7 +2797,7 @@ pure fn is_public(f: field_ty) -> bool {
// Look up the list of method names and IDs for a given class
// Fails if the id is not bound to a class.
fn lookup_class_method_ids(cx: ctxt, did: ast::def_id)
: is_local(did) -> [{name: ident, id: node_id, vis: visibility}] {
: is_local(did) -> [{name: ident, id: node_id, vis: visibility}]/~ {
alt cx.items.find(did.node) {
some(ast_map::node_item(@{node: item_class(_,_,items,_,_,_), _}, _)) {
let (_,ms) = split_class_items(items);
@ -2831,13 +2832,13 @@ fn lookup_class_method_by_name(cx:ctxt, did: ast::def_id, name: ident,
}
}
fn class_field_tys(items: [@class_member]) -> [field_ty] {
let mut rslt = [];
fn class_field_tys(items: [@class_member]/~) -> [field_ty]/~ {
let mut rslt = []/~;
for items.each {|it|
alt it.node {
instance_var(nm, _, cm, id, vis) {
rslt += [{ident: nm, id: ast_util::local_def(id),
vis: vis, mutability: cm}];
vis: vis, mutability: cm}]/~;
}
class_method(_) { }
}
@ -2852,14 +2853,14 @@ fn class_field_tys(items: [@class_member]) -> [field_ty] {
// mutable, regardless of how they were declared. It's meant to
// be used in trans.
fn class_items_as_mutable_fields(cx:ctxt, did: ast::def_id,
substs: substs) -> [field] {
substs: substs) -> [field]/~ {
class_item_fields(cx, did, substs, {|_mt| m_mutbl})
}
// Same as class_items_as_mutable_fields, but doesn't change
// mutability.
fn class_items_as_fields(cx:ctxt, did: ast::def_id,
substs: substs) -> [field] {
substs: substs) -> [field]/~ {
class_item_fields(cx, did, substs, {|mt| alt mt {
class_mutable { m_mutbl }
class_immutable { m_imm }}})
@ -2868,14 +2869,14 @@ fn class_items_as_fields(cx:ctxt, did: ast::def_id,
fn class_item_fields(cx:ctxt, did: ast::def_id,
substs: substs, frob_mutability: fn(class_mutability) -> mutability)
-> [field] {
let mut rslt = [];
-> [field]/~ {
let mut rslt = []/~;
for lookup_class_fields(cx, did).each {|f|
// consider all instance vars mut, because the
// constructor may mutate all vars
rslt += [{ident: f.ident, mt:
{ty: lookup_field_type(cx, did, f.id, substs),
mutbl: frob_mutability(f.mutability)}}];
mutbl: frob_mutability(f.mutability)}}]/~;
}
rslt
}
@ -2942,14 +2943,14 @@ fn is_binopable(_cx: ctxt, ty: t, op: ast::binop) -> bool {
/*. add, shift, bit
. sub, rel, logic
. mult, eq, */
/*other*/ [f, f, f, f, t, t, f, f],
/*bool*/ [f, f, f, f, t, t, t, t],
/*int*/ [t, t, t, t, t, t, t, f],
/*float*/ [t, t, t, f, t, t, f, f],
/*str*/ [t, f, f, f, t, t, f, f],
/*vec*/ [t, f, f, f, t, t, f, f],
/*bot*/ [f, f, f, f, t, t, f, f],
/*struct*/ [t, t, t, t, t, t, t, t]];
/*other*/ [f, f, f, f, t, t, f, f]/~,
/*bool*/ [f, f, f, f, t, t, t, t]/~,
/*int*/ [t, t, t, t, t, t, t, f]/~,
/*float*/ [t, t, t, f, t, t, f, f]/~,
/*str*/ [t, f, f, f, t, t, f, f]/~,
/*vec*/ [t, f, f, f, t, t, f, f]/~,
/*bot*/ [f, f, f, f, t, t, f, f]/~,
/*struct*/ [t, t, t, t, t, t, t, t]/~]/~;
ret tbl[tycat(ty)][opcat(op)];
}
@ -2972,7 +2973,7 @@ fn ast_constr_to_constr<T>(tcx: ctxt, c: @ast::constr_general<T>) ->
}
}
fn ty_params_to_tys(tcx: ty::ctxt, tps: [ast::ty_param]) -> [t] {
fn ty_params_to_tys(tcx: ty::ctxt, tps: [ast::ty_param]/~) -> [t]/~ {
vec::from_fn(tps.len(), {|i|
ty::mk_param(tcx, i, ast_util::local_def(tps[i].id))
})

13
src/rustc/middle/typeck.rs
View file

@ -120,7 +120,7 @@ type method_map_entry = {
type method_map = hashmap<ast::node_id, method_map_entry>;
// Resolutions for bounds of all parameters, left to right, for a given path.
type vtable_res = @[vtable_origin];
type vtable_res = @[vtable_origin]/~;
enum vtable_origin {
/*
@ -128,7 +128,7 @@ enum vtable_origin {
from whence comes the vtable, and tys are the type substs.
vtable_res is the vtable itself
*/
vtable_static(ast::def_id, [ty::t], vtable_res),
vtable_static(ast::def_id, [ty::t]/~, vtable_res),
/*
Dynamic vtable, comes from a parameter that has a bound on it:
fn foo<T: quux, baz, bar>(a: T) -- a's vtable would have a
@ -142,7 +142,7 @@ enum vtable_origin {
Dynamic vtable, comes from something known to have an interface
type. def_id refers to the iface item, tys are the substs
*/
vtable_iface(ast::def_id, [ty::t]),
vtable_iface(ast::def_id, [ty::t]/~),
}
type vtable_map = hashmap<ast::node_id, vtable_res>;
@ -163,7 +163,7 @@ fn write_ty_to_tcx(tcx: ty::ctxt, node_id: ast::node_id, ty: ty::t) {
}
fn write_substs_to_tcx(tcx: ty::ctxt,
node_id: ast::node_id,
+substs: [ty::t]) {
+substs: [ty::t]/~) {
if substs.len() > 0u {
tcx.node_type_substs.insert(node_id, substs);
}
@ -183,7 +183,7 @@ fn lookup_def_ccx(ccx: @crate_ctxt, sp: span, id: ast::node_id) -> ast::def {
}
fn no_params(t: ty::t) -> ty::ty_param_bounds_and_ty {
{bounds: @[], rp: ast::rp_none, ty: t}
{bounds: @[]/~, rp: ast::rp_none, ty: t}
}
fn require_same_types(
@ -259,7 +259,8 @@ fn check_main_fn_ty(ccx: @crate_ctxt,
if !ok {
tcx.sess.span_err(main_span,
#fmt("Wrong type in main function: found `%s`, \
expecting `native fn([str]) -> ()` or `native fn() -> ()`",
expecting `native fn([str]/~) -> ()` \
or `native fn() -> ()`",
ty_to_str(tcx, main_t)));
}
}

6
src/rustc/middle/typeck/astconv.rs
View file

@ -337,9 +337,9 @@ fn ast_ty_to_ty<AC: ast_conv, RS: region_scope copy>(
"implied fixed length for bound");
}
ast::ty_constr(t, cs) {
let mut out_cs = [];
let mut out_cs = []/~;
for cs.each {|constr|
out_cs += [ty::ast_constr_to_constr(tcx, constr)];
out_cs += [ty::ast_constr_to_constr(tcx, constr)]/~;
}
ty::mk_constr(tcx, ast_ty_to_ty(self, rscope, t), out_cs)
}
@ -402,7 +402,7 @@ fn ty_of_arg<AC: ast_conv, RS: region_scope copy>(
{mode: mode, ty: ty}
}
type expected_tys = option<{inputs: [ty::arg],
type expected_tys = option<{inputs: [ty::arg]/~,
output: ty::t}>;
fn ty_of_fn_decl<AC: ast_conv, RS: region_scope copy>(

98
src/rustc/middle/typeck/check.rs
View file

@ -89,7 +89,7 @@ type fn_ctxt =
infcx: infer::infer_ctxt,
locals: hashmap<ast::node_id, tv_vid>,
mut blocks: [ast::node_id], // stack of blocks in scope, may be empty
mut blocks: [ast::node_id]/~, // stack of blocks in scope, may be empty
in_scope_regions: isr_alist,
node_types: smallintmap::smallintmap<ty::t>,
@ -107,7 +107,7 @@ fn blank_fn_ctxt(ccx: @crate_ctxt, rty: ty::t) -> @fn_ctxt {
purity: ast::pure_fn,
infcx: infer::new_infer_ctxt(ccx.tcx),
locals: int_hash(),
mut blocks: [],
mut blocks: []/~,
in_scope_regions: @nil,
node_types: smallintmap::mk(),
node_type_substs: map::int_hash(),
@ -217,7 +217,7 @@ fn check_fn(ccx: @crate_ctxt,
purity: purity,
infcx: infcx,
locals: locals,
mut blocks: [],
mut blocks: []/~,
in_scope_regions: isr,
node_types: node_types,
node_type_substs: node_type_substs,
@ -257,7 +257,7 @@ fn check_fn(ccx: @crate_ctxt,
fn gather_locals(fcx: @fn_ctxt,
decl: ast::fn_decl,
body: ast::blk,
arg_tys: [ty::t]) {
arg_tys: [ty::t]/~) {
let tcx = fcx.ccx.tcx;
let assign = fn@(nid: ast::node_id, ty_opt: option<ty::t>) {
@ -565,7 +565,7 @@ impl methods for @fn_ctxt {
fn do_autoderef(fcx: @fn_ctxt, sp: span, t: ty::t) -> ty::t {
let mut t1 = t;
let mut enum_dids = [];
let mut enum_dids = []/~;
loop {
let sty = structure_of(fcx, sp, t1);
@ -639,9 +639,10 @@ fn check_expr(fcx: @fn_ctxt, expr: @ast::expr,
};
}
// determine the `self` type, using fresh variables for all variables declared
// on the impl declaration e.g., `impl<A,B> for [(A,B)]` would return ($0, $1)
// where $0 and $1 are freshly instantiated type variables.
// determine the `self` type, using fresh variables for all variables
// declared on the impl declaration e.g., `impl<A,B> for [(A,B)]/~`
// would return ($0, $1) where $0 and $1 are freshly instantiated type
// variables.
fn impl_self_ty(fcx: @fn_ctxt, did: ast::def_id) -> ty_param_substs_and_ty {
let tcx = fcx.ccx.tcx;
@ -692,7 +693,7 @@ fn impl_self_ty(fcx: @fn_ctxt, did: ast::def_id) -> ty_param_substs_and_ty {
// Only for fields! Returns <none> for methods>
// Indifferent to privacy flags
fn lookup_field_ty(tcx: ty::ctxt, class_id: ast::def_id,
items:[ty::field_ty], fieldname: ast::ident,
items:[ty::field_ty]/~, fieldname: ast::ident,
substs: ty::substs) -> option<ty::t> {
let o_field = vec::find(items, {|f| f.ident == fieldname});
@ -713,7 +714,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
// expressions.
fn check_call_or_bind(
fcx: @fn_ctxt, sp: span, call_expr_id: ast::node_id, in_fty: ty::t,
args: [option<@ast::expr>]) -> {fty: ty::t, bot: bool} {
args: [option<@ast::expr>]/~) -> {fty: ty::t, bot: bool} {
let mut bot = false;
@ -780,7 +781,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
// functions. This is so that we have more information about the types
// of arguments when we typecheck the functions. This isn't really the
// right way to do this.
for [false, true].each { |check_blocks|
for [false, true]/~.each { |check_blocks|
for args.eachi {|i, a_opt|
alt a_opt {
some(a) {
@ -816,7 +817,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
// A generic function for doing all of the checking for call expressions
fn check_call(fcx: @fn_ctxt, sp: span, call_expr_id: ast::node_id,
f: @ast::expr, args: [@ast::expr]) -> bool {
f: @ast::expr, args: [@ast::expr]/~) -> bool {
let mut bot = check_expr(fcx, f, none);
let fn_ty = fcx.expr_ty(f);
@ -889,11 +890,11 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
}
fn lookup_op_method(fcx: @fn_ctxt, op_ex: @ast::expr,
self_ex: @ast::expr, self_t: ty::t,
opname: str, args: [option<@ast::expr>])
opname: str, args: [option<@ast::expr>]/~)
-> option<(ty::t, bool)> {
let callee_id = ast_util::op_expr_callee_id(op_ex);
let lkup = method::lookup(fcx, op_ex, self_ex, op_ex.id,
callee_id, @opname, self_t, [], false);
callee_id, @opname, self_t, []/~, false);
alt lkup.method() {
some(origin) {
let {fty: method_ty, bot: bot} = {
@ -964,7 +965,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
some(name) {
alt lookup_op_method(fcx, ex,
lhs_expr, lhs_resolved_t,
name, [some(rhs)]) {
name, [some(rhs)]/~) {
some(pair) { ret pair; }
_ {}
}
@ -982,7 +983,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
fn check_user_unop(fcx: @fn_ctxt, op_str: str, mname: str,
ex: @ast::expr,
rhs_expr: @ast::expr, rhs_t: ty::t) -> ty::t {
alt lookup_op_method(fcx, ex, rhs_expr, rhs_t, mname, []) {
alt lookup_op_method(fcx, ex, rhs_expr, rhs_t, mname, []/~) {
some((ret_ty, _)) { ret_ty }
_ {
fcx.ccx.tcx.sess.span_err(
@ -1415,7 +1416,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
fcx.write_ty(id, typ);
}
ast::expr_tup(elts) {
let mut elt_ts = [];
let mut elt_ts = []/~;
vec::reserve(elt_ts, vec::len(elts));
let flds = unpack_expected(fcx, expected) {|sty|
alt sty { ty::ty_tup(flds) { some(flds) } _ { none } }
@ -1423,7 +1424,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
for elts.eachi {|i, e|
check_expr(fcx, e, flds.map {|fs| fs[i]});
let ety = fcx.expr_ty(e);
elt_ts += [ety];
elt_ts += [ety]/~;
}
let typ = ty::mk_tup(tcx, elt_ts);
fcx.write_ty(id, typ);
@ -1574,7 +1575,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
let resolved = structurally_resolved_type(fcx, expr.span,
raw_base_t);
alt lookup_op_method(fcx, expr, base, resolved, "[]",
[some(idx)]) {
[some(idx)]/~) {
some((ret_ty, _)) { fcx.write_ty(id, ret_ty); }
_ {
tcx.sess.span_fatal(
@ -1592,7 +1593,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
let p_ty = fcx.expr_ty(p);
let lkup = method::lookup(fcx, p, p, expr.id, alloc_id,
@"alloc", p_ty, [], false);
@"alloc", p_ty, []/~, false);
alt lkup.method() {
some(entry) {
fcx.ccx.method_map.insert(alloc_id, entry);
@ -1607,10 +1608,10 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
ty::mk_fn(tcx, {purity: ast::impure_fn,
proto: ast::proto_any,
inputs: [{mode: m, ty: ty_uint},
{mode: m, ty: ty_uint}],
{mode: m, ty: ty_uint}]/~,
output: ty_nilp,
ret_style: ast::return_val,
constraints: []})
constraints: []/~})
};
demand::suptype(fcx, expr.span,
@ -1791,13 +1792,13 @@ fn check_instantiable(tcx: ty::ctxt,
fn check_enum_variants(ccx: @crate_ctxt,
sp: span,
vs: [ast::variant],
vs: [ast::variant]/~,
id: ast::node_id) {
let rty = ty::node_id_to_type(ccx.tcx, id);
let fcx = blank_fn_ctxt(ccx, rty);
let mut disr_vals: [int] = [];
let mut disr_vals: [int]/~ = []/~;
let mut disr_val = 0;
let mut variants = [];
let mut variants = []/~;
for vs.each {|v|
alt v.node.disr_expr {
some(e) {
@ -1825,14 +1826,14 @@ fn check_enum_variants(ccx: @crate_ctxt,
ccx.tcx.sess.span_err(v.span,
"discriminator value already exists");
}
disr_vals += [disr_val];
disr_vals += [disr_val]/~;
let ctor_ty = ty::node_id_to_type(ccx.tcx, v.node.id);
let arg_tys = if v.node.args.len() > 0u {
ty::ty_fn_args(ctor_ty).map {|a| a.ty }
} else { [] };
} else { []/~ };
variants += [@{args: arg_tys, ctor_ty: ctor_ty,
name: v.node.name, id: local_def(v.node.id),
disr_val: disr_val}];
disr_val: disr_val}]/~;
disr_val += 1;
}
@ -1906,10 +1907,11 @@ fn check_pred_expr(fcx: @fn_ctxt, e: @ast::expr) -> bool {
ret bot;
}
fn check_constraints(fcx: @fn_ctxt, cs: [@ast::constr], args: [ast::arg]) {
fn check_constraints(fcx: @fn_ctxt, cs: [@ast::constr]/~,
args: [ast::arg]/~) {
let num_args = vec::len(args);
for cs.each {|c|
let mut c_args = [];
let mut c_args = []/~;
for c.node.args.each {|a|
c_args += [
// "base" should not occur in a fn type thing, as of
@ -1935,8 +1937,8 @@ fn check_constraints(fcx: @fn_ctxt, cs: [@ast::constr], args: [ast::arg]) {
ast::carg_ident(i) {
if i < num_args {
let p = @{span: a.span, global: false,
idents: [args[i].ident],
rp: none, types: []};
idents: [args[i].ident]/~,
rp: none, types: []/~};
let arg_occ_node_id =
fcx.ccx.tcx.sess.next_node_id();
fcx.ccx.tcx.def_map.insert
@ -1951,7 +1953,7 @@ fn check_constraints(fcx: @fn_ctxt, cs: [@ast::constr], args: [ast::arg]) {
carg_ident index out of bounds");
}
}
}];
}]/~;
}
let p_op: ast::expr_ = ast::expr_path(c.node.path);
let oper: @ast::expr = @{id: c.node.id, node: p_op, span: c.span};
@ -2017,7 +2019,7 @@ fn ty_param_bounds_and_ty_for_def(fcx: @fn_ctxt, sp: span, defn: ast::def) ->
ast::def_fn(id, ast::crust_fn) {
// Crust functions are just u8 pointers
ret {
bounds: @[],
bounds: @[]/~,
rp: ast::rp_none,
ty: ty::mk_ptr(
fcx.ccx.tcx,
@ -2167,7 +2169,7 @@ fn ast_expr_vstore_to_vstore(fcx: @fn_ctxt, e: @ast::expr, n: uint,
fn check_bounds_are_used(ccx: @crate_ctxt,
span: span,
tps: [ast::ty_param],
tps: [ast::ty_param]/~,
rp: ast::region_param,
ty: ty::t) {
let mut r_used = alt rp {
@ -2218,26 +2220,26 @@ fn check_intrinsic_type(ccx: @crate_ctxt, it: @ast::native_item) {
let tcx = ccx.tcx;
let (n_tps, inputs, output) = alt *it.ident {
"size_of" |
"pref_align_of" | "min_align_of" { (1u, [], ty::mk_uint(ccx.tcx)) }
"get_tydesc" { (1u, [], ty::mk_nil_ptr(tcx)) }
"init" { (1u, [], param(ccx, 0u)) }
"forget" { (1u, [arg(ast::by_move, param(ccx, 0u))],
"pref_align_of" | "min_align_of" { (1u, []/~, ty::mk_uint(ccx.tcx)) }
"get_tydesc" { (1u, []/~, ty::mk_nil_ptr(tcx)) }
"init" { (1u, []/~, param(ccx, 0u)) }
"forget" { (1u, [arg(ast::by_move, param(ccx, 0u))]/~,
ty::mk_nil(tcx)) }
"reinterpret_cast" { (2u, [arg(ast::by_ref, param(ccx, 0u))],
"reinterpret_cast" { (2u, [arg(ast::by_ref, param(ccx, 0u))]/~,
param(ccx, 1u)) }
"addr_of" { (1u, [arg(ast::by_ref, param(ccx, 0u))],
"addr_of" { (1u, [arg(ast::by_ref, param(ccx, 0u))]/~,
ty::mk_imm_ptr(tcx, param(ccx, 0u))) }
"move_val" | "move_val_init" {
(1u, [arg(ast::by_mutbl_ref, param(ccx, 0u)),
arg(ast::by_move, param(ccx, 0u))],
arg(ast::by_move, param(ccx, 0u))]/~,
ty::mk_nil(tcx))
}
"needs_drop" { (1u, [], ty::mk_bool(tcx)) }
"needs_drop" { (1u, []/~, ty::mk_bool(tcx)) }
"visit_ty" {
assert ccx.tcx.intrinsic_ifaces.contains_key(@"ty_visitor");
let (_, visitor_iface) = ccx.tcx.intrinsic_ifaces.get(@"ty_visitor");
(1u, [arg(ast::by_ref, visitor_iface)], ty::mk_nil(tcx))
(1u, [arg(ast::by_ref, visitor_iface)]/~, ty::mk_nil(tcx))
}
"frame_address" {
let fty = ty::mk_fn(ccx.tcx, {
@ -2248,12 +2250,12 @@ fn check_intrinsic_type(ccx: @crate_ctxt, it: @ast::native_item) {
ty: ty::mk_imm_ptr(
ccx.tcx,
ty::mk_mach_uint(ccx.tcx, ast::ty_u8))
}],
}]/~,
output: ty::mk_nil(ccx.tcx),
ret_style: ast::return_val,
constraints: []
constraints: []/~
});
(0u, [arg(ast::by_ref, fty)], ty::mk_nil(tcx))
(0u, [arg(ast::by_ref, fty)]/~, ty::mk_nil(tcx))
}
other {
tcx.sess.span_err(it.span, "unrecognized intrinsic function: `" +
@ -2265,7 +2267,7 @@ fn check_intrinsic_type(ccx: @crate_ctxt, it: @ast::native_item) {
proto: ast::proto_bare,
inputs: inputs, output: output,
ret_style: ast::return_val,
constraints: []});
constraints: []/~});
let i_ty = ty::lookup_item_type(ccx.tcx, local_def(it.id));
let i_n_tps = (*i_ty.bounds).len();
if i_n_tps != n_tps {

6
src/rustc/middle/typeck/check/alt.rs
View file

@ -4,7 +4,7 @@ import middle::typeck::infer::methods; // next_ty_var,
fn check_alt(fcx: @fn_ctxt,
expr: @ast::expr,
discrim: @ast::expr,
arms: [ast::arm]) -> bool {
arms: [ast::arm]/~) -> bool {
let tcx = fcx.ccx.tcx;
let mut bot;
@ -52,7 +52,7 @@ type pat_ctxt = {
};
fn check_pat_variant(pcx: pat_ctxt, pat: @ast::pat, path: @ast::path,
subpats: option<[@ast::pat]>, expected: ty::t) {
subpats: option<[@ast::pat]/~>, expected: ty::t) {
// Typecheck the path.
let fcx = pcx.fcx;
@ -170,7 +170,7 @@ fn check_pat(pcx: pat_ctxt, pat: @ast::pat, expected: ty::t) {
}
}
ast::pat_ident(path, c) {
check_pat_variant(pcx, pat, path, some([]), expected);
check_pat_variant(pcx, pat, path, some([]/~), expected);
}
ast::pat_enum(path, subpats) {
check_pat_variant(pcx, pat, path, subpats, expected);

4
src/rustc/middle/typeck/check/method.rs
View file

@ -23,7 +23,7 @@ class lookup {
let mut self_ty: ty::t;
let mut derefs: uint;
let candidates: dvec<candidate>;
let supplied_tps: [ty::t];
let supplied_tps: [ty::t]/~;
let include_private: bool;
new(fcx: @fn_ctxt,
@ -33,7 +33,7 @@ class lookup {
node_id: ast::node_id, //node id where to store type of fn
m_name: ast::ident, //b in a.b(...)
self_ty: ty::t, //type of a in a.b(...)
supplied_tps: [ty::t], //Xs in a.b::<Xs>(...)
supplied_tps: [ty::t]/~, //Xs in a.b::<Xs>(...)
include_private: bool) {
self.fcx = fcx;

4
src/rustc/middle/typeck/check/regionmanip.rs
View file

@ -12,7 +12,7 @@ fn replace_bound_regions_in_fn_ty(
fn_ty: ty::fn_ty} {
let mut all_tys = ty::tys_in_fn_ty(fn_ty);
for self_ty.each { |t| all_tys += [t] }
for self_ty.each { |t| all_tys += [t]/~ }
#debug["replace_bound_regions_in_fn_ty(self_ty=%?, fn_ty=%s, all_tys=%?)",
self_ty.map { |t| ty_to_str(tcx, t) },
@ -50,7 +50,7 @@ fn replace_bound_regions_in_fn_ty(
fn create_bound_region_mapping(
tcx: ty::ctxt,
isr: isr_alist,
tys: [ty::t],
tys: [ty::t]/~,
to_r: fn(ty::bound_region) -> ty::region) -> isr_alist {
// Takes `isr` (described above), `to_r` (described above),

18
src/rustc/middle/typeck/check/vtable.rs
View file

@ -1,6 +1,6 @@
import check::{fn_ctxt, impl_self_ty, methods};
fn has_iface_bounds(tps: [ty::param_bounds]) -> bool {
fn has_iface_bounds(tps: [ty::param_bounds]/~) -> bool {
vec::any(tps, {|bs|
vec::any(*bs, {|b|
alt b { ty::bound_iface(_) { true } _ { false } }
@ -9,17 +9,17 @@ fn has_iface_bounds(tps: [ty::param_bounds]) -> bool {
}
fn lookup_vtables(fcx: @fn_ctxt, isc: resolve::iscopes, sp: span,
bounds: @[ty::param_bounds], substs: ty::substs,
bounds: @[ty::param_bounds]/~, substs: ty::substs,
allow_unsafe: bool) -> vtable_res {
let tcx = fcx.ccx.tcx;
let mut result = [], i = 0u;
let mut result = []/~, i = 0u;
for substs.tps.each {|ty|
for vec::each(*bounds[i]) {|bound|
alt bound {
ty::bound_iface(i_ty) {
let i_ty = ty::subst(tcx, substs, i_ty);
result += [lookup_vtable(fcx, isc, sp, ty, i_ty,
allow_unsafe)];
allow_unsafe)]/~;
}
_ {}
}
@ -105,7 +105,7 @@ fn lookup_vtable(fcx: @fn_ctxt, isc: resolve::iscopes, sp: span,
}
_ {
let mut found = [];
let mut found = []/~;
for list::each(isc) {|impls|
/* For each impl in scope... */
@ -144,7 +144,7 @@ fn lookup_vtable(fcx: @fn_ctxt, isc: resolve::iscopes, sp: span,
iface_tps, im.did);
let subres = lookup_vtables(fcx, isc, sp,
im_bs, substs_f, false);
found += [vtable_static(im.did, substs_f.tps, subres)];
found += [vtable_static(im.did, substs_f.tps, subres)]/~;
}
alt found.len() {
@ -180,8 +180,8 @@ fn fixup_ty(fcx: @fn_ctxt, sp: span, ty: ty::t) -> ty::t {
}
}
fn connect_iface_tps(fcx: @fn_ctxt, sp: span, impl_tys: [ty::t],
iface_tys: [ty::t], impl_did: ast::def_id) {
fn connect_iface_tps(fcx: @fn_ctxt, sp: span, impl_tys: [ty::t]/~,
iface_tys: [ty::t]/~, impl_did: ast::def_id) {
let tcx = fcx.ccx.tcx;
let ity = option::get(ty::impl_iface(tcx, impl_did));
let iface_ty = ty::subst_tps(tcx, impl_tys, ity);
@ -251,7 +251,7 @@ fn resolve_expr(ex: @ast::expr, &&fcx: @fn_ctxt, v: visit::vt<@fn_ctxt>) {
Map this expression to that vtable (that is: "ex has
vtable <vtable>")
*/
cx.vtable_map.insert(ex.id, @[vtable]);
cx.vtable_map.insert(ex.id, @[vtable]/~);
}
_ {}
}

4
src/rustc/middle/typeck/check/writeback.rs
View file

@ -40,10 +40,10 @@ fn resolve_type_vars_for_node(wbcx: wb_ctxt, sp: span, id: ast::node_id)
write_ty_to_tcx(tcx, id, t);
alt fcx.opt_node_ty_substs(id) {
some(substs) {
let mut new_tps = [];
let mut new_tps = []/~;
for substs.tps.each {|subst|
alt resolve_type_vars_in_type(fcx, sp, subst) {
some(t) { new_tps += [t]; }
some(t) { new_tps += [t]/~; }
none { wbcx.success = false; ret none; }
}
}

48
src/rustc/middle/typeck/collect.rs
View file

@ -37,7 +37,7 @@ fn collect_item_types(ccx: @crate_ctxt, crate: @ast::crate) {
ast::item_iface(_, _, _) {
let def_id = { crate: ast::local_crate,
node: intrinsic_item.id };
let substs = {self_r: none, self_ty: none, tps: []};
let substs = {self_r: none, self_ty: none, tps: []/~};
let ty = ty::mk_iface(ccx.tcx, def_id, substs);
ccx.tcx.intrinsic_ifaces.insert
(intrinsic_item.ident, (def_id, ty));
@ -96,8 +96,8 @@ impl of ast_conv for @crate_ctxt {
fn get_enum_variant_types(ccx: @crate_ctxt,
enum_ty: ty::t,
variants: [ast::variant],
ty_params: [ast::ty_param],
variants: [ast::variant]/~,
ty_params: [ast::ty_param]/~,
rp: ast::region_param) {
let tcx = ccx.tcx;
@ -118,7 +118,7 @@ fn get_enum_variant_types(ccx: @crate_ctxt,
inputs: args,
output: enum_ty,
ret_style: ast::return_val,
constraints: []})
constraints: []/~})
};
let tpt = {bounds: ty_param_bounds(ccx, ty_params),
rp: rp,
@ -130,7 +130,7 @@ fn get_enum_variant_types(ccx: @crate_ctxt,
fn ensure_iface_methods(ccx: @crate_ctxt, id: ast::node_id) {
fn store_methods<T>(ccx: @crate_ctxt, id: ast::node_id,
stuff: [T], f: fn@(T) -> ty::method) {
stuff: [T]/~, f: fn@(T) -> ty::method) {
ty::store_iface_methods(ccx.tcx, id, @vec::map(stuff, f));
}
@ -224,11 +224,11 @@ fn compare_impl_method(tcx: ty::ctxt, sp: span,
}
fn check_methods_against_iface(ccx: @crate_ctxt,
tps: [ast::ty_param],
tps: [ast::ty_param]/~,
rp: ast::region_param,
selfty: ty::t,
a_ifacety: @ast::iface_ref,
ms: [converted_method]) {
ms: [converted_method]/~) {
let tcx = ccx.tcx;
let (did, tpt) = instantiate_iface_ref(ccx, a_ifacety, rp);
@ -259,7 +259,7 @@ fn check_methods_against_iface(ccx: @crate_ctxt,
fn convert_class_item(ccx: @crate_ctxt,
rp: ast::region_param,
bounds: @[ty::param_bounds],
bounds: @[ty::param_bounds]/~,
v: ast_util::ivar) {
let tt = ccx.to_ty(type_rscope(rp), v.ty);
write_ty_to_tcx(ccx.tcx, v.id, tt);
@ -270,10 +270,10 @@ fn convert_class_item(ccx: @crate_ctxt,
type converted_method = {mty: ty::method, id: ast::node_id, span: span};
fn convert_methods(ccx: @crate_ctxt,
ms: [@ast::method],
ms: [@ast::method]/~,
rp: ast::region_param,
rcvr_bounds: @[ty::param_bounds],
self_ty: ty::t) -> [converted_method] {
rcvr_bounds: @[ty::param_bounds]/~,
self_ty: ty::t) -> [converted_method]/~ {
let tcx = ccx.tcx;
vec::map(ms) { |m|
@ -344,7 +344,7 @@ fn convert(ccx: @crate_ctxt, it: @ast::item) {
inputs: t_args,
output: t_res,
ret_style: ast::return_val,
constraints: []}); // tjc TODO
constraints: []/~}); // tjc TODO
write_ty_to_tcx(tcx, ctor.node.id, t_ctor);
tcx.tcache.insert(local_def(ctor.node.id),
{bounds: tpt.bounds,
@ -549,26 +549,26 @@ fn ty_of_native_item(ccx: @crate_ctxt, it: @ast::native_item)
}
}
fn ty_param_bounds(ccx: @crate_ctxt,
params: [ast::ty_param]) -> @[ty::param_bounds] {
params: [ast::ty_param]/~) -> @[ty::param_bounds]/~ {
fn compute_bounds(ccx: @crate_ctxt,
param: ast::ty_param) -> ty::param_bounds {
@vec::flat_map(*param.bounds) { |b|
alt b {
ast::bound_send { [ty::bound_send] }
ast::bound_copy { [ty::bound_copy] }
ast::bound_const { [ty::bound_const] }
ast::bound_send { [ty::bound_send]/~ }
ast::bound_copy { [ty::bound_copy]/~ }
ast::bound_const { [ty::bound_const]/~ }
ast::bound_iface(t) {
let ity = ast_ty_to_ty(ccx, empty_rscope, t);
alt ty::get(ity).struct {
ty::ty_iface(*) {
[ty::bound_iface(ity)]
[ty::bound_iface(ity)]/~
}
_ {
ccx.tcx.sess.span_err(
t.span, "type parameter bounds must be \
interface types");
[]
[]/~
}
}
}
@ -590,7 +590,7 @@ fn ty_param_bounds(ccx: @crate_ctxt,
fn ty_of_native_fn_decl(ccx: @crate_ctxt,
decl: ast::fn_decl,
ty_params: [ast::ty_param],
ty_params: [ast::ty_param]/~,
def_id: ast::def_id) -> ty::ty_param_bounds_and_ty {
let bounds = ty_param_bounds(ccx, ty_params);
@ -603,14 +603,14 @@ fn ty_of_native_fn_decl(ccx: @crate_ctxt,
inputs: input_tys,
output: output_ty,
ret_style: ast::return_val,
constraints: []});
constraints: []/~});
let tpt = {bounds: bounds, rp: ast::rp_none, ty: t_fn};
ccx.tcx.tcache.insert(def_id, tpt);
ret tpt;
}
fn mk_ty_params(ccx: @crate_ctxt, atps: [ast::ty_param])
-> {bounds: @[ty::param_bounds], params: [ty::t]} {
fn mk_ty_params(ccx: @crate_ctxt, atps: [ast::ty_param]/~)
-> {bounds: @[ty::param_bounds]/~, params: [ty::t]/~} {
let mut i = 0u;
let bounds = ty_param_bounds(ccx, atps);
@ -622,8 +622,8 @@ fn mk_ty_params(ccx: @crate_ctxt, atps: [ast::ty_param])
})}
}
fn mk_substs(ccx: @crate_ctxt, atps: [ast::ty_param], rp: ast::region_param)
-> {bounds: @[ty::param_bounds], substs: ty::substs} {
fn mk_substs(ccx: @crate_ctxt, atps: [ast::ty_param]/~, rp: ast::region_param)
-> {bounds: @[ty::param_bounds]/~, substs: ty::substs} {
let {bounds, params} = mk_ty_params(ccx, atps);
let self_r = alt rp {

48
src/rustc/middle/typeck/infer.rs
View file

@ -293,7 +293,7 @@ enum var_value<V:copy, T:copy> {
type vals_and_bindings<V:copy, T:copy> = {
vals: smallintmap<var_value<V, T>>,
mut bindings: [(V, var_value<V, T>)]
mut bindings: [(V, var_value<V, T>)]/~
};
enum node<V:copy, T:copy> = {
@ -346,9 +346,9 @@ type fres<T> = result::result<T, fixup_err>;
fn new_infer_ctxt(tcx: ty::ctxt) -> infer_ctxt {
infer_ctxt(@{tcx: tcx,
tvb: {vals: smallintmap::mk(), mut bindings: []},
tvib: {vals: smallintmap::mk(), mut bindings: []},
rb: {vals: smallintmap::mk(), mut bindings: []},
tvb: {vals: smallintmap::mk(), mut bindings: []/~},
tvib: {vals: smallintmap::mk(), mut bindings: []/~},
rb: {vals: smallintmap::mk(), mut bindings: []/~},
ty_var_counter: @mut 0u,
ty_var_integral_counter: @mut 0u,
region_var_counter: @mut 0u})}
@ -556,8 +556,8 @@ impl transaction_methods for infer_ctxt {
// TODO---could use a vec::clear() that ran destructors but kept
// the vec at its currently allocated length
self.tvb.bindings = [];
self.rb.bindings = [];
self.tvb.bindings = []/~;
self.rb.bindings = []/~;
ret r;
}
@ -604,7 +604,7 @@ impl methods for infer_ctxt {
ty::mk_var(self.tcx, self.next_ty_var_id())
}
fn next_ty_vars(n: uint) -> [ty::t] {
fn next_ty_vars(n: uint) -> [ty::t]/~ {
vec::from_fn(n) {|_i| self.next_ty_var() }
}
@ -1041,7 +1041,7 @@ impl unify_methods for infer_ctxt {
}
fn constrvecs(
as: [@ty::type_constr], bs: [@ty::type_constr]) -> ures {
as: [@ty::type_constr]/~, bs: [@ty::type_constr]/~) -> ures {
if check vec::same_length(as, bs) {
iter_vec2(as, bs) {|a,b|
@ -1082,8 +1082,8 @@ impl unify_methods for infer_ctxt {
// resolution. The first is a shallow resolution: this only resolves
// one layer, but does not resolve any nested variables. So, for
// example, if we have two variables A and B, and the constraint that
// A <: [B] and B <: int, then shallow resolution on A would yield
// [B]. Deep resolution, on the other hand, would yield [int].
// A <: [B]/~ and B <: int, then shallow resolution on A would yield
// [B]/~. Deep resolution, on the other hand, would yield [int]/~.
//
// But there is one more knob: the `force_level` variable controls
// the behavior in the face of unconstrained type and region
@ -1107,8 +1107,8 @@ type resolve_state = @{
deep: bool,
force_vars: force_level,
mut err: option<fixup_err>,
mut r_seen: [region_vid],
mut v_seen: [tv_vid]
mut r_seen: [region_vid]/~,
mut v_seen: [tv_vid]/~
};
fn resolver(infcx: infer_ctxt, deep: bool, fvars: force_level)
@ -1117,8 +1117,8 @@ fn resolver(infcx: infer_ctxt, deep: bool, fvars: force_level)
deep: deep,
force_vars: fvars,
mut err: none,
mut r_seen: [],
mut v_seen: []}
mut r_seen: []/~,
mut v_seen: []/~}
}
impl methods for resolve_state {
@ -1308,14 +1308,14 @@ impl methods for resolve_state {
//
// Assuming we have a bound from both sides, we will then examine
// these bounds and see if they have the form (@M_a T_a, &rb.M_b T_b)
// (resp. ~M_a T_a, [M_a T_a], etc). If they do not, we fall back to
// (resp. ~M_a T_a, [M_a T_a]/~, etc). If they do not, we fall back to
// subtyping.
//
// If they *do*, then we know that the two types could never be
// subtypes of one another. We will then construct a type @const T_b
// and ensure that type a is a subtype of that. This allows for the
// possibility of assigning from a type like (say) @[mut T1] to a type
// &[T2] where T1 <: T2. This might seem surprising, since the `@`
// possibility of assigning from a type like (say) @[mut T1]/~ to a type
// &[T2]/~ where T1 <: T2. This might seem surprising, since the `@`
// points at mutable memory but the `&` points at immutable memory.
// This would in fact be unsound, except for the borrowck, which comes
// later and guarantees that such mutability conversions are safe.
@ -1533,7 +1533,7 @@ iface combine {
fn mts(a: ty::mt, b: ty::mt) -> cres<ty::mt>;
fn contratys(a: ty::t, b: ty::t) -> cres<ty::t>;
fn tys(a: ty::t, b: ty::t) -> cres<ty::t>;
fn tps(as: [ty::t], bs: [ty::t]) -> cres<[ty::t]>;
fn tps(as: [ty::t]/~, bs: [ty::t]/~) -> cres<[ty::t]/~>;
fn self_tys(a: option<ty::t>, b: option<ty::t>) -> cres<option<ty::t>>;
fn substs(as: ty::substs, bs: ty::substs) -> cres<ty::substs>;
fn fns(a: ty::fn_ty, b: ty::fn_ty) -> cres<ty::fn_ty>;
@ -1592,7 +1592,7 @@ fn super_substs<C:combine>(
}
fn super_tps<C:combine>(
self: C, as: [ty::t], bs: [ty::t]) -> cres<[ty::t]> {
self: C, as: [ty::t]/~, bs: [ty::t]/~) -> cres<[ty::t]/~> {
// Note: type parameters are always treated as *invariant*
// (otherwise the type system would be unsound). In the
@ -1692,8 +1692,8 @@ fn super_vstores<C:combine>(
fn super_fns<C:combine>(
self: C, a_f: ty::fn_ty, b_f: ty::fn_ty) -> cres<ty::fn_ty> {
fn argvecs<C:combine>(
self: C, a_args: [ty::arg], b_args: [ty::arg]) -> cres<[ty::arg]> {
fn argvecs<C:combine>(self: C, a_args: [ty::arg]/~,
b_args: [ty::arg]/~) -> cres<[ty::arg]/~> {
if check vec::same_length(a_args, b_args) {
map_vec2(a_args, b_args) {|a, b| self.args(a, b) }
@ -2061,7 +2061,7 @@ impl of combine for sub {
super_substs(self, as, bs)
}
fn tps(as: [ty::t], bs: [ty::t]) -> cres<[ty::t]> {
fn tps(as: [ty::t]/~, bs: [ty::t]/~) -> cres<[ty::t]/~> {
super_tps(self, as, bs)
}
@ -2247,7 +2247,7 @@ impl of combine for lub {
super_substs(self, as, bs)
}
fn tps(as: [ty::t], bs: [ty::t]) -> cres<[ty::t]> {
fn tps(as: [ty::t]/~, bs: [ty::t]/~) -> cres<[ty::t]/~> {
super_tps(self, as, bs)
}
@ -2446,7 +2446,7 @@ impl of combine for glb {
super_substs(self, as, bs)
}
fn tps(as: [ty::t], bs: [ty::t]) -> cres<[ty::t]> {
fn tps(as: [ty::t]/~, bs: [ty::t]/~) -> cres<[ty::t]/~> {
super_tps(self, as, bs)
}

6
src/rustc/util/common.rs
View file

@ -29,9 +29,9 @@ type flag = hashmap<str, ()>;
fn field_expr(f: ast::field) -> @ast::expr { ret f.node.expr; }
fn field_exprs(fields: [ast::field]) -> [@ast::expr] {
let mut es = [];
for fields.each {|f| es += [f.node.expr]; }
fn field_exprs(fields: [ast::field]/~) -> [@ast::expr]/~ {
let mut es = []/~;
for fields.each {|f| es += [f.node.expr]/~; }
ret es;
}

24
src/rustc/util/ppaux.rs
View file

@ -96,7 +96,7 @@ fn vstore_to_str(cx: ctxt, vs: ty::vstore) -> str {
}
}
fn tys_to_str(cx: ctxt, ts: [t]) -> str {
fn tys_to_str(cx: ctxt, ts: [t]/~) -> str {
let mut rs = "";
for ts.each {|t| rs += ty_to_str(cx, t); }
rs
@ -121,8 +121,8 @@ fn ty_to_str(cx: ctxt, typ: t) -> str {
}
fn fn_to_str(cx: ctxt, purity: ast::purity, proto: ast::proto,
ident: option<ast::ident>,
inputs: [arg], output: t, cf: ast::ret_style,
constrs: [@constr]) -> str {
inputs: [arg]/~, output: t, cf: ast::ret_style,
constrs: [@constr]/~) -> str {
let mut s;
s = alt purity {
@ -132,8 +132,8 @@ fn ty_to_str(cx: ctxt, typ: t) -> str {
s += proto_to_str(proto);
alt ident { some(i) { s += " "; s += *i; } _ { } }
s += "(";
let mut strs = [];
for inputs.each {|a| strs += [fn_input_to_str(cx, a)]; }
let mut strs = []/~;
for inputs.each {|a| strs += [fn_input_to_str(cx, a)]/~; }
s += str::connect(strs, ", ");
s += ")";
if ty::get(output).struct != ty_nil {
@ -189,13 +189,13 @@ fn ty_to_str(cx: ctxt, typ: t) -> str {
ty_unboxed_vec(tm) { "unboxed_vec<" + mt_to_str(cx, tm) + ">" }
ty_type { "type" }
ty_rec(elems) {
let mut strs: [str] = [];
for elems.each {|fld| strs += [field_to_str(cx, fld)]; }
let mut strs: [str]/~ = []/~;
for elems.each {|fld| strs += [field_to_str(cx, fld)]/~; }
"{" + str::connect(strs, ",") + "}"
}
ty_tup(elems) {
let mut strs = [];
for elems.each {|elem| strs += [ty_to_str(cx, elem)]; }
let mut strs = []/~;
for elems.each {|elem| strs += [ty_to_str(cx, elem)]/~; }
"(" + str::connect(strs, ",") + ")"
}
ty_fn(f) {
@ -205,7 +205,7 @@ fn ty_to_str(cx: ctxt, typ: t) -> str {
ty_var(v) { v.to_str() }
ty_var_integral(v) { v.to_str() }
ty_param(id, _) {
"'" + str::from_bytes([('a' as u8) + (id as u8)])
"'" + str::from_bytes([('a' as u8) + (id as u8)]/~)
}
ty_self { "self" }
ty_enum(did, substs) | ty_class(did, substs) {
@ -234,7 +234,7 @@ fn ty_to_str(cx: ctxt, typ: t) -> str {
fn parameterized(cx: ctxt,
base: str,
self_r: option<ty::region>,
tps: [ty::t]) -> str {
tps: [ty::t]/~) -> str {
let r_str = alt self_r {
none { "" }
@ -262,7 +262,7 @@ fn constr_to_str(c: @constr) -> str {
pprust::constr_args_to_str(pprust::uint_to_str, c.node.args);
}
fn constrs_str(constrs: [@constr]) -> str {
fn constrs_str(constrs: [@constr]/~) -> str {
let mut s = "";
let mut colon = true;
for constrs.each {|c|