diff options
Diffstat (limited to 'src')
422 files changed, 8010 insertions, 7942 deletions
diff --git a/src/cargo/cargo.rs b/src/cargo/cargo.rs index 6271c35f494..6b9b6c9c39d 100644 --- a/src/cargo/cargo.rs +++ b/src/cargo/cargo.rs @@ -15,106 +15,106 @@ import json::to_str; import getopts::{optflag, optopt, opt_present}; type package = { - name: str, - uuid: str, - url: str, - method: str, - description: str, - ref: option<str>, - tags: ~[str], - versions: ~[(str, str)] + name: ~str, + uuid: ~str, + url: ~str, + method: ~str, + description: ~str, + ref: option<~str>, + tags: ~[~str], + versions: ~[(~str, ~str)] }; type local_package = { - name: str, - metaname: str, - version: str, - files: ~[str] + name: ~str, + metaname: ~str, + version: ~str, + files: ~[~str] }; type source = @{ - name: str, - mut url: str, - mut method: str, - mut key: option<str>, - mut keyfp: option<str>, + name: ~str, + mut url: ~str, + mut method: ~str, + mut key: option<~str>, + mut keyfp: option<~str>, mut packages: ~[mut package] }; type cargo = { pgp: bool, - root: str, - installdir: str, - bindir: str, - libdir: str, - workdir: str, - sourcedir: str, - sources: map::hashmap<str, source>, - mut current_install: str, - dep_cache: map::hashmap<str, bool>, + root: ~str, + installdir: ~str, + bindir: ~str, + libdir: ~str, + workdir: ~str, + sourcedir: ~str, + sources: map::hashmap<~str, source>, + mut current_install: ~str, + dep_cache: map::hashmap<~str, bool>, opts: options }; type crate = { - name: str, - vers: str, - uuid: str, - desc: option<str>, - sigs: option<str>, - crate_type: option<str>, - deps: ~[str] + name: ~str, + vers: ~str, + uuid: ~str, + desc: option<~str>, + sigs: option<~str>, + crate_type: option<~str>, + deps: ~[~str] }; type options = { test: bool, mode: mode, - free: ~[str], + free: ~[~str], help: bool, }; enum mode { system_mode, user_mode, local_mode } fn opts() -> ~[getopts::opt] { - ~[optflag("g"), optflag("G"), optflag("test"), - optflag("h"), optflag("help")] + ~[optflag(~"g"), optflag(~"G"), optflag(~"test"), + optflag(~"h"), optflag(~"help")] } -fn info(msg: str) { +fn info(msg: ~str) { let out = io::stdout(); if term::color_supported() { term::fg(out, term::color_green); - out.write_str("info: "); + out.write_str(~"info: "); term::reset(out); out.write_line(msg); - } else { out.write_line("info: " + msg); } + } else { out.write_line(~"info: " + msg); } } -fn warn(msg: str) { +fn warn(msg: ~str) { let out = io::stdout(); if term::color_supported() { term::fg(out, term::color_yellow); - out.write_str("warning: "); + out.write_str(~"warning: "); term::reset(out); out.write_line(msg); - }else { out.write_line("warning: " + msg); } + }else { out.write_line(~"warning: " + msg); } } -fn error(msg: str) { +fn error(msg: ~str) { let out = io::stdout(); if term::color_supported() { term::fg(out, term::color_red); - out.write_str("error: "); + out.write_str(~"error: "); term::reset(out); out.write_line(msg); } - else { out.write_line("error: " + msg); } + else { out.write_line(~"error: " + msg); } } -fn is_uuid(id: str) -> bool { - let parts = str::split_str(id, "-"); +fn is_uuid(id: ~str) -> bool { + let parts = str::split_str(id, ~"-"); if vec::len(parts) == 5u { let mut correct = 0u; for vec::eachi(parts) |i, part| { @@ -156,69 +156,69 @@ fn is_uuid(id: str) -> bool { #[test] fn test_is_uuid() { - assert is_uuid("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaafAF09"); - assert !is_uuid("aaaaaaaa-aaaa-aaaa-aaaaa-aaaaaaaaaaaa"); - assert !is_uuid(""); - assert !is_uuid("aaaaaaaa-aaa -aaaa-aaaa-aaaaaaaaaaaa"); - assert !is_uuid("aaaaaaaa-aaa!-aaaa-aaaa-aaaaaaaaaaaa"); - assert !is_uuid("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa-a"); - assert !is_uuid("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaป"); + assert is_uuid(~"aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaafAF09"); + assert !is_uuid(~"aaaaaaaa-aaaa-aaaa-aaaaa-aaaaaaaaaaaa"); + assert !is_uuid(~""); + assert !is_uuid(~"aaaaaaaa-aaa -aaaa-aaaa-aaaaaaaaaaaa"); + assert !is_uuid(~"aaaaaaaa-aaa!-aaaa-aaaa-aaaaaaaaaaaa"); + assert !is_uuid(~"aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa-a"); + assert !is_uuid(~"aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaป"); } // FIXME (#2661): implement url/URL parsing so we don't have to resort // to weak checks -fn has_archive_extension(p: str) -> bool { - str::ends_with(p, ".tar") || - str::ends_with(p, ".tar.gz") || - str::ends_with(p, ".tar.bz2") || - str::ends_with(p, ".tar.Z") || - str::ends_with(p, ".tar.lz") || - str::ends_with(p, ".tar.xz") || - str::ends_with(p, ".tgz") || - str::ends_with(p, ".tbz") || - str::ends_with(p, ".tbz2") || - str::ends_with(p, ".tb2") || - str::ends_with(p, ".taz") || - str::ends_with(p, ".tlz") || - str::ends_with(p, ".txz") -} - -fn is_archive_path(u: str) -> bool { +fn has_archive_extension(p: ~str) -> bool { + str::ends_with(p, ~".tar") || + str::ends_with(p, ~".tar.gz") || + str::ends_with(p, ~".tar.bz2") || + str::ends_with(p, ~".tar.Z") || + str::ends_with(p, ~".tar.lz") || + str::ends_with(p, ~".tar.xz") || + str::ends_with(p, ~".tgz") || + str::ends_with(p, ~".tbz") || + str::ends_with(p, ~".tbz2") || + str::ends_with(p, ~".tb2") || + str::ends_with(p, ~".taz") || + str::ends_with(p, ~".tlz") || + str::ends_with(p, ~".txz") +} + +fn is_archive_path(u: ~str) -> bool { has_archive_extension(u) && os::path_exists(u) } -fn is_archive_url(u: str) -> bool { +fn is_archive_url(u: ~str) -> bool { // FIXME (#2661): this requires the protocol bit - if we had proper // url parsing, we wouldn't need it - alt str::find_str(u, "://") { + alt str::find_str(u, ~"://") { option::some(i) { has_archive_extension(u) } _ { false } } } -fn is_git_url(url: str) -> bool { - if str::ends_with(url, "/") { str::ends_with(url, ".git/") } +fn is_git_url(url: ~str) -> bool { + if str::ends_with(url, ~"/") { str::ends_with(url, ~".git/") } else { - str::starts_with(url, "git://") || str::ends_with(url, ".git") + str::starts_with(url, ~"git://") || str::ends_with(url, ~".git") } } -fn assume_source_method(url: str) -> str { +fn assume_source_method(url: ~str) -> ~str { if is_git_url(url) { - ret "git"; + ret ~"git"; } - if str::starts_with(url, "file://") || os::path_exists(url) { - ret "file"; + if str::starts_with(url, ~"file://") || os::path_exists(url) { + ret ~"file"; } - "curl" + ~"curl" } -fn load_link(mis: ~[@ast::meta_item]) -> (option<str>, - option<str>, - option<str>) { +fn load_link(mis: ~[@ast::meta_item]) -> (option<~str>, + option<~str>, + option<~str>) { let mut name = none; let mut vers = none; let mut uuid = none; @@ -226,19 +226,19 @@ fn load_link(mis: ~[@ast::meta_item]) -> (option<str>, alt a.node { ast::meta_name_value(v, {node: ast::lit_str(s), span: _}) { alt *v { - "name" { name = some(*s); } - "vers" { vers = some(*s); } - "uuid" { uuid = some(*s); } + ~"name" { name = some(*s); } + ~"vers" { vers = some(*s); } + ~"uuid" { uuid = some(*s); } _ { } } } - _ { fail "load_link: meta items must be name-values"; } + _ { fail ~"load_link: meta items must be name-values"; } } } (name, vers, uuid) } -fn load_crate(filename: str) -> option<crate> { +fn load_crate(filename: ~str) -> option<crate> { let sess = parse::new_parse_sess(none); let c = parse::parse_crate_from_crate_file(filename, ~[], sess); @@ -253,14 +253,14 @@ fn load_crate(filename: str) -> option<crate> { alt a.node.value.node { ast::meta_name_value(v, {node: ast::lit_str(s), span: _}) { alt *v { - "desc" { desc = some(*v); } - "sigs" { sigs = some(*v); } - "crate_type" { crate_type = some(*v); } + ~"desc" { desc = some(*v); } + ~"sigs" { sigs = some(*v); } + ~"crate_type" { crate_type = some(*v); } _ { } } } ast::meta_list(v, mis) { - if *v == "link" { + if *v == ~"link" { let (n, v, u) = load_link(mis); name = n; vers = v; @@ -268,28 +268,29 @@ fn load_crate(filename: str) -> option<crate> { } } _ { - fail "crate attributes may not contain " + - "meta_words"; + fail ~"crate attributes may not contain " + + ~"meta_words"; } } } type env = @{ - mut deps: ~[str] + mut deps: ~[~str] }; fn goto_view_item(e: env, i: @ast::view_item) { alt i.node { ast::view_item_use(ident, metas, id) { - let name_items = attr::find_meta_items_by_name(metas, "name"); + let name_items = + attr::find_meta_items_by_name(metas, ~"name"); let m = if name_items.is_empty() { - metas + ~[attr::mk_name_value_item_str(@"name"/~, *ident)] + metas + ~[attr::mk_name_value_item_str(@~"name", *ident)] } else { metas }; let mut attr_name = ident; - let mut attr_vers = ""; - let mut attr_from = ""; + let mut attr_vers = ~""; + let mut attr_from = ~""; for m.each |item| { alt attr::get_meta_item_value_str(item) { @@ -297,8 +298,8 @@ fn load_crate(filename: str) -> option<crate> { let name = attr::get_meta_item_name(item); alt *name { - "vers" { attr_vers = *value; } - "from" { attr_from = *value; } + ~"vers" { attr_vers = *value; } + ~"from" { attr_from = *value; } _ {} } } @@ -310,12 +311,12 @@ fn load_crate(filename: str) -> option<crate> { attr_from } else { if !str::is_empty(attr_vers) { - *attr_name + "@" + attr_vers + *attr_name + ~"@" + attr_vers } else { *attr_name } }; alt *attr_name { - "std" | "core" { } + ~"std" | ~"core" { } _ { vec::push(e.deps, query); } } } @@ -353,26 +354,26 @@ fn load_crate(filename: str) -> option<crate> { } } -fn print(s: str) { +fn print(s: ~str) { io::stdout().write_line(s); } -fn rest(s: str, start: uint) -> str { +fn rest(s: ~str, start: uint) -> ~str { if (start >= str::len(s)) { - "" + ~"" } else { str::slice(s, start, str::len(s)) } } -fn need_dir(s: str) { +fn need_dir(s: ~str) { if os::path_is_dir(s) { ret; } if !os::make_dir(s, 493_i32 /* oct: 755 */) { fail #fmt["can't make_dir %s", s]; } } -fn valid_pkg_name(s: str) -> bool { +fn valid_pkg_name(s: ~str) -> bool { fn is_valid_digit(c: char) -> bool { ('0' <= c && c <= '9') || ('a' <= c && c <= 'z') || @@ -384,38 +385,38 @@ fn valid_pkg_name(s: str) -> bool { s.all(is_valid_digit) } -fn parse_source(name: str, j: json::json) -> source { +fn parse_source(name: ~str, j: json::json) -> source { if !valid_pkg_name(name) { fail #fmt("'%s' is an invalid source name", name); } alt j { json::dict(j) { - let mut url = alt j.find("url") { + let mut url = alt j.find(~"url") { some(json::string(u)) { *u } - _ { fail "needed 'url' field in source"; } + _ { fail ~"needed 'url' field in source"; } }; - let method = alt j.find("method") { + let method = alt j.find(~"method") { some(json::string(u)) { *u } _ { assume_source_method(url) } }; - let key = alt j.find("key") { + let key = alt j.find(~"key") { some(json::string(u)) { some(*u) } _ { none } }; - let keyfp = alt j.find("keyfp") { + let keyfp = alt j.find(~"keyfp") { some(json::string(u)) { some(*u) } _ { none } }; - if method == "file" { + if method == ~"file" { url = os::make_absolute(url); } ret @{ @@ -426,11 +427,11 @@ fn parse_source(name: str, j: json::json) -> source { mut keyfp: keyfp, mut packages: ~[mut] }; } - _ { fail "needed dict value in source"; } + _ { fail ~"needed dict value in source"; } }; } -fn try_parse_sources(filename: str, sources: map::hashmap<str, source>) { +fn try_parse_sources(filename: ~str, sources: map::hashmap<~str, source>) { if !os::path_exists(filename) { ret; } let c = io::read_whole_file_str(filename); alt json::from_str(result::get(c)) { @@ -440,66 +441,69 @@ fn try_parse_sources(filename: str, sources: map::hashmap<str, source>) { #debug("source: %s", k); } } - ok(_) { fail "malformed sources.json"; } + ok(_) { fail ~"malformed sources.json"; } err(e) { fail #fmt("%s:%s", filename, e.to_str()); } } } -fn load_one_source_package(src: source, p: map::hashmap<str, json::json>) { - let name = alt p.find("name") { +fn load_one_source_package(src: source, p: map::hashmap<~str, json::json>) { + let name = alt p.find(~"name") { some(json::string(n)) { if !valid_pkg_name(*n) { - warn("malformed source json: " + src.name + ", '" + *n + "'"+ - " is an invalid name (alphanumeric, underscores and" + - " dashes only)"); + warn(~"malformed source json: " + + src.name + ~", '" + *n + ~"'"+ + ~" is an invalid name (alphanumeric, underscores and" + + ~" dashes only)"); ret; } *n } _ { - warn("malformed source json: " + src.name + " (missing name)"); + warn(~"malformed source json: " + src.name + ~" (missing name)"); ret; } }; - let uuid = alt p.find("uuid") { + let uuid = alt p.find(~"uuid") { some(json::string(n)) { if !is_uuid(*n) { - warn("malformed source json: " + src.name + ", '" + *n + "'"+ - " is an invalid uuid"); + warn(~"malformed source json: " + + src.name + ~", '" + *n + ~"'"+ + ~" is an invalid uuid"); ret; } *n } _ { - warn("malformed source json: " + src.name + " (missing uuid)"); + warn(~"malformed source json: " + src.name + ~" (missing uuid)"); ret; } }; - let url = alt p.find("url") { + let url = alt p.find(~"url") { some(json::string(n)) { *n } _ { - warn("malformed source json: " + src.name + " (missing url)"); + warn(~"malformed source json: " + src.name + ~" (missing url)"); ret; } }; - let method = alt p.find("method") { + let method = alt p.find(~"method") { some(json::string(n)) { *n } _ { - warn("malformed source json: " + src.name + " (missing method)"); + warn(~"malformed source json: " + + src.name + ~" (missing method)"); ret; } }; - let ref = alt p.find("ref") { + let ref = alt p.find(~"ref") { some(json::string(n)) { some(*n) } _ { none } }; let mut tags = ~[]; - alt p.find("tags") { + alt p.find(~"tags") { some(json::list(js)) { for (*js).each |j| { alt j { @@ -511,11 +515,11 @@ fn load_one_source_package(src: source, p: map::hashmap<str, json::json>) { _ { } } - let description = alt p.find("description") { + let description = alt p.find(~"description") { some(json::string(n)) { *n } _ { - warn("malformed source json: " + src.name - + " (missing description)"); + warn(~"malformed source json: " + src.name + + ~" (missing description)"); ret; } }; @@ -534,19 +538,19 @@ fn load_one_source_package(src: source, p: map::hashmap<str, json::json>) { alt src.packages.position(|pkg| pkg.uuid == uuid ) { some(idx) { src.packages[idx] = newpkg; - log(debug, " updated package: " + src.name + "/" + name); + log(debug, ~" updated package: " + src.name + ~"/" + name); } none { vec::grow(src.packages, 1u, newpkg); } } - log(debug, " loaded package: " + src.name + "/" + name); + log(debug, ~" loaded package: " + src.name + ~"/" + name); } fn load_source_info(c: cargo, src: source) { let dir = path::connect(c.sourcedir, src.name); - let srcfile = path::connect(dir, "source.json"); + let srcfile = path::connect(dir, ~"source.json"); if !os::path_exists(srcfile) { ret; } let srcstr = io::read_whole_file_str(srcfile); alt json::from_str(result::get(srcstr)) { @@ -557,8 +561,8 @@ fn load_source_info(c: cargo, src: source) { src.keyfp = o.keyfp; } ok(_) { - warn("malformed source.json: " + src.name + - "(source info is not a dict)"); + warn(~"malformed source.json: " + src.name + + ~"(source info is not a dict)"); } err(e) { warn(#fmt("%s:%s", src.name, e.to_str())); @@ -566,9 +570,9 @@ fn load_source_info(c: cargo, src: source) { }; } fn load_source_packages(c: cargo, src: source) { - log(debug, "loading source: " + src.name); + log(debug, ~"loading source: " + src.name); let dir = path::connect(c.sourcedir, src.name); - let pkgfile = path::connect(dir, "packages.json"); + let pkgfile = path::connect(dir, ~"packages.json"); if !os::path_exists(pkgfile) { ret; } let pkgstr = io::read_whole_file_str(pkgfile); alt json::from_str(result::get(pkgstr)) { @@ -579,15 +583,15 @@ fn load_source_packages(c: cargo, src: source) { load_one_source_package(src, p); } _ { - warn("malformed source json: " + src.name + - " (non-dict pkg)"); + warn(~"malformed source json: " + src.name + + ~" (non-dict pkg)"); } } } } ok(_) { - warn("malformed packages.json: " + src.name + - "(packages is not a list)"); + warn(~"malformed packages.json: " + src.name + + ~"(packages is not a list)"); } err(e) { warn(#fmt("%s:%s", src.name, e.to_str())); @@ -595,7 +599,7 @@ fn load_source_packages(c: cargo, src: source) { }; } -fn build_cargo_options(argv: ~[str]) -> options { +fn build_cargo_options(argv: ~[~str]) -> options { let match = alt getopts::getopts(argv, opts()) { result::ok(m) { m } result::err(f) { @@ -603,19 +607,19 @@ fn build_cargo_options(argv: ~[str]) -> options { } }; - let test = opt_present(match, "test"); - let G = opt_present(match, "G"); - let g = opt_present(match, "g"); - let help = opt_present(match, "h") || opt_present(match, "help"); + let test = opt_present(match, ~"test"); + let G = opt_present(match, ~"G"); + let g = opt_present(match, ~"g"); + let help = opt_present(match, ~"h") || opt_present(match, ~"help"); let len = vec::len(match.free); - let is_install = len > 1u && match.free[1] == "install"; - let is_uninstall = len > 1u && match.free[1] == "uninstall"; + let is_install = len > 1u && match.free[1] == ~"install"; + let is_uninstall = len > 1u && match.free[1] == ~"uninstall"; - if G && g { fail "-G and -g both provided"; } + if G && g { fail ~"-G and -g both provided"; } if !is_install && !is_uninstall && (g || G) { - fail "-g and -G are only valid for `install` and `uninstall|rm`"; + fail ~"-g and -G are only valid for `install` and `uninstall|rm`"; } let mode = @@ -641,8 +645,8 @@ fn configure(opts: options) -> cargo { let p = result::get(get_cargo_dir()); let sources = map::str_hash(); - try_parse_sources(path::connect(home, "sources.json"), sources); - try_parse_sources(path::connect(home, "local-sources.json"), sources); + try_parse_sources(path::connect(home, ~"sources.json"), sources); + try_parse_sources(path::connect(home, ~"local-sources.json"), sources); let dep_cache = map::str_hash(); @@ -650,12 +654,12 @@ fn configure(opts: options) -> cargo { pgp: pgp::supported(), root: home, installdir: p, - bindir: path::connect(p, "bin"), - libdir: path::connect(p, "lib"), - workdir: path::connect(p, "work"), - sourcedir: path::connect(home, "sources"), + bindir: path::connect(p, ~"bin"), + libdir: path::connect(p, ~"lib"), + workdir: path::connect(p, ~"work"), + sourcedir: path::connect(home, ~"sources"), sources: sources, - mut current_install: "", + mut current_install: ~"", dep_cache: dep_cache, opts: opts }; @@ -676,9 +680,9 @@ fn configure(opts: options) -> cargo { if c.pgp { pgp::init(c.root); } else { - warn("command `gpg` was not found"); - warn("you have to install gpg from source " + - " or package manager to get it to work correctly"); + warn(~"command `gpg` was not found"); + warn(~"you have to install gpg from source " + + ~" or package manager to get it to work correctly"); } c @@ -696,7 +700,7 @@ fn for_each_package(c: cargo, b: fn(source, package)) { } // Runs all programs in directory <buildpath> -fn run_programs(buildpath: str) { +fn run_programs(buildpath: ~str) { let newv = os::list_dir_path(buildpath); for newv.each |ct| { run::run_program(ct, ~[]); @@ -705,13 +709,13 @@ fn run_programs(buildpath: str) { // Runs rustc in <path + subdir> with the given flags // and returns <path + subdir> -fn run_in_buildpath(what: str, path: str, subdir: str, cf: str, - extra_flags: ~[str]) -> option<str> { +fn run_in_buildpath(what: ~str, path: ~str, subdir: ~str, cf: ~str, + extra_flags: ~[~str]) -> option<~str> { let buildpath = path::connect(path, subdir); need_dir(buildpath); #debug("%s: %s -> %s", what, cf, buildpath); let p = run::program_output(rustc_sysroot(), - ~["--out-dir", buildpath, cf] + extra_flags); + ~[~"--out-dir", buildpath, cf] + extra_flags); if p.status != 0 { error(#fmt["rustc failed: %d\n%s\n%s", p.status, p.err, p.out]); ret none; @@ -719,27 +723,27 @@ fn run_in_buildpath(what: str, path: str, subdir: str, cf: str, some(buildpath) } -fn test_one_crate(_c: cargo, path: str, cf: str) { - let buildpath = alt run_in_buildpath("testing", path, "/test", cf, - ~[ "--test"]) { +fn test_one_crate(_c: cargo, path: ~str, cf: ~str) { + let buildpath = alt run_in_buildpath(~"testing", path, ~"/test", cf, + ~[ ~"--test"]) { none { ret; } some(bp) { bp } }; run_programs(buildpath); } -fn install_one_crate(c: cargo, path: str, cf: str) { - let buildpath = alt run_in_buildpath("installing", path, - "/build", cf, ~[]) { +fn install_one_crate(c: cargo, path: ~str, cf: ~str) { + let buildpath = alt run_in_buildpath(~"installing", path, + ~"/build", cf, ~[]) { none { ret; } some(bp) { bp } }; let newv = os::list_dir_path(buildpath); let exec_suffix = os::exe_suffix(); for newv.each |ct| { - if (exec_suffix != "" && str::ends_with(ct, exec_suffix)) || - (exec_suffix == "" && !str::starts_with(path::basename(ct), - "lib")) { + if (exec_suffix != ~"" && str::ends_with(ct, exec_suffix)) || + (exec_suffix == ~"" && !str::starts_with(path::basename(ct), + ~"lib")) { #debug(" bin: %s", ct); install_to_dir(ct, c.bindir); if c.opts.mode == system_mode { @@ -755,32 +759,32 @@ fn install_one_crate(c: cargo, path: str, cf: str) { } -fn rustc_sysroot() -> str { +fn rustc_sysroot() -> ~str { alt os::self_exe_path() { some(path) { - let path = ~[path, "..", "bin", "rustc"]; + let path = ~[path, ~"..", ~"bin", ~"rustc"]; check vec::is_not_empty(path); let rustc = path::normalize(path::connect_many(path)); #debug(" rustc: %s", rustc); rustc } - none { "rustc" } + none { ~"rustc" } } } -fn install_source(c: cargo, path: str) { +fn install_source(c: cargo, path: ~str) { #debug("source: %s", path); os::change_dir(path); let mut cratefiles = ~[]; - for os::walk_dir(".") |p| { - if str::ends_with(p, ".rc") { + for os::walk_dir(~".") |p| { + if str::ends_with(p, ~".rc") { vec::push(cratefiles, p); } } if vec::is_empty(cratefiles) { - fail "this doesn't look like a rust package (no .rc files)"; + fail ~"this doesn't look like a rust package (no .rc files)"; } for cratefiles.each |cf| { @@ -793,7 +797,7 @@ fn install_source(c: cargo, path: str) { // condition") let wd_base = c.workdir + path::path_sep(); - let wd = alt tempfile::mkdtemp(wd_base, "") { + let wd = alt tempfile::mkdtemp(wd_base, ~"") { some(wd) { wd } none { fail #fmt("needed temp dir: %s", wd_base); } }; @@ -812,49 +816,49 @@ fn install_source(c: cargo, path: str) { } } -fn install_git(c: cargo, wd: str, url: str, ref: option<str>) { - run::program_output("git", ~["clone", url, wd]); +fn install_git(c: cargo, wd: ~str, url: ~str, ref: option<~str>) { + run::program_output(~"git", ~[~"clone", url, wd]); if option::is_some(ref) { let r = option::get(ref); os::change_dir(wd); - run::run_program("git", ~["checkout", r]); + run::run_program(~"git", ~[~"checkout", r]); } install_source(c, wd); } -fn install_curl(c: cargo, wd: str, url: str) { - let tarpath = path::connect(wd, "pkg.tar"); - let p = run::program_output("curl", ~["-f", "-s", "-o", +fn install_curl(c: cargo, wd: ~str, url: ~str) { + let tarpath = path::connect(wd, ~"pkg.tar"); + let p = run::program_output(~"curl", ~[~"-f", ~"-s", ~"-o", tarpath, url]); if p.status != 0 { fail #fmt["fetch of %s failed: %s", url, p.err]; } - run::run_program("tar", ~["-x", "--strip-components=1", - "-C", wd, "-f", tarpath]); + run::run_program(~"tar", ~[~"-x", ~"--strip-components=1", + ~"-C", wd, ~"-f", tarpath]); install_source(c, wd); } -fn install_file(c: cargo, wd: str, path: str) { - run::program_output("tar", ~["-x", "--strip-components=1", - "-C", wd, "-f", path]); +fn install_file(c: cargo, wd: ~str, path: ~str) { + run::program_output(~"tar", ~[~"-x", ~"--strip-components=1", + ~"-C", wd, ~"-f", path]); install_source(c, wd); } -fn install_package(c: cargo, src: str, wd: str, pkg: package) { +fn install_package(c: cargo, src: ~str, wd: ~str, pkg: package) { let url = copy pkg.url; let method = alt pkg.method { - "git" { "git" } - "file" { "file" } - _ { "curl" } + ~"git" { ~"git" } + ~"file" { ~"file" } + _ { ~"curl" } }; info(#fmt["installing %s/%s via %s...", src, pkg.name, method]); alt method { - "git" { install_git(c, wd, url, copy pkg.ref); } - "file" { install_file(c, wd, url); } - "curl" { install_curl(c, wd, copy url); } + ~"git" { install_git(c, wd, url, copy pkg.ref); } + ~"file" { install_file(c, wd, url); } + ~"curl" { install_curl(c, wd, copy url); } _ {} } } @@ -862,14 +866,14 @@ fn install_package(c: cargo, src: str, wd: str, pkg: package) { fn cargo_suggestion(c: cargo, fallback: fn()) { if c.sources.size() == 0u { - error("no sources defined - you may wish to run " + - "`cargo init`"); + error(~"no sources defined - you may wish to run " + + ~"`cargo init`"); ret; } fallback(); } -fn install_uuid(c: cargo, wd: str, uuid: str) { +fn install_uuid(c: cargo, wd: ~str, uuid: ~str) { let mut ps = ~[]; for_each_package(c, |s, p| { if p.uuid == uuid { @@ -882,18 +886,18 @@ fn install_uuid(c: cargo, wd: str, uuid: str) { ret; } else if vec::len(ps) == 0u { cargo_suggestion(c, || { - error("can't find package: " + uuid); + error(~"can't find package: " + uuid); }); ret; } - error("found multiple packages:"); + error(~"found multiple packages:"); for ps.each |elt| { let (sname,p) = copy elt; - info(" " + sname + "/" + p.uuid + " (" + p.name + ")"); + info(~" " + sname + ~"/" + p.uuid + ~" (" + p.name + ~")"); } } -fn install_named(c: cargo, wd: str, name: str) { +fn install_named(c: cargo, wd: ~str, name: ~str) { let mut ps = ~[]; for_each_package(c, |s, p| { if p.name == name { @@ -906,18 +910,18 @@ fn install_named(c: cargo, wd: str, name: str) { ret; } else if vec::len(ps) == 0u { cargo_suggestion(c, || { - error("can't find package: " + name); + error(~"can't find package: " + name); }); ret; } - error("found multiple packages:"); + error(~"found multiple packages:"); for ps.each |elt| { let (sname,p) = copy elt; - info(" " + sname + "/" + p.uuid + " (" + p.name + ")"); + info(~" " + sname + ~"/" + p.uuid + ~" (" + p.name + ~")"); } } -fn install_uuid_specific(c: cargo, wd: str, src: str, uuid: str) { +fn install_uuid_specific(c: cargo, wd: ~str, src: ~str, uuid: ~str) { alt c.sources.find(src) { some(s) { let packages = copy s.packages; @@ -930,10 +934,10 @@ fn install_uuid_specific(c: cargo, wd: str, src: str, uuid: str) { } _ { } } - error("can't find package: " + src + "/" + uuid); + error(~"can't find package: " + src + ~"/" + uuid); } -fn install_named_specific(c: cargo, wd: str, src: str, name: str) { +fn install_named_specific(c: cargo, wd: ~str, src: ~str, name: ~str) { alt c.sources.find(src) { some(s) { let packages = copy s.packages; @@ -946,7 +950,7 @@ fn install_named_specific(c: cargo, wd: str, src: str, name: str) { } _ { } } - error("can't find package: " + src + "/" + name); + error(~"can't find package: " + src + ~"/" + name); } fn cmd_uninstall(c: cargo) { @@ -965,13 +969,13 @@ fn cmd_uninstall(c: cargo) { // name only) if is_uuid(target) { for os::list_dir(lib).each |file| { - alt str::find_str(file, "-" + target + "-") { + alt str::find_str(file, ~"-" + target + ~"-") { some(idx) { let full = path::normalize(path::connect(lib, file)); if os::remove_file(full) { - info("uninstalled: '" + full + "'"); + info(~"uninstalled: '" + full + ~"'"); } else { - error("could not uninstall: '" + full + "'"); + error(~"could not uninstall: '" + full + ~"'"); } ret; } @@ -979,17 +983,17 @@ fn cmd_uninstall(c: cargo) { } } - error("can't find package with uuid: " + target); + error(~"can't find package with uuid: " + target); } else { for os::list_dir(lib).each |file| { - alt str::find_str(file, "lib" + target + "-") { + alt str::find_str(file, ~"lib" + target + ~"-") { some(idx) { let full = path::normalize(path::connect(lib, file)); if os::remove_file(full) { - info("uninstalled: '" + full + "'"); + info(~"uninstalled: '" + full + ~"'"); } else { - error("could not uninstall: '" + full + "'"); + error(~"could not uninstall: '" + full + ~"'"); } ret; } @@ -1001,9 +1005,9 @@ fn cmd_uninstall(c: cargo) { some(idx) { let full = path::normalize(path::connect(bin, file)); if os::remove_file(full) { - info("uninstalled: '" + full + "'"); + info(~"uninstalled: '" + full + ~"'"); } else { - error("could not uninstall: '" + full + "'"); + error(~"could not uninstall: '" + full + ~"'"); } ret; } @@ -1011,11 +1015,11 @@ fn cmd_uninstall(c: cargo) { } } - error("can't find package with name: " + target); + error(~"can't find package with name: " + target); } } -fn install_query(c: cargo, wd: str, target: str) { +fn install_query(c: cargo, wd: ~str, target: ~str) { alt c.dep_cache.find(target) { some(inst) { if inst { @@ -1071,20 +1075,20 @@ fn install_query(c: cargo, wd: str, target: str) { c.dep_cache.remove(k); } - c.current_install = ""; + c.current_install = ~""; } } fn cmd_install(c: cargo) unsafe { let wd_base = c.workdir + path::path_sep(); - let wd = alt tempfile::mkdtemp(wd_base, "") { + let wd = alt tempfile::mkdtemp(wd_base, ~"") { some(wd) { wd } none { fail #fmt("needed temp dir: %s", wd_base); } }; if vec::len(c.opts.free) == 2u { let cwd = os::getcwd(); - let status = run::run_program("cp", ~["-R", cwd, wd]); + let status = run::run_program(~"cp", ~[~"-R", cwd, wd]); if status != 0 { fail #fmt("could not copy directory: %s", cwd); @@ -1110,34 +1114,34 @@ fn sync(c: cargo) { } } -fn sync_one_file(c: cargo, dir: str, src: source) -> bool { +fn sync_one_file(c: cargo, dir: ~str, src: source) -> bool { let name = src.name; - let srcfile = path::connect(dir, "source.json.new"); - let destsrcfile = path::connect(dir, "source.json"); - let pkgfile = path::connect(dir, "packages.json.new"); - let destpkgfile = path::connect(dir, "packages.json"); - let keyfile = path::connect(dir, "key.gpg"); - let srcsigfile = path::connect(dir, "source.json.sig"); - let sigfile = path::connect(dir, "packages.json.sig"); + let srcfile = path::connect(dir, ~"source.json.new"); + let destsrcfile = path::connect(dir, ~"source.json"); + let pkgfile = path::connect(dir, ~"packages.json.new"); + let destpkgfile = path::connect(dir, ~"packages.json"); + let keyfile = path::connect(dir, ~"key.gpg"); + let srcsigfile = path::connect(dir, ~"source.json.sig"); + let sigfile = path::connect(dir, ~"packages.json.sig"); let url = src.url; let mut has_src_file = false; - if !os::copy_file(path::connect(url, "packages.json"), pkgfile) { + if !os::copy_file(path::connect(url, ~"packages.json"), pkgfile) { error(#fmt["fetch for source %s (url %s) failed", name, url]); ret false; } - if os::copy_file(path::connect(url, "source.json"), srcfile) { + if os::copy_file(path::connect(url, ~"source.json"), srcfile) { has_src_file = false; } - os::copy_file(path::connect(url, "source.json.sig"), srcsigfile); - os::copy_file(path::connect(url, "packages.json.sig"), sigfile); + os::copy_file(path::connect(url, ~"source.json.sig"), srcsigfile); + os::copy_file(path::connect(url, ~"packages.json.sig"), sigfile); alt copy src.key { some(u) { - let p = run::program_output("curl", ~["-f", "-s", "-o", keyfile, - u]); + let p = run::program_output(~"curl", + ~[~"-f", ~"-s", ~"-o", keyfile, u]); if p.status != 0 { error(#fmt["fetch for source %s (key %s) failed", name, u]); ret false; @@ -1186,23 +1190,23 @@ fn sync_one_file(c: cargo, dir: str, src: source) -> bool { ret true; } -fn sync_one_git(c: cargo, dir: str, src: source) -> bool { +fn sync_one_git(c: cargo, dir: ~str, src: source) -> bool { let name = src.name; - let srcfile = path::connect(dir, "source.json"); - let pkgfile = path::connect(dir, "packages.json"); - let keyfile = path::connect(dir, "key.gpg"); - let srcsigfile = path::connect(dir, "source.json.sig"); - let sigfile = path::connect(dir, "packages.json.sig"); + let srcfile = path::connect(dir, ~"source.json"); + let pkgfile = path::connect(dir, ~"packages.json"); + let keyfile = path::connect(dir, ~"key.gpg"); + let srcsigfile = path::connect(dir, ~"source.json.sig"); + let sigfile = path::connect(dir, ~"packages.json.sig"); let url = src.url; - fn rollback(name: str, dir: str, insecure: bool) { - fn msg(name: str, insecure: bool) { + fn rollback(name: ~str, dir: ~str, insecure: bool) { + fn msg(name: ~str, insecure: bool) { error(#fmt["could not rollback source: %s", name]); if insecure { - warn("a past security check failed on source " + - name + " and rolling back the source failed -" - + " this source may be compromised"); + warn(~"a past security check failed on source " + + name + ~" and rolling back the source failed -" + + ~" this source may be compromised"); } } @@ -1210,8 +1214,8 @@ fn sync_one_git(c: cargo, dir: str, src: source) -> bool { msg(name, insecure); } else { - let p = run::program_output("git", ~["reset", "--hard", - "HEAD@{1}"]); + let p = run::program_output(~"git", ~[~"reset", ~"--hard", + ~"HEAD@{1}"]); if p.status != 0 { msg(name, insecure); @@ -1219,8 +1223,8 @@ fn sync_one_git(c: cargo, dir: str, src: source) -> bool { } } - if !os::path_exists(path::connect(dir, ".git")) { - let p = run::program_output("git", ~["clone", url, dir]); + if !os::path_exists(path::connect(dir, ~".git")) { + let p = run::program_output(~"git", ~[~"clone", url, dir]); if p.status != 0 { error(#fmt["fetch for source %s (url %s) failed", name, url]); @@ -1233,7 +1237,7 @@ fn sync_one_git(c: cargo, dir: str, src: source) -> bool { ret false; } - let p = run::program_output("git", ~["pull"]); + let p = run::program_output(~"git", ~[~"pull"]); if p.status != 0 { error(#fmt["fetch for source %s (url %s) failed", name, url]); @@ -1245,8 +1249,8 @@ fn sync_one_git(c: cargo, dir: str, src: source) -> bool { alt copy src.key { some(u) { - let p = run::program_output("curl", ~["-f", "-s", "-o", keyfile, - u]); + let p = run::program_output(~"curl", + ~[~"-f", ~"-s", ~"-o", keyfile, u]); if p.status != 0 { error(#fmt["fetch for source %s (key %s) failed", name, u]); rollback(name, dir, false); @@ -1288,33 +1292,35 @@ fn sync_one_git(c: cargo, dir: str, src: source) -> bool { ret true; } -fn sync_one_curl(c: cargo, dir: str, src: source) -> bool { +fn sync_one_curl(c: cargo, dir: ~str, src: source) -> bool { let name = src.name; - let srcfile = path::connect(dir, "source.json.new"); - let destsrcfile = path::connect(dir, "source.json"); - let pkgfile = path::connect(dir, "packages.json.new"); - let destpkgfile = path::connect(dir, "packages.json"); - let keyfile = path::connect(dir, "key.gpg"); - let srcsigfile = path::connect(dir, "source.json.sig"); - let sigfile = path::connect(dir, "packages.json.sig"); + let srcfile = path::connect(dir, ~"source.json.new"); + let destsrcfile = path::connect(dir, ~"source.json"); + let pkgfile = path::connect(dir, ~"packages.json.new"); + let destpkgfile = path::connect(dir, ~"packages.json"); + let keyfile = path::connect(dir, ~"key.gpg"); + let srcsigfile = path::connect(dir, ~"source.json.sig"); + let sigfile = path::connect(dir, ~"packages.json.sig"); let mut url = src.url; - let smart = !str::ends_with(src.url, "packages.json"); + let smart = !str::ends_with(src.url, ~"packages.json"); let mut has_src_file = false; if smart { - url += "/packages.json"; + url += ~"/packages.json"; } - let p = run::program_output("curl", ~["-f", "-s", "-o", pkgfile, url]); + let p = run::program_output(~"curl", + ~[~"-f", ~"-s", ~"-o", pkgfile, url]); if p.status != 0 { error(#fmt["fetch for source %s (url %s) failed", name, url]); ret false; } if smart { - url = src.url + "/source.json"; + url = src.url + ~"/source.json"; let p = - run::program_output("curl", ~["-f", "-s", "-o", srcfile, url]); + run::program_output(~"curl", + ~[~"-f", ~"-s", ~"-o", srcfile, url]); if p.status == 0 { has_src_file = true; @@ -1323,8 +1329,8 @@ fn sync_one_curl(c: cargo, dir: str, src: source) -> bool { alt copy src.key { some(u) { - let p = run::program_output("curl", ~["-f", "-s", "-o", keyfile, - u]); + let p = run::program_output(~"curl", + ~[~"-f", ~"-s", ~"-o", keyfile, u]); if p.status != 0 { error(#fmt["fetch for source %s (key %s) failed", name, u]); ret false; @@ -1336,13 +1342,13 @@ fn sync_one_curl(c: cargo, dir: str, src: source) -> bool { alt (src.key, src.keyfp) { (some(_), some(f)) { if smart { - url = src.url + "/packages.json.sig"; + url = src.url + ~"/packages.json.sig"; } else { - url = src.url + ".sig"; + url = src.url + ~".sig"; } - let mut p = run::program_output("curl", ~["-f", "-s", "-o", + let mut p = run::program_output(~"curl", ~[~"-f", ~"-s", ~"-o", sigfile, url]); if p.status != 0 { error(#fmt["fetch for source %s (sig %s) failed", name, url]); @@ -1358,10 +1364,11 @@ fn sync_one_curl(c: cargo, dir: str, src: source) -> bool { } if smart && has_src_file { - url = src.url + "/source.json.sig"; + url = src.url + ~"/source.json.sig"; - p = run::program_output("curl", - ~["-f", "-s", "-o", srcsigfile, url]); + p = run::program_output(~"curl", + ~[~"-f", ~"-s", ~"-o", + srcsigfile, url]); if p.status != 0 { error(#fmt["fetch for source %s (sig %s) failed", name, url]); @@ -1371,8 +1378,8 @@ fn sync_one_curl(c: cargo, dir: str, src: source) -> bool { let e = pgp::verify(c.root, srcfile, srcsigfile, f); if !e { - error("signature verification failed for " + - "source " + name); + error(~"signature verification failed for " + + ~"source " + name); ret false; } } @@ -1406,8 +1413,8 @@ fn sync_one(c: cargo, src: source) { need_dir(dir); let result = alt src.method { - "git" { sync_one_git(c, dir, src) } - "file" { sync_one_file(c, dir, src) } + ~"git" { sync_one_git(c, dir, src) } + ~"file" { sync_one_file(c, dir, src) } _ { sync_one_curl(c, dir, src) } }; @@ -1418,22 +1425,22 @@ fn sync_one(c: cargo, src: source) { } fn cmd_init(c: cargo) { - let srcurl = "http://www.rust-lang.org/cargo/sources.json"; - let sigurl = "http://www.rust-lang.org/cargo/sources.json.sig"; + let srcurl = ~"http://www.rust-lang.org/cargo/sources.json"; + let sigurl = ~"http://www.rust-lang.org/cargo/sources.json.sig"; - let srcfile = path::connect(c.root, "sources.json.new"); - let sigfile = path::connect(c.root, "sources.json.sig"); - let destsrcfile = path::connect(c.root, "sources.json"); + let srcfile = path::connect(c.root, ~"sources.json.new"); + let sigfile = path::connect(c.root, ~"sources.json.sig"); + let destsrcfile = path::connect(c.root, ~"sources.json"); let p = - run::program_output("curl", ~["-f", "-s", "-o", srcfile, srcurl]); + run::program_output(~"curl", ~[~"-f", ~"-s", ~"-o", srcfile, srcurl]); if p.status != 0 { error(#fmt["fetch of sources.json failed: %s", p.out]); ret; } let p = - run::program_output("curl", ~["-f", "-s", "-o", sigfile, sigurl]); + run::program_output(~"curl", ~[~"-f", ~"-s", ~"-o", sigfile, sigurl]); if p.status != 0 { error(#fmt["fetch of sources.json.sig failed: %s", p.out]); ret; @@ -1453,31 +1460,31 @@ fn cmd_init(c: cargo) { } fn print_pkg(s: source, p: package) { - let mut m = s.name + "/" + p.name + " (" + p.uuid + ")"; + let mut m = s.name + ~"/" + p.name + ~" (" + p.uuid + ~")"; if vec::len(p.tags) > 0u { - m = m + " [" + str::connect(p.tags, ", ") + "]"; + m = m + ~" [" + str::connect(p.tags, ~", ") + ~"]"; } info(m); - if p.description != "" { - print(" >> " + p.description + "\n") + if p.description != ~"" { + print(~" >> " + p.description + ~"\n") } } fn print_source(s: source) { - info(s.name + " (" + s.url + ")"); + info(s.name + ~" (" + s.url + ~")"); let pks = sort::merge_sort(|a, b| a < b, copy s.packages); let l = vec::len(pks); print(io::with_str_writer(|writer| { - let mut list = " >> "; + let mut list = ~" >> "; do vec::iteri(pks) |i, pk| { if str::len(list) > 78u { writer.write_line(list); - list = " >> "; + list = ~" >> "; } - list += pk.name + (if l - 1u == i { "" } else { ", " }); + list += pk.name + (if l - 1u == i { ~"" } else { ~", " }); } writer.write_line(list); @@ -1521,7 +1528,7 @@ fn cmd_search(c: cargo) { let name = c.opts.free[2]; let tags = vec::slice(c.opts.free, 3u, vec::len(c.opts.free)); for_each_package(c, |s, p| { - if (str::contains(p.name, name) || name == "*") && + if (str::contains(p.name, name) || name == ~"*") && vec::all(tags, |t| vec::contains(p.tags, t) ) { print_pkg(s, p); n += 1; @@ -1530,10 +1537,10 @@ fn cmd_search(c: cargo) { info(#fmt["found %d packages", n]); } -fn install_to_dir(srcfile: str, destdir: str) { +fn install_to_dir(srcfile: ~str, destdir: ~str) { let newfile = path::connect(destdir, path::basename(srcfile)); - let status = run::run_program("cp", ~["-r", srcfile, newfile]); + let status = run::run_program(~"cp", ~[~"-r", srcfile, newfile]); if status == 0 { info(#fmt["installed: '%s'", newfile]); } else { @@ -1544,11 +1551,11 @@ fn install_to_dir(srcfile: str, destdir: str) { fn dump_cache(c: cargo) { need_dir(c.root); - let out = path::connect(c.root, "cache.json"); + let out = path::connect(c.root, ~"cache.json"); let _root = json::dict(map::str_hash()); if os::path_exists(out) { - copy_warn(out, path::connect(c.root, "cache.json.old")); + copy_warn(out, path::connect(c.root, ~"cache.json.old")); } } fn dump_sources(c: cargo) { @@ -1558,10 +1565,10 @@ fn dump_sources(c: cargo) { need_dir(c.root); - let out = path::connect(c.root, "sources.json"); + let out = path::connect(c.root, ~"sources.json"); if os::path_exists(out) { - copy_warn(out, path::connect(c.root, "sources.json.old")); + copy_warn(out, path::connect(c.root, ~"sources.json.old")); } alt io::buffered_file_writer(out) { @@ -1573,18 +1580,18 @@ fn dump_sources(c: cargo) { let chash = map::str_hash(); let child = json::dict(chash); - chash.insert("url", json::string(@v.url)); - chash.insert("method", json::string(@v.method)); + chash.insert(~"url", json::string(@v.url)); + chash.insert(~"method", json::string(@v.method)); alt copy v.key { some(key) { - chash.insert("key", json::string(@key)); + chash.insert(~"key", json::string(@key)); } _ {} } alt copy v.keyfp { some(keyfp) { - chash.insert("keyfp", json::string(@keyfp)); + chash.insert(~"keyfp", json::string(@keyfp)); } _ {} } @@ -1600,7 +1607,7 @@ fn dump_sources(c: cargo) { } } -fn copy_warn(srcfile: str, destfile: str) { +fn copy_warn(srcfile: ~str, destfile: ~str) { if !os::copy_file(srcfile, destfile) { warn(#fmt["copying %s to %s failed", srcfile, destfile]); } @@ -1618,14 +1625,14 @@ fn cmd_sources(c: cargo) { let action = c.opts.free[2u]; alt action { - "clear" { + ~"clear" { for c.sources.each_key |k| { c.sources.remove(k); } - info("cleared sources"); + info(~"cleared sources"); } - "add" { + ~"add" { if vec::len(c.opts.free) < 5u { cmd_usage(); ret; @@ -1656,7 +1663,7 @@ fn cmd_sources(c: cargo) { } } } - "remove" { + ~"remove" { if vec::len(c.opts.free) < 4u { cmd_usage(); ret; @@ -1679,7 +1686,7 @@ fn cmd_sources(c: cargo) { } } } - "set-url" { + ~"set-url" { if vec::len(c.opts.free) < 5u { cmd_usage(); ret; @@ -1710,7 +1717,7 @@ fn cmd_sources(c: cargo) { } } } - "set-method" { + ~"set-method" { if vec::len(c.opts.free) < 5u { cmd_usage(); ret; @@ -1729,9 +1736,9 @@ fn cmd_sources(c: cargo) { let old = copy source.method; source.method = alt method { - "git" { "git" } - "file" { "file" } - _ { "curl" } + ~"git" { ~"git" } + ~"file" { ~"file" } + _ { ~"curl" } }; c.sources.insert(name, source); @@ -1744,7 +1751,7 @@ fn cmd_sources(c: cargo) { } } } - "rename" { + ~"rename" { if vec::len(c.opts.free) < 5u { cmd_usage(); ret; @@ -1778,7 +1785,7 @@ fn cmd_sources(c: cargo) { } fn cmd_usage() { - print("Usage: cargo <cmd> [options] [args..] + print(~"Usage: cargo <cmd> [options] [args..] e.g. cargo install <name> Where <cmd> is one of: @@ -1793,14 +1800,14 @@ Options: } fn cmd_usage_init() { - print("cargo init + print(~"cargo init Re-initialize cargo in ~/.cargo. Clears all sources and then adds the default sources from <www.rust-lang.org/sources.json>."); } fn cmd_usage_install() { - print("cargo install + print(~"cargo install cargo install [source/]<name>[@version] cargo install [source/]<uuid>[@version] cargo install <git url> [ref] @@ -1819,7 +1826,7 @@ from that source, otherwise it installs from any source."); } fn cmd_usage_uninstall() { - print("cargo uninstall [source/]<name>[@version] + print(~"cargo uninstall [source/]<name>[@version] cargo uninstall [source/]<uuid>[@version] cargo uninstall <meta-name>[@version] cargo uninstall <meta-uuid>[@version] @@ -1836,7 +1843,7 @@ it by metadata."); } fn cmd_usage_list() { - print("cargo list [sources..] + print(~"cargo list [sources..] If no arguments are provided, list all sources and their packages. If source names are provided, list those sources and their packages. @@ -1844,13 +1851,13 @@ If source names are provided, list those sources and their packages. } fn cmd_usage_search() { - print("cargo search <query | '*'> [tags..] + print(~"cargo search <query | '*'> [tags..] Search packages."); } fn cmd_usage_sources() { - print("cargo sources + print(~"cargo sources cargo sources add <name> <url> cargo sources remove <name> cargo sources rename <name> <new> @@ -1868,7 +1875,7 @@ Commands: set-method Change the method for a source."); } -fn main(argv: ~[str]) { +fn main(argv: ~[~str]) { let o = build_cargo_options(argv); if vec::len(o.free) < 2u { @@ -1877,26 +1884,26 @@ fn main(argv: ~[str]) { } if o.help { alt o.free[1] { - "init" { cmd_usage_init(); } - "install" { cmd_usage_install(); } - "uninstall" { cmd_usage_uninstall(); } - "list" { cmd_usage_list(); } - "search" { cmd_usage_search(); } - "sources" { cmd_usage_sources(); } + ~"init" { cmd_usage_init(); } + ~"install" { cmd_usage_install(); } + ~"uninstall" { cmd_usage_uninstall(); } + ~"list" { cmd_usage_list(); } + ~"search" { cmd_usage_search(); } + ~"sources" { cmd_usage_sources(); } _ { cmd_usage(); } } ret; } - if o.free[1] == "usage" { + if o.free[1] == ~"usage" { cmd_usage(); ret; } let mut c = configure(o); let home = c.root; - let first_time = os::path_exists(path::connect(home, "sources.json")); + let first_time = os::path_exists(path::connect(home, ~"sources.json")); - if !first_time && o.free[1] != "init" { + if !first_time && o.free[1] != ~"init" { cmd_init(c); // FIXME (#2662): shouldn't need to reconfigure @@ -1904,12 +1911,12 @@ fn main(argv: ~[str]) { } alt o.free[1] { - "init" { cmd_init(c); } - "install" { cmd_install(c); } - "uninstall" { cmd_uninstall(c); } - "list" { cmd_list(c); } - "search" { cmd_search(c); } - "sources" { cmd_sources(c); } + ~"init" { cmd_init(c); } + ~"install" { cmd_install(c); } + ~"uninstall" { cmd_uninstall(c); } + ~"list" { cmd_list(c); } + ~"search" { cmd_search(c); } + ~"sources" { cmd_sources(c); } _ { cmd_usage(); } } diff --git a/src/cargo/pgp.rs b/src/cargo/pgp.rs index 9078e943cf2..6977cdf0256 100644 --- a/src/cargo/pgp.rs +++ b/src/cargo/pgp.rs @@ -1,9 +1,9 @@ -fn gpg(args: ~[str]) -> { status: int, out: str, err: str } { - ret run::program_output("gpg", args); +fn gpg(args: ~[~str]) -> { status: int, out: ~str, err: ~str } { + ret run::program_output(~"gpg", args); } -fn signing_key() -> str { - " +fn signing_key() -> ~str { + ~" -----BEGIN PGP PUBLIC KEY BLOCK----- Version: SKS 1.1.0 @@ -54,42 +54,42 @@ HI1jilzwKSXuV2EmyBk3tKh9NwscT/A78pr30FxxPUg3v72raNgusTo= " } -fn signing_key_fp() -> str { - "FE79 EDB0 3DEF B0D8 27D2 6C41 0B2D 6A28 3033 6376" +fn signing_key_fp() -> ~str { + ~"FE79 EDB0 3DEF B0D8 27D2 6C41 0B2D 6A28 3033 6376" } fn supported() -> bool { - let r = gpg(~["--version"]); + let r = gpg(~[~"--version"]); r.status == 0 } -fn init(root: str) { - let p = path::connect(root, "gpg"); +fn init(root: ~str) { + let p = path::connect(root, ~"gpg"); if !os::path_is_dir(p) { os::make_dir(p, 0x1c0i32); - let p = run::start_program("gpg", ~["--homedir", p, "--import"]); + let p = run::start_program(~"gpg", ~[~"--homedir", p, ~"--import"]); p.input().write_str(signing_key()); let s = p.finish(); if s != 0 { - fail "pgp init failed"; + fail ~"pgp init failed"; } } } -fn add(root: str, key: str) { - let path = path::connect(root, "gpg"); +fn add(root: ~str, key: ~str) { + let path = path::connect(root, ~"gpg"); let p = - run::program_output("gpg", ~["--homedir", path, "--import", key]); + run::program_output(~"gpg", ~[~"--homedir", path, ~"--import", key]); if p.status != 0 { - fail "pgp add failed: " + p.out; + fail ~"pgp add failed: " + p.out; } } -fn verify(root: str, data: str, sig: str, keyfp: str) -> bool { - let path = path::connect(root, "gpg"); - let p = gpg(~["--homedir", path, "--with-fingerprint", "--verify", sig, +fn verify(root: ~str, data: ~str, sig: ~str, keyfp: ~str) -> bool { + let path = path::connect(root, ~"gpg"); + let p = gpg(~[~"--homedir", path, ~"--with-fingerprint", ~"--verify", sig, data]); - let res = "Primary key fingerprint: " + keyfp; + let res = ~"Primary key fingerprint: " + keyfp; for str::split_char(p.err, '\n').each |line| { if line == res { ret true; } } diff --git a/src/compiletest/common.rs b/src/compiletest/common.rs index 0f68a756ec8..a7bcc8d67cc 100644 --- a/src/compiletest/common.rs +++ b/src/compiletest/common.rs @@ -4,25 +4,25 @@ enum mode { mode_compile_fail, mode_run_fail, mode_run_pass, mode_pretty, } type config = { // The library paths required for running the compiler - compile_lib_path: str, + compile_lib_path: ~str, // The library paths required for running compiled programs - run_lib_path: str, + run_lib_path: ~str, // The rustc executable - rustc_path: str, + rustc_path: ~str, // The directory containing the tests to run - src_base: str, + src_base: ~str, // The directory where programs should be built - build_base: str, + build_base: ~str, // Directory for auxiliary libraries - aux_base: str, + aux_base: ~str, // The name of the stage being built (stage1, etc) - stage_id: str, + stage_id: ~str, // The test mode, compile-fail, run-fail, run-pass mode: mode, @@ -31,17 +31,17 @@ type config = { run_ignored: bool, // Only run tests that match this filter - filter: option<str>, + filter: option<~str>, // Write out a parseable log of tests that were run - logfile: option<str>, + logfile: option<~str>, // A command line to prefix program execution with, // for running under valgrind - runtool: option<str>, + runtool: option<~str>, // Flags to pass to the compiler - rustcflags: option<str>, + rustcflags: option<~str>, // Explain what's going on verbose: bool}; diff --git a/src/compiletest/compiletest.rs b/src/compiletest/compiletest.rs index 359ca0c5bcc..30adf8ba5bb 100644 --- a/src/compiletest/compiletest.rs +++ b/src/compiletest/compiletest.rs @@ -21,23 +21,23 @@ import common::mode_pretty; import common::mode; import util::logv; -fn main(args: ~[str]) { +fn main(args: ~[~str]) { let config = parse_config(args); log_config(config); run_tests(config); } -fn parse_config(args: ~[str]) -> config { +fn parse_config(args: ~[~str]) -> config { let opts = - ~[getopts::reqopt("compile-lib-path"), - getopts::reqopt("run-lib-path"), - getopts::reqopt("rustc-path"), getopts::reqopt("src-base"), - getopts::reqopt("build-base"), getopts::reqopt("aux-base"), - getopts::reqopt("stage-id"), - getopts::reqopt("mode"), getopts::optflag("ignored"), - getopts::optopt("runtool"), getopts::optopt("rustcflags"), - getopts::optflag("verbose"), - getopts::optopt("logfile")]; + ~[getopts::reqopt(~"compile-lib-path"), + getopts::reqopt(~"run-lib-path"), + getopts::reqopt(~"rustc-path"), getopts::reqopt(~"src-base"), + getopts::reqopt(~"build-base"), getopts::reqopt(~"aux-base"), + getopts::reqopt(~"stage-id"), + getopts::reqopt(~"mode"), getopts::optflag(~"ignored"), + getopts::optopt(~"runtool"), getopts::optopt(~"rustcflags"), + getopts::optflag(~"verbose"), + getopts::optopt(~"logfile")]; check (vec::is_not_empty(args)); let args_ = vec::tail(args); @@ -47,23 +47,23 @@ fn parse_config(args: ~[str]) -> config { err(f) { fail getopts::fail_str(f) } }; - ret {compile_lib_path: getopts::opt_str(match, "compile-lib-path"), - run_lib_path: getopts::opt_str(match, "run-lib-path"), - rustc_path: getopts::opt_str(match, "rustc-path"), - src_base: getopts::opt_str(match, "src-base"), - build_base: getopts::opt_str(match, "build-base"), - aux_base: getopts::opt_str(match, "aux-base"), - stage_id: getopts::opt_str(match, "stage-id"), - mode: str_mode(getopts::opt_str(match, "mode")), - run_ignored: getopts::opt_present(match, "ignored"), + ret {compile_lib_path: getopts::opt_str(match, ~"compile-lib-path"), + run_lib_path: getopts::opt_str(match, ~"run-lib-path"), + rustc_path: getopts::opt_str(match, ~"rustc-path"), + src_base: getopts::opt_str(match, ~"src-base"), + build_base: getopts::opt_str(match, ~"build-base"), + aux_base: getopts::opt_str(match, ~"aux-base"), + stage_id: getopts::opt_str(match, ~"stage-id"), + mode: str_mode(getopts::opt_str(match, ~"mode")), + run_ignored: getopts::opt_present(match, ~"ignored"), filter: if vec::len(match.free) > 0u { option::some(match.free[0]) } else { option::none }, - logfile: getopts::opt_maybe_str(match, "logfile"), - runtool: getopts::opt_maybe_str(match, "runtool"), - rustcflags: getopts::opt_maybe_str(match, "rustcflags"), - verbose: getopts::opt_present(match, "verbose")}; + logfile: getopts::opt_maybe_str(match, ~"logfile"), + runtool: getopts::opt_maybe_str(match, ~"runtool"), + rustcflags: getopts::opt_maybe_str(match, ~"rustcflags"), + verbose: getopts::opt_present(match, ~"verbose")}; } fn log_config(config: config) { @@ -84,30 +84,30 @@ fn log_config(config: config) { logv(c, #fmt["\n"]); } -fn opt_str(maybestr: option<str>) -> str { - alt maybestr { option::some(s) { s } option::none { "(none)" } } +fn opt_str(maybestr: option<~str>) -> ~str { + alt maybestr { option::some(s) { s } option::none { ~"(none)" } } } -fn str_opt(maybestr: str) -> option<str> { - if maybestr != "(none)" { option::some(maybestr) } else { option::none } +fn str_opt(maybestr: ~str) -> option<~str> { + if maybestr != ~"(none)" { option::some(maybestr) } else { option::none } } -fn str_mode(s: str) -> mode { +fn str_mode(s: ~str) -> mode { alt s { - "compile-fail" { mode_compile_fail } - "run-fail" { mode_run_fail } - "run-pass" { mode_run_pass } - "pretty" { mode_pretty } - _ { fail "invalid mode" } + ~"compile-fail" { mode_compile_fail } + ~"run-fail" { mode_run_fail } + ~"run-pass" { mode_run_pass } + ~"pretty" { mode_pretty } + _ { fail ~"invalid mode" } } } -fn mode_str(mode: mode) -> str { +fn mode_str(mode: mode) -> ~str { alt mode { - mode_compile_fail { "compile-fail" } - mode_run_fail { "run-fail" } - mode_run_pass { "run-pass" } - mode_pretty { "pretty" } + mode_compile_fail { ~"compile-fail" } + mode_run_fail { ~"run-fail" } + mode_run_pass { ~"run-pass" } + mode_pretty { ~"pretty" } } } @@ -115,7 +115,7 @@ fn run_tests(config: config) { let opts = test_opts(config); let tests = make_tests(config); let res = test::run_tests_console(opts, tests); - if !res { fail "Some tests failed"; } + if !res { fail ~"Some tests failed"; } } fn test_opts(config: config) -> test::test_opts { @@ -146,11 +146,11 @@ fn make_tests(config: config) -> ~[test::test_desc] { ret tests; } -fn is_test(config: config, testfile: str) -> bool { +fn is_test(config: config, testfile: ~str) -> bool { // Pretty-printer does not work with .rc files yet let valid_extensions = - alt config.mode { mode_pretty { ~[".rs"] } _ { ~[".rc", ".rs"] } }; - let invalid_prefixes = ~[".", "#", "~"]; + alt config.mode { mode_pretty { ~[~".rs"] } _ { ~[~".rc", ~".rs"] } }; + let invalid_prefixes = ~[~".", ~"#", ~"~"]; let name = path::basename(testfile); let mut valid = false; @@ -166,7 +166,7 @@ fn is_test(config: config, testfile: str) -> bool { ret valid; } -fn make_test(config: config, testfile: str) -> +fn make_test(config: config, testfile: ~str) -> test::test_desc { { name: make_test_name(config, testfile), @@ -176,11 +176,11 @@ fn make_test(config: config, testfile: str) -> } } -fn make_test_name(config: config, testfile: str) -> str { +fn make_test_name(config: config, testfile: ~str) -> ~str { #fmt["[%s] %s", mode_str(config.mode), testfile] } -fn make_test_closure(config: config, testfile: str) -> test::test_fn { +fn make_test_closure(config: config, testfile: ~str) -> test::test_fn { fn~() { runtest::run(config, copy testfile) } } diff --git a/src/compiletest/errors.rs b/src/compiletest/errors.rs index 3ccedc60921..64e36cb1f5e 100644 --- a/src/compiletest/errors.rs +++ b/src/compiletest/errors.rs @@ -5,10 +5,10 @@ import common::config; export load_errors; export expected_error; -type expected_error = { line: uint, kind: str, msg: str }; +type expected_error = { line: uint, kind: ~str, msg: ~str }; // Load any test directives embedded in the file -fn load_errors(testfile: str) -> ~[expected_error] { +fn load_errors(testfile: ~str) -> ~[expected_error] { let mut error_patterns = ~[]; let rdr = result::get(io::file_reader(testfile)); let mut line_num = 1u; @@ -20,8 +20,8 @@ fn load_errors(testfile: str) -> ~[expected_error] { ret error_patterns; } -fn parse_expected(line_num: uint, line: str) -> ~[expected_error] unsafe { - let error_tag = "//~"; +fn parse_expected(line_num: uint, line: ~str) -> ~[expected_error] unsafe { + let error_tag = ~"//~"; let mut idx; alt str::find_str(line, error_tag) { option::none { ret ~[]; } diff --git a/src/compiletest/header.rs b/src/compiletest/header.rs index 53f3876d9f6..0d90f1435b9 100644 --- a/src/compiletest/header.rs +++ b/src/compiletest/header.rs @@ -10,20 +10,20 @@ export is_test_ignored; type test_props = { // Lines that should be expected, in order, on standard out - error_patterns: ~[str], + error_patterns: ~[~str], // Extra flags to pass to the compiler - compile_flags: option<str>, + compile_flags: option<~str>, // If present, the name of a file that this test should match when // pretty-printed - pp_exact: option<str>, + pp_exact: option<~str>, // Modules from aux directory that should be compiled - aux_builds: ~[str], + aux_builds: ~[~str], // Environment settings to use during execution - exec_env: ~[(str,str)] + exec_env: ~[(~str,~str)] }; // Load any test directives embedded in the file -fn load_props(testfile: str) -> test_props { +fn load_props(testfile: ~str) -> test_props { let mut error_patterns = ~[]; let mut aux_builds = ~[]; let mut exec_env = ~[]; @@ -60,22 +60,22 @@ fn load_props(testfile: str) -> test_props { }; } -fn is_test_ignored(config: config, testfile: str) -> bool { +fn is_test_ignored(config: config, testfile: ~str) -> bool { let mut found = false; for iter_header(testfile) |ln| { - if parse_name_directive(ln, "xfail-test") { ret true; } + if parse_name_directive(ln, ~"xfail-test") { ret true; } if parse_name_directive(ln, xfail_target()) { ret true; } if config.mode == common::mode_pretty && - parse_name_directive(ln, "xfail-pretty") { ret true; } + parse_name_directive(ln, ~"xfail-pretty") { ret true; } }; ret found; - fn xfail_target() -> str { - "xfail-" + os::sysname() + fn xfail_target() -> ~str { + ~"xfail-" + os::sysname() } } -fn iter_header(testfile: str, it: fn(str) -> bool) -> bool { +fn iter_header(testfile: ~str, it: fn(~str) -> bool) -> bool { let rdr = result::get(io::file_reader(testfile)); while !rdr.eof() { let ln = rdr.read_line(); @@ -83,43 +83,43 @@ fn iter_header(testfile: str, it: fn(str) -> bool) -> bool { // Assume that any directives will be found before the first // module or function. This doesn't seem to be an optimization // with a warm page cache. Maybe with a cold one. - if str::starts_with(ln, "fn") - || str::starts_with(ln, "mod") { + if str::starts_with(ln, ~"fn") + || str::starts_with(ln, ~"mod") { ret false; } else { if !(it(ln)) { ret false; } } } ret true; } -fn parse_error_pattern(line: str) -> option<str> { - parse_name_value_directive(line, "error-pattern") +fn parse_error_pattern(line: ~str) -> option<~str> { + parse_name_value_directive(line, ~"error-pattern") } -fn parse_aux_build(line: str) -> option<str> { - parse_name_value_directive(line, "aux-build") +fn parse_aux_build(line: ~str) -> option<~str> { + parse_name_value_directive(line, ~"aux-build") } -fn parse_compile_flags(line: str) -> option<str> { - parse_name_value_directive(line, "compile-flags") +fn parse_compile_flags(line: ~str) -> option<~str> { + parse_name_value_directive(line, ~"compile-flags") } -fn parse_exec_env(line: str) -> option<(str, str)> { - do parse_name_value_directive(line, "exec-env").map |nv| { +fn parse_exec_env(line: ~str) -> option<(~str, ~str)> { + do parse_name_value_directive(line, ~"exec-env").map |nv| { // nv is either FOO or FOO=BAR let strs = str::splitn_char(nv, '=', 1u); alt strs.len() { - 1u { (strs[0], "") } + 1u { (strs[0], ~"") } 2u { (strs[0], strs[1]) } n { fail #fmt["Expected 1 or 2 strings, not %u", n]; } } } } -fn parse_pp_exact(line: str, testfile: str) -> option<str> { - alt parse_name_value_directive(line, "pp-exact") { +fn parse_pp_exact(line: ~str, testfile: ~str) -> option<~str> { + alt parse_name_value_directive(line, ~"pp-exact") { option::some(s) { option::some(s) } option::none { - if parse_name_directive(line, "pp-exact") { + if parse_name_directive(line, ~"pp-exact") { option::some(path::basename(testfile)) } else { option::none @@ -128,13 +128,13 @@ fn parse_pp_exact(line: str, testfile: str) -> option<str> { } } -fn parse_name_directive(line: str, directive: str) -> bool { +fn parse_name_directive(line: ~str, directive: ~str) -> bool { str::contains(line, directive) } -fn parse_name_value_directive(line: str, - directive: str) -> option<str> unsafe { - let keycolon = directive + ":"; +fn parse_name_value_directive(line: ~str, + directive: ~str) -> option<~str> unsafe { + let keycolon = directive + ~":"; alt str::find_str(line, keycolon) { option::some(colon) { let value = str::slice(line, colon + str::len(keycolon), diff --git a/src/compiletest/procsrv.rs b/src/compiletest/procsrv.rs index c46196fd7f6..d69d02c32eb 100644 --- a/src/compiletest/procsrv.rs +++ b/src/compiletest/procsrv.rs @@ -27,17 +27,17 @@ fn target_env(lib_path: str, prog: str) -> ~[(str,str)] { #[cfg(target_os = "linux")] #[cfg(target_os = "macos")] #[cfg(target_os = "freebsd")] -fn target_env(_lib_path: str, _prog: str) -> ~[(str,str)] { +fn target_env(_lib_path: ~str, _prog: ~str) -> ~[(~str,~str)] { ~[] } // FIXME (#2659): This code is duplicated in core::run::program_output -fn run(lib_path: str, - prog: str, - args: ~[str], - env: ~[(str, str)], - input: option<str>) -> {status: int, out: str, err: str} { +fn run(lib_path: ~str, + prog: ~str, + args: ~[~str], + env: ~[(~str, ~str)], + input: option<~str>) -> {status: int, out: ~str, err: ~str} { let pipe_in = os::pipe(); let pipe_out = os::pipe(); @@ -69,8 +69,8 @@ fn run(lib_path: str, comm::send(ch, (1, output)); } let status = run::waitpid(pid); - let mut errs = ""; - let mut outs = ""; + let mut errs = ~""; + let mut outs = ~""; let mut count = 2; while count > 0 { let stream = comm::recv(p); @@ -87,7 +87,7 @@ fn run(lib_path: str, ret {status: status, out: outs, err: errs}; } -fn writeclose(fd: c_int, s: option<str>) { +fn writeclose(fd: c_int, s: option<~str>) { if option::is_some(s) { let writer = io::fd_writer(fd, false); writer.write_str(option::get(s)); @@ -96,11 +96,11 @@ fn writeclose(fd: c_int, s: option<str>) { os::close(fd); } -fn readclose(fd: c_int) -> str { +fn readclose(fd: c_int) -> ~str { // Copied from run::program_output let file = os::fdopen(fd); let reader = io::FILE_reader(file, false); - let mut buf = ""; + let mut buf = ~""; while !reader.eof() { let bytes = reader.read_bytes(4096u); buf += str::from_bytes(bytes); diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs index 9c131f18564..cd8bcb79a9a 100644 --- a/src/compiletest/runtest.rs +++ b/src/compiletest/runtest.rs @@ -11,10 +11,10 @@ import util::logv; export run; -fn run(config: config, testfile: str) { +fn run(config: config, testfile: ~str) { if config.verbose { // We're going to be dumping a lot of info. Start on a new line. - io::stdout().write_str("\n\n"); + io::stdout().write_str(~"\n\n"); } #debug("running %s", testfile); let props = load_props(testfile); @@ -26,11 +26,11 @@ fn run(config: config, testfile: str) { } } -fn run_cfail_test(config: config, props: test_props, testfile: str) { +fn run_cfail_test(config: config, props: test_props, testfile: ~str) { let procres = compile_test(config, props, testfile); if procres.status == 0 { - fatal_procres("compile-fail test compiled successfully!", procres); + fatal_procres(~"compile-fail test compiled successfully!", procres); } check_correct_failure_status(procres); @@ -38,7 +38,7 @@ fn run_cfail_test(config: config, props: test_props, testfile: str) { let expected_errors = errors::load_errors(testfile); if vec::is_not_empty(expected_errors) { if vec::is_not_empty(props.error_patterns) { - fatal("both error pattern and expected errors specified"); + fatal(~"both error pattern and expected errors specified"); } check_expected_errors(expected_errors, testfile, procres); } else { @@ -46,17 +46,17 @@ fn run_cfail_test(config: config, props: test_props, testfile: str) { } } -fn run_rfail_test(config: config, props: test_props, testfile: str) { +fn run_rfail_test(config: config, props: test_props, testfile: ~str) { let mut procres = compile_test(config, props, testfile); - if procres.status != 0 { fatal_procres("compilation failed!", procres); } + if procres.status != 0 { fatal_procres(~"compilation failed!", procres); } procres = exec_compiled_test(config, props, testfile); // The value our Makefile configures valgrind to return on failure const valgrind_err: int = 100; if procres.status == valgrind_err { - fatal_procres("run-fail test isn't valgrind-clean!", procres); + fatal_procres(~"run-fail test isn't valgrind-clean!", procres); } check_correct_failure_status(procres); @@ -74,20 +74,20 @@ fn check_correct_failure_status(procres: procres) { } } -fn run_rpass_test(config: config, props: test_props, testfile: str) { +fn run_rpass_test(config: config, props: test_props, testfile: ~str) { let mut procres = compile_test(config, props, testfile); - if procres.status != 0 { fatal_procres("compilation failed!", procres); } + if procres.status != 0 { fatal_procres(~"compilation failed!", procres); } procres = exec_compiled_test(config, props, testfile); - if procres.status != 0 { fatal_procres("test run failed!", procres); } + if procres.status != 0 { fatal_procres(~"test run failed!", procres); } } -fn run_pretty_test(config: config, props: test_props, testfile: str) { +fn run_pretty_test(config: config, props: test_props, testfile: ~str) { if option::is_some(props.pp_exact) { - logv(config, "testing for exact pretty-printing"); - } else { logv(config, "testing for converging pretty-printing"); } + logv(config, ~"testing for exact pretty-printing"); + } else { logv(config, ~"testing for converging pretty-printing"); } let rounds = alt props.pp_exact { option::some(_) { 1 } option::none { 2 } }; @@ -120,10 +120,10 @@ fn run_pretty_test(config: config, props: test_props, testfile: str) { if option::is_some(props.pp_exact) { // Now we have to care about line endings - let cr = "\r"; + let cr = ~"\r"; check (str::is_not_empty(cr)); - actual = str::replace(actual, cr, ""); - expected = str::replace(expected, cr, ""); + actual = str::replace(actual, cr, ~""); + expected = str::replace(expected, cr, ~""); } compare_source(expected, actual); @@ -132,25 +132,25 @@ fn run_pretty_test(config: config, props: test_props, testfile: str) { let procres = typecheck_source(config, props, testfile, actual); if procres.status != 0 { - fatal_procres("pretty-printed source does not typecheck", procres); + fatal_procres(~"pretty-printed source does not typecheck", procres); } ret; - fn print_source(config: config, testfile: str, src: str) -> procres { + fn print_source(config: config, testfile: ~str, src: ~str) -> procres { compose_and_run(config, testfile, make_pp_args(config, testfile), ~[], config.compile_lib_path, option::some(src)) } - fn make_pp_args(config: config, _testfile: str) -> procargs { + fn make_pp_args(config: config, _testfile: ~str) -> procargs { let prog = config.rustc_path; - let args = ~["-", "--pretty", "normal"]; + let args = ~[~"-", ~"--pretty", ~"normal"]; ret {prog: prog, args: args}; } - fn compare_source(expected: str, actual: str) { + fn compare_source(expected: ~str, actual: ~str) { if expected != actual { - error("pretty-printed source does not match expected source"); + error(~"pretty-printed source does not match expected source"); let msg = #fmt["\n\ expected:\n\ @@ -169,31 +169,32 @@ actual:\n\ } fn typecheck_source(config: config, props: test_props, - testfile: str, src: str) -> procres { + testfile: ~str, src: ~str) -> procres { compose_and_run_compiler( config, props, testfile, make_typecheck_args(config, testfile), option::some(src)) } - fn make_typecheck_args(config: config, testfile: str) -> procargs { + fn make_typecheck_args(config: config, testfile: ~str) -> procargs { let prog = config.rustc_path; - let mut args = ~["-", "--no-trans", "--lib", "-L", config.build_base, - "-L", aux_output_dir_name(config, testfile)]; + let mut args = ~[~"-", + ~"--no-trans", ~"--lib", ~"-L", config.build_base, + ~"-L", aux_output_dir_name(config, testfile)]; args += split_maybe_args(config.rustcflags); ret {prog: prog, args: args}; } } fn check_error_patterns(props: test_props, - testfile: str, + testfile: ~str, procres: procres) { if vec::is_empty(props.error_patterns) { - fatal("no error pattern specified in " + testfile); + fatal(~"no error pattern specified in " + testfile); } if procres.status == 0 { - fatal("process did not return an error status"); + fatal(~"process did not return an error status"); } let mut next_err_idx = 0u; @@ -223,12 +224,12 @@ fn check_error_patterns(props: test_props, for missing_patterns.each |pattern| { error(#fmt["error pattern '%s' not found!", pattern]); } - fatal_procres("multiple error patterns not found", procres); + fatal_procres(~"multiple error patterns not found", procres); } } fn check_expected_errors(expected_errors: ~[errors::expected_error], - testfile: str, + testfile: ~str, procres: procres) { // true if we found the error in question @@ -236,7 +237,7 @@ fn check_expected_errors(expected_errors: ~[errors::expected_error], vec::len(expected_errors), false)); if procres.status == 0 { - fatal("process did not return an error status"); + fatal(~"process did not return an error status"); } let prefixes = vec::map(expected_errors, |ee| { @@ -266,12 +267,12 @@ fn check_expected_errors(expected_errors: ~[errors::expected_error], } // ignore this msg which gets printed at the end - if str::contains(line, "aborting due to") { + if str::contains(line, ~"aborting due to") { was_expected = true; } - if !was_expected && (str::contains(line, "error") || - str::contains(line, "warning")) { + if !was_expected && (str::contains(line, ~"error") || + str::contains(line, ~"warning")) { fatal_procres(#fmt["unexpected error pattern '%s'!", line], procres); } @@ -286,13 +287,13 @@ fn check_expected_errors(expected_errors: ~[errors::expected_error], } } -type procargs = {prog: str, args: ~[str]}; +type procargs = {prog: ~str, args: ~[~str]}; -type procres = {status: int, stdout: str, stderr: str, cmdline: str}; +type procres = {status: int, stdout: ~str, stderr: ~str, cmdline: ~str}; fn compile_test(config: config, props: test_props, - testfile: str) -> procres { - let link_args = ~["-L", aux_output_dir_name(config, testfile)]; + testfile: ~str) -> procres { + let link_args = ~[~"-L", aux_output_dir_name(config, testfile)]; compose_and_run_compiler( config, props, testfile, make_compile_args(config, props, link_args, @@ -301,7 +302,7 @@ fn compile_test(config: config, props: test_props, } fn exec_compiled_test(config: config, props: test_props, - testfile: str) -> procres { + testfile: ~str) -> procres { compose_and_run(config, testfile, make_run_args(config, props, testfile), props.exec_env, @@ -311,20 +312,20 @@ fn exec_compiled_test(config: config, props: test_props, fn compose_and_run_compiler( config: config, props: test_props, - testfile: str, + testfile: ~str, args: procargs, - input: option<str>) -> procres { + input: option<~str>) -> procres { if props.aux_builds.is_not_empty() { ensure_dir(aux_output_dir_name(config, testfile)); } - let extra_link_args = ~["-L", aux_output_dir_name(config, testfile)]; + let extra_link_args = ~[~"-L", aux_output_dir_name(config, testfile)]; do vec::iter(props.aux_builds) |rel_ab| { let abs_ab = path::connect(config.aux_base, rel_ab); let aux_args = - make_compile_args(config, props, ~["--lib"] + extra_link_args, + make_compile_args(config, props, ~[~"--lib"] + extra_link_args, |a,b| make_lib_name(a, b, testfile), abs_ab); let auxres = compose_and_run(config, abs_ab, aux_args, ~[], config.compile_lib_path, option::none); @@ -346,38 +347,38 @@ fn ensure_dir(path: path) { } } -fn compose_and_run(config: config, testfile: str, +fn compose_and_run(config: config, testfile: ~str, procargs: procargs, - procenv: ~[(str, str)], - lib_path: str, - input: option<str>) -> procres { + procenv: ~[(~str, ~str)], + lib_path: ~str, + input: option<~str>) -> procres { ret program_output(config, testfile, lib_path, procargs.prog, procargs.args, procenv, input); } -fn make_compile_args(config: config, props: test_props, extras: ~[str], - xform: fn(config, str) -> str, testfile: str) -> +fn make_compile_args(config: config, props: test_props, extras: ~[~str], + xform: fn(config, ~str) -> ~str, testfile: ~str) -> procargs { let prog = config.rustc_path; - let mut args = ~[testfile, "-o", xform(config, testfile), - "-L", config.build_base] + extras; + let mut args = ~[testfile, ~"-o", xform(config, testfile), + ~"-L", config.build_base] + extras; args += split_maybe_args(config.rustcflags); args += split_maybe_args(props.compile_flags); ret {prog: prog, args: args}; } -fn make_lib_name(config: config, auxfile: str, testfile: str) -> str { +fn make_lib_name(config: config, auxfile: ~str, testfile: ~str) -> ~str { // what we return here is not particularly important, as it // happens; rustc ignores everything except for the directory. let auxname = output_testname(auxfile); path::connect(aux_output_dir_name(config, testfile), auxname) } -fn make_exe_name(config: config, testfile: str) -> str { +fn make_exe_name(config: config, testfile: ~str) -> ~str { output_base_name(config, testfile) + os::exe_suffix() } -fn make_run_args(config: config, _props: test_props, testfile: str) -> +fn make_run_args(config: config, _props: test_props, testfile: ~str) -> procargs { let toolargs = { // If we've got another tool to run under (valgrind), @@ -394,9 +395,9 @@ fn make_run_args(config: config, _props: test_props, testfile: str) -> ret {prog: args[0], args: vec::slice(args, 1u, vec::len(args))}; } -fn split_maybe_args(argstr: option<str>) -> ~[str] { - fn rm_whitespace(v: ~[str]) -> ~[str] { - fn flt(&&s: str) -> option<str> { +fn split_maybe_args(argstr: option<~str>) -> ~[~str] { + fn rm_whitespace(v: ~[~str]) -> ~[~str] { + fn flt(&&s: ~str) -> option<~str> { if !str::is_whitespace(s) { option::some(s) } else { option::none } } vec::filter_map(v, flt) @@ -408,9 +409,9 @@ fn split_maybe_args(argstr: option<str>) -> ~[str] { } } -fn program_output(config: config, testfile: str, lib_path: str, prog: str, - args: ~[str], env: ~[(str, str)], - input: option<str>) -> procres { +fn program_output(config: config, testfile: ~str, lib_path: ~str, prog: ~str, + args: ~[~str], env: ~[(~str, ~str)], + input: option<~str>) -> procres { let cmdline = { let cmdline = make_cmdline(lib_path, prog, args); @@ -429,8 +430,8 @@ fn program_output(config: config, testfile: str, lib_path: str, prog: str, #[cfg(target_os = "linux")] #[cfg(target_os = "macos")] #[cfg(target_os = "freebsd")] -fn make_cmdline(_libpath: str, prog: str, args: ~[str]) -> str { - #fmt["%s %s", prog, str::connect(args, " ")] +fn make_cmdline(_libpath: ~str, prog: ~str, args: ~[~str]) -> ~str { + #fmt["%s %s", prog, str::connect(args, ~" ")] } #[cfg(target_os = "win32")] @@ -441,47 +442,48 @@ fn make_cmdline(libpath: str, prog: str, args: ~[str]) -> str { // Build the LD_LIBRARY_PATH variable as it would be seen on the command line // for diagnostic purposes -fn lib_path_cmd_prefix(path: str) -> str { +fn lib_path_cmd_prefix(path: ~str) -> ~str { #fmt["%s=\"%s\"", util::lib_path_env_var(), util::make_new_path(path)] } -fn dump_output(config: config, testfile: str, out: str, err: str) { - dump_output_file(config, testfile, out, "out"); - dump_output_file(config, testfile, err, "err"); +fn dump_output(config: config, testfile: ~str, out: ~str, err: ~str) { + dump_output_file(config, testfile, out, ~"out"); + dump_output_file(config, testfile, err, ~"err"); maybe_dump_to_stdout(config, out, err); } -fn dump_output_file(config: config, testfile: str, out: str, extension: str) { +fn dump_output_file(config: config, testfile: ~str, + out: ~str, extension: ~str) { let outfile = make_out_name(config, testfile, extension); let writer = result::get( io::file_writer(outfile, ~[io::create, io::truncate])); writer.write_str(out); } -fn make_out_name(config: config, testfile: str, extension: str) -> str { - output_base_name(config, testfile) + "." + extension +fn make_out_name(config: config, testfile: ~str, extension: ~str) -> ~str { + output_base_name(config, testfile) + ~"." + extension } -fn aux_output_dir_name(config: config, testfile: str) -> str { - output_base_name(config, testfile) + ".libaux" +fn aux_output_dir_name(config: config, testfile: ~str) -> ~str { + output_base_name(config, testfile) + ~".libaux" } -fn output_testname(testfile: str) -> str { +fn output_testname(testfile: ~str) -> ~str { let parts = str::split_char(path::basename(testfile), '.'); - str::connect(vec::slice(parts, 0u, vec::len(parts) - 1u), ".") + str::connect(vec::slice(parts, 0u, vec::len(parts) - 1u), ~".") } -fn output_base_name(config: config, testfile: str) -> str { +fn output_base_name(config: config, testfile: ~str) -> ~str { let base = config.build_base; let filename = output_testname(testfile); #fmt["%s%s.%s", base, filename, config.stage_id] } -fn maybe_dump_to_stdout(config: config, out: str, err: str) { +fn maybe_dump_to_stdout(config: config, out: ~str, err: ~str) { if config.verbose { - let sep1 = #fmt["------%s------------------------------", "stdout"]; - let sep2 = #fmt["------%s------------------------------", "stderr"]; - let sep3 = "------------------------------------------"; + let sep1 = #fmt["------%s------------------------------", ~"stdout"]; + let sep2 = #fmt["------%s------------------------------", ~"stderr"]; + let sep3 = ~"------------------------------------------"; io::stdout().write_line(sep1); io::stdout().write_line(out); io::stdout().write_line(sep2); @@ -490,11 +492,11 @@ fn maybe_dump_to_stdout(config: config, out: str, err: str) { } } -fn error(err: str) { io::stdout().write_line(#fmt["\nerror: %s", err]); } +fn error(err: ~str) { io::stdout().write_line(#fmt["\nerror: %s", err]); } -fn fatal(err: str) -> ! { error(err); fail; } +fn fatal(err: ~str) -> ! { error(err); fail; } -fn fatal_procres(err: str, procres: procres) -> ! { +fn fatal_procres(err: ~str, procres: procres) -> ! { let msg = #fmt["\n\ error: %s\n\ diff --git a/src/compiletest/util.rs b/src/compiletest/util.rs index b29b0d968c4..7a38ffcc212 100644 --- a/src/compiletest/util.rs +++ b/src/compiletest/util.rs @@ -3,7 +3,7 @@ import os::getenv; import common::config; -fn make_new_path(path: str) -> str { +fn make_new_path(path: ~str) -> ~str { // Windows just uses PATH as the library search path, so we have to // maintain the current value while adding our own @@ -17,7 +17,7 @@ fn make_new_path(path: str) -> str { #[cfg(target_os = "linux")] #[cfg(target_os = "freebsd")] -fn lib_path_env_var() -> str { "LD_LIBRARY_PATH" } +fn lib_path_env_var() -> ~str { ~"LD_LIBRARY_PATH" } #[cfg(target_os = "macos")] fn lib_path_env_var() -> str { "DYLD_LIBRARY_PATH" } @@ -28,12 +28,12 @@ fn lib_path_env_var() -> str { "PATH" } #[cfg(target_os = "linux")] #[cfg(target_os = "macos")] #[cfg(target_os = "freebsd")] -fn path_div() -> str { ":" } +fn path_div() -> ~str { ~":" } #[cfg(target_os = "win32")] fn path_div() -> str { ";" } -fn logv(config: config, s: str) { +fn logv(config: config, s: ~str) { log(debug, s); if config.verbose { io::println(s); } } diff --git a/src/fuzzer/fuzzer.rs b/src/fuzzer/fuzzer.rs index 8816b58d9e6..047d6433915 100644 --- a/src/fuzzer/fuzzer.rs +++ b/src/fuzzer/fuzzer.rs @@ -8,23 +8,23 @@ import syntax::diagnostic; enum test_mode { tm_converge, tm_run, } type context = { mode: test_mode }; // + rng -fn write_file(filename: str, content: str) { +fn write_file(filename: ~str, content: ~str) { result::get( io::file_writer(filename, ~[io::create, io::truncate])) .write_str(content); } -fn contains(haystack: str, needle: str) -> bool { +fn contains(haystack: ~str, needle: ~str) -> bool { str::contains(haystack, needle) } -fn find_rust_files(&files: ~[str], path: str) { - if str::ends_with(path, ".rs") && !contains(path, "utf8") { +fn find_rust_files(&files: ~[~str], path: ~str) { + if str::ends_with(path, ~".rs") && !contains(path, ~"utf8") { // ignoring "utf8" tests because something is broken files += ~[path]; } else if os::path_is_dir(path) - && !contains(path, "compile-fail") - && !contains(path, "build") { + && !contains(path, ~"compile-fail") + && !contains(path, ~"build") { for os::list_dir_path(path).each |p| { find_rust_files(files, p); } @@ -45,7 +45,7 @@ fn common_exprs() -> ~[ast::expr] { dse(ast::expr_again), dse(ast::expr_fail(option::none)), dse(ast::expr_fail(option::some( - @dse(ast::expr_lit(@dsl(ast::lit_str(@"boo"/~))))))), + @dse(ast::expr_lit(@dsl(ast::lit_str(@~"boo"))))))), dse(ast::expr_ret(option::none)), dse(ast::expr_lit(@dsl(ast::lit_nil))), dse(ast::expr_lit(@dsl(ast::lit_bool(false)))), @@ -228,31 +228,31 @@ fn under(n: uint, it: fn(uint)) { fn devnull() -> io::writer { io::mem_buffer_writer(io::mem_buffer()) } -fn as_str(f: fn@(io::writer)) -> str { +fn as_str(f: fn@(io::writer)) -> ~str { let buf = io::mem_buffer(); f(io::mem_buffer_writer(buf)); io::mem_buffer_str(buf) } fn check_variants_of_ast(crate: ast::crate, codemap: codemap::codemap, - filename: str, cx: context) { + filename: ~str, cx: context) { let stolen = steal(crate, cx.mode); let extra_exprs = vec::filter(common_exprs(), |a| safe_to_use_expr(a, cx.mode) ); - check_variants_T(crate, codemap, filename, "expr", + check_variants_T(crate, codemap, filename, ~"expr", extra_exprs + stolen.exprs, pprust::expr_to_str, replace_expr_in_crate, cx); - check_variants_T(crate, codemap, filename, "ty", stolen.tys, + check_variants_T(crate, codemap, filename, ~"ty", stolen.tys, pprust::ty_to_str, replace_ty_in_crate, cx); } fn check_variants_T<T: copy>( crate: ast::crate, codemap: codemap::codemap, - filename: str, - thing_label: str, + filename: ~str, + thing_label: ~str, things: ~[T], - stringifier: fn@(@T) -> str, + stringifier: fn@(@T) -> ~str, replacer: fn@(ast::crate, uint, T, test_mode) -> ast::crate, cx: context ) { @@ -263,9 +263,9 @@ fn check_variants_T<T: copy>( if L < 100u { do under(uint::min(L, 20u)) |i| { - log(error, "Replacing... #" + uint::str(i)); + log(error, ~"Replacing... #" + uint::str(i)); do under(uint::min(L, 30u)) |j| { - log(error, "With... " + stringifier(@things[j])); + log(error, ~"With... " + stringifier(@things[j])); let crate2 = @replacer(crate, i, things[j], cx.mode); // It would be best to test the *crate* for stability, but // testing the string for stability is easier and ok for now. @@ -276,7 +276,7 @@ fn check_variants_T<T: copy>( diagnostic::mk_span_handler(handler, codemap), crate2, filename, - io::str_reader(""), a, + io::str_reader(~""), a, pprust::no_ann(), false)); alt cx.mode { @@ -297,21 +297,26 @@ fn check_variants_T<T: copy>( } } -fn last_part(filename: str) -> str { +fn last_part(filename: ~str) -> ~str { let ix = option::get(str::rfind_char(filename, '/')); str::slice(filename, ix + 1u, str::len(filename) - 3u) } -enum happiness { passed, cleanly_rejected(str), known_bug(str), failed(str), } +enum happiness { + passed, + cleanly_rejected(~str), + known_bug(~str), + failed(~str), +} // We'd find more bugs if we could take an AST here, but // - that would find many "false positives" or unimportant bugs // - that would be tricky, requiring use of tasks or serialization // or randomness. // This seems to find plenty of bugs as it is :) -fn check_whole_compiler(code: str, suggested_filename_prefix: str, +fn check_whole_compiler(code: ~str, suggested_filename_prefix: ~str, allow_running: bool) { - let filename = suggested_filename_prefix + ".rs"; + let filename = suggested_filename_prefix + ~".rs"; write_file(filename, code); let compile_result = check_compiling(filename); @@ -324,102 +329,102 @@ fn check_whole_compiler(code: str, suggested_filename_prefix: str, alt run_result { passed | cleanly_rejected(_) | known_bug(_) { removeIfExists(suggested_filename_prefix); - removeIfExists(suggested_filename_prefix + ".rs"); - removeDirIfExists(suggested_filename_prefix + ".dSYM"); + removeIfExists(suggested_filename_prefix + ~".rs"); + removeDirIfExists(suggested_filename_prefix + ~".dSYM"); } failed(s) { - log(error, "check_whole_compiler failure: " + s); - log(error, "Saved as: " + filename); + log(error, ~"check_whole_compiler failure: " + s); + log(error, ~"Saved as: " + filename); } } } -fn removeIfExists(filename: str) { +fn removeIfExists(filename: ~str) { // So sketchy! - assert !contains(filename, " "); - run::program_output("bash", ~["-c", "rm " + filename]); + assert !contains(filename, ~" "); + run::program_output(~"bash", ~[~"-c", ~"rm " + filename]); } -fn removeDirIfExists(filename: str) { +fn removeDirIfExists(filename: ~str) { // So sketchy! - assert !contains(filename, " "); - run::program_output("bash", ~["-c", "rm -r " + filename]); + assert !contains(filename, ~" "); + run::program_output(~"bash", ~[~"-c", ~"rm -r " + filename]); } -fn check_running(exe_filename: str) -> happiness { +fn check_running(exe_filename: ~str) -> happiness { let p = run::program_output( - "/Users/jruderman/scripts/timed_run_rust_program.py", + ~"/Users/jruderman/scripts/timed_run_rust_program.py", ~[exe_filename]); - let comb = p.out + "\n" + p.err; + let comb = p.out + ~"\n" + p.err; if str::len(comb) > 1u { - log(error, "comb comb comb: " + comb); + log(error, ~"comb comb comb: " + comb); } - if contains(comb, "Assertion failed:") { - failed("C++ assertion failure") - } else if contains(comb, "leaked memory in rust main loop") { + if contains(comb, ~"Assertion failed:") { + failed(~"C++ assertion failure") + } else if contains(comb, ~"leaked memory in rust main loop") { // might also use exit code 134 //failed("Leaked") - known_bug("https://github.com/mozilla/rust/issues/910") - } else if contains(comb, "src/rt/") { - failed("Mentioned src/rt/") - } else if contains(comb, "malloc") { - failed("Mentioned malloc") + known_bug(~"https://github.com/mozilla/rust/issues/910") + } else if contains(comb, ~"src/rt/") { + failed(~"Mentioned src/rt/") + } else if contains(comb, ~"malloc") { + failed(~"Mentioned malloc") } else { alt p.status { 0 { passed } - 100 { cleanly_rejected("running: explicit fail") } - 101 | 247 { cleanly_rejected("running: timed out") } + 100 { cleanly_rejected(~"running: explicit fail") } + 101 | 247 { cleanly_rejected(~"running: timed out") } 245 | 246 | 138 | 252 { - known_bug("https://github.com/mozilla/rust/issues/1466") + known_bug(~"https://github.com/mozilla/rust/issues/1466") } 136 | 248 { known_bug( - "SIGFPE - https://github.com/mozilla/rust/issues/944") + ~"SIGFPE - https://github.com/mozilla/rust/issues/944") } rc { - failed("Rust program ran but exited with status " + + failed(~"Rust program ran but exited with status " + int::str(rc)) } } } } -fn check_compiling(filename: str) -> happiness { +fn check_compiling(filename: ~str) -> happiness { let p = run::program_output( - "/Users/jruderman/code/rust/build/x86_64-apple-darwin/\ + ~"/Users/jruderman/code/rust/build/x86_64-apple-darwin/\ stage1/bin/rustc", ~[filename]); //#error("Status: %d", p.status); if p.status == 0 { passed - } else if p.err != "" { - if contains(p.err, "error:") { - cleanly_rejected("rejected with span_error") + } else if p.err != ~"" { + if contains(p.err, ~"error:") { + cleanly_rejected(~"rejected with span_error") } else { - log(error, "Stderr: " + p.err); - failed("Unfamiliar error message") + log(error, ~"Stderr: " + p.err); + failed(~"Unfamiliar error message") } - } else if contains(p.out, "Assertion") && contains(p.out, "failed") { - log(error, "Stdout: " + p.out); - failed("Looks like an llvm assertion failure") - } else if contains(p.out, "internal compiler error unimplemented") { - known_bug("Something unimplemented") - } else if contains(p.out, "internal compiler error") { - log(error, "Stdout: " + p.out); - failed("internal compiler error") + } else if contains(p.out, ~"Assertion") && contains(p.out, ~"failed") { + log(error, ~"Stdout: " + p.out); + failed(~"Looks like an llvm assertion failure") + } else if contains(p.out, ~"internal compiler error unimplemented") { + known_bug(~"Something unimplemented") + } else if contains(p.out, ~"internal compiler error") { + log(error, ~"Stdout: " + p.out); + failed(~"internal compiler error") } else { log(error, p.status); - log(error, "!Stdout: " + p.out); - failed("What happened?") + log(error, ~"!Stdout: " + p.out); + failed(~"What happened?") } } -fn parse_and_print(code: @str/~) -> str { - let filename = "tmp.rs"; +fn parse_and_print(code: @~str) -> ~str { + let filename = ~"tmp.rs"; let sess = parse::new_parse_sess(option::none); write_file(filename, *code); let crate = parse::parse_crate_from_source_str( @@ -450,49 +455,49 @@ fn has_raw_pointers(c: ast::crate) -> bool { ret *has_rp; } -fn content_is_dangerous_to_run(code: str) -> bool { +fn content_is_dangerous_to_run(code: ~str) -> bool { let dangerous_patterns = - ~["xfail-test", - "import", // espeically fs, run - "extern", - "unsafe", - "log"]; // python --> rust pipe deadlock? + ~[~"xfail-test", + ~"import", // espeically fs, run + ~"extern", + ~"unsafe", + ~"log"]; // python --> rust pipe deadlock? for dangerous_patterns.each |p| { if contains(code, p) { ret true; } } ret false; } -fn content_is_dangerous_to_compile(code: str) -> bool { +fn content_is_dangerous_to_compile(code: ~str) -> bool { let dangerous_patterns = - ~["xfail-test"]; + ~[~"xfail-test"]; for dangerous_patterns.each |p| { if contains(code, p) { ret true; } } ret false; } -fn content_might_not_converge(code: str) -> bool { +fn content_might_not_converge(code: ~str) -> bool { let confusing_patterns = - ~["xfail-test", - "xfail-pretty", - "self", // crazy rules enforced by parser not typechecker? - "spawn", // precedence issues? - "bind", // precedence issues? - " be ", // don't want to replace its child with a non-call: + ~[~"xfail-test", + ~"xfail-pretty", + ~"self", // crazy rules enforced by parser not typechecker? + ~"spawn", // precedence issues? + ~"bind", // precedence issues? + ~" be ", // don't want to replace its child with a non-call: // "Non-call expression in tail call" - "\n\n\n\n\n" // https://github.com/mozilla/rust/issues/850 + ~"\n\n\n\n\n" // https://github.com/mozilla/rust/issues/850 ]; for confusing_patterns.each |p| { if contains(code, p) { ret true; } } ret false; } -fn file_might_not_converge(filename: str) -> bool { +fn file_might_not_converge(filename: ~str) -> bool { let confusing_files = ~[ - "expr-alt.rs", // pretty-printing "(a = b) = c" + ~"expr-alt.rs", // pretty-printing "(a = b) = c" // vs "a = b = c" and wrapping - "block-arg-in-ternary.rs", // wrapping - "move-3-unique.rs", // 0 becomes (0), but both seem reasonable. wtf? - "move-3.rs" // 0 becomes (0), but both seem reasonable. wtf? + ~"block-arg-in-ternary.rs", // wrapping + ~"move-3-unique.rs", // 0 becomes (0), but both seem reasonable. wtf? + ~"move-3.rs" // 0 becomes (0), but both seem reasonable. wtf? ]; @@ -501,7 +506,7 @@ fn file_might_not_converge(filename: str) -> bool { ret false; } -fn check_roundtrip_convergence(code: @str/~, maxIters: uint) { +fn check_roundtrip_convergence(code: @~str, maxIters: uint) { let mut i = 0u; let mut newv = code; @@ -519,16 +524,16 @@ fn check_roundtrip_convergence(code: @str/~, maxIters: uint) { #error("Converged after %u iterations", i); } else { #error("Did not converge after %u iterations!", i); - write_file("round-trip-a.rs", *oldv); - write_file("round-trip-b.rs", *newv); - run::run_program("diff", - ~["-w", "-u", "round-trip-a.rs", - "round-trip-b.rs"]); - fail "Mismatch"; + write_file(~"round-trip-a.rs", *oldv); + write_file(~"round-trip-b.rs", *newv); + run::run_program(~"diff", + ~[~"-w", ~"-u", ~"round-trip-a.rs", + ~"round-trip-b.rs"]); + fail ~"Mismatch"; } } -fn check_convergence(files: ~[str]) { +fn check_convergence(files: ~[~str]) { #error("pp convergence tests: %u files", vec::len(files)); for files.each |file| { if !file_might_not_converge(file) { @@ -543,7 +548,7 @@ fn check_convergence(files: ~[str]) { } } -fn check_variants(files: ~[str], cx: context) { +fn check_variants(files: ~[~str], cx: context) { for files.each |file| { if cx.mode == tm_converge && file_might_not_converge(file) { #error("Skipping convergence test based on\ @@ -552,7 +557,7 @@ fn check_variants(files: ~[str], cx: context) { } let s = @result::get(io::read_whole_file_str(file)); - if contains(*s, "#") { + if contains(*s, ~"#") { again; // Macros are confusing } if cx.mode == tm_converge && content_might_not_converge(*s) { @@ -562,7 +567,7 @@ fn check_variants(files: ~[str], cx: context) { again; } - log(error, "check_variants: " + file); + log(error, ~"check_variants: " + file); let sess = parse::new_parse_sess(option::none); let crate = parse::parse_crate_from_source_str( @@ -582,7 +587,7 @@ fn check_variants(files: ~[str], cx: context) { } } -fn main(args: ~[str]) { +fn main(args: ~[~str]) { if vec::len(args) != 2u { #error("usage: %s <testdir>", args[0]); ret; diff --git a/src/libcore/bool.rs b/src/libcore/bool.rs index 1f0d9174c73..83e7ebec860 100644 --- a/src/libcore/bool.rs +++ b/src/libcore/bool.rs @@ -38,16 +38,16 @@ pure fn is_true(v: bool) -> bool { v } pure fn is_false(v: bool) -> bool { !v } /// Parse logic value from `s` -pure fn from_str(s: str) -> option<bool> { +pure fn from_str(s: ~str) -> option<bool> { alt check s { - "true" { some(true) } - "false" { some(false) } + ~"true" { some(true) } + ~"false" { some(false) } _ { none } } } /// Convert `v` into a string -pure fn to_str(v: bool) -> str { if v { "true" } else { "false" } } +pure fn to_str(v: bool) -> ~str { if v { ~"true" } else { ~"false" } } /** * Iterates over all truth values by passing them to `blk` in an unspecified @@ -70,8 +70,8 @@ fn test_bool_from_str() { #[test] fn test_bool_to_str() { - assert to_str(false) == "false"; - assert to_str(true) == "true"; + assert to_str(false) == ~"false"; + assert to_str(true) == ~"true"; } #[test] diff --git a/src/libcore/char.rs b/src/libcore/char.rs index d68800a96fc..af65c3f4b96 100644 --- a/src/libcore/char.rs +++ b/src/libcore/char.rs @@ -132,15 +132,15 @@ pure fn to_digit(c: char, radix: uint) -> option<uint> { * - chars in [0x100,0xffff] get 4-digit escapes: `\\uNNNN` * - chars above 0x10000 get 8-digit escapes: `\\UNNNNNNNN` */ -fn escape_unicode(c: char) -> str { +fn escape_unicode(c: char) -> ~str { let s = u32::to_str(c as u32, 16u); let (c, pad) = (if c <= '\xff' { ('x', 2u) } else if c <= '\uffff' { ('u', 4u) } else { ('U', 8u) }); assert str::len(s) <= pad; - let mut out = "\\"; + let mut out = ~"\\"; str::push_str(out, str::from_char(c)); - for uint::range(str::len(s), pad) |_i| { str::push_str(out, "0"); } + for uint::range(str::len(s), pad) |_i| { str::push_str(out, ~"0"); } str::push_str(out, s); ret out; } @@ -157,14 +157,14 @@ fn escape_unicode(c: char) -> str { * - Any other chars in the range [0x20,0x7e] are not escaped. * - Any other chars are given hex unicode escapes; see `escape_unicode`. */ -fn escape_default(c: char) -> str { +fn escape_default(c: char) -> ~str { alt c { - '\t' { "\\t" } - '\r' { "\\r" } - '\n' { "\\n" } - '\\' { "\\\\" } - '\'' { "\\'" } - '"' { "\\\"" } + '\t' { ~"\\t" } + '\r' { ~"\\r" } + '\n' { ~"\\n" } + '\\' { ~"\\\\" } + '\'' { ~"\\'" } + '"' { ~"\\\"" } '\x20' to '\x7e' { str::from_char(c) } _ { escape_unicode(c) } } @@ -232,8 +232,8 @@ fn test_to_digit() { #[test] fn test_is_ascii() { - assert str::all("banana", char::is_ascii); - assert ! str::all("ประเทศไทย中华Việt Nam", char::is_ascii); + assert str::all(~"banana", char::is_ascii); + assert ! str::all(~"ประเทศไทย中华Việt Nam", char::is_ascii); } #[test] @@ -248,28 +248,28 @@ fn test_is_digit() { #[test] fn test_escape_default() { - assert escape_default('\n') == "\\n"; - assert escape_default('\r') == "\\r"; - assert escape_default('\'') == "\\'"; - assert escape_default('"') == "\\\""; - assert escape_default(' ') == " "; - assert escape_default('a') == "a"; - assert escape_default('~') == "~"; - assert escape_default('\x00') == "\\x00"; - assert escape_default('\x1f') == "\\x1f"; - assert escape_default('\x7f') == "\\x7f"; - assert escape_default('\xff') == "\\xff"; - assert escape_default('\u011b') == "\\u011b"; - assert escape_default('\U0001d4b6') == "\\U0001d4b6"; + assert escape_default('\n') == ~"\\n"; + assert escape_default('\r') == ~"\\r"; + assert escape_default('\'') == ~"\\'"; + assert escape_default('"') == ~"\\\""; + assert escape_default(' ') == ~" "; + assert escape_default('a') == ~"a"; + assert escape_default('~') == ~"~"; + assert escape_default('\x00') == ~"\\x00"; + assert escape_default('\x1f') == ~"\\x1f"; + assert escape_default('\x7f') == ~"\\x7f"; + assert escape_default('\xff') == ~"\\xff"; + assert escape_default('\u011b') == ~"\\u011b"; + assert escape_default('\U0001d4b6') == ~"\\U0001d4b6"; } #[test] fn test_escape_unicode() { - assert escape_unicode('\x00') == "\\x00"; - assert escape_unicode('\n') == "\\x0a"; - assert escape_unicode(' ') == "\\x20"; - assert escape_unicode('a') == "\\x61"; - assert escape_unicode('\u011b') == "\\u011b"; - assert escape_unicode('\U0001d4b6') == "\\U0001d4b6"; + assert escape_unicode('\x00') == ~"\\x00"; + assert escape_unicode('\n') == ~"\\x0a"; + assert escape_unicode(' ') == ~"\\x20"; + assert escape_unicode('a') == ~"\\x61"; + assert escape_unicode('\u011b') == ~"\\u011b"; + assert escape_unicode('\U0001d4b6') == ~"\\U0001d4b6"; } diff --git a/src/libcore/comm.rs b/src/libcore/comm.rs index 9a50f4758f0..7c85e5c5d5a 100644 --- a/src/libcore/comm.rs +++ b/src/libcore/comm.rs @@ -142,9 +142,9 @@ fn as_raw_port<T: send, U>(ch: comm::chan<T>, f: fn(*rust_port) -> U) -> U { let p = portref(rustrt::rust_port_take(*ch)); if ptr::is_null(p.p) { - fail "unable to locate port for channel" + fail ~"unable to locate port for channel" } else if rustrt::get_task_id() != rustrt::rust_port_task(p.p) { - fail "unable to access unowned port" + fail ~"unable to access unowned port" } f(p.p) @@ -245,7 +245,7 @@ fn select2<A: send, B: send>(p_a: port<A>, p_b: port<B>) } else if resport == (**p_b).po { either::right(recv(p_b)) } else { - fail "unexpected result from rust_port_select"; + fail ~"unexpected result from rust_port_select"; } } @@ -348,13 +348,13 @@ fn test_select2_available() { let ch_a = chan(po_a); let ch_b = chan(po_b); - send(ch_a, "a"); + send(ch_a, ~"a"); - assert select2(po_a, po_b) == either::left("a"); + assert select2(po_a, po_b) == either::left(~"a"); - send(ch_b, "b"); + send(ch_b, ~"b"); - assert select2(po_a, po_b) == either::right("b"); + assert select2(po_a, po_b) == either::right(~"b"); } #[test] @@ -367,17 +367,17 @@ fn test_select2_rendezvous() { for iter::repeat(10u) { do task::spawn { for iter::repeat(10u) { task::yield() } - send(ch_a, "a"); + send(ch_a, ~"a"); }; - assert select2(po_a, po_b) == either::left("a"); + assert select2(po_a, po_b) == either::left(~"a"); do task::spawn { for iter::repeat(10u) { task::yield() } - send(ch_b, "b"); + send(ch_b, ~"b"); }; - assert select2(po_a, po_b) == either::right("b"); + assert select2(po_a, po_b) == either::right(~"b"); } } @@ -394,12 +394,12 @@ fn test_select2_stress() { for iter::repeat(times) { do task::spawn { for iter::repeat(msgs) { - send(ch_a, "a") + send(ch_a, ~"a") } }; do task::spawn { for iter::repeat(msgs) { - send(ch_b, "b") + send(ch_b, ~"b") } }; } @@ -408,8 +408,8 @@ fn test_select2_stress() { let mut bs = 0; for iter::repeat(msgs * times * 2u) { alt check select2(po_a, po_b) { - either::left("a") { as += 1 } - either::right("b") { bs += 1 } + either::left(~"a") { as += 1 } + either::right(~"b") { bs += 1 } } } @@ -421,8 +421,8 @@ fn test_select2_stress() { fn test_recv_chan() { let po = port(); let ch = chan(po); - send(ch, "flower"); - assert recv_chan(ch) == "flower"; + send(ch, ~"flower"); + assert recv_chan(ch) == ~"flower"; } #[test] @@ -430,7 +430,7 @@ fn test_recv_chan() { #[ignore(cfg(windows))] fn test_recv_chan_dead() { let ch = chan(port()); - send(ch, "flower"); + send(ch, ~"flower"); recv_chan(ch); } @@ -439,7 +439,7 @@ fn test_recv_chan_dead() { fn test_recv_chan_wrong_task() { let po = port(); let ch = chan(po); - send(ch, "flower"); + send(ch, ~"flower"); assert result::is_err(task::try(|| recv_chan(ch) )) @@ -464,9 +464,9 @@ fn test_chan_peek() { fn test_listen() { do listen |parent| { do task::spawn { - parent.send("oatmeal-salad"); + parent.send(~"oatmeal-salad"); } - assert parent.recv() == "oatmeal-salad"; + assert parent.recv() == ~"oatmeal-salad"; } } diff --git a/src/libcore/core.rs b/src/libcore/core.rs index 7e0ab17df17..4cadf018df8 100644 --- a/src/libcore/core.rs +++ b/src/libcore/core.rs @@ -69,6 +69,6 @@ mod std { * any code paths following the appearance of this function as unreachable. */ fn unreachable() -> ! { - fail "Internal error: entered unreachable code"; + fail ~"Internal error: entered unreachable code"; } diff --git a/src/libcore/dlist.rs b/src/libcore/dlist.rs index c66f094eec0..859e4a8eb0c 100644 --- a/src/libcore/dlist.rs +++ b/src/libcore/dlist.rs @@ -32,10 +32,10 @@ impl private_methods<T> for dlist_node<T> { alt neighbour.prev { some(me) { if !box::ptr_eq(*self, *me) { - fail "Asymmetric next-link in dlist node." + fail ~"Asymmetric next-link in dlist node." } } - none { fail "One-way next-link in dlist node." } + none { fail ~"One-way next-link in dlist node." } } } none { } @@ -45,10 +45,10 @@ impl private_methods<T> for dlist_node<T> { alt neighbour.next { some(me) { if !box::ptr_eq(*me, *self) { - fail "Asymmetric prev-link in dlist node." + fail ~"Asymmetric prev-link in dlist node." } } - none { fail "One-way prev-link in dlist node." } + none { fail ~"One-way prev-link in dlist node." } } } none { } @@ -66,7 +66,7 @@ impl extensions<T> for dlist_node<T> { pure fn next_node() -> dlist_node<T> { alt self.next_link() { some(nobe) { nobe } - none { fail "This dlist node has no next neighbour." } + none { fail ~"This dlist node has no next neighbour." } } } /// Get the previous node in the list, if there is one. @@ -78,7 +78,7 @@ impl extensions<T> for dlist_node<T> { pure fn prev_node() -> dlist_node<T> { alt self.prev_link() { some(nobe) { nobe } - none { fail "This dlist node has no previous neighbour." } + none { fail ~"This dlist node has no previous neighbour." } } } @@ -87,7 +87,7 @@ impl extensions<T> for dlist_node<T> { if option::is_some(self.root) { option::get(self.root).remove(self); } else { - fail "Removing an orphaned dlist node - what do I remove from?" + fail ~"Removing an orphaned dlist node - what do I remove from?" } } } @@ -124,12 +124,12 @@ impl private_methods<T> for dlist<T> { pure fn assert_mine(nobe: dlist_node<T>) { alt nobe.root { some(me) { assert box::ptr_eq(*self, *me); } - none { fail "This node isn't on this dlist." } + none { fail ~"This node isn't on this dlist." } } } fn make_mine(nobe: dlist_node<T>) { if option::is_some(nobe.root) { - fail "Cannot insert node that's already on a dlist!" + fail ~"Cannot insert node that's already on a dlist!" } nobe.root = some(self); } @@ -287,14 +287,18 @@ impl extensions<T> for dlist<T> { pure fn head_n() -> dlist_node<T> { alt self.hd { some(nobe) { nobe } - none { fail "Attempted to get the head of an empty dlist." } + none { + fail ~"Attempted to get the head of an empty dlist." + } } } /// Get the node at the list's tail, failing if empty. O(1). pure fn tail_n() -> dlist_node<T> { alt self.tl { some(nobe) { nobe } - none { fail "Attempted to get the tail of an empty dlist." } + none { + fail ~"Attempted to get the tail of an empty dlist." + } } } diff --git a/src/libcore/dvec.rs b/src/libcore/dvec.rs index 1784acc1414..2a5df0ea156 100644 --- a/src/libcore/dvec.rs +++ b/src/libcore/dvec.rs @@ -80,7 +80,7 @@ impl private_methods<A> for dvec<A> { unsafe { let data: *() = unsafe::reinterpret_cast(self.data); if data.is_null() { - fail "Recursive use of dvec"; + fail ~"Recursive use of dvec"; } } } @@ -91,7 +91,7 @@ impl private_methods<A> for dvec<A> { let mut data = unsafe::reinterpret_cast(null::<()>()); data <-> self.data; let data_ptr: *() = unsafe::reinterpret_cast(data); - if data_ptr.is_null() { fail "Recursive use of dvec"; } + if data_ptr.is_null() { fail ~"Recursive use of dvec"; } ret f(data); } } @@ -149,11 +149,11 @@ impl extensions<A> for dvec<A> { let mut data = unsafe::reinterpret_cast(null::<()>()); data <-> self.data; let data_ptr: *() = unsafe::reinterpret_cast(data); - if data_ptr.is_null() { fail "Recursive use of dvec"; } - log(error, "a"); + if data_ptr.is_null() { fail ~"Recursive use of dvec"; } + log(error, ~"a"); self.data <- ~[mut t]; vec::push_all_move(self.data, data); - log(error, "b"); + log(error, ~"b"); } } @@ -276,7 +276,7 @@ impl extensions<A:copy> for dvec<A> { let length = self.len(); if length == 0u { - fail "attempt to retrieve the last element of an empty vector"; + fail ~"attempt to retrieve the last element of an empty vector"; } ret self.data[length - 1u]; diff --git a/src/libcore/extfmt.rs b/src/libcore/extfmt.rs index 9d37ac14fbf..09910ce5cff 100644 --- a/src/libcore/extfmt.rs +++ b/src/libcore/extfmt.rs @@ -78,31 +78,31 @@ mod ct { // A fragment of the output sequence - enum piece { piece_string(str), piece_conv(conv), } - type error_fn = fn@(str) -> ! ; + enum piece { piece_string(~str), piece_conv(conv), } + type error_fn = fn@(~str) -> ! ; - fn parse_fmt_string(s: str, error: error_fn) -> ~[piece] { + fn parse_fmt_string(s: ~str, error: error_fn) -> ~[piece] { let mut pieces: ~[piece] = ~[]; let lim = str::len(s); - let mut buf = ""; - fn flush_buf(buf: str, &pieces: ~[piece]) -> str { + let mut buf = ~""; + fn flush_buf(buf: ~str, &pieces: ~[piece]) -> ~str { if str::len(buf) > 0u { let piece = piece_string(buf); vec::push(pieces, piece); } - ret ""; + ret ~""; } let mut i = 0u; while i < lim { let size = str::utf8_char_width(s[i]); let curr = str::slice(s, i, i+size); - if str::eq(curr, "%") { + if str::eq(curr, ~"%") { i += 1u; if i >= lim { - error("unterminated conversion at end of string"); + error(~"unterminated conversion at end of string"); } let curr2 = str::slice(s, i, i+1u); - if str::eq(curr2, "%") { + if str::eq(curr2, ~"%") { buf += curr2; i += 1u; } else { @@ -116,7 +116,7 @@ mod ct { flush_buf(buf, pieces); ret pieces; } - fn peek_num(s: str, i: uint, lim: uint) -> + fn peek_num(s: ~str, i: uint, lim: uint) -> option<{num: uint, next: uint}> { if i >= lim { ret none; } let c = s[i]; @@ -131,7 +131,7 @@ mod ct { } }; } - fn parse_conversion(s: str, i: uint, lim: uint, error: error_fn) -> + fn parse_conversion(s: ~str, i: uint, lim: uint, error: error_fn) -> {piece: piece, next: uint} { let parm = parse_parameter(s, i, lim); let flags = parse_flags(s, parm.next, lim); @@ -146,7 +146,7 @@ mod ct { ty: ty.ty}), next: ty.next}; } - fn parse_parameter(s: str, i: uint, lim: uint) -> + fn parse_parameter(s: ~str, i: uint, lim: uint) -> {param: option<int>, next: uint} { if i >= lim { ret {param: none, next: i}; } let num = peek_num(s, i, lim); @@ -161,12 +161,12 @@ mod ct { } }; } - fn parse_flags(s: str, i: uint, lim: uint) -> + fn parse_flags(s: ~str, i: uint, lim: uint) -> {flags: ~[flag], next: uint} { let noflags: ~[flag] = ~[]; if i >= lim { ret {flags: noflags, next: i}; } - fn more_(f: flag, s: str, i: uint, lim: uint) -> + fn more_(f: flag, s: ~str, i: uint, lim: uint) -> {flags: ~[flag], next: uint} { let next = parse_flags(s, i + 1u, lim); let rest = next.flags; @@ -188,7 +188,8 @@ mod ct { more(flag_alternate) } else { {flags: noflags, next: i} }; } - fn parse_count(s: str, i: uint, lim: uint) -> {count: count, next: uint} { + fn parse_count(s: ~str, i: uint, lim: uint) + -> {count: count, next: uint} { ret if i >= lim { {count: count_implied, next: i} } else if s[i] == '*' as u8 { @@ -208,7 +209,7 @@ mod ct { } }; } - fn parse_precision(s: str, i: uint, lim: uint) -> + fn parse_precision(s: ~str, i: uint, lim: uint) -> {count: count, next: uint} { ret if i >= lim { {count: count_implied, next: i} @@ -224,36 +225,36 @@ mod ct { } } else { {count: count_implied, next: i} }; } - fn parse_type(s: str, i: uint, lim: uint, error: error_fn) -> + fn parse_type(s: ~str, i: uint, lim: uint, error: error_fn) -> {ty: ty, next: uint} { - if i >= lim { error("missing type in conversion"); } + if i >= lim { error(~"missing type in conversion"); } let tstr = str::slice(s, i, i+1u); // FIXME (#2249): Do we really want two signed types here? // How important is it to be printf compatible? let t = - if str::eq(tstr, "b") { + if str::eq(tstr, ~"b") { ty_bool - } else if str::eq(tstr, "s") { + } else if str::eq(tstr, ~"s") { ty_str - } else if str::eq(tstr, "c") { + } else if str::eq(tstr, ~"c") { ty_char - } else if str::eq(tstr, "d") || str::eq(tstr, "i") { + } else if str::eq(tstr, ~"d") || str::eq(tstr, ~"i") { ty_int(signed) - } else if str::eq(tstr, "u") { + } else if str::eq(tstr, ~"u") { ty_int(unsigned) - } else if str::eq(tstr, "x") { + } else if str::eq(tstr, ~"x") { ty_hex(case_lower) - } else if str::eq(tstr, "X") { + } else if str::eq(tstr, ~"X") { ty_hex(case_upper) - } else if str::eq(tstr, "t") { + } else if str::eq(tstr, ~"t") { ty_bits - } else if str::eq(tstr, "o") { + } else if str::eq(tstr, ~"o") { ty_octal - } else if str::eq(tstr, "f") { + } else if str::eq(tstr, ~"f") { ty_float - } else if str::eq(tstr, "?") { + } else if str::eq(tstr, ~"?") { ty_poly - } else { error("unknown type in conversion: " + tstr) }; + } else { error(~"unknown type in conversion: " + tstr) }; ret {ty: t, next: i + 1u}; } } @@ -276,10 +277,10 @@ mod rt { type conv = {flags: u32, width: count, precision: count, ty: ty}; - fn conv_int(cv: conv, i: int) -> str { + fn conv_int(cv: conv, i: int) -> ~str { let radix = 10u; let prec = get_int_precision(cv); - let mut s : str = int_to_str_prec(i, radix, prec); + let mut s : ~str = int_to_str_prec(i, radix, prec); if 0 <= i { if have_flag(cv.flags, flag_sign_always) { str::unshift_char(s, '+'); @@ -289,7 +290,7 @@ mod rt { } ret pad(cv, s, pad_signed); } - fn conv_uint(cv: conv, u: uint) -> str { + fn conv_uint(cv: conv, u: uint) -> ~str { let prec = get_int_precision(cv); let mut rs = alt cv.ty { @@ -301,17 +302,17 @@ mod rt { }; ret pad(cv, rs, pad_unsigned); } - fn conv_bool(cv: conv, b: bool) -> str { - let s = if b { "true" } else { "false" }; + fn conv_bool(cv: conv, b: bool) -> ~str { + let s = if b { ~"true" } else { ~"false" }; // run the boolean conversion through the string conversion logic, // giving it the same rules for precision, etc. ret conv_str(cv, s); } - fn conv_char(cv: conv, c: char) -> str { + fn conv_char(cv: conv, c: char) -> ~str { let mut s = str::from_char(c); ret pad(cv, s, pad_nozero); } - fn conv_str(cv: conv, s: str) -> str { + fn conv_str(cv: conv, s: ~str) -> ~str { // For strings, precision is the maximum characters // displayed let mut unpadded = alt cv.precision { @@ -324,7 +325,7 @@ mod rt { }; ret pad(cv, unpadded, pad_nozero); } - fn conv_float(cv: conv, f: float) -> str { + fn conv_float(cv: conv, f: float) -> ~str { let (to_str, digits) = alt cv.precision { count_is(c) { (float::to_str_exact, c as uint) } count_implied { (float::to_str, 6u) } @@ -332,32 +333,32 @@ mod rt { let mut s = to_str(f, digits); if 0.0 <= f { if have_flag(cv.flags, flag_sign_always) { - s = "+" + s; + s = ~"+" + s; } else if have_flag(cv.flags, flag_space_for_sign) { - s = " " + s; + s = ~" " + s; } } ret pad(cv, s, pad_float); } - fn conv_poly<T>(cv: conv, v: T) -> str { + fn conv_poly<T>(cv: conv, v: T) -> ~str { let s = sys::log_str(v); ret conv_str(cv, s); } // Convert an int to string with minimum number of digits. If precision is // 0 and num is 0 then the result is the empty string. - fn int_to_str_prec(num: int, radix: uint, prec: uint) -> str { + fn int_to_str_prec(num: int, radix: uint, prec: uint) -> ~str { ret if num < 0 { - "-" + uint_to_str_prec(-num as uint, radix, prec) + ~"-" + uint_to_str_prec(-num as uint, radix, prec) } else { uint_to_str_prec(num as uint, radix, prec) }; } // Convert a uint to string with a minimum number of digits. If precision // is 0 and num is 0 then the result is the empty string. Could move this // to uint: but it doesn't seem all that useful. - fn uint_to_str_prec(num: uint, radix: uint, prec: uint) -> str { + fn uint_to_str_prec(num: uint, radix: uint, prec: uint) -> ~str { ret if prec == 0u && num == 0u { - "" + ~"" } else { let s = uint::to_str(num, radix); let len = str::char_len(s); @@ -375,7 +376,7 @@ mod rt { }; } enum pad_mode { pad_signed, pad_unsigned, pad_nozero, pad_float } - fn pad(cv: conv, &s: str, mode: pad_mode) -> str { + fn pad(cv: conv, &s: ~str, mode: pad_mode) -> ~str { let uwidth : uint = alt cv.width { count_implied { ret s; } count_is(width) { diff --git a/src/libcore/float.rs b/src/libcore/float.rs index 1ba6e75a1ec..0139c60873b 100644 --- a/src/libcore/float.rs +++ b/src/libcore/float.rs @@ -102,12 +102,12 @@ mod consts { * * digits - The number of significant digits * * exact - Whether to enforce the exact number of significant digits */ -fn to_str_common(num: float, digits: uint, exact: bool) -> str { - if is_NaN(num) { ret "NaN"; } - if num == infinity { ret "inf"; } - if num == neg_infinity { ret "-inf"; } +fn to_str_common(num: float, digits: uint, exact: bool) -> ~str { + if is_NaN(num) { ret ~"NaN"; } + if num == infinity { ret ~"inf"; } + if num == neg_infinity { ret ~"-inf"; } - let mut (num, sign) = if num < 0.0 { (-num, "-") } else { (num, "") }; + let mut (num, sign) = if num < 0.0 { (-num, ~"-") } else { (num, ~"") }; // truncated integer let trunc = num as uint; @@ -145,7 +145,7 @@ fn to_str_common(num: float, digits: uint, exact: bool) -> str { } let mut acc; - let mut racc = ""; + let mut racc = ~""; let mut carry = if frac * 10.0 as uint >= 5u { 1u } else { 0u }; // turn digits into string @@ -165,15 +165,15 @@ fn to_str_common(num: float, digits: uint, exact: bool) -> str { // pad decimals with trailing zeroes while str::len(racc) < digits && exact { - racc += "0" + racc += ~"0" } // combine ints and decimals let mut ones = uint::str(trunc + carry); - if racc == "" { + if racc == ~"" { acc = sign + ones; } else { - acc = sign + ones + "." + racc; + acc = sign + ones + ~"." + racc; } ret acc; @@ -188,14 +188,14 @@ fn to_str_common(num: float, digits: uint, exact: bool) -> str { * * num - The float value * * digits - The number of significant digits */ -fn to_str_exact(num: float, digits: uint) -> str { +fn to_str_exact(num: float, digits: uint) -> ~str { to_str_common(num, digits, true) } #[test] fn test_to_str_exact_do_decimal() { let s = to_str_exact(5.0, 4u); - assert s == "5.0000"; + assert s == ~"5.0000"; } @@ -208,7 +208,7 @@ fn test_to_str_exact_do_decimal() { * * num - The float value * * digits - The number of significant digits */ -fn to_str(num: float, digits: uint) -> str { +fn to_str(num: float, digits: uint) -> ~str { to_str_common(num, digits, false) } @@ -238,12 +238,12 @@ fn to_str(num: float, digits: uint) -> str { * `none` if the string did not represent a valid number. Otherwise, * `some(n)` where `n` is the floating-point number represented by `[num]`. */ -fn from_str(num: str) -> option<float> { - if num == "inf" { +fn from_str(num: ~str) -> option<float> { + if num == ~"inf" { ret some(infinity as float); - } else if num == "-inf" { + } else if num == ~"-inf" { ret some(neg_infinity as float); - } else if num == "NaN" { + } else if num == ~"NaN" { ret some(NaN as float); } @@ -433,45 +433,45 @@ impl num of num::num for float { #[test] fn test_from_str() { - assert from_str("3") == some(3.); - assert from_str("3") == some(3.); - assert from_str("3.14") == some(3.14); - assert from_str("+3.14") == some(3.14); - assert from_str("-3.14") == some(-3.14); - assert from_str("2.5E10") == some(25000000000.); - assert from_str("2.5e10") == some(25000000000.); - assert from_str("25000000000.E-10") == some(2.5); - assert from_str(".") == some(0.); - assert from_str(".e1") == some(0.); - assert from_str(".e-1") == some(0.); - assert from_str("5.") == some(5.); - assert from_str(".5") == some(0.5); - assert from_str("0.5") == some(0.5); - assert from_str("0.5") == some(0.5); - assert from_str("0.5") == some(0.5); - assert from_str("-.5") == some(-0.5); - assert from_str("-.5") == some(-0.5); - assert from_str("-5") == some(-5.); - assert from_str("-0") == some(-0.); - assert from_str("0") == some(0.); - assert from_str("inf") == some(infinity); - assert from_str("-inf") == some(neg_infinity); + assert from_str(~"3") == some(3.); + assert from_str(~"3") == some(3.); + assert from_str(~"3.14") == some(3.14); + assert from_str(~"+3.14") == some(3.14); + assert from_str(~"-3.14") == some(-3.14); + assert from_str(~"2.5E10") == some(25000000000.); + assert from_str(~"2.5e10") == some(25000000000.); + assert from_str(~"25000000000.E-10") == some(2.5); + assert from_str(~".") == some(0.); + assert from_str(~".e1") == some(0.); + assert from_str(~".e-1") == some(0.); + assert from_str(~"5.") == some(5.); + assert from_str(~".5") == some(0.5); + assert from_str(~"0.5") == some(0.5); + assert from_str(~"0.5") == some(0.5); + assert from_str(~"0.5") == some(0.5); + assert from_str(~"-.5") == some(-0.5); + assert from_str(~"-.5") == some(-0.5); + assert from_str(~"-5") == some(-5.); + assert from_str(~"-0") == some(-0.); + assert from_str(~"0") == some(0.); + assert from_str(~"inf") == some(infinity); + assert from_str(~"-inf") == some(neg_infinity); // note: NaN != NaN, hence this slightly complex test - alt from_str("NaN") { + alt from_str(~"NaN") { some(f) { assert is_NaN(f); } none { fail; } } - assert from_str("") == none; - assert from_str("x") == none; - assert from_str(" ") == none; - assert from_str(" ") == none; - assert from_str("e") == none; - assert from_str("E") == none; - assert from_str("E1") == none; - assert from_str("1e1e1") == none; - assert from_str("1e1.1") == none; - assert from_str("1e1-1") == none; + assert from_str(~"") == none; + assert from_str(~"x") == none; + assert from_str(~" ") == none; + assert from_str(~" ") == none; + assert from_str(~"e") == none; + assert from_str(~"E") == none; + assert from_str(~"E1") == none; + assert from_str(~"1e1e1") == none; + assert from_str(~"1e1.1") == none; + assert from_str(~"1e1-1") == none; } #[test] @@ -520,8 +520,8 @@ fn test_nonnegative() { #[test] fn test_to_str_inf() { - assert to_str(infinity, 10u) == "inf"; - assert to_str(-infinity, 10u) == "-inf"; + assert to_str(infinity, 10u) == ~"inf"; + assert to_str(-infinity, 10u) == ~"-inf"; } #[test] diff --git a/src/libcore/future.rs b/src/libcore/future.rs index 05af670db17..f26643a6cab 100644 --- a/src/libcore/future.rs +++ b/src/libcore/future.rs @@ -143,47 +143,47 @@ proto! future_pipe { #[test] fn test_from_value() { - let f = from_value("snail"); - assert get(f) == "snail"; + let f = from_value(~"snail"); + assert get(f) == ~"snail"; } #[test] fn test_from_port() { let (po, ch) = future_pipe::init(); - future_pipe::server::completed(ch, "whale"); + future_pipe::server::completed(ch, ~"whale"); let f = from_port(po); - assert get(f) == "whale"; + assert get(f) == ~"whale"; } #[test] fn test_from_fn() { - let f = fn@() -> str { "brail" }; + let f = fn@() -> ~str { ~"brail" }; let f = from_fn(f); - assert get(f) == "brail"; + assert get(f) == ~"brail"; } #[test] fn test_iface_get() { - let f = from_value("fail"); - assert f.get() == "fail"; + let f = from_value(~"fail"); + assert f.get() == ~"fail"; } #[test] fn test_with() { - let f = from_value("nail"); - assert with(f, |v| v) == "nail"; + let f = from_value(~"nail"); + assert with(f, |v| v) == ~"nail"; } #[test] fn test_iface_with() { - let f = from_value("kale"); - assert f.with(|v| v) == "kale"; + let f = from_value(~"kale"); + assert f.with(|v| v) == ~"kale"; } #[test] fn test_spawn() { - let f = spawn(|| "bale"); - assert get(f) == "bale"; + let f = spawn(|| ~"bale"); + assert get(f) == ~"bale"; } #[test] @@ -191,5 +191,5 @@ fn test_spawn() { #[ignore(cfg(target_os = "win32"))] fn test_futurefail() { let f = spawn(|| fail); - let _x: str = get(f); + let _x: ~str = get(f); } diff --git a/src/libcore/int-template.rs b/src/libcore/int-template.rs index b712c68888b..983d1b9968f 100644 --- a/src/libcore/int-template.rs +++ b/src/libcore/int-template.rs @@ -89,10 +89,10 @@ fn parse_buf(buf: ~[u8], radix: uint) -> option<T> { } /// Parse a string to an int -fn from_str(s: str) -> option<T> { parse_buf(str::bytes(s), 10u) } +fn from_str(s: ~str) -> option<T> { parse_buf(str::bytes(s), 10u) } /// Convert to a string in a given base -fn to_str(n: T, radix: uint) -> str { +fn to_str(n: T, radix: uint) -> ~str { do to_str_bytes(n, radix) |slice| { do vec::unpack_slice(slice) |p, len| { unsafe { str::unsafe::from_buf_len(p, len) } @@ -109,7 +109,7 @@ fn to_str_bytes<U>(n: T, radix: uint, f: fn(v: &[u8]) -> U) -> U { } /// Convert to a string -fn str(i: T) -> str { ret to_str(i, 10u); } +fn str(i: T) -> ~str { ret to_str(i, 10u); } impl ord of ord for T { fn lt(&&other: T) -> bool { @@ -159,20 +159,20 @@ impl times of iter::times for T { #[test] #[ignore] fn test_from_str() { - assert from_str("0") == some(0 as T); - assert from_str("3") == some(3 as T); - assert from_str("10") == some(10 as T); - assert from_str("123456789") == some(123456789 as T); - assert from_str("00100") == some(100 as T); + assert from_str(~"0") == some(0 as T); + assert from_str(~"3") == some(3 as T); + assert from_str(~"10") == some(10 as T); + assert from_str(~"123456789") == some(123456789 as T); + assert from_str(~"00100") == some(100 as T); - assert from_str("-1") == some(-1 as T); - assert from_str("-3") == some(-3 as T); - assert from_str("-10") == some(-10 as T); - assert from_str("-123456789") == some(-123456789 as T); - assert from_str("-00100") == some(-100 as T); + assert from_str(~"-1") == some(-1 as T); + assert from_str(~"-3") == some(-3 as T); + assert from_str(~"-10") == some(-10 as T); + assert from_str(~"-123456789") == some(-123456789 as T); + assert from_str(~"-00100") == some(-100 as T); - assert from_str(" ") == none; - assert from_str("x") == none; + assert from_str(~" ") == none; + assert from_str(~"x") == none; } // FIXME: Has alignment issues on windows and 32-bit linux (#2609) @@ -180,36 +180,36 @@ fn test_from_str() { #[ignore] fn test_parse_buf() { import str::bytes; - assert parse_buf(bytes("123"), 10u) == some(123 as T); - assert parse_buf(bytes("1001"), 2u) == some(9 as T); - assert parse_buf(bytes("123"), 8u) == some(83 as T); - assert parse_buf(bytes("123"), 16u) == some(291 as T); - assert parse_buf(bytes("ffff"), 16u) == some(65535 as T); - assert parse_buf(bytes("FFFF"), 16u) == some(65535 as T); - assert parse_buf(bytes("z"), 36u) == some(35 as T); - assert parse_buf(bytes("Z"), 36u) == some(35 as T); - - assert parse_buf(bytes("-123"), 10u) == some(-123 as T); - assert parse_buf(bytes("-1001"), 2u) == some(-9 as T); - assert parse_buf(bytes("-123"), 8u) == some(-83 as T); - assert parse_buf(bytes("-123"), 16u) == some(-291 as T); - assert parse_buf(bytes("-ffff"), 16u) == some(-65535 as T); - assert parse_buf(bytes("-FFFF"), 16u) == some(-65535 as T); - assert parse_buf(bytes("-z"), 36u) == some(-35 as T); - assert parse_buf(bytes("-Z"), 36u) == some(-35 as T); - - assert parse_buf(str::bytes("Z"), 35u) == none; - assert parse_buf(str::bytes("-9"), 2u) == none; + assert parse_buf(bytes(~"123"), 10u) == some(123 as T); + assert parse_buf(bytes(~"1001"), 2u) == some(9 as T); + assert parse_buf(bytes(~"123"), 8u) == some(83 as T); + assert parse_buf(bytes(~"123"), 16u) == some(291 as T); + assert parse_buf(bytes(~"ffff"), 16u) == some(65535 as T); + assert parse_buf(bytes(~"FFFF"), 16u) == some(65535 as T); + assert parse_buf(bytes(~"z"), 36u) == some(35 as T); + assert parse_buf(bytes(~"Z"), 36u) == some(35 as T); + + assert parse_buf(bytes(~"-123"), 10u) == some(-123 as T); + assert parse_buf(bytes(~"-1001"), 2u) == some(-9 as T); + assert parse_buf(bytes(~"-123"), 8u) == some(-83 as T); + assert parse_buf(bytes(~"-123"), 16u) == some(-291 as T); + assert parse_buf(bytes(~"-ffff"), 16u) == some(-65535 as T); + assert parse_buf(bytes(~"-FFFF"), 16u) == some(-65535 as T); + assert parse_buf(bytes(~"-z"), 36u) == some(-35 as T); + assert parse_buf(bytes(~"-Z"), 36u) == some(-35 as T); + + assert parse_buf(str::bytes(~"Z"), 35u) == none; + assert parse_buf(str::bytes(~"-9"), 2u) == none; } #[test] fn test_to_str() { import str::eq; - assert (eq(to_str(0 as T, 10u), "0")); - assert (eq(to_str(1 as T, 10u), "1")); - assert (eq(to_str(-1 as T, 10u), "-1")); - assert (eq(to_str(127 as T, 16u), "7f")); - assert (eq(to_str(100 as T, 10u), "100")); + assert (eq(to_str(0 as T, 10u), ~"0")); + assert (eq(to_str(1 as T, 10u), ~"1")); + assert (eq(to_str(-1 as T, 10u), ~"-1")); + assert (eq(to_str(127 as T, 16u), ~"7f")); + assert (eq(to_str(100 as T, 10u), ~"100")); } #[test] @@ -243,5 +243,5 @@ fn test_times() { #[should_fail] #[ignore(cfg(windows))] fn test_times_negative() { - for (-10).times { log(error, "nope!"); } + for (-10).times { log(error, ~"nope!"); } } diff --git a/src/libcore/io.rs b/src/libcore/io.rs index f9666a1f22e..cb4b94b8286 100644 --- a/src/libcore/io.rs +++ b/src/libcore/io.rs @@ -109,7 +109,7 @@ impl reader_util for reader { ret c[0]; } - fn read_line() -> str { + fn read_line() -> ~str { let mut buf = ~[]; loop { let ch = self.read_byte(); @@ -119,7 +119,7 @@ impl reader_util for reader { str::from_bytes(buf) } - fn read_c_str() -> str { + fn read_c_str() -> ~str { let mut buf: ~[u8] = ~[]; loop { let ch = self.read_byte(); @@ -174,7 +174,7 @@ impl reader_util for reader { } } - fn each_line(it: fn(str) -> bool) { + fn each_line(it: fn(~str) -> bool) { while !self.eof() { if !it(self.read_line()) { break; } } @@ -244,13 +244,13 @@ fn FILE_reader(f: *libc::FILE, cleanup: bool) -> reader { fn stdin() -> reader { rustrt::rust_get_stdin() as reader } -fn file_reader(path: str) -> result<reader, str> { +fn file_reader(path: ~str) -> result<reader, ~str> { let f = os::as_c_charp(path, |pathbuf| { - os::as_c_charp("r", |modebuf| + os::as_c_charp(~"r", |modebuf| libc::fopen(pathbuf, modebuf) ) }); - ret if f as uint == 0u { result::err("error opening " + path) } + ret if f as uint == 0u { result::err(~"error opening " + path) } else { result::ok(FILE_reader(f, true)) } @@ -303,11 +303,11 @@ fn with_bytes_reader_between<t>(bytes: ~[u8], start: uint, end: uint, f(bytes_reader_between(bytes, start, end)) } -fn str_reader(s: str) -> reader { +fn str_reader(s: ~str) -> reader { bytes_reader(str::bytes(s)) } -fn with_str_reader<T>(s: str, f: fn(reader) -> T) -> T { +fn with_str_reader<T>(s: ~str, f: fn(reader) -> T) -> T { do str::as_bytes(s) |bytes| { with_bytes_reader_between(bytes, 0u, str::len(s), f) } @@ -402,8 +402,8 @@ fn fd_writer(fd: fd_t, cleanup: bool) -> writer { } -fn mk_file_writer(path: str, flags: ~[fileflag]) - -> result<writer, str> { +fn mk_file_writer(path: ~str, flags: ~[fileflag]) + -> result<writer, ~str> { #[cfg(windows)] fn wb() -> c_int { (O_WRONLY | O_BINARY) as c_int } @@ -514,10 +514,10 @@ impl writer_util for writer { self.write_str(str::from_char(ch)); } } - fn write_str(s: str/&) { str::byte_slice(s, |v| self.write(v)) } - fn write_line(s: str/&) { + fn write_str(s: &str) { str::byte_slice(s, |v| self.write(v)) } + fn write_line(s: &str) { self.write_str(s); - self.write_str("\n"/&); + self.write_str(&"\n"); } fn write_int(n: int) { int::to_str_bytes(n, 10u, |buf| self.write(buf)) @@ -577,19 +577,19 @@ impl writer_util for writer { fn write_u8(n: u8) { self.write(&[n]) } } -fn file_writer(path: str, flags: ~[fileflag]) -> result<writer, str> { +fn file_writer(path: ~str, flags: ~[fileflag]) -> result<writer, ~str> { result::chain(mk_file_writer(path, flags), |w| result::ok(w)) } // FIXME: fileflags // #2004 -fn buffered_file_writer(path: str) -> result<writer, str> { +fn buffered_file_writer(path: ~str) -> result<writer, ~str> { let f = do os::as_c_charp(path) |pathbuf| { - do os::as_c_charp("w") |modebuf| { + do os::as_c_charp(~"w") |modebuf| { libc::fopen(pathbuf, modebuf) } }; - ret if f as uint == 0u { result::err("error opening " + path) } + ret if f as uint == 0u { result::err(~"error opening " + path) } else { result::ok(FILE_writer(f, true)) } } @@ -599,8 +599,8 @@ fn buffered_file_writer(path: str) -> result<writer, str> { fn stdout() -> writer { fd_writer(libc::STDOUT_FILENO as c_int, false) } fn stderr() -> writer { fd_writer(libc::STDERR_FILENO as c_int, false) } -fn print(s: str) { stdout().write_str(s); } -fn println(s: str) { stdout().write_line(s); } +fn print(s: ~str) { stdout().write_str(s); } +fn println(s: ~str) { stdout().write_line(s); } type mem_buffer = @{buf: dvec<u8>, mut pos: uint}; @@ -639,11 +639,11 @@ fn mem_buffer() -> mem_buffer { } fn mem_buffer_writer(b: mem_buffer) -> writer { b as writer } fn mem_buffer_buf(b: mem_buffer) -> ~[u8] { b.buf.get() } -fn mem_buffer_str(b: mem_buffer) -> str { +fn mem_buffer_str(b: mem_buffer) -> ~str { str::from_bytes(b.buf.get()) } -fn with_str_writer(f: fn(writer)) -> str { +fn with_str_writer(f: fn(writer)) -> ~str { let buf = mem_buffer(); let wr = mem_buffer_writer(buf); f(wr); @@ -671,7 +671,7 @@ fn seek_in_buf(offset: int, pos: uint, len: uint, whence: seek_style) -> ret bpos as uint; } -fn read_whole_file_str(file: str) -> result<str, str> { +fn read_whole_file_str(file: ~str) -> result<~str, ~str> { result::chain(read_whole_file(file), |bytes| { result::ok(str::from_bytes(bytes)) }) @@ -679,7 +679,7 @@ fn read_whole_file_str(file: str) -> result<str, str> { // FIXME (#2004): implement this in a low-level way. Going through the // abstractions is pointless. -fn read_whole_file(file: str) -> result<~[u8], str> { +fn read_whole_file(file: ~str) -> result<~[u8], ~str> { result::chain(file_reader(file), |rdr| { result::ok(rdr.read_whole_stream()) }) @@ -765,9 +765,10 @@ mod tests { #[test] fn test_simple() { - let tmpfile: str = "tmp/lib-io-test-simple.tmp"; + let tmpfile: ~str = ~"tmp/lib-io-test-simple.tmp"; log(debug, tmpfile); - let frood: str = "A hoopy frood who really knows where his towel is."; + let frood: ~str = + ~"A hoopy frood who really knows where his towel is."; log(debug, frood); { let out: io::writer = @@ -776,28 +777,28 @@ mod tests { out.write_str(frood); } let inp: io::reader = result::get(io::file_reader(tmpfile)); - let frood2: str = inp.read_c_str(); + let frood2: ~str = inp.read_c_str(); log(debug, frood2); assert (str::eq(frood, frood2)); } #[test] fn test_readchars_empty() { - let inp : io::reader = io::str_reader(""); + let inp : io::reader = io::str_reader(~""); let res : ~[char] = inp.read_chars(128u); assert(vec::len(res) == 0u); } #[test] fn test_readchars_wide() { - let wide_test = "生锈的汤匙切肉汤hello生锈的汤匙切肉汤"; + let wide_test = ~"生锈的汤匙切肉汤hello生锈的汤匙切肉汤"; let ivals : ~[int] = ~[ 29983, 38152, 30340, 27748, 21273, 20999, 32905, 27748, 104, 101, 108, 108, 111, 29983, 38152, 30340, 27748, 21273, 20999, 32905, 27748]; - fn check_read_ln(len : uint, s: str, ivals: ~[int]) { + fn check_read_ln(len : uint, s: ~str, ivals: ~[int]) { let inp : io::reader = io::str_reader(s); let res : ~[char] = inp.read_chars(len); if (len <= vec::len(ivals)) { @@ -817,23 +818,23 @@ mod tests { #[test] fn test_readchar() { - let inp : io::reader = io::str_reader("生"); + let inp : io::reader = io::str_reader(~"生"); let res : char = inp.read_char(); assert(res as int == 29983); } #[test] fn test_readchar_empty() { - let inp : io::reader = io::str_reader(""); + let inp : io::reader = io::str_reader(~""); let res : char = inp.read_char(); assert(res as int == -1); } #[test] fn file_reader_not_exist() { - alt io::file_reader("not a file") { + alt io::file_reader(~"not a file") { result::err(e) { - assert e == "error opening not a file"; + assert e == ~"error opening not a file"; } result::ok(_) { fail; } } @@ -841,9 +842,9 @@ mod tests { #[test] fn file_writer_bad_name() { - alt io::file_writer("?/?", ~[]) { + alt io::file_writer(~"?/?", ~[]) { result::err(e) { - assert str::starts_with(e, "error opening ?/?"); + assert str::starts_with(e, ~"error opening ?/?"); } result::ok(_) { fail; } } @@ -851,9 +852,9 @@ mod tests { #[test] fn buffered_file_writer_bad_name() { - alt io::buffered_file_writer("?/?") { + alt io::buffered_file_writer(~"?/?") { result::err(e) { - assert e == "error opening ?/?"; + assert e == ~"error opening ?/?"; } result::ok(_) { fail; } } diff --git a/src/libcore/iter-trait/dlist.rs b/src/libcore/iter-trait/dlist.rs index d34ea38034d..93706323246 100644 --- a/src/libcore/iter-trait/dlist.rs +++ b/src/libcore/iter-trait/dlist.rs @@ -16,7 +16,7 @@ fn EACH<A>(self: IMPL_T<A>, f: fn(A) -> bool) { // Check dlist invariant. if !option::is_some(nobe.root) || !box::ptr_eq(*option::get(nobe.root), *self) { - fail "Iteration encountered a dlist node not on this dlist." + fail ~"Iteration encountered a dlist node not on this dlist." } f(nobe.data); // Check that the user didn't do a remove. @@ -24,7 +24,7 @@ fn EACH<A>(self: IMPL_T<A>, f: fn(A) -> bool) { // immediately put it back in a different position. I allow this. if !option::is_some(nobe.root) || !box::ptr_eq(*option::get(nobe.root), *self) { - fail "Removing a dlist node during iteration is forbidden!" + fail ~"Removing a dlist node during iteration is forbidden!" } link = nobe.next_link(); } diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs index 31e47d19c8f..e2a321cde23 100644 --- a/src/libcore/iter.rs +++ b/src/libcore/iter.rs @@ -132,7 +132,7 @@ fn min<A:copy,IA:base_iter<A>>(self: IA) -> A { } } { some(val) { val } - none { fail "min called on empty iterator" } + none { fail ~"min called on empty iterator" } } } @@ -148,7 +148,7 @@ fn max<A:copy,IA:base_iter<A>>(self: IA) -> A { } } { some(val) { val } - none { fail "max called on empty iterator" } + none { fail ~"max called on empty iterator" } } } diff --git a/src/libcore/option.rs b/src/libcore/option.rs index ac7dd013be9..80b3915cb90 100644 --- a/src/libcore/option.rs +++ b/src/libcore/option.rs @@ -23,10 +23,10 @@ pure fn get<T: copy>(opt: option<T>) -> T { * Fails if the value equals `none` */ - alt opt { some(x) { ret x; } none { fail "option none"; } } + alt opt { some(x) { ret x; } none { fail ~"option none"; } } } -pure fn expect<T: copy>(opt: option<T>, reason: str) -> T { +pure fn expect<T: copy>(opt: option<T>, reason: ~str) -> T { #[doc = " Gets the value out of an option, printing a specified message on failure @@ -93,7 +93,7 @@ pure fn unwrap<T>(-opt: option<T>) -> T { unsafe { let addr = alt opt { some(x) { ptr::addr_of(x) } - none { fail "option none" } + none { fail ~"option none" } }; let liberated_value = unsafe::reinterpret_cast(*addr); unsafe::forget(opt); @@ -138,7 +138,7 @@ impl extensions<T: copy> for option<T> { * * Fails if the value equals `none` */ - pure fn expect(reason: str) -> T { expect(self, reason) } + pure fn expect(reason: ~str) -> T { expect(self, reason) } } #[test] @@ -153,7 +153,7 @@ fn test_unwrap_ptr() { #[test] fn test_unwrap_str() { - let x = "test"; + let x = ~"test"; let addr_x = str::as_buf(x, |buf| ptr::addr_of(buf)); let opt = some(x); let y = unwrap(opt); diff --git a/src/libcore/os.rs b/src/libcore/os.rs index c1b7574c9cc..24988870c0d 100644 --- a/src/libcore/os.rs +++ b/src/libcore/os.rs @@ -40,18 +40,18 @@ export walk_dir; export as_c_charp, fill_charp_buf; extern mod rustrt { - fn rust_env_pairs() -> ~[str]; - fn rust_getcwd() -> str; + fn rust_env_pairs() -> ~[~str]; + fn rust_getcwd() -> ~str; fn rust_path_is_dir(path: *libc::c_char) -> c_int; fn rust_path_exists(path: *libc::c_char) -> c_int; - fn rust_list_files(path: str) -> ~[str]; + fn rust_list_files(path: ~str) -> ~[~str]; fn rust_process_wait(handle: c_int) -> c_int; - fn last_os_error() -> str; + fn last_os_error() -> ~str; fn rust_set_exit_status(code: libc::intptr_t); } -fn env() -> ~[(str,str)] { +fn env() -> ~[(~str,~str)] { let mut pairs = ~[]; for vec::each(rustrt::rust_env_pairs()) |p| { let vs = str::splitn_char(p, '=', 1u); @@ -63,12 +63,12 @@ fn env() -> ~[(str,str)] { const tmpbuf_sz : uint = 1000u; -fn as_c_charp<T>(s: str, f: fn(*c_char) -> T) -> T { +fn as_c_charp<T>(s: ~str, f: fn(*c_char) -> T) -> T { str::as_c_str(s, |b| f(b as *c_char)) } fn fill_charp_buf(f: fn(*mut c_char, size_t) -> bool) - -> option<str> { + -> option<~str> { let buf = vec::to_mut(vec::from_elem(tmpbuf_sz, 0u8 as c_char)); do vec::as_mut_buf(buf) |b| { if f(b, tmpbuf_sz as size_t) unsafe { @@ -121,11 +121,11 @@ mod win32 { } } -fn getenv(n: str) -> option<str> { +fn getenv(n: ~str) -> option<~str> { global_env::getenv(n) } -fn setenv(n: str, v: str) { +fn setenv(n: ~str, v: ~str) { global_env::setenv(n, v) } @@ -140,18 +140,18 @@ mod global_env { } enum msg { - msg_getenv(str, comm::chan<option<str>>), - msg_setenv(str, str, comm::chan<()>) + msg_getenv(~str, comm::chan<option<~str>>), + msg_setenv(~str, ~str, comm::chan<()>) } - fn getenv(n: str) -> option<str> { + fn getenv(n: ~str) -> option<~str> { let env_ch = get_global_env_chan(); let po = comm::port(); comm::send(env_ch, msg_getenv(n, comm::chan(po))); comm::recv(po) } - fn setenv(n: str, v: str) { + fn setenv(n: ~str, v: ~str) { let env_ch = get_global_env_chan(); let po = comm::port(); comm::send(env_ch, msg_setenv(n, v, comm::chan(po))); @@ -199,14 +199,14 @@ mod global_env { mod impl { #[cfg(unix)] - fn getenv(n: str) -> option<str> { + fn getenv(n: ~str) -> option<~str> { unsafe { let s = str::as_c_str(n, libc::getenv); ret if unsafe::reinterpret_cast(s) == 0 { - option::none::<str> + option::none::<~str> } else { let s = unsafe::reinterpret_cast(s); - option::some::<str>(str::unsafe::from_buf(s)) + option::some::<~str>(str::unsafe::from_buf(s)) }; } } @@ -225,7 +225,7 @@ mod global_env { #[cfg(unix)] - fn setenv(n: str, v: str) { + fn setenv(n: ~str, v: ~str) { // FIXME: remove this when export globs work properly. #1238 import libc::funcs::posix01::unistd::setenv; @@ -253,7 +253,7 @@ mod global_env { } fn fdopen(fd: c_int) -> *FILE { - ret do as_c_charp("r") |modebuf| { + ret do as_c_charp(~"r") |modebuf| { libc::fdopen(fd, modebuf) }; } @@ -348,11 +348,11 @@ fn pipe() -> {in: c_int, out: c_int} { } -fn dll_filename(base: str) -> str { +fn dll_filename(base: ~str) -> ~str { ret pre() + base + dll_suffix(); #[cfg(unix)] - fn pre() -> str { "lib" } + fn pre() -> ~str { ~"lib" } #[cfg(windows)] fn pre() -> str { "" } @@ -381,7 +381,7 @@ fn self_exe_path() -> option<path> { fn load_self() -> option<path> { import libc::funcs::posix01::unistd::readlink; do fill_charp_buf() |buf, sz| { - do as_c_charp("/proc/self/exe") |proc_self_buf| { + do as_c_charp(~"/proc/self/exe") |proc_self_buf| { readlink(proc_self_buf, buf, sz) != (-1 as ssize_t) } } @@ -428,7 +428,7 @@ fn self_exe_path() -> option<path> { * Otherwise, homedir returns option::none. */ fn homedir() -> option<path> { - ret alt getenv("HOME") { + ret alt getenv(~"HOME") { some(p) { if !str::is_empty(p) { some(p) @@ -548,10 +548,10 @@ fn make_dir(p: path, mode: c_int) -> bool { } /// Lists the contents of a directory -fn list_dir(p: path) -> ~[str] { +fn list_dir(p: path) -> ~[~str] { #[cfg(unix)] - fn star(p: str) -> str { p } + fn star(p: ~str) -> ~str { p } #[cfg(windows)] fn star(p: str) -> str { @@ -565,7 +565,7 @@ fn list_dir(p: path) -> ~[str] { } do rustrt::rust_list_files(star(p)).filter |filename| { - !str::eq(filename, ".") && !str::eq(filename, "..") + !str::eq(filename, ~".") && !str::eq(filename, ~"..") } } @@ -574,7 +574,7 @@ fn list_dir(p: path) -> ~[str] { * * This version prepends each entry with the directory. */ -fn list_dir_path(p: path) -> ~[str] { +fn list_dir_path(p: path) -> ~[~str] { let mut p = p; let pl = str::len(p); if pl == 0u || (p[pl - 1u] as char != path::consts::path_sep @@ -649,7 +649,7 @@ fn copy_file(from: path, to: path) -> bool { #[cfg(unix)] fn do_copy_file(from: path, to: path) -> bool { let istream = do as_c_charp(from) |fromp| { - do as_c_charp("rb") |modebuf| { + do as_c_charp(~"rb") |modebuf| { libc::fopen(fromp, modebuf) } }; @@ -657,7 +657,7 @@ fn copy_file(from: path, to: path) -> bool { ret false; } let ostream = do as_c_charp(to) |top| { - do as_c_charp("w+b") |modebuf| { + do as_c_charp(~"w+b") |modebuf| { libc::fopen(top, modebuf) } }; @@ -717,7 +717,7 @@ fn remove_file(p: path) -> bool { } /// Get a string representing the platform-dependent last error -fn last_os_error() -> str { +fn last_os_error() -> ~str { rustrt::last_os_error() } @@ -734,7 +734,7 @@ fn set_exit_status(code: int) { } #[cfg(unix)] -fn family() -> str { "unix" } +fn family() -> ~str { ~"unix" } #[cfg(windows)] fn family() -> str { "windows" } @@ -755,9 +755,9 @@ mod consts { #[cfg(target_os = "linux")] mod consts { - fn sysname() -> str { "linux" } - fn exe_suffix() -> str { "" } - fn dll_suffix() -> str { ".so" } + fn sysname() -> ~str { ~"linux" } + fn exe_suffix() -> ~str { ~"" } + fn dll_suffix() -> ~str { ~".so" } } #[cfg(target_os = "win32")] @@ -771,7 +771,7 @@ mod consts { fn arch() -> str { "x86" } #[cfg(target_arch = "x86_64")] -fn arch() -> str { "x86_64" } +fn arch() -> ~str { ~"x86_64" } #[cfg(target_arch = "arm")] fn arch() -> str { "arm" } @@ -784,10 +784,10 @@ mod tests { log(debug, last_os_error()); } - fn make_rand_name() -> str { + fn make_rand_name() -> ~str { import rand; let rng: rand::rng = rand::rng(); - let n = "TEST" + rng.gen_str(10u); + let n = ~"TEST" + rng.gen_str(10u); assert option::is_none(getenv(n)); n } @@ -795,8 +795,8 @@ mod tests { #[test] fn test_setenv() { let n = make_rand_name(); - setenv(n, "VALUE"); - assert getenv(n) == option::some("VALUE"); + setenv(n, ~"VALUE"); + assert getenv(n) == option::some(~"VALUE"); } #[test] @@ -804,11 +804,11 @@ mod tests { #[ignore] fn test_setenv_overwrite() { let n = make_rand_name(); - setenv(n, "1"); - setenv(n, "2"); - assert getenv(n) == option::some("2"); - setenv(n, ""); - assert getenv(n) == option::some(""); + setenv(n, ~"1"); + setenv(n, ~"2"); + assert getenv(n) == option::some(~"2"); + setenv(n, ~""); + assert getenv(n) == option::some(~""); } // Windows GetEnvironmentVariable requires some extra work to make sure @@ -817,9 +817,9 @@ mod tests { #[ignore(cfg(windows))] #[ignore] fn test_getenv_big() { - let mut s = ""; + let mut s = ~""; let mut i = 0; - while i < 100 { s += "aaaaaaaaaa"; i += 1; } + while i < 100 { s += ~"aaaaaaaaaa"; i += 1; } let n = make_rand_name(); setenv(n, s); log(debug, s); @@ -834,7 +834,7 @@ mod tests { log(debug, path); // Hard to test this function - if os::sysname() != "win32" { + if os::sysname() != ~"win32" { assert str::starts_with(path, path::path_sep()); } else { assert path[1] == ':' as u8; @@ -862,35 +862,35 @@ mod tests { let n = make_rand_name(); let mut e = env(); - setenv(n, "VALUE"); - assert !vec::contains(e, (n, "VALUE")); + setenv(n, ~"VALUE"); + assert !vec::contains(e, (n, ~"VALUE")); e = env(); - assert vec::contains(e, (n, "VALUE")); + assert vec::contains(e, (n, ~"VALUE")); } #[test] fn test() { - assert (!path::path_is_absolute("test-path")); + assert (!path::path_is_absolute(~"test-path")); - log(debug, "Current working directory: " + getcwd()); + log(debug, ~"Current working directory: " + getcwd()); - log(debug, make_absolute("test-path")); - log(debug, make_absolute("/usr/bin")); + log(debug, make_absolute(~"test-path")); + log(debug, make_absolute(~"/usr/bin")); } #[test] #[cfg(unix)] fn homedir() { - let oldhome = getenv("HOME"); + let oldhome = getenv(~"HOME"); - setenv("HOME", "/home/MountainView"); - assert os::homedir() == some("/home/MountainView"); + setenv(~"HOME", ~"/home/MountainView"); + assert os::homedir() == some(~"/home/MountainView"); - setenv("HOME", ""); + setenv(~"HOME", ~""); assert os::homedir() == none; - option::iter(oldhome, |s| setenv("HOME", s)); + option::iter(oldhome, |s| setenv(~"HOME", s)); } #[test] @@ -927,11 +927,11 @@ mod tests { // Issue #712 #[test] - fn test_list_dir_no_invalid_memory_access() { os::list_dir("."); } + fn test_list_dir_no_invalid_memory_access() { os::list_dir(~"."); } #[test] fn list_dir() { - let dirs = os::list_dir("."); + let dirs = os::list_dir(~"."); // Just assuming that we've got some contents in the current directory assert (vec::len(dirs) > 0u); @@ -940,21 +940,21 @@ mod tests { #[test] fn path_is_dir() { - assert (os::path_is_dir(".")); - assert (!os::path_is_dir("test/stdtest/fs.rs")); + assert (os::path_is_dir(~".")); + assert (!os::path_is_dir(~"test/stdtest/fs.rs")); } #[test] fn path_exists() { - assert (os::path_exists(".")); - assert (!os::path_exists("test/nonexistent-bogus-path")); + assert (os::path_exists(~".")); + assert (!os::path_exists(~"test/nonexistent-bogus-path")); } #[test] fn copy_file_does_not_exist() { - assert !os::copy_file("test/nonexistent-bogus-path", - "test/other-bogus-path"); - assert !os::path_exists("test/other-bogus-path"); + assert !os::copy_file(~"test/nonexistent-bogus-path", + ~"test/other-bogus-path"); + assert !os::path_exists(~"test/other-bogus-path"); } #[test] @@ -962,17 +962,17 @@ mod tests { let tempdir = getcwd(); // would like to use $TMPDIR, // doesn't seem to work on Linux assert (str::len(tempdir) > 0u); - let in = tempdir + path::path_sep() + "in.txt"; - let out = tempdir + path::path_sep() + "out.txt"; + let in = tempdir + path::path_sep() + ~"in.txt"; + let out = tempdir + path::path_sep() + ~"out.txt"; /* Write the temp input file */ let ostream = do as_c_charp(in) |fromp| { - do as_c_charp("w+b") |modebuf| { + do as_c_charp(~"w+b") |modebuf| { libc::fopen(fromp, modebuf) } }; assert (ostream as uint != 0u); - let s = "hello"; + let s = ~"hello"; let mut buf = vec::to_mut(str::bytes(s) + ~[0 as u8]); do vec::as_mut_buf(buf) |b| { assert (libc::fwrite(b as *c_void, 1u as size_t, @@ -984,7 +984,7 @@ mod tests { fail (#fmt("%s doesn't exist", in)); } assert(rs); - let rslt = run::run_program("diff", ~[in, out]); + let rslt = run::run_program(~"diff", ~[in, out]); assert (rslt == 0); assert (remove_file(in)); assert (remove_file(out)); diff --git a/src/libcore/path.rs b/src/libcore/path.rs index 67f42002557..35fc7510757 100644 --- a/src/libcore/path.rs +++ b/src/libcore/path.rs @@ -14,7 +14,7 @@ export normalize; // FIXME: This type should probably be constrained (#2624) /// A path or fragment of a filesystem path -type path = str; +type path = ~str; #[cfg(unix)] mod consts { @@ -58,9 +58,9 @@ fn path_is_absolute(p: str) -> bool { } /// Get the default path separator for the host platform -fn path_sep() -> str { ret str::from_char(consts::path_sep); } +fn path_sep() -> ~str { ret str::from_char(consts::path_sep); } -fn split_dirname_basename (pp: path) -> {dirname: str, basename: str} { +fn split_dirname_basename (pp: path) -> {dirname: ~str, basename: ~str} { alt str::rfind(pp, |ch| ch == consts::path_sep || ch == consts::alt_path_sep ) { @@ -68,7 +68,7 @@ fn split_dirname_basename (pp: path) -> {dirname: str, basename: str} { {dirname: str::slice(pp, 0u, i), basename: str::slice(pp, i + 1u, str::len(pp))} } - none { {dirname: ".", basename: pp} } + none { {dirname: ~".", basename: pp} } } } @@ -159,16 +159,16 @@ fn split(p: path) -> ~[path] { * ignored. If the path includes directory components then they are included * in the filename part of the result pair. */ -fn splitext(p: path) -> (str, str) { - if str::is_empty(p) { ("", "") } +fn splitext(p: path) -> (~str, ~str) { + if str::is_empty(p) { (~"", ~"") } else { let parts = str::split_char(p, '.'); if vec::len(parts) > 1u { - let base = str::connect(vec::init(parts), "."); + let base = str::connect(vec::init(parts), ~"."); // We just checked that parts is non-empty, so this is safe - let ext = "." + vec::last(parts); + let ext = ~"." + vec::last(parts); - fn is_dotfile(base: str) -> bool { + fn is_dotfile(base: ~str) -> bool { str::is_empty(base) || str::ends_with( base, str::from_char(consts::path_sep)) @@ -176,11 +176,11 @@ fn splitext(p: path) -> (str, str) { base, str::from_char(consts::alt_path_sep)) } - fn ext_contains_sep(ext: str) -> bool { + fn ext_contains_sep(ext: ~str) -> bool { vec::len(split(ext)) > 1u } - fn no_basename(ext: str) -> bool { + fn no_basename(ext: ~str) -> bool { str::ends_with( ext, str::from_char(consts::path_sep)) || str::ends_with( @@ -190,12 +190,12 @@ fn splitext(p: path) -> (str, str) { if is_dotfile(base) || ext_contains_sep(ext) || no_basename(ext) { - (p, "") + (p, ~"") } else { (base, ext) } } else { - (p, "") + (p, ~"") } } } @@ -220,13 +220,13 @@ fn normalize(p: path) -> path { let s = if check vec::is_not_empty(s) { connect_many(s) } else { - "" + ~"" }; let s = reabsolute(p, s); let s = reterminate(p, s); let s = if str::len(s) == 0u { - "." + ~"." } else { s }; @@ -235,7 +235,7 @@ fn normalize(p: path) -> path { fn strip_dots(s: ~[path]) -> ~[path] { vec::filter_map(s, |elem| - if elem == "." { + if elem == ~"." { option::none } else { option::some(elem) @@ -252,7 +252,7 @@ fn normalize(p: path) -> path { let mut skip = 0; while i != 0u { i -= 1u; - if s[i] == ".." { + if s[i] == ~".." { skip += 1; } else { if skip == 0 { @@ -264,7 +264,7 @@ fn normalize(p: path) -> path { } let mut t = vec::reversed(t); while skip > 0 { - vec::push(t, ".."); + vec::push(t, ~".."); skip -= 1; } ret t; @@ -304,122 +304,122 @@ mod tests { #[test] fn test_connect() { let slash = path_sep(); - log(error, connect("a", "b")); - assert (connect("a", "b") == "a" + slash + "b"); - assert (connect("a" + slash, "b") == "a" + slash + "b"); + log(error, connect(~"a", ~"b")); + assert (connect(~"a", ~"b") == ~"a" + slash + ~"b"); + assert (connect(~"a" + slash, ~"b") == ~"a" + slash + ~"b"); } - fn ps() -> str { + fn ps() -> ~str { path_sep() } - fn aps() -> str { - "/" + fn aps() -> ~str { + ~"/" } #[test] fn split1() { - let actual = split("a" + ps() + "b"); - let expected = ~["a", "b"]; + let actual = split(~"a" + ps() + ~"b"); + let expected = ~[~"a", ~"b"]; assert actual == expected; } #[test] fn split2() { - let actual = split("a" + aps() + "b"); - let expected = ~["a", "b"]; + let actual = split(~"a" + aps() + ~"b"); + let expected = ~[~"a", ~"b"]; assert actual == expected; } #[test] fn split3() { - let actual = split(ps() + "a" + ps() + "b"); - let expected = ~["a", "b"]; + let actual = split(ps() + ~"a" + ps() + ~"b"); + let expected = ~[~"a", ~"b"]; assert actual == expected; } #[test] fn split4() { - let actual = split("a" + ps() + "b" + aps() + "c"); - let expected = ~["a", "b", "c"]; + let actual = split(~"a" + ps() + ~"b" + aps() + ~"c"); + let expected = ~[~"a", ~"b", ~"c"]; assert actual == expected; } #[test] fn normalize1() { - let actual = normalize("a/b/.."); - let expected = "a"; + let actual = normalize(~"a/b/.."); + let expected = ~"a"; assert actual == expected; } #[test] fn normalize2() { - let actual = normalize("/a/b/.."); - let expected = "/a"; + let actual = normalize(~"/a/b/.."); + let expected = ~"/a"; assert actual == expected; } #[test] fn normalize3() { - let actual = normalize("a/../b"); - let expected = "b"; + let actual = normalize(~"a/../b"); + let expected = ~"b"; assert actual == expected; } #[test] fn normalize4() { - let actual = normalize("/a/../b"); - let expected = "/b"; + let actual = normalize(~"/a/../b"); + let expected = ~"/b"; assert actual == expected; } #[test] fn normalize5() { - let actual = normalize("a/."); - let expected = "a"; + let actual = normalize(~"a/."); + let expected = ~"a"; assert actual == expected; } #[test] fn normalize6() { - let actual = normalize("a/./b/"); - let expected = "a/b/"; + let actual = normalize(~"a/./b/"); + let expected = ~"a/b/"; assert actual == expected; } #[test] fn normalize7() { - let actual = normalize("a/.."); - let expected = "."; + let actual = normalize(~"a/.."); + let expected = ~"."; assert actual == expected; } #[test] fn normalize8() { - let actual = normalize("../../.."); - let expected = "../../.."; + let actual = normalize(~"../../.."); + let expected = ~"../../.."; assert actual == expected; } #[test] fn normalize9() { - let actual = normalize("a/b/../../.."); - let expected = ".."; + let actual = normalize(~"a/b/../../.."); + let expected = ~".."; assert actual == expected; } #[test] fn normalize10() { - let actual = normalize("/a/b/c/../d/./../../e/"); - let expected = "/a/e/"; + let actual = normalize(~"/a/b/c/../d/./../../e/"); + let expected = ~"/a/e/"; log(error, actual); assert actual == expected; } #[test] fn normalize11() { - let actual = normalize("/a/.."); - let expected = "/"; + let actual = normalize(~"/a/.."); + let expected = ~"/"; assert actual == expected; } @@ -440,58 +440,58 @@ mod tests { #[test] fn splitext_empty() { - let (base, ext) = splitext(""); - assert base == ""; - assert ext == ""; + let (base, ext) = splitext(~""); + assert base == ~""; + assert ext == ~""; } #[test] fn splitext_ext() { - let (base, ext) = splitext("grum.exe"); - assert base == "grum"; - assert ext == ".exe"; + let (base, ext) = splitext(~"grum.exe"); + assert base == ~"grum"; + assert ext == ~".exe"; } #[test] fn splitext_noext() { - let (base, ext) = splitext("grum"); - assert base == "grum"; - assert ext == ""; + let (base, ext) = splitext(~"grum"); + assert base == ~"grum"; + assert ext == ~""; } #[test] fn splitext_dotfile() { - let (base, ext) = splitext(".grum"); - assert base == ".grum"; - assert ext == ""; + let (base, ext) = splitext(~".grum"); + assert base == ~".grum"; + assert ext == ~""; } #[test] fn splitext_path_ext() { - let (base, ext) = splitext("oh/grum.exe"); - assert base == "oh/grum"; - assert ext == ".exe"; + let (base, ext) = splitext(~"oh/grum.exe"); + assert base == ~"oh/grum"; + assert ext == ~".exe"; } #[test] fn splitext_path_noext() { - let (base, ext) = splitext("oh/grum"); - assert base == "oh/grum"; - assert ext == ""; + let (base, ext) = splitext(~"oh/grum"); + assert base == ~"oh/grum"; + assert ext == ~""; } #[test] fn splitext_dot_in_path() { - let (base, ext) = splitext("oh.my/grum"); - assert base == "oh.my/grum"; - assert ext == ""; + let (base, ext) = splitext(~"oh.my/grum"); + assert base == ~"oh.my/grum"; + assert ext == ~""; } #[test] fn splitext_nobasename() { - let (base, ext) = splitext("oh.my/"); - assert base == "oh.my/"; - assert ext == ""; + let (base, ext) = splitext(~"oh.my/"); + assert base == ~"oh.my/"; + assert ext == ~""; } } diff --git a/src/libcore/pipes.rs b/src/libcore/pipes.rs index 7362614a769..d16f0f3a330 100644 --- a/src/libcore/pipes.rs +++ b/src/libcore/pipes.rs @@ -84,7 +84,7 @@ fn wait_event(this: *rust_task) -> *libc::c_void { let res = rustrt::task_wait_event(this, &mut killed); if killed && !task::failing() { - fail "killed" + fail ~"killed" } res } @@ -118,7 +118,7 @@ fn send<T: send>(-p: send_packet<T>, -payload: T) { // The receiver will eventually clean this up. unsafe { forget(p); } } - full { fail "duplicate send" } + full { fail ~"duplicate send" } blocked { #debug("waking up task for %?", p_); alt p.header.blocked_task { @@ -126,7 +126,7 @@ fn send<T: send>(-p: send_packet<T>, -payload: T) { rustrt::task_signal_event( task, ptr::addr_of(p.header) as *libc::c_void); } - none { fail "blocked packet has no task" } + none { fail ~"blocked packet has no task" } } // The receiver will eventually clean this up. @@ -162,7 +162,7 @@ fn try_recv<T: send>(-p: recv_packet<T>) -> option<T> { } blocked { if first { - fail "blocking on already blocked packet" + fail ~"blocking on already blocked packet" } } full { @@ -184,7 +184,7 @@ fn try_recv<T: send>(-p: recv_packet<T>) -> option<T> { pure fn peek<T: send>(p: recv_packet<T>) -> bool { alt unsafe {(*p.header()).state} { empty { false } - blocked { fail "peeking on blocked packet" } + blocked { fail ~"peeking on blocked packet" } full | terminated { true } } } @@ -207,7 +207,7 @@ fn sender_terminate<T: send>(p: *packet<T>) { } full { // This is impossible - fail "you dun goofed" + fail ~"you dun goofed" } terminated { // I have to clean up, use drop_glue @@ -224,7 +224,7 @@ fn receiver_terminate<T: send>(p: *packet<T>) { } blocked { // this shouldn't happen. - fail "terminating a blocked packet" + fail ~"terminating a blocked packet" } terminated | full { // I have to clean up, use drop_glue @@ -267,7 +267,7 @@ fn wait_many(pkts: &[*packet_header]) -> uint { (*p).state = old; break; } - blocked { fail "blocking on blocked packet" } + blocked { fail ~"blocking on blocked packet" } empty { } } } @@ -313,7 +313,7 @@ fn select2<A: send, B: send>( alt i { 0 { left((try_recv(a), b)) } 1 { right((a, try_recv(b))) } - _ { fail "select2 return an invalid packet" } + _ { fail ~"select2 return an invalid packet" } } } } @@ -397,7 +397,7 @@ class recv_packet<T: send> { header } } - none { fail "packet already consumed" } + none { fail ~"packet already consumed" } } } } @@ -508,7 +508,7 @@ impl port<T: send> for port<T> { some(endp) { pipes::peek(endp) } - none { fail "peeking empty stream" } + none { fail ~"peeking empty stream" } }; self.endp <-> endp; peek @@ -558,7 +558,7 @@ impl private_methods/&<T: send> for pipes::port<T> { some(endp) { endp.header() } - none { fail "peeking empty stream" } + none { fail ~"peeking empty stream" } } } } diff --git a/src/libcore/priv.rs b/src/libcore/priv.rs index adda674de32..4d6ac7bac35 100644 --- a/src/libcore/priv.rs +++ b/src/libcore/priv.rs @@ -32,11 +32,11 @@ unsafe fn chan_from_global_ptr<T: send>( abort } - log(debug,"ENTERING chan_from_global_ptr, before is_prob_zero check"); + log(debug,~"ENTERING chan_from_global_ptr, before is_prob_zero check"); let is_probably_zero = *global == 0u; - log(debug,"after is_prob_zero check"); + log(debug,~"after is_prob_zero check"); if is_probably_zero { - log(debug,"is probably zero..."); + log(debug,~"is probably zero..."); // There's no global channel. We must make it let setup_po = comm::port(); @@ -54,14 +54,14 @@ unsafe fn chan_from_global_ptr<T: send>( } }; - log(debug,"before setup recv.."); + log(debug,~"before setup recv.."); // This is the proposed global channel let ch = comm::recv(setup_po); // 0 is our sentinal value. It is not a valid channel assert unsafe::reinterpret_cast(ch) != 0u; // Install the channel - log(debug,"BEFORE COMPARE AND SWAP"); + log(debug,~"BEFORE COMPARE AND SWAP"); let swapped = compare_and_swap( global, 0u, unsafe::reinterpret_cast(ch)); log(debug,#fmt("AFTER .. swapped? %?", swapped)); @@ -76,7 +76,7 @@ unsafe fn chan_from_global_ptr<T: send>( unsafe::reinterpret_cast(*global) } } else { - log(debug, "global != 0"); + log(debug, ~"global != 0"); unsafe::reinterpret_cast(*global) } } diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs index 97795103f52..178a68a1c65 100644 --- a/src/libcore/ptr.rs +++ b/src/libcore/ptr.rs @@ -174,7 +174,7 @@ fn test_position() { import str::as_c_str; import libc::c_char; - let s = "hello"; + let s = ~"hello"; unsafe { assert 2u == as_c_str(s, |p| position(p, |c| c == 'l' as c_char)); assert 4u == as_c_str(s, |p| position(p, |c| c == 'o' as c_char)); @@ -184,9 +184,9 @@ fn test_position() { #[test] fn test_buf_len() { - let s0 = "hello"; - let s1 = "there"; - let s2 = "thing"; + let s0 = ~"hello"; + let s1 = ~"there"; + let s2 = ~"thing"; do str::as_c_str(s0) |p0| { do str::as_c_str(s1) |p1| { do str::as_c_str(s2) |p2| { diff --git a/src/libcore/rand.rs b/src/libcore/rand.rs index ce4a29f376a..8d392e1be90 100644 --- a/src/libcore/rand.rs +++ b/src/libcore/rand.rs @@ -121,7 +121,7 @@ impl extensions for rng { /** * Return a char randomly chosen from chars, failing if chars is empty */ - fn gen_char_from(chars: str) -> char { + fn gen_char_from(chars: ~str) -> char { assert !chars.is_empty(); self.choose(str::chars(chars)) } @@ -143,11 +143,11 @@ impl extensions for rng { /** * Return a random string of the specified length composed of A-Z,a-z,0-9 */ - fn gen_str(len: uint) -> str { - let charset = "ABCDEFGHIJKLMNOPQRSTUVWXYZ\ + fn gen_str(len: uint) -> ~str { + let charset = ~"ABCDEFGHIJKLMNOPQRSTUVWXYZ\ abcdefghijklmnopqrstuvwxyz\ 0123456789"; - let mut s = ""; + let mut s = ~""; let mut i = 0u; while (i < len) { s = s + str::from_char(self.gen_char_from(charset)); diff --git a/src/libcore/result.rs b/src/libcore/result.rs index f7f6f9ca03b..c0c68459fb6 100644 --- a/src/libcore/result.rs +++ b/src/libcore/result.rs @@ -37,7 +37,7 @@ pure fn get_err<T, U: copy>(res: result<T, U>) -> U { alt res { err(u) { u } ok(_) { - fail "get_error called on ok result"; + fail ~"get_error called on ok result"; } } } @@ -333,7 +333,7 @@ fn unwrap<T, U>(-res: result<T, U>) -> T { unsafe { let addr = alt res { ok(x) { ptr::addr_of(x) } - err(_) { fail "error result" } + err(_) { fail ~"error result" } }; let liberated_value = unsafe::reinterpret_cast(*addr); unsafe::forget(res); @@ -343,13 +343,13 @@ fn unwrap<T, U>(-res: result<T, U>) -> T { #[cfg(test)] mod tests { - fn op1() -> result::result<int, str> { result::ok(666) } + fn op1() -> result::result<int, ~str> { result::ok(666) } - fn op2(&&i: int) -> result::result<uint, str> { + fn op2(&&i: int) -> result::result<uint, ~str> { result::ok(i as uint + 1u) } - fn op3() -> result::result<int, str> { result::err("sadface") } + fn op3() -> result::result<int, ~str> { result::err(~"sadface") } #[test] fn chain_success() { @@ -358,39 +358,39 @@ mod tests { #[test] fn chain_failure() { - assert get_err(chain(op3(), op2)) == "sadface"; + assert get_err(chain(op3(), op2)) == ~"sadface"; } #[test] fn test_impl_iter() { let mut valid = false; - ok::<str, str>("a").iter(|_x| valid = true); + ok::<~str, ~str>(~"a").iter(|_x| valid = true); assert valid; - err::<str, str>("b").iter(|_x| valid = false); + err::<~str, ~str>(~"b").iter(|_x| valid = false); assert valid; } #[test] fn test_impl_iter_err() { let mut valid = true; - ok::<str, str>("a").iter_err(|_x| valid = false); + ok::<~str, ~str>(~"a").iter_err(|_x| valid = false); assert valid; valid = false; - err::<str, str>("b").iter_err(|_x| valid = true); + err::<~str, ~str>(~"b").iter_err(|_x| valid = true); assert valid; } #[test] fn test_impl_map() { - assert ok::<str, str>("a").map(|_x| "b") == ok("b"); - assert err::<str, str>("a").map(|_x| "b") == err("a"); + assert ok::<~str, ~str>(~"a").map(|_x| ~"b") == ok(~"b"); + assert err::<~str, ~str>(~"a").map(|_x| ~"b") == err(~"a"); } #[test] fn test_impl_map_err() { - assert ok::<str, str>("a").map_err(|_x| "b") == ok("a"); - assert err::<str, str>("a").map_err(|_x| "b") == err("b"); + assert ok::<~str, ~str>(~"a").map_err(|_x| ~"b") == ok(~"a"); + assert err::<~str, ~str>(~"a").map_err(|_x| ~"b") == err(~"b"); } } diff --git a/src/libcore/run.rs b/src/libcore/run.rs index 55a58430fc0..c8e55bea2a5 100644 --- a/src/libcore/run.rs +++ b/src/libcore/run.rs @@ -62,9 +62,9 @@ iface program { * * The process id of the spawned process */ -fn spawn_process(prog: str, args: ~[str], - env: option<~[(str,str)]>, - dir: option<str>, +fn spawn_process(prog: ~str, args: ~[~str], + env: option<~[(~str,~str)]>, + dir: option<~str>, in_fd: c_int, out_fd: c_int, err_fd: c_int) -> pid_t { do with_argv(prog, args) |argv| { @@ -77,7 +77,7 @@ fn spawn_process(prog: str, args: ~[str], } } -fn with_argv<T>(prog: str, args: ~[str], +fn with_argv<T>(prog: ~str, args: ~[~str], cb: fn(**libc::c_char) -> T) -> T { let mut argptrs = str::as_c_str(prog, |b| ~[b]); let mut tmps = ~[]; @@ -91,7 +91,7 @@ fn with_argv<T>(prog: str, args: ~[str], } #[cfg(unix)] -fn with_envp<T>(env: option<~[(str,str)]>, +fn with_envp<T>(env: option<~[(~str,~str)]>, cb: fn(*c_void) -> T) -> T { // On posixy systems we can pass a char** for envp, which is // a null-terminated array of "k=v\n" strings. @@ -144,7 +144,7 @@ fn with_envp<T>(env: option<~[(str,str)]>, } } -fn with_dirp<T>(d: option<str>, +fn with_dirp<T>(d: option<~str>, cb: fn(*libc::c_char) -> T) -> T { alt d { some(dir) { str::as_c_str(dir, cb) } @@ -164,7 +164,7 @@ fn with_dirp<T>(d: option<str>, * * The process id */ -fn run_program(prog: str, args: ~[str]) -> int { +fn run_program(prog: ~str, args: ~[~str]) -> int { let pid = spawn_process(prog, args, none, none, 0i32, 0i32, 0i32); if pid == -1 as pid_t { fail; } @@ -187,7 +187,7 @@ fn run_program(prog: str, args: ~[str]) -> int { * * A class with a <program> field */ -fn start_program(prog: str, args: ~[str]) -> program { +fn start_program(prog: ~str, args: ~[~str]) -> program { let pipe_input = os::pipe(); let pipe_output = os::pipe(); let pipe_err = os::pipe(); @@ -248,8 +248,8 @@ fn start_program(prog: str, args: ~[str]) -> program { ret prog_res(repr) as program; } -fn read_all(rd: io::reader) -> str { - let mut buf = ""; +fn read_all(rd: io::reader) -> ~str { + let mut buf = ~""; while !rd.eof() { let bytes = rd.read_bytes(4096u); buf += str::from_bytes(bytes); @@ -271,8 +271,8 @@ fn read_all(rd: io::reader) -> str { * A record, {status: int, out: str, err: str} containing the exit code, * the contents of stdout and the contents of stderr. */ -fn program_output(prog: str, args: ~[str]) -> - {status: int, out: str, err: str} { +fn program_output(prog: ~str, args: ~[~str]) -> + {status: int, out: ~str, err: ~str} { let pipe_in = os::pipe(); let pipe_out = os::pipe(); @@ -307,8 +307,8 @@ fn program_output(prog: str, args: ~[str]) -> comm::send(ch, (1, output)); }; let status = run::waitpid(pid); - let mut errs = ""; - let mut outs = ""; + let mut errs = ~""; + let mut outs = ~""; let mut count = 2; while count > 0 { let stream = comm::recv(p); @@ -325,7 +325,7 @@ fn program_output(prog: str, args: ~[str]) -> ret {status: status, out: outs, err: errs}; } -fn writeclose(fd: c_int, s: str) { +fn writeclose(fd: c_int, s: ~str) { import io::writer_util; #error("writeclose %d, %s", fd as int, s); @@ -335,10 +335,10 @@ fn writeclose(fd: c_int, s: str) { os::close(fd); } -fn readclose(fd: c_int) -> str { +fn readclose(fd: c_int) -> ~str { let file = os::fdopen(fd); let reader = io::FILE_reader(file, false); - let mut buf = ""; + let mut buf = ~""; while !reader.eof() { let bytes = reader.read_bytes(4096u); buf += str::from_bytes(bytes); @@ -397,9 +397,9 @@ mod tests { // Regression test for memory leaks #[ignore(cfg(windows))] // FIXME (#2626) fn test_leaks() { - run::run_program("echo", ~[]); - run::start_program("echo", ~[]); - run::program_output("echo", ~[]); + run::run_program(~"echo", ~[]); + run::start_program(~"echo", ~[]); + run::program_output(~"echo", ~[]); } #[test] @@ -410,14 +410,14 @@ mod tests { let pid = run::spawn_process( - "cat", ~[], none, none, + ~"cat", ~[], none, none, pipe_in.in, pipe_out.out, pipe_err.out); os::close(pipe_in.in); os::close(pipe_out.out); os::close(pipe_err.out); if pid == -1i32 { fail; } - let expected = "test"; + let expected = ~"test"; writeclose(pipe_in.out, expected); let actual = readclose(pipe_out.in); readclose(pipe_err.in); @@ -430,7 +430,7 @@ mod tests { #[test] fn waitpid() { - let pid = run::spawn_process("false", ~[], + let pid = run::spawn_process(~"false", ~[], none, none, 0i32, 0i32, 0i32); let status = run::waitpid(pid); diff --git a/src/libcore/str.rs b/src/libcore/str.rs index f05410bafe9..cc5ae30268d 100644 --- a/src/libcore/str.rs +++ b/src/libcore/str.rs @@ -110,8 +110,8 @@ export #[abi = "cdecl"] extern mod rustrt { - fn rust_str_push(&s: str, ch: u8); - fn str_reserve_shared(&ss: str, nn: libc::size_t); + fn rust_str_push(&s: ~str, ch: u8); + fn str_reserve_shared(&ss: ~str, nn: libc::size_t); } /* @@ -125,7 +125,7 @@ Section: Creating a string * * Fails if invalid UTF-8 */ -pure fn from_bytes(+vv: ~[u8]) -> str { +pure fn from_bytes(+vv: ~[u8]) -> ~str { assert is_utf8(vv); ret unsafe { unsafe::from_bytes(vv) }; } @@ -137,14 +137,14 @@ pure fn from_bytes(+vv: ~[u8]) -> str { * * Fails if invalid UTF-8 */ -pure fn from_byte(b: u8) -> str { +pure fn from_byte(b: u8) -> ~str { assert b < 128u8; let mut v = ~[b, 0u8]; unsafe { ::unsafe::transmute(v) } } /// Appends a character at the end of a string -fn push_char(&s: str, ch: char) { +fn push_char(&s: ~str, ch: char) { unsafe { let code = ch as uint; let nb = if code < max_one_b { 1u } @@ -220,15 +220,15 @@ fn push_char(&s: str, ch: char) { } /// Convert a char to a string -pure fn from_char(ch: char) -> str { - let mut buf = ""; +pure fn from_char(ch: char) -> ~str { + let mut buf = ~""; unchecked { push_char(buf, ch); } ret buf; } /// Convert a vector of chars to a string -pure fn from_chars(chs: &[const char]) -> str { - let mut buf = ""; +pure fn from_chars(chs: &[const char]) -> ~str { + let mut buf = ~""; unchecked { reserve(buf, chs.len()); for vec::each(chs) |ch| { push_char(buf, ch); } @@ -238,7 +238,7 @@ pure fn from_chars(chs: &[const char]) -> str { /// Appends a string slice to the back of a string, without overallocating #[inline(always)] -fn push_str_no_overallocate(&lhs: str, rhs: str/&) { +fn push_str_no_overallocate(&lhs: ~str, rhs: &str) { unsafe { let llen = lhs.len(); let rlen = rhs.len(); @@ -254,7 +254,7 @@ fn push_str_no_overallocate(&lhs: str, rhs: str/&) { } /// Appends a string slice to the back of a string #[inline(always)] -fn push_str(&lhs: str, rhs: str/&) { +fn push_str(&lhs: ~str, rhs: &str) { unsafe { let llen = lhs.len(); let rlen = rhs.len(); @@ -271,7 +271,7 @@ fn push_str(&lhs: str, rhs: str/&) { /// Concatenate two strings together #[inline(always)] -pure fn append(+lhs: str, rhs: str/&) -> str { +pure fn append(+lhs: ~str, rhs: &str) -> ~str { let mut v <- lhs; unchecked { push_str_no_overallocate(v, rhs); @@ -281,15 +281,15 @@ pure fn append(+lhs: str, rhs: str/&) -> str { /// Concatenate a vector of strings -pure fn concat(v: &[const str]) -> str { - let mut s: str = ""; +pure fn concat(v: &[const ~str]) -> ~str { + let mut s: ~str = ~""; for vec::each(v) |ss| { unchecked { push_str(s, ss) }; } ret s; } /// Concatenate a vector of strings, placing a given separator between each -pure fn connect(v: &[const str], sep: str) -> str { - let mut s = "", first = true; +pure fn connect(v: &[const ~str], sep: ~str) -> ~str { + let mut s = ~"", first = true; for vec::each(v) |ss| { if first { first = false; } else { unchecked { push_str(s, sep); } } unchecked { push_str(s, ss) }; @@ -308,7 +308,7 @@ Section: Adding to and removing from a string * * If the string does not contain any characters */ -fn pop_char(&s: str) -> char { +fn pop_char(&s: ~str) -> char { let end = len(s); assert end > 0u; let {ch, prev} = char_range_at_reverse(s, end); @@ -323,19 +323,19 @@ fn pop_char(&s: str) -> char { * * If the string does not contain any characters */ -fn shift_char(&s: str) -> char { +fn shift_char(&s: ~str) -> char { let {ch, next} = char_range_at(s, 0u); s = unsafe { unsafe::slice_bytes(s, next, len(s)) }; ret ch; } /// Prepend a char to a string -fn unshift_char(&s: str, ch: char) { s = from_char(ch) + s; } +fn unshift_char(&s: ~str, ch: char) { s = from_char(ch) + s; } /// Returns a string with leading whitespace removed -pure fn trim_left(+s: str) -> str { +pure fn trim_left(+s: ~str) -> ~str { alt find(s, |c| !char::is_whitespace(c)) { - none { "" } + none { ~"" } some(first) { if first == 0u { s } else unsafe { unsafe::slice_bytes(s, first, len(s)) } @@ -344,9 +344,9 @@ pure fn trim_left(+s: str) -> str { } /// Returns a string with trailing whitespace removed -pure fn trim_right(+s: str) -> str { +pure fn trim_right(+s: ~str) -> ~str { alt rfind(s, |c| !char::is_whitespace(c)) { - none { "" } + none { ~"" } some(last) { let {next, _} = char_range_at(s, last); if next == len(s) { s } @@ -356,7 +356,7 @@ pure fn trim_right(+s: str) -> str { } /// Returns a string with leading and trailing whitespace removed -pure fn trim(+s: str) -> str { trim_left(trim_right(s)) } +pure fn trim(+s: ~str) -> ~str { trim_left(trim_right(s)) } /* Section: Transforming strings @@ -367,7 +367,7 @@ Section: Transforming strings * * The result vector is not null-terminated. */ -pure fn bytes(s: str) -> ~[u8] { +pure fn bytes(s: ~str) -> ~[u8] { unsafe { let mut s_copy = s; let mut v: ~[u8] = ::unsafe::transmute(s_copy); @@ -378,14 +378,14 @@ pure fn bytes(s: str) -> ~[u8] { /// Work with the string as a byte slice, not including trailing null. #[inline(always)] -pure fn byte_slice<T>(s: str/&, f: fn(v: &[u8]) -> T) -> T { +pure fn byte_slice<T>(s: &str, f: fn(v: &[u8]) -> T) -> T { do unpack_slice(s) |p,n| { unsafe { vec::unsafe::form_slice(p, n-1u, f) } } } /// Convert a string to a vector of characters -pure fn chars(s: str/&) -> ~[char] { +pure fn chars(s: &str) -> ~[char] { let mut buf = ~[], i = 0u; let len = len(s); while i < len { @@ -402,7 +402,7 @@ pure fn chars(s: str/&) -> ~[char] { * Returns a string containing `n` characters starting at byte offset * `begin`. */ -pure fn substr(s: str/&, begin: uint, n: uint) -> str { +pure fn substr(s: &str, begin: uint, n: uint) -> ~str { slice(s, begin, begin + count_bytes(s, begin, n)) } @@ -412,14 +412,14 @@ pure fn substr(s: str/&, begin: uint, n: uint) -> str { * Fails when `begin` and `end` do not point to valid characters or * beyond the last character of the string */ -pure fn slice(s: str/&, begin: uint, end: uint) -> str { +pure fn slice(s: &str, begin: uint, end: uint) -> ~str { assert is_char_boundary(s, begin); assert is_char_boundary(s, end); unsafe { unsafe::slice_bytes(s, begin, end) } } /// Splits a string into substrings at each occurrence of a given character -pure fn split_char(s: str/&, sep: char) -> ~[str] { +pure fn split_char(s: &str, sep: char) -> ~[~str] { split_char_inner(s, sep, len(s), true) } @@ -429,17 +429,17 @@ pure fn split_char(s: str/&, sep: char) -> ~[str] { * * The byte must be a valid UTF-8/ASCII byte */ -pure fn splitn_char(s: str/&, sep: char, count: uint) -> ~[str] { +pure fn splitn_char(s: &str, sep: char, count: uint) -> ~[~str] { split_char_inner(s, sep, count, true) } /// Like `split_char`, but omits empty strings from the returned vector -pure fn split_char_nonempty(s: str/&, sep: char) -> ~[str] { +pure fn split_char_nonempty(s: &str, sep: char) -> ~[~str] { split_char_inner(s, sep, len(s), false) } -pure fn split_char_inner(s: str/&, sep: char, count: uint, allow_empty: bool) - -> ~[str] { +pure fn split_char_inner(s: &str, sep: char, count: uint, allow_empty: bool) + -> ~[~str] { if sep < 128u as char { let b = sep as u8, l = len(s); let mut result = ~[], done = 0u; @@ -466,7 +466,7 @@ pure fn split_char_inner(s: str/&, sep: char, count: uint, allow_empty: bool) /// Splits a string into substrings using a character function -pure fn split(s: str/&, sepfn: fn(char) -> bool) -> ~[str] { +pure fn split(s: &str, sepfn: fn(char) -> bool) -> ~[~str] { split_inner(s, sepfn, len(s), true) } @@ -474,17 +474,17 @@ pure fn split(s: str/&, sepfn: fn(char) -> bool) -> ~[str] { * Splits a string into substrings using a character function, cutting at * most `count` times. */ -pure fn splitn(s: str/&, sepfn: fn(char) -> bool, count: uint) -> ~[str] { +pure fn splitn(s: &str, sepfn: fn(char) -> bool, count: uint) -> ~[~str] { split_inner(s, sepfn, count, true) } /// Like `split`, but omits empty strings from the returned vector -pure fn split_nonempty(s: str/&, sepfn: fn(char) -> bool) -> ~[str] { +pure fn split_nonempty(s: &str, sepfn: fn(char) -> bool) -> ~[~str] { split_inner(s, sepfn, len(s), false) } -pure fn split_inner(s: str/&, sepfn: fn(cc: char) -> bool, count: uint, - allow_empty: bool) -> ~[str] { +pure fn split_inner(s: &str, sepfn: fn(cc: char) -> bool, count: uint, + allow_empty: bool) -> ~[~str] { let l = len(s); let mut result = ~[], i = 0u, start = 0u, done = 0u; while i < l && done < count { @@ -505,7 +505,7 @@ pure fn split_inner(s: str/&, sepfn: fn(cc: char) -> bool, count: uint, } // See Issue #1932 for why this is a naive search -pure fn iter_matches(s: str/&a, sep: str/&b, f: fn(uint, uint)) { +pure fn iter_matches(s: &a/str, sep: &b/str, f: fn(uint, uint)) { let sep_len = len(sep), l = len(s); assert sep_len > 0u; let mut i = 0u, match_start = 0u, match_i = 0u; @@ -532,7 +532,7 @@ pure fn iter_matches(s: str/&a, sep: str/&b, f: fn(uint, uint)) { } } -pure fn iter_between_matches(s: str/&a, sep: str/&b, f: fn(uint, uint)) { +pure fn iter_between_matches(s: &a/str, sep: &b/str, f: fn(uint, uint)) { let mut last_end = 0u; do iter_matches(s, sep) |from, to| { f(last_end, from); @@ -550,7 +550,7 @@ pure fn iter_between_matches(s: str/&a, sep: str/&b, f: fn(uint, uint)) { * assert ["", "XXX", "YYY", ""] == split_str(".XXX.YYY.", ".") * ~~~ */ -pure fn split_str(s: str/&a, sep: str/&b) -> ~[str] { +pure fn split_str(s: &a/str, sep: &b/str) -> ~[~str] { let mut result = ~[]; do iter_between_matches(s, sep) |from, to| { unsafe { vec::push(result, unsafe::slice_bytes(s, from, to)); } @@ -558,7 +558,7 @@ pure fn split_str(s: str/&a, sep: str/&b) -> ~[str] { result } -pure fn split_str_nonempty(s: str/&a, sep: str/&b) -> ~[str] { +pure fn split_str_nonempty(s: &a/str, sep: &b/str) -> ~[~str] { let mut result = ~[]; do iter_between_matches(s, sep) |from, to| { if to > from { @@ -571,13 +571,13 @@ pure fn split_str_nonempty(s: str/&a, sep: str/&b) -> ~[str] { /** * Splits a string into a vector of the substrings separated by LF ('\n') */ -pure fn lines(s: str/&) -> ~[str] { split_char(s, '\n') } +pure fn lines(s: &str) -> ~[~str] { split_char(s, '\n') } /** * Splits a string into a vector of the substrings separated by LF ('\n') * and/or CR LF ("\r\n") */ -pure fn lines_any(s: str/&) -> ~[str] { +pure fn lines_any(s: &str) -> ~[~str] { vec::map(lines(s), |s| { let l = len(s); let mut cp = s; @@ -589,19 +589,19 @@ pure fn lines_any(s: str/&) -> ~[str] { } /// Splits a string into a vector of the substrings separated by whitespace -pure fn words(s: str/&) -> ~[str] { +pure fn words(s: &str) -> ~[~str] { split_nonempty(s, |c| char::is_whitespace(c)) } /// Convert a string to lowercase. ASCII only -pure fn to_lower(s: str/&) -> str { +pure fn to_lower(s: &str) -> ~str { map(s, |c| unchecked{(libc::tolower(c as libc::c_char)) as char} ) } /// Convert a string to uppercase. ASCII only -pure fn to_upper(s: str/&) -> str { +pure fn to_upper(s: &str) -> ~str { map(s, |c| unchecked{(libc::toupper(c as libc::c_char)) as char} ) @@ -620,8 +620,8 @@ pure fn to_upper(s: str/&) -> str { * * The original string with all occurances of `from` replaced with `to` */ -pure fn replace(s: str, from: str, to: str) -> str { - let mut result = "", first = true; +pure fn replace(s: ~str, from: ~str, to: ~str) -> ~str { + let mut result = ~"", first = true; do iter_between_matches(s, from) |start, end| { if first { first = false; } else { unchecked {push_str(result, to); }} unsafe { push_str(result, unsafe::slice_bytes(s, start, end)); } @@ -634,7 +634,7 @@ Section: Comparing strings */ /// Bytewise string equality -pure fn eq(&&a: str, &&b: str) -> bool { +pure fn eq(&&a: ~str, &&b: ~str) -> bool { // FIXME (#2627): This should just be "a == b" but that calls into the // shape code. let a_len = a.len(); @@ -652,10 +652,10 @@ pure fn eq(&&a: str, &&b: str) -> bool { } /// Bytewise less than or equal -pure fn le(&&a: str, &&b: str) -> bool { a <= b } +pure fn le(&&a: ~str, &&b: ~str) -> bool { a <= b } /// String hash function -pure fn hash(&&s: str) -> uint { +pure fn hash(&&s: ~str) -> uint { // djb hash. // FIXME: replace with murmur. (see #859 and #1616) let mut u: uint = 5381u; @@ -671,7 +671,7 @@ Section: Iterating through strings * Return true if a predicate matches all characters or if the string * contains no characters */ -pure fn all(s: str/&, it: fn(char) -> bool) -> bool { +pure fn all(s: &str, it: fn(char) -> bool) -> bool { all_between(s, 0u, len(s), it) } @@ -679,13 +679,13 @@ pure fn all(s: str/&, it: fn(char) -> bool) -> bool { * Return true if a predicate matches any character (and false if it * matches none or there are no characters) */ -pure fn any(ss: str/&, pred: fn(char) -> bool) -> bool { +pure fn any(ss: &str, pred: fn(char) -> bool) -> bool { !all(ss, |cc| !pred(cc)) } /// Apply a function to each character -pure fn map(ss: str/&, ff: fn(char) -> char) -> str { - let mut result = ""; +pure fn map(ss: &str, ff: fn(char) -> char) -> ~str { + let mut result = ~""; unchecked { reserve(result, len(ss)); do chars_iter(ss) |cc| { @@ -696,7 +696,7 @@ pure fn map(ss: str/&, ff: fn(char) -> char) -> str { } /// Iterate over the bytes in a string -pure fn bytes_iter(ss: str/&, it: fn(u8)) { +pure fn bytes_iter(ss: &str, it: fn(u8)) { let mut pos = 0u; let len = len(ss); @@ -708,13 +708,13 @@ pure fn bytes_iter(ss: str/&, it: fn(u8)) { /// Iterate over the bytes in a string #[inline(always)] -pure fn each(s: str/&, it: fn(u8) -> bool) { +pure fn each(s: &str, it: fn(u8) -> bool) { eachi(s, |_i, b| it(b) ) } /// Iterate over the bytes in a string, with indices #[inline(always)] -pure fn eachi(s: str/&, it: fn(uint, u8) -> bool) { +pure fn eachi(s: &str, it: fn(uint, u8) -> bool) { let mut i = 0u, l = len(s); while (i < l) { if !it(i, s[i]) { break; } @@ -724,13 +724,13 @@ pure fn eachi(s: str/&, it: fn(uint, u8) -> bool) { /// Iterates over the chars in a string #[inline(always)] -pure fn each_char(s: str/&, it: fn(char) -> bool) { +pure fn each_char(s: &str, it: fn(char) -> bool) { each_chari(s, |_i, c| it(c)) } /// Iterates over the chars in a string, with indices #[inline(always)] -pure fn each_chari(s: str/&, it: fn(uint, char) -> bool) { +pure fn each_chari(s: &str, it: fn(uint, char) -> bool) { let mut pos = 0u, ch_pos = 0u; let len = len(s); while pos < len { @@ -742,7 +742,7 @@ pure fn each_chari(s: str/&, it: fn(uint, char) -> bool) { } /// Iterate over the characters in a string -pure fn chars_iter(s: str/&, it: fn(char)) { +pure fn chars_iter(s: &str, it: fn(char)) { let mut pos = 0u; let len = len(s); while (pos < len) { @@ -753,7 +753,7 @@ pure fn chars_iter(s: str/&, it: fn(char)) { } /// Apply a function to each substring after splitting by character -pure fn split_char_iter(ss: str/&, cc: char, ff: fn(&&str)) { +pure fn split_char_iter(ss: &str, cc: char, ff: fn(&&~str)) { vec::iter(split_char(ss, cc), ff) } @@ -761,20 +761,20 @@ pure fn split_char_iter(ss: str/&, cc: char, ff: fn(&&str)) { * Apply a function to each substring after splitting by character, up to * `count` times */ -pure fn splitn_char_iter(ss: str/&, sep: char, count: uint, - ff: fn(&&str)) { +pure fn splitn_char_iter(ss: &str, sep: char, count: uint, + ff: fn(&&~str)) { vec::iter(splitn_char(ss, sep, count), ff) } /// Apply a function to each word -pure fn words_iter(ss: str/&, ff: fn(&&str)) { +pure fn words_iter(ss: &str, ff: fn(&&~str)) { vec::iter(words(ss), ff) } /** * Apply a function to each line (by '\n') */ -pure fn lines_iter(ss: str/&, ff: fn(&&str)) { +pure fn lines_iter(ss: &str, ff: fn(&&~str)) { vec::iter(lines(ss), ff) } @@ -795,7 +795,7 @@ Section: Searching * An `option` containing the byte index of the first matching character * or `none` if there is no match */ -pure fn find_char(s: str/&, c: char) -> option<uint> { +pure fn find_char(s: &str, c: char) -> option<uint> { find_char_between(s, c, 0u, len(s)) } @@ -819,7 +819,7 @@ pure fn find_char(s: str/&, c: char) -> option<uint> { * `start` must be less than or equal to `len(s)`. `start` must be the * index of a character boundary, as defined by `is_char_boundary`. */ -pure fn find_char_from(s: str/&, c: char, start: uint) -> option<uint> { +pure fn find_char_from(s: &str, c: char, start: uint) -> option<uint> { find_char_between(s, c, start, len(s)) } @@ -844,7 +844,7 @@ pure fn find_char_from(s: str/&, c: char, start: uint) -> option<uint> { * or equal to `len(s)`. `start` must be the index of a character boundary, * as defined by `is_char_boundary`. */ -pure fn find_char_between(s: str/&, c: char, start: uint, end: uint) +pure fn find_char_between(s: &str, c: char, start: uint, end: uint) -> option<uint> { if c < 128u as char { assert start <= end; @@ -874,7 +874,7 @@ pure fn find_char_between(s: str/&, c: char, start: uint, end: uint) * An `option` containing the byte index of the last matching character * or `none` if there is no match */ -pure fn rfind_char(s: str/&, c: char) -> option<uint> { +pure fn rfind_char(s: &str, c: char) -> option<uint> { rfind_char_between(s, c, len(s), 0u) } @@ -898,7 +898,7 @@ pure fn rfind_char(s: str/&, c: char) -> option<uint> { * `start` must be less than or equal to `len(s)`. `start` must be * the index of a character boundary, as defined by `is_char_boundary`. */ -pure fn rfind_char_from(s: str/&, c: char, start: uint) -> option<uint> { +pure fn rfind_char_from(s: &str, c: char, start: uint) -> option<uint> { rfind_char_between(s, c, start, 0u) } @@ -923,7 +923,7 @@ pure fn rfind_char_from(s: str/&, c: char, start: uint) -> option<uint> { * or equal to `len(s)`. `start` must be the index of a character boundary, * as defined by `is_char_boundary`. */ -pure fn rfind_char_between(s: str/&, c: char, start: uint, end: uint) +pure fn rfind_char_between(s: &str, c: char, start: uint, end: uint) -> option<uint> { if c < 128u as char { assert start >= end; @@ -954,7 +954,7 @@ pure fn rfind_char_between(s: str/&, c: char, start: uint, end: uint) * An `option` containing the byte index of the first matching character * or `none` if there is no match */ -pure fn find(s: str/&, f: fn(char) -> bool) -> option<uint> { +pure fn find(s: &str, f: fn(char) -> bool) -> option<uint> { find_between(s, 0u, len(s), f) } @@ -978,7 +978,7 @@ pure fn find(s: str/&, f: fn(char) -> bool) -> option<uint> { * `start` must be less than or equal to `len(s)`. `start` must be the * index of a character boundary, as defined by `is_char_boundary`. */ -pure fn find_from(s: str/&, start: uint, f: fn(char) +pure fn find_from(s: &str, start: uint, f: fn(char) -> bool) -> option<uint> { find_between(s, start, len(s), f) } @@ -1005,7 +1005,7 @@ pure fn find_from(s: str/&, start: uint, f: fn(char) * or equal to `len(s)`. `start` must be the index of a character * boundary, as defined by `is_char_boundary`. */ -pure fn find_between(s: str/&, start: uint, end: uint, f: fn(char) -> bool) +pure fn find_between(s: &str, start: uint, end: uint, f: fn(char) -> bool) -> option<uint> { assert start <= end; assert end <= len(s); @@ -1033,7 +1033,7 @@ pure fn find_between(s: str/&, start: uint, end: uint, f: fn(char) -> bool) * An option containing the byte index of the last matching character * or `none` if there is no match */ -pure fn rfind(s: str/&, f: fn(char) -> bool) -> option<uint> { +pure fn rfind(s: &str, f: fn(char) -> bool) -> option<uint> { rfind_between(s, len(s), 0u, f) } @@ -1057,7 +1057,7 @@ pure fn rfind(s: str/&, f: fn(char) -> bool) -> option<uint> { * `start` must be less than or equal to `len(s)', `start` must be the * index of a character boundary, as defined by `is_char_boundary` */ -pure fn rfind_from(s: str/&, start: uint, f: fn(char) -> bool) +pure fn rfind_from(s: &str, start: uint, f: fn(char) -> bool) -> option<uint> { rfind_between(s, start, 0u, f) } @@ -1084,7 +1084,7 @@ pure fn rfind_from(s: str/&, start: uint, f: fn(char) -> bool) * than or equal to `len(s)`. `start` must be the index of a character * boundary, as defined by `is_char_boundary` */ -pure fn rfind_between(s: str/&, start: uint, end: uint, f: fn(char) -> bool) +pure fn rfind_between(s: &str, start: uint, end: uint, f: fn(char) -> bool) -> option<uint> { assert start >= end; assert start <= len(s); @@ -1099,7 +1099,7 @@ pure fn rfind_between(s: str/&, start: uint, end: uint, f: fn(char) -> bool) } // Utility used by various searching functions -pure fn match_at(haystack: str/&a, needle: str/&b, at: uint) -> bool { +pure fn match_at(haystack: &a/str, needle: &b/str, at: uint) -> bool { let mut i = at; for each(needle) |c| { if haystack[i] != c { ret false; } i += 1u; } ret true; @@ -1118,7 +1118,7 @@ pure fn match_at(haystack: str/&a, needle: str/&b, at: uint) -> bool { * An `option` containing the byte index of the first matching substring * or `none` if there is no match */ -pure fn find_str(haystack: str/&a, needle: str/&b) -> option<uint> { +pure fn find_str(haystack: &a/str, needle: &b/str) -> option<uint> { find_str_between(haystack, needle, 0u, len(haystack)) } @@ -1141,7 +1141,7 @@ pure fn find_str(haystack: str/&a, needle: str/&b) -> option<uint> { * * `start` must be less than or equal to `len(s)` */ -pure fn find_str_from(haystack: str/&a, needle: str/&b, start: uint) +pure fn find_str_from(haystack: &a/str, needle: &b/str, start: uint) -> option<uint> { find_str_between(haystack, needle, start, len(haystack)) } @@ -1166,7 +1166,7 @@ pure fn find_str_from(haystack: str/&a, needle: str/&b, start: uint) * `start` must be less than or equal to `end` and `end` must be less than * or equal to `len(s)`. */ -pure fn find_str_between(haystack: str/&a, needle: str/&b, start: uint, +pure fn find_str_between(haystack: &a/str, needle: &b/str, start: uint, end:uint) -> option<uint> { // See Issue #1932 for why this is a naive search @@ -1192,7 +1192,7 @@ pure fn find_str_between(haystack: str/&a, needle: str/&b, start: uint, * * haystack - The string to look in * * needle - The string to look for */ -pure fn contains(haystack: str/&a, needle: str/&b) -> bool { +pure fn contains(haystack: &a/str, needle: &b/str) -> bool { option::is_some(find_str(haystack, needle)) } @@ -1204,7 +1204,7 @@ pure fn contains(haystack: str/&a, needle: str/&b) -> bool { * * haystack - The string to look in * * needle - The char to look for */ -pure fn contains_char(haystack: str/&, needle: char) -> bool { +pure fn contains_char(haystack: &str, needle: char) -> bool { option::is_some(find_char(haystack, needle)) } @@ -1216,7 +1216,7 @@ pure fn contains_char(haystack: str/&, needle: char) -> bool { * * haystack - The string to look in * * needle - The string to look for */ -pure fn starts_with(haystack: str/&a, needle: str/&b) -> bool { +pure fn starts_with(haystack: &a/str, needle: &b/str) -> bool { let haystack_len = len(haystack), needle_len = len(needle); if needle_len == 0u { true } else if needle_len > haystack_len { false } @@ -1231,7 +1231,7 @@ pure fn starts_with(haystack: str/&a, needle: str/&b) -> bool { * * haystack - The string to look in * * needle - The string to look for */ -pure fn ends_with(haystack: str/&a, needle: str/&b) -> bool { +pure fn ends_with(haystack: &a/str, needle: &b/str) -> bool { let haystack_len = len(haystack), needle_len = len(needle); if needle_len == 0u { true } else if needle_len > haystack_len { false } @@ -1243,24 +1243,24 @@ Section: String properties */ /// Determines if a string contains only ASCII characters -pure fn is_ascii(s: str/&) -> bool { +pure fn is_ascii(s: &str) -> bool { let mut i: uint = len(s); while i > 0u { i -= 1u; if !u8::is_ascii(s[i]) { ret false; } } ret true; } /// Returns true if the string has length 0 -pure fn is_empty(s: str/&) -> bool { len(s) == 0u } +pure fn is_empty(s: &str) -> bool { len(s) == 0u } /// Returns true if the string has length greater than 0 -pure fn is_not_empty(s: str/&) -> bool { !is_empty(s) } +pure fn is_not_empty(s: &str) -> bool { !is_empty(s) } /** * Returns true if the string contains only whitespace * * Whitespace characters are determined by `char::is_whitespace` */ -pure fn is_whitespace(s: str/&) -> bool { +pure fn is_whitespace(s: &str) -> bool { ret all(s, char::is_whitespace); } @@ -1269,17 +1269,17 @@ pure fn is_whitespace(s: str/&) -> bool { * * Alphanumeric characters are determined by `char::is_alphanumeric` */ -fn is_alphanumeric(s: str/&) -> bool { +fn is_alphanumeric(s: &str) -> bool { ret all(s, char::is_alphanumeric); } /// Returns the string length/size in bytes not counting the null terminator -pure fn len(s: str/&) -> uint { +pure fn len(s: &str) -> uint { do unpack_slice(s) |_p, n| { n - 1u } } /// Returns the number of characters that a string holds -pure fn char_len(s: str/&) -> uint { count_chars(s, 0u, len(s)) } +pure fn char_len(s: &str) -> uint { count_chars(s, 0u, len(s)) } /* Section: Misc @@ -1325,7 +1325,7 @@ pure fn is_utf16(v: &[const u16]) -> bool { } /// Converts to a vector of `u16` encoded as UTF-16 -pure fn to_utf16(s: str/&) -> ~[u16] { +pure fn to_utf16(s: &str) -> ~[u16] { let mut u = ~[]; do chars_iter(s) |cch| { // Arithmetic with u32 literals is easier on the eyes than chars. @@ -1372,8 +1372,8 @@ pure fn utf16_chars(v: &[const u16], f: fn(char)) { } -pure fn from_utf16(v: &[const u16]) -> str { - let mut buf = ""; +pure fn from_utf16(v: &[const u16]) -> ~str { + let mut buf = ~""; unchecked { reserve(buf, vec::len(v)); utf16_chars(v, |ch| push_char(buf, ch)); @@ -1395,7 +1395,7 @@ pure fn from_utf16(v: &[const u16]) -> str { * * The number of Unicode characters in `s` between the given indices. */ -pure fn count_chars(s: str/&, start: uint, end: uint) -> uint { +pure fn count_chars(s: &str, start: uint, end: uint) -> uint { assert is_char_boundary(s, start); assert is_char_boundary(s, end); let mut i = start, len = 0u; @@ -1408,7 +1408,7 @@ pure fn count_chars(s: str/&, start: uint, end: uint) -> uint { } /// Counts the number of bytes taken by the `n` in `s` starting from `start`. -pure fn count_bytes(s: str/&b, start: uint, n: uint) -> uint { +pure fn count_bytes(s: &b/str, start: uint, n: uint) -> uint { assert is_char_boundary(s, start); let mut end = start, cnt = n; let l = len(s); @@ -1438,7 +1438,7 @@ pure fn utf8_char_width(b: u8) -> uint { * Returns false if the index points into the middle of a multi-byte * character sequence. */ -pure fn is_char_boundary(s: str/&, index: uint) -> bool { +pure fn is_char_boundary(s: &str, index: uint) -> bool { if index == len(s) { ret true; } let b = s[index]; ret b < 128u8 || b >= 192u8; @@ -1493,7 +1493,7 @@ pure fn is_char_boundary(s: str/&, index: uint) -> bool { * If `i` is greater than or equal to the length of the string. * If `i` is not the index of the beginning of a valid UTF-8 character. */ -pure fn char_range_at(s: str/&, i: uint) -> {ch: char, next: uint} { +pure fn char_range_at(s: &str, i: uint) -> {ch: char, next: uint} { let b0 = s[i]; let w = utf8_char_width(b0); assert (w != 0u); @@ -1516,14 +1516,14 @@ pure fn char_range_at(s: str/&, i: uint) -> {ch: char, next: uint} { } /// Pluck a character out of a string -pure fn char_at(s: str/&, i: uint) -> char { ret char_range_at(s, i).ch; } +pure fn char_at(s: &str, i: uint) -> char { ret char_range_at(s, i).ch; } /** * Given a byte position and a str, return the previous char and its position * * This function can be used to iterate over a unicode string in reverse. */ -pure fn char_range_at_reverse(ss: str/&, start: uint) +pure fn char_range_at_reverse(ss: &str, start: uint) -> {ch: char, prev: uint} { let mut prev = start; @@ -1562,7 +1562,7 @@ pure fn char_range_at_reverse(ss: str/&, start: uint) * `true` If execution proceeded correctly, `false` if it was interrupted, * that is if `it` returned `false` at any point. */ -pure fn all_between(s: str/&, start: uint, end: uint, +pure fn all_between(s: &str, start: uint, end: uint, it: fn(char) -> bool) -> bool { assert is_char_boundary(s, start); let mut i = start; @@ -1595,7 +1595,7 @@ pure fn all_between(s: str/&, start: uint, end: uint, * * `true` if `it` returns `true` for any character */ -pure fn any_between(s: str/&, start: uint, end: uint, +pure fn any_between(s: &str, start: uint, end: uint, it: fn(char) -> bool) -> bool { !all_between(s, start, end, |c| !it(c)) } @@ -1627,7 +1627,7 @@ const tag_six_b: uint = 252u; * let i = str::as_bytes("Hello World") { |bytes| vec::len(bytes) }; * ~~~ */ -pure fn as_bytes<T>(s: str, f: fn(~[u8]) -> T) -> T { +pure fn as_bytes<T>(s: ~str, f: fn(~[u8]) -> T) -> T { unsafe { let v: *~[u8] = ::unsafe::reinterpret_cast(ptr::addr_of(s)); f(*v) @@ -1640,7 +1640,7 @@ pure fn as_bytes<T>(s: str, f: fn(~[u8]) -> T) -> T { * Allows for unsafe manipulation of strings, which is useful for foreign * interop. */ -pure fn as_buf<T>(s: str, f: fn(*u8) -> T) -> T { +pure fn as_buf<T>(s: ~str, f: fn(*u8) -> T) -> T { as_bytes(s, |v| unsafe { vec::as_buf(v, f) }) } @@ -1656,7 +1656,7 @@ pure fn as_buf<T>(s: str, f: fn(*u8) -> T) -> T { * let s = str::as_buf("PATH", { |path_buf| libc::getenv(path_buf) }); * ~~~ */ -pure fn as_c_str<T>(s: str, f: fn(*libc::c_char) -> T) -> T { +pure fn as_c_str<T>(s: ~str, f: fn(*libc::c_char) -> T) -> T { as_buf(s, |buf| f(buf as *libc::c_char)) } @@ -1670,7 +1670,7 @@ pure fn as_c_str<T>(s: str, f: fn(*libc::c_char) -> T) -> T { * to full strings, or suffixes of them. */ #[inline(always)] -pure fn unpack_slice<T>(s: str/&, f: fn(*u8, uint) -> T) -> T { +pure fn unpack_slice<T>(s: &str, f: fn(*u8, uint) -> T) -> T { unsafe { let v : *(*u8,uint) = ::unsafe::reinterpret_cast(ptr::addr_of(s)); let (buf,len) = *v; @@ -1694,7 +1694,7 @@ pure fn unpack_slice<T>(s: str/&, f: fn(*u8, uint) -> T) -> T { * * s - A string * * n - The number of bytes to reserve space for */ -fn reserve(&s: str, n: uint) { +fn reserve(&s: ~str, n: uint) { if capacity(s) < n { rustrt::str_reserve_shared(s, n as size_t); } @@ -1720,7 +1720,7 @@ fn reserve(&s: str, n: uint) { * * s - A string * * n - The number of bytes to reserve space for */ -fn reserve_at_least(&s: str, n: uint) { +fn reserve_at_least(&s: ~str, n: uint) { reserve(s, uint::next_power_of_two(n + 1u) - 1u) } @@ -1728,7 +1728,7 @@ fn reserve_at_least(&s: str, n: uint) { * Returns the number of single-byte characters the string can hold without * reallocating */ -pure fn capacity(&&s: str) -> uint { +pure fn capacity(&&s: ~str) -> uint { do as_bytes(s) |buf| { let vcap = vec::capacity(buf); assert vcap > 0u; @@ -1737,8 +1737,8 @@ pure fn capacity(&&s: str) -> uint { } /// Escape each char in `s` with char::escape_default. -pure fn escape_default(s: str/&) -> str { - let mut out: str = ""; +pure fn escape_default(s: &str) -> ~str { + let mut out: ~str = ~""; unchecked { reserve_at_least(out, str::len(s)); chars_iter(s, |c| push_str(out, char::escape_default(c))); @@ -1747,8 +1747,8 @@ pure fn escape_default(s: str/&) -> str { } /// Escape each char in `s` with char::escape_unicode. -pure fn escape_unicode(s: str/&) -> str { - let mut out: str = ""; +pure fn escape_unicode(s: &str) -> ~str { + let mut out: ~str = ~""; unchecked { reserve_at_least(out, str::len(s)); chars_iter(s, |c| push_str(out, char::escape_unicode(c))); @@ -1771,7 +1771,7 @@ mod unsafe { set_len; /// Create a Rust string from a null-terminated *u8 buffer - unsafe fn from_buf(buf: *u8) -> str { + unsafe fn from_buf(buf: *u8) -> ~str { let mut curr = buf, i = 0u; while *curr != 0u8 { i += 1u; @@ -1781,7 +1781,7 @@ mod unsafe { } /// Create a Rust string from a *u8 buffer of the given length - unsafe fn from_buf_len(buf: *u8, len: uint) -> str { + unsafe fn from_buf_len(buf: *u8, len: uint) -> ~str { let mut v: ~[u8] = ~[]; vec::reserve(v, len + 1u); vec::as_buf(v, |b| ptr::memcpy(b, buf, len)); @@ -1793,12 +1793,12 @@ mod unsafe { } /// Create a Rust string from a null-terminated C string - unsafe fn from_c_str(c_str: *libc::c_char) -> str { + unsafe fn from_c_str(c_str: *libc::c_char) -> ~str { from_buf(::unsafe::reinterpret_cast(c_str)) } /// Create a Rust string from a `*c_char` buffer of the given length - unsafe fn from_c_str_len(c_str: *libc::c_char, len: uint) -> str { + unsafe fn from_c_str_len(c_str: *libc::c_char, len: uint) -> ~str { from_buf_len(::unsafe::reinterpret_cast(c_str), len) } @@ -1807,7 +1807,7 @@ mod unsafe { * * Does not verify that the vector contains valid UTF-8. */ - unsafe fn from_bytes(+v: ~[const u8]) -> str { + unsafe fn from_bytes(+v: ~[const u8]) -> ~str { unsafe { let mut vcopy = ::unsafe::transmute(v); vec::push(vcopy, 0u8); @@ -1820,7 +1820,7 @@ mod unsafe { * * Does not verify that the byte is valid UTF-8. */ - unsafe fn from_byte(u: u8) -> str { unsafe::from_bytes(~[u]) } + unsafe fn from_byte(u: u8) -> ~str { unsafe::from_bytes(~[u]) } /** * Takes a bytewise (not UTF-8) slice from a string. @@ -1832,7 +1832,7 @@ mod unsafe { * If begin is greater than end. * If end is greater than the length of the string. */ - unsafe fn slice_bytes(s: str/&, begin: uint, end: uint) -> str { + unsafe fn slice_bytes(s: &str, begin: uint, end: uint) -> ~str { do unpack_slice(s) |sbuf, n| { assert (begin <= end); assert (end <= n); @@ -1852,17 +1852,17 @@ mod unsafe { } /// Appends a byte to a string. (Not UTF-8 safe). - unsafe fn push_byte(&s: str, b: u8) { + unsafe fn push_byte(&s: ~str, b: u8) { rustrt::rust_str_push(s, b); } /// Appends a vector of bytes to a string. (Not UTF-8 safe). - unsafe fn push_bytes(&s: str, bytes: ~[u8]) { + unsafe fn push_bytes(&s: ~str, bytes: ~[u8]) { for vec::each(bytes) |byte| { rustrt::rust_str_push(s, byte); } } /// Removes the last byte from a string and returns it. (Not UTF-8 safe). - unsafe fn pop_byte(&s: str) -> u8 { + unsafe fn pop_byte(&s: ~str) -> u8 { let len = len(s); assert (len > 0u); let b = s[len - 1u]; @@ -1871,7 +1871,7 @@ mod unsafe { } /// Removes the first byte from a string and returns it. (Not UTF-8 safe). - unsafe fn shift_byte(&s: str) -> u8 { + unsafe fn shift_byte(&s: ~str) -> u8 { let len = len(s); assert (len > 0u); let b = s[0]; @@ -1880,7 +1880,7 @@ mod unsafe { } /// Sets the length of the string and adds the null terminator - unsafe fn set_len(&v: str, new_len: uint) { + unsafe fn set_len(&v: ~str, new_len: uint) { let repr: *vec::unsafe::vec_repr = ::unsafe::reinterpret_cast(v); (*repr).fill = new_len + 1u; let null = ptr::mut_offset(ptr::mut_addr_of((*repr).data), new_len); @@ -1893,7 +1893,7 @@ mod unsafe { let a = ~[65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 0u8]; let b = vec::unsafe::to_ptr(a); let c = from_buf_len(b, 3u); - assert (c == "AAA"); + assert (c == ~"AAA"); } } @@ -1903,24 +1903,24 @@ trait unique_str { fn trim() -> self; fn trim_left() -> self; fn trim_right() -> self; - pure fn +(rhs: str/&) -> self; + pure fn +(rhs: &str) -> self; } /// Extension methods for strings -impl extensions of unique_str for str { +impl extensions of unique_str for ~str { /// Returns a string with leading and trailing whitespace removed #[inline] - fn trim() -> str { trim(self) } + fn trim() -> ~str { trim(self) } /// Returns a string with leading whitespace removed #[inline] - fn trim_left() -> str { trim_left(self) } + fn trim_left() -> ~str { trim_left(self) } /// Returns a string with trailing whitespace removed #[inline] - fn trim_right() -> str { trim_right(self) } + fn trim_right() -> ~str { trim_right(self) } /// Concatenate two strings: operator version #[inline(always)] - pure fn +(rhs: str/&) -> str { + pure fn +(rhs: &str) -> ~str { append(self, rhs) } } @@ -1928,32 +1928,32 @@ impl extensions of unique_str for str { trait str_slice { fn all(it: fn(char) -> bool) -> bool; fn any(it: fn(char) -> bool) -> bool; - fn contains(needle: str/&a) -> bool; + fn contains(needle: &a/str) -> bool; fn contains_char(needle: char) -> bool; fn each(it: fn(u8) -> bool); fn eachi(it: fn(uint, u8) -> bool); fn each_char(it: fn(char) -> bool); fn each_chari(it: fn(uint, char) -> bool); - fn ends_with(needle: str/&) -> bool; + fn ends_with(needle: &str) -> bool; fn is_empty() -> bool; fn is_not_empty() -> bool; fn is_whitespace() -> bool; fn is_alphanumeric() -> bool; pure fn len() -> uint; - fn slice(begin: uint, end: uint) -> str; - fn split(sepfn: fn(char) -> bool) -> ~[str]; - fn split_char(sep: char) -> ~[str]; - fn split_str(sep: str/&a) -> ~[str]; - fn starts_with(needle: str/&a) -> bool; - fn substr(begin: uint, n: uint) -> str; - fn to_lower() -> str; - fn to_upper() -> str; - fn escape_default() -> str; - fn escape_unicode() -> str; + fn slice(begin: uint, end: uint) -> ~str; + fn split(sepfn: fn(char) -> bool) -> ~[~str]; + fn split_char(sep: char) -> ~[~str]; + fn split_str(sep: &a/str) -> ~[~str]; + fn starts_with(needle: &a/str) -> bool; + fn substr(begin: uint, n: uint) -> ~str; + fn to_lower() -> ~str; + fn to_upper() -> ~str; + fn escape_default() -> ~str; + fn escape_unicode() -> ~str; } /// Extension methods for strings -impl extensions/& of str_slice for str/& { +impl extensions/& of str_slice for &str { /** * Return true if a predicate matches all characters or if the string * contains no characters @@ -1968,7 +1968,7 @@ impl extensions/& of str_slice for str/& { fn any(it: fn(char) -> bool) -> bool { any(self, it) } /// Returns true if one string contains another #[inline] - fn contains(needle: str/&a) -> bool { contains(self, needle) } + fn contains(needle: &a/str) -> bool { contains(self, needle) } /// Returns true if a string contains a char #[inline] fn contains_char(needle: char) -> bool { contains_char(self, needle) } @@ -1986,7 +1986,7 @@ impl extensions/& of str_slice for str/& { fn each_chari(it: fn(uint, char) -> bool) { each_chari(self, it) } /// Returns true if one string ends with another #[inline] - fn ends_with(needle: str/&) -> bool { ends_with(self, needle) } + fn ends_with(needle: &str) -> bool { ends_with(self, needle) } /// Returns true if the string has length 0 #[inline] fn is_empty() -> bool { is_empty(self) } @@ -2018,24 +2018,24 @@ impl extensions/& of str_slice for str/& { * beyond the last character of the string */ #[inline] - fn slice(begin: uint, end: uint) -> str { slice(self, begin, end) } + fn slice(begin: uint, end: uint) -> ~str { slice(self, begin, end) } /// Splits a string into substrings using a character function #[inline] - fn split(sepfn: fn(char) -> bool) -> ~[str] { split(self, sepfn) } + fn split(sepfn: fn(char) -> bool) -> ~[~str] { split(self, sepfn) } /** * Splits a string into substrings at each occurrence of a given character */ #[inline] - fn split_char(sep: char) -> ~[str] { split_char(self, sep) } + fn split_char(sep: char) -> ~[~str] { split_char(self, sep) } /** * Splits a string into a vector of the substrings separated by a given * string */ #[inline] - fn split_str(sep: str/&a) -> ~[str] { split_str(self, sep) } + fn split_str(sep: &a/str) -> ~[~str] { split_str(self, sep) } /// Returns true if one string starts with another #[inline] - fn starts_with(needle: str/&a) -> bool { starts_with(self, needle) } + fn starts_with(needle: &a/str) -> bool { starts_with(self, needle) } /** * Take a substring of another. * @@ -2043,19 +2043,19 @@ impl extensions/& of str_slice for str/& { * `begin`. */ #[inline] - fn substr(begin: uint, n: uint) -> str { substr(self, begin, n) } + fn substr(begin: uint, n: uint) -> ~str { substr(self, begin, n) } /// Convert a string to lowercase #[inline] - fn to_lower() -> str { to_lower(self) } + fn to_lower() -> ~str { to_lower(self) } /// Convert a string to uppercase #[inline] - fn to_upper() -> str { to_upper(self) } + fn to_upper() -> ~str { to_upper(self) } /// Escape each char in `s` with char::escape_default. #[inline] - fn escape_default() -> str { escape_default(self) } + fn escape_default() -> ~str { escape_default(self) } /// Escape each char in `s` with char::escape_unicode. #[inline] - fn escape_unicode() -> str { escape_unicode(self) } + fn escape_unicode() -> ~str { escape_unicode(self) } } #[cfg(test)] @@ -2065,61 +2065,61 @@ mod tests { #[test] fn test_eq() { - assert (eq("", "")); - assert (eq("foo", "foo")); - assert (!eq("foo", "bar")); + assert (eq(~"", ~"")); + assert (eq(~"foo", ~"foo")); + assert (!eq(~"foo", ~"bar")); } #[test] fn test_le() { - assert (le("", "")); - assert (le("", "foo")); - assert (le("foo", "foo")); - assert (!eq("foo", "bar")); + assert (le(~"", ~"")); + assert (le(~"", ~"foo")); + assert (le(~"foo", ~"foo")); + assert (!eq(~"foo", ~"bar")); } #[test] fn test_len() { - assert (len("") == 0u); - assert (len("hello world") == 11u); - assert (len("\x63") == 1u); - assert (len("\xa2") == 2u); - assert (len("\u03c0") == 2u); - assert (len("\u2620") == 3u); - assert (len("\U0001d11e") == 4u); + assert (len(~"") == 0u); + assert (len(~"hello world") == 11u); + assert (len(~"\x63") == 1u); + assert (len(~"\xa2") == 2u); + assert (len(~"\u03c0") == 2u); + assert (len(~"\u2620") == 3u); + assert (len(~"\U0001d11e") == 4u); - assert (char_len("") == 0u); - assert (char_len("hello world") == 11u); - assert (char_len("\x63") == 1u); - assert (char_len("\xa2") == 1u); - assert (char_len("\u03c0") == 1u); - assert (char_len("\u2620") == 1u); - assert (char_len("\U0001d11e") == 1u); - assert (char_len("ประเทศไทย中华Việt Nam") == 19u); + assert (char_len(~"") == 0u); + assert (char_len(~"hello world") == 11u); + assert (char_len(~"\x63") == 1u); + assert (char_len(~"\xa2") == 1u); + assert (char_len(~"\u03c0") == 1u); + assert (char_len(~"\u2620") == 1u); + assert (char_len(~"\U0001d11e") == 1u); + assert (char_len(~"ประเทศไทย中华Việt Nam") == 19u); } #[test] fn test_rfind_char() { - assert rfind_char("hello", 'l') == some(3u); - assert rfind_char("hello", 'o') == some(4u); - assert rfind_char("hello", 'h') == some(0u); - assert rfind_char("hello", 'z') == none; - assert rfind_char("ประเทศไทย中华Việt Nam", '华') == some(30u); + assert rfind_char(~"hello", 'l') == some(3u); + assert rfind_char(~"hello", 'o') == some(4u); + assert rfind_char(~"hello", 'h') == some(0u); + assert rfind_char(~"hello", 'z') == none; + assert rfind_char(~"ประเทศไทย中华Việt Nam", '华') == some(30u); } #[test] fn test_pop_char() { - let mut data = "ประเทศไทย中华"; + let mut data = ~"ประเทศไทย中华"; let cc = pop_char(data); - assert "ประเทศไทย中" == data; + assert ~"ประเทศไทย中" == data; assert '华' == cc; } #[test] fn test_pop_char_2() { - let mut data2 = "华"; + let mut data2 = ~"华"; let cc2 = pop_char(data2); - assert "" == data2; + assert ~"" == data2; assert '华' == cc2; } @@ -2127,247 +2127,248 @@ mod tests { #[should_fail] #[ignore(cfg(windows))] fn test_pop_char_fail() { - let mut data = ""; + let mut data = ~""; let _cc3 = pop_char(data); } #[test] fn test_split_char() { - fn t(s: str, c: char, u: ~[str]) { - log(debug, "split_byte: " + s); + fn t(s: ~str, c: char, u: ~[~str]) { + log(debug, ~"split_byte: " + s); let v = split_char(s, c); #debug("split_byte to: %?", v); assert vec::all2(v, u, |a,b| a == b); } - t("abc.hello.there", '.', ~["abc", "hello", "there"]); - t(".hello.there", '.', ~["", "hello", "there"]); - t("...hello.there.", '.', ~["", "", "", "hello", "there", ""]); + t(~"abc.hello.there", '.', ~[~"abc", ~"hello", ~"there"]); + t(~".hello.there", '.', ~[~"", ~"hello", ~"there"]); + t(~"...hello.there.", '.', ~[~"", ~"", ~"", ~"hello", ~"there", ~""]); - assert ~["", "", "", "hello", "there", ""] - == split_char("...hello.there.", '.'); + assert ~[~"", ~"", ~"", ~"hello", ~"there", ~""] + == split_char(~"...hello.there.", '.'); - assert ~[""] == split_char("", 'z'); - assert ~["",""] == split_char("z", 'z'); - assert ~["ok"] == split_char("ok", 'z'); + assert ~[~""] == split_char(~"", 'z'); + assert ~[~"",~""] == split_char(~"z", 'z'); + assert ~[~"ok"] == split_char(~"ok", 'z'); } #[test] fn test_split_char_2() { - let data = "ประเทศไทย中华Việt Nam"; - assert ~["ประเทศไทย中华", "iệt Nam"] + let data = ~"ประเทศไทย中华Việt Nam"; + assert ~[~"ประเทศไทย中华", ~"iệt Nam"] == split_char(data, 'V'); - assert ~["ประเ", "ศไ", "ย中华Việt Nam"] + assert ~[~"ประเ", ~"ศไ", ~"ย中华Việt Nam"] == split_char(data, 'ท'); } #[test] fn test_splitn_char() { - fn t(s: str, c: char, n: uint, u: ~[str]) { - log(debug, "splitn_byte: " + s); + fn t(s: ~str, c: char, n: uint, u: ~[~str]) { + log(debug, ~"splitn_byte: " + s); let v = splitn_char(s, c, n); #debug("split_byte to: %?", v); #debug("comparing vs. %?", u); assert vec::all2(v, u, |a,b| a == b); } - t("abc.hello.there", '.', 0u, ~["abc.hello.there"]); - t("abc.hello.there", '.', 1u, ~["abc", "hello.there"]); - t("abc.hello.there", '.', 2u, ~["abc", "hello", "there"]); - t("abc.hello.there", '.', 3u, ~["abc", "hello", "there"]); - t(".hello.there", '.', 0u, ~[".hello.there"]); - t(".hello.there", '.', 1u, ~["", "hello.there"]); - t("...hello.there.", '.', 3u, ~["", "", "", "hello.there."]); - t("...hello.there.", '.', 5u, ~["", "", "", "hello", "there", ""]); + t(~"abc.hello.there", '.', 0u, ~[~"abc.hello.there"]); + t(~"abc.hello.there", '.', 1u, ~[~"abc", ~"hello.there"]); + t(~"abc.hello.there", '.', 2u, ~[~"abc", ~"hello", ~"there"]); + t(~"abc.hello.there", '.', 3u, ~[~"abc", ~"hello", ~"there"]); + t(~".hello.there", '.', 0u, ~[~".hello.there"]); + t(~".hello.there", '.', 1u, ~[~"", ~"hello.there"]); + t(~"...hello.there.", '.', 3u, ~[~"", ~"", ~"", ~"hello.there."]); + t(~"...hello.there.", '.', 5u, + ~[~"", ~"", ~"", ~"hello", ~"there", ~""]); - assert ~[""] == splitn_char("", 'z', 5u); - assert ~["",""] == splitn_char("z", 'z', 5u); - assert ~["ok"] == splitn_char("ok", 'z', 5u); - assert ~["z"] == splitn_char("z", 'z', 0u); - assert ~["w.x.y"] == splitn_char("w.x.y", '.', 0u); - assert ~["w","x.y"] == splitn_char("w.x.y", '.', 1u); + assert ~[~""] == splitn_char(~"", 'z', 5u); + assert ~[~"",~""] == splitn_char(~"z", 'z', 5u); + assert ~[~"ok"] == splitn_char(~"ok", 'z', 5u); + assert ~[~"z"] == splitn_char(~"z", 'z', 0u); + assert ~[~"w.x.y"] == splitn_char(~"w.x.y", '.', 0u); + assert ~[~"w",~"x.y"] == splitn_char(~"w.x.y", '.', 1u); } #[test] fn test_splitn_char_2 () { - let data = "ประเทศไทย中华Việt Nam"; - assert ~["ประเทศไทย中", "Việt Nam"] + let data = ~"ประเทศไทย中华Việt Nam"; + assert ~[~"ประเทศไทย中", ~"Việt Nam"] == splitn_char(data, '华', 1u); - assert ~["", "", "XXX", "YYYzWWWz"] - == splitn_char("zzXXXzYYYzWWWz", 'z', 3u); - assert ~["",""] == splitn_char("z", 'z', 5u); - assert ~[""] == splitn_char("", 'z', 5u); - assert ~["ok"] == splitn_char("ok", 'z', 5u); + assert ~[~"", ~"", ~"XXX", ~"YYYzWWWz"] + == splitn_char(~"zzXXXzYYYzWWWz", 'z', 3u); + assert ~[~"",~""] == splitn_char(~"z", 'z', 5u); + assert ~[~""] == splitn_char(~"", 'z', 5u); + assert ~[~"ok"] == splitn_char(~"ok", 'z', 5u); } #[test] fn test_splitn_char_3() { - let data = "ประเทศไทย中华Việt Nam"; - assert ~["ประเทศไทย中华", "iệt Nam"] + let data = ~"ประเทศไทย中华Việt Nam"; + assert ~[~"ประเทศไทย中华", ~"iệt Nam"] == splitn_char(data, 'V', 1u); - assert ~["ประเ", "ศไทย中华Việt Nam"] + assert ~[~"ประเ", ~"ศไทย中华Việt Nam"] == splitn_char(data, 'ท', 1u); } #[test] fn test_split_str() { - fn t(s: str, sep: str/&a, i: int, k: str) { + fn t(s: ~str, sep: &a/str, i: int, k: ~str) { let v = split_str(s, sep); assert eq(v[i], k); } - t("--1233345--", "12345", 0, "--1233345--"); - t("abc::hello::there", "::", 0, "abc"); - t("abc::hello::there", "::", 1, "hello"); - t("abc::hello::there", "::", 2, "there"); - t("::hello::there", "::", 0, ""); - t("hello::there::", "::", 2, ""); - t("::hello::there::", "::", 3, ""); + t(~"--1233345--", ~"12345", 0, ~"--1233345--"); + t(~"abc::hello::there", ~"::", 0, ~"abc"); + t(~"abc::hello::there", ~"::", 1, ~"hello"); + t(~"abc::hello::there", ~"::", 2, ~"there"); + t(~"::hello::there", ~"::", 0, ~""); + t(~"hello::there::", ~"::", 2, ~""); + t(~"::hello::there::", ~"::", 3, ~""); - let data = "ประเทศไทย中华Việt Nam"; - assert ~["ประเทศไทย", "Việt Nam"] - == split_str (data, "中华"); + let data = ~"ประเทศไทย中华Việt Nam"; + assert ~[~"ประเทศไทย", ~"Việt Nam"] + == split_str (data, ~"中华"); - assert ~["", "XXX", "YYY", ""] - == split_str("zzXXXzzYYYzz", "zz"); + assert ~[~"", ~"XXX", ~"YYY", ~""] + == split_str(~"zzXXXzzYYYzz", ~"zz"); - assert ~["zz", "zYYYz"] - == split_str("zzXXXzYYYz", "XXX"); + assert ~[~"zz", ~"zYYYz"] + == split_str(~"zzXXXzYYYz", ~"XXX"); - assert ~["", "XXX", "YYY", ""] == split_str(".XXX.YYY.", "."); - assert ~[""] == split_str("", "."); - assert ~["",""] == split_str("zz", "zz"); - assert ~["ok"] == split_str("ok", "z"); - assert ~["","z"] == split_str("zzz", "zz"); - assert ~["","","z"] == split_str("zzzzz", "zz"); + assert ~[~"", ~"XXX", ~"YYY", ~""] == split_str(~".XXX.YYY.", ~"."); + assert ~[~""] == split_str(~"", ~"."); + assert ~[~"",~""] == split_str(~"zz", ~"zz"); + assert ~[~"ok"] == split_str(~"ok", ~"z"); + assert ~[~"",~"z"] == split_str(~"zzz", ~"zz"); + assert ~[~"",~"",~"z"] == split_str(~"zzzzz", ~"zz"); } #[test] fn test_split() { - let data = "ประเทศไทย中华Việt Nam"; - assert ~["ประเทศไทย中", "Việt Nam"] + let data = ~"ประเทศไทย中华Việt Nam"; + assert ~[~"ประเทศไทย中", ~"Việt Nam"] == split (data, |cc| cc == '华'); - assert ~["", "", "XXX", "YYY", ""] - == split("zzXXXzYYYz", char::is_lowercase); + assert ~[~"", ~"", ~"XXX", ~"YYY", ~""] + == split(~"zzXXXzYYYz", char::is_lowercase); - assert ~["zz", "", "", "z", "", "", "z"] - == split("zzXXXzYYYz", char::is_uppercase); + assert ~[~"zz", ~"", ~"", ~"z", ~"", ~"", ~"z"] + == split(~"zzXXXzYYYz", char::is_uppercase); - assert ~["",""] == split("z", |cc| cc == 'z'); - assert ~[""] == split("", |cc| cc == 'z'); - assert ~["ok"] == split("ok", |cc| cc == 'z'); + assert ~[~"",~""] == split(~"z", |cc| cc == 'z'); + assert ~[~""] == split(~"", |cc| cc == 'z'); + assert ~[~"ok"] == split(~"ok", |cc| cc == 'z'); } #[test] fn test_lines() { - let lf = "\nMary had a little lamb\nLittle lamb\n"; - let crlf = "\r\nMary had a little lamb\r\nLittle lamb\r\n"; + let lf = ~"\nMary had a little lamb\nLittle lamb\n"; + let crlf = ~"\r\nMary had a little lamb\r\nLittle lamb\r\n"; - assert ~["", "Mary had a little lamb", "Little lamb", ""] + assert ~[~"", ~"Mary had a little lamb", ~"Little lamb", ~""] == lines(lf); - assert ~["", "Mary had a little lamb", "Little lamb", ""] + assert ~[~"", ~"Mary had a little lamb", ~"Little lamb", ~""] == lines_any(lf); - assert ~["\r", "Mary had a little lamb\r", "Little lamb\r", ""] + assert ~[~"\r", ~"Mary had a little lamb\r", ~"Little lamb\r", ~""] == lines(crlf); - assert ~["", "Mary had a little lamb", "Little lamb", ""] + assert ~[~"", ~"Mary had a little lamb", ~"Little lamb", ~""] == lines_any(crlf); - assert ~[""] == lines (""); - assert ~[""] == lines_any(""); - assert ~["",""] == lines ("\n"); - assert ~["",""] == lines_any("\n"); - assert ~["banana"] == lines ("banana"); - assert ~["banana"] == lines_any("banana"); + assert ~[~""] == lines (~""); + assert ~[~""] == lines_any(~""); + assert ~[~"",~""] == lines (~"\n"); + assert ~[~"",~""] == lines_any(~"\n"); + assert ~[~"banana"] == lines (~"banana"); + assert ~[~"banana"] == lines_any(~"banana"); } #[test] fn test_words () { - let data = "\nMary had a little lamb\nLittle lamb\n"; - assert ~["Mary","had","a","little","lamb","Little","lamb"] + let data = ~"\nMary had a little lamb\nLittle lamb\n"; + assert ~[~"Mary",~"had",~"a",~"little",~"lamb",~"Little",~"lamb"] == words(data); - assert ~["ok"] == words("ok"); - assert ~[] == words(""); + assert ~[~"ok"] == words(~"ok"); + assert ~[] == words(~""); } #[test] fn test_find_str() { // byte positions - assert find_str("banana", "apple pie") == none; - assert find_str("", "") == some(0u); + assert find_str(~"banana", ~"apple pie") == none; + assert find_str(~"", ~"") == some(0u); - let data = "ประเทศไทย中华Việt Nam"; - assert find_str(data, "") == some(0u); - assert find_str(data, "ประเ") == some( 0u); - assert find_str(data, "ะเ") == some( 6u); - assert find_str(data, "中华") == some(27u); - assert find_str(data, "ไท华") == none; + let data = ~"ประเทศไทย中华Việt Nam"; + assert find_str(data, ~"") == some(0u); + assert find_str(data, ~"ประเ") == some( 0u); + assert find_str(data, ~"ะเ") == some( 6u); + assert find_str(data, ~"中华") == some(27u); + assert find_str(data, ~"ไท华") == none; } #[test] fn test_find_str_between() { // byte positions - assert find_str_between("", "", 0u, 0u) == some(0u); + assert find_str_between(~"", ~"", 0u, 0u) == some(0u); - let data = "abcabc"; - assert find_str_between(data, "ab", 0u, 6u) == some(0u); - assert find_str_between(data, "ab", 2u, 6u) == some(3u); - assert find_str_between(data, "ab", 2u, 4u) == none; + let data = ~"abcabc"; + assert find_str_between(data, ~"ab", 0u, 6u) == some(0u); + assert find_str_between(data, ~"ab", 2u, 6u) == some(3u); + assert find_str_between(data, ~"ab", 2u, 4u) == none; - let mut data = "ประเทศไทย中华Việt Nam"; + let mut data = ~"ประเทศไทย中华Việt Nam"; data += data; - assert find_str_between(data, "", 0u, 43u) == some(0u); - assert find_str_between(data, "", 6u, 43u) == some(6u); + assert find_str_between(data, ~"", 0u, 43u) == some(0u); + assert find_str_between(data, ~"", 6u, 43u) == some(6u); - assert find_str_between(data, "ประ", 0u, 43u) == some( 0u); - assert find_str_between(data, "ทศไ", 0u, 43u) == some(12u); - assert find_str_between(data, "ย中", 0u, 43u) == some(24u); - assert find_str_between(data, "iệt", 0u, 43u) == some(34u); - assert find_str_between(data, "Nam", 0u, 43u) == some(40u); + assert find_str_between(data, ~"ประ", 0u, 43u) == some( 0u); + assert find_str_between(data, ~"ทศไ", 0u, 43u) == some(12u); + assert find_str_between(data, ~"ย中", 0u, 43u) == some(24u); + assert find_str_between(data, ~"iệt", 0u, 43u) == some(34u); + assert find_str_between(data, ~"Nam", 0u, 43u) == some(40u); - assert find_str_between(data, "ประ", 43u, 86u) == some(43u); - assert find_str_between(data, "ทศไ", 43u, 86u) == some(55u); - assert find_str_between(data, "ย中", 43u, 86u) == some(67u); - assert find_str_between(data, "iệt", 43u, 86u) == some(77u); - assert find_str_between(data, "Nam", 43u, 86u) == some(83u); + assert find_str_between(data, ~"ประ", 43u, 86u) == some(43u); + assert find_str_between(data, ~"ทศไ", 43u, 86u) == some(55u); + assert find_str_between(data, ~"ย中", 43u, 86u) == some(67u); + assert find_str_between(data, ~"iệt", 43u, 86u) == some(77u); + assert find_str_between(data, ~"Nam", 43u, 86u) == some(83u); } #[test] fn test_substr() { - fn t(a: str, b: str, start: int) { + fn t(a: ~str, b: ~str, start: int) { assert (eq(substr(a, start as uint, len(b)), b)); } - t("hello", "llo", 2); - t("hello", "el", 1); - assert "ะเทศไท" == substr("ประเทศไทย中华Việt Nam", 6u, 6u); + t(~"hello", ~"llo", 2); + t(~"hello", ~"el", 1); + assert ~"ะเทศไท" == substr(~"ประเทศไทย中华Việt Nam", 6u, 6u); } #[test] fn test_concat() { - fn t(v: ~[str], s: str) { assert (eq(concat(v), s)); } - t(~["you", "know", "I'm", "no", "good"], "youknowI'mnogood"); - let v: ~[str] = ~[]; - t(v, ""); - t(~["hi"], "hi"); + fn t(v: ~[~str], s: ~str) { assert (eq(concat(v), s)); } + t(~[~"you", ~"know", ~"I'm", ~"no", ~"good"], ~"youknowI'mnogood"); + let v: ~[~str] = ~[]; + t(v, ~""); + t(~[~"hi"], ~"hi"); } #[test] fn test_connect() { - fn t(v: ~[str], sep: str, s: str) { + fn t(v: ~[~str], sep: ~str, s: ~str) { assert (eq(connect(v, sep), s)); } - t(~["you", "know", "I'm", "no", "good"], - " ", "you know I'm no good"); - let v: ~[str] = ~[]; - t(v, " ", ""); - t(~["hi"], " ", "hi"); + t(~[~"you", ~"know", ~"I'm", ~"no", ~"good"], + ~" ", ~"you know I'm no good"); + let v: ~[~str] = ~[]; + t(v, ~" ", ~""); + t(~[~"hi"], ~" ", ~"hi"); } #[test] @@ -2375,36 +2376,36 @@ mod tests { // libc::toupper, and hence str::to_upper // are culturally insensitive: they only work for ASCII // (see Issue #1347) - let unicode = ""; //"\u65e5\u672c"; // uncomment once non-ASCII works - let input = "abcDEF" + unicode + "xyz:.;"; - let expected = "ABCDEF" + unicode + "XYZ:.;"; + let unicode = ~""; //"\u65e5\u672c"; // uncomment once non-ASCII works + let input = ~"abcDEF" + unicode + ~"xyz:.;"; + let expected = ~"ABCDEF" + unicode + ~"XYZ:.;"; let actual = to_upper(input); assert (eq(expected, actual)); } #[test] fn test_to_lower() { - assert "" == map("", |c| libc::tolower(c as c_char) as char); - assert "ymca" == map("YMCA", + assert ~"" == map(~"", |c| libc::tolower(c as c_char) as char); + assert ~"ymca" == map(~"YMCA", |c| libc::tolower(c as c_char) as char); } #[test] fn test_unsafe_slice() { unsafe { - assert (eq("ab", unsafe::slice_bytes("abc", 0u, 2u))); - assert (eq("bc", unsafe::slice_bytes("abc", 1u, 3u))); - assert (eq("", unsafe::slice_bytes("abc", 1u, 1u))); - fn a_million_letter_a() -> str { + assert (eq(~"ab", unsafe::slice_bytes(~"abc", 0u, 2u))); + assert (eq(~"bc", unsafe::slice_bytes(~"abc", 1u, 3u))); + assert (eq(~"", unsafe::slice_bytes(~"abc", 1u, 1u))); + fn a_million_letter_a() -> ~str { let mut i = 0; - let mut rs = ""; - while i < 100000 { push_str(rs, "aaaaaaaaaa"); i += 1; } + let mut rs = ~""; + while i < 100000 { push_str(rs, ~"aaaaaaaaaa"); i += 1; } ret rs; } - fn half_a_million_letter_a() -> str { + fn half_a_million_letter_a() -> ~str { let mut i = 0; - let mut rs = ""; - while i < 100000 { push_str(rs, "aaaaa"); i += 1; } + let mut rs = ~""; + while i < 100000 { push_str(rs, ~"aaaaa"); i += 1; } ret rs; } assert eq(half_a_million_letter_a(), @@ -2415,107 +2416,107 @@ mod tests { #[test] fn test_starts_with() { - assert (starts_with("", "")); - assert (starts_with("abc", "")); - assert (starts_with("abc", "a")); - assert (!starts_with("a", "abc")); - assert (!starts_with("", "abc")); + assert (starts_with(~"", ~"")); + assert (starts_with(~"abc", ~"")); + assert (starts_with(~"abc", ~"a")); + assert (!starts_with(~"a", ~"abc")); + assert (!starts_with(~"", ~"abc")); } #[test] fn test_ends_with() { - assert (ends_with("", "")); - assert (ends_with("abc", "")); - assert (ends_with("abc", "c")); - assert (!ends_with("a", "abc")); - assert (!ends_with("", "abc")); + assert (ends_with(~"", ~"")); + assert (ends_with(~"abc", ~"")); + assert (ends_with(~"abc", ~"c")); + assert (!ends_with(~"a", ~"abc")); + assert (!ends_with(~"", ~"abc")); } #[test] fn test_is_empty() { - assert (is_empty("")); - assert (!is_empty("a")); + assert (is_empty(~"")); + assert (!is_empty(~"a")); } #[test] fn test_is_not_empty() { - assert (is_not_empty("a")); - assert (!is_not_empty("")); + assert (is_not_empty(~"a")); + assert (!is_not_empty(~"")); } #[test] fn test_replace() { - let a = "a"; - assert replace("", a, "b") == ""; - assert replace("a", a, "b") == "b"; - assert replace("ab", a, "b") == "bb"; - let test = "test"; - assert replace(" test test ", test, "toast") == " toast toast "; - assert replace(" test test ", test, "") == " "; + let a = ~"a"; + assert replace(~"", a, ~"b") == ~""; + assert replace(~"a", a, ~"b") == ~"b"; + assert replace(~"ab", a, ~"b") == ~"bb"; + let test = ~"test"; + assert replace(~" test test ", test, ~"toast") == ~" toast toast "; + assert replace(~" test test ", test, ~"") == ~" "; } #[test] fn test_replace_2a() { - let data = "ประเทศไทย中华"; - let repl = "دولة الكويت"; + let data = ~"ประเทศไทย中华"; + let repl = ~"دولة الكويت"; - let a = "ประเ"; - let A = "دولة الكويتทศไทย中华"; + let a = ~"ประเ"; + let A = ~"دولة الكويتทศไทย中华"; assert (replace(data, a, repl) == A); } #[test] fn test_replace_2b() { - let data = "ประเทศไทย中华"; - let repl = "دولة الكويت"; + let data = ~"ประเทศไทย中华"; + let repl = ~"دولة الكويت"; - let b = "ะเ"; - let B = "ปรدولة الكويتทศไทย中华"; + let b = ~"ะเ"; + let B = ~"ปรدولة الكويتทศไทย中华"; assert (replace(data, b, repl) == B); } #[test] fn test_replace_2c() { - let data = "ประเทศไทย中华"; - let repl = "دولة الكويت"; + let data = ~"ประเทศไทย中华"; + let repl = ~"دولة الكويت"; - let c = "中华"; - let C = "ประเทศไทยدولة الكويت"; + let c = ~"中华"; + let C = ~"ประเทศไทยدولة الكويت"; assert (replace(data, c, repl) == C); } #[test] fn test_replace_2d() { - let data = "ประเทศไทย中华"; - let repl = "دولة الكويت"; + let data = ~"ประเทศไทย中华"; + let repl = ~"دولة الكويت"; - let d = "ไท华"; + let d = ~"ไท华"; assert (replace(data, d, repl) == data); } #[test] fn test_slice() { - assert (eq("ab", slice("abc", 0u, 2u))); - assert (eq("bc", slice("abc", 1u, 3u))); - assert (eq("", slice("abc", 1u, 1u))); - assert (eq("\u65e5", slice("\u65e5\u672c", 0u, 3u))); - - let data = "ประเทศไทย中华"; - assert "ป" == slice(data, 0u, 3u); - assert "ร" == slice(data, 3u, 6u); - assert "" == slice(data, 3u, 3u); - assert "华" == slice(data, 30u, 33u); - - fn a_million_letter_X() -> str { + assert (eq(~"ab", slice(~"abc", 0u, 2u))); + assert (eq(~"bc", slice(~"abc", 1u, 3u))); + assert (eq(~"", slice(~"abc", 1u, 1u))); + assert (eq(~"\u65e5", slice(~"\u65e5\u672c", 0u, 3u))); + + let data = ~"ประเทศไทย中华"; + assert ~"ป" == slice(data, 0u, 3u); + assert ~"ร" == slice(data, 3u, 6u); + assert ~"" == slice(data, 3u, 3u); + assert ~"华" == slice(data, 30u, 33u); + + fn a_million_letter_X() -> ~str { let mut i = 0; - let mut rs = ""; - while i < 100000 { push_str(rs, "华华华华华华华华华华"); i += 1; } + let mut rs = ~""; + while i < 100000 { push_str(rs, ~"华华华华华华华华华华"); i += 1; } ret rs; } - fn half_a_million_letter_X() -> str { + fn half_a_million_letter_X() -> ~str { let mut i = 0; - let mut rs = ""; - while i < 100000 { push_str(rs, "华华华华华"); i += 1; } + let mut rs = ~""; + while i < 100000 { push_str(rs, ~"华华华华华"); i += 1; } ret rs; } assert eq(half_a_million_letter_X(), @@ -2524,18 +2525,18 @@ mod tests { #[test] fn test_slice_2() { - let ss = "中华Việt Nam"; + let ss = ~"中华Việt Nam"; - assert "华" == slice(ss, 3u, 6u); - assert "Việt Nam" == slice(ss, 6u, 16u); + assert ~"华" == slice(ss, 3u, 6u); + assert ~"Việt Nam" == slice(ss, 6u, 16u); - assert "ab" == slice("abc", 0u, 2u); - assert "bc" == slice("abc", 1u, 3u); - assert "" == slice("abc", 1u, 1u); + assert ~"ab" == slice(~"abc", 0u, 2u); + assert ~"bc" == slice(~"abc", 1u, 3u); + assert ~"" == slice(~"abc", 1u, 1u); - assert "中" == slice(ss, 0u, 3u); - assert "华V" == slice(ss, 3u, 7u); - assert "" == slice(ss, 3u, 3u); + assert ~"中" == slice(ss, 0u, 3u); + assert ~"华V" == slice(ss, 3u, 7u); + assert ~"" == slice(ss, 3u, 3u); /*0: 中 3: 华 6: V @@ -2552,68 +2553,68 @@ mod tests { #[should_fail] #[ignore(cfg(windows))] fn test_slice_fail() { - slice("中华Việt Nam", 0u, 2u); + slice(~"中华Việt Nam", 0u, 2u); } #[test] fn test_trim_left() { - assert (trim_left("") == ""); - assert (trim_left("a") == "a"); - assert (trim_left(" ") == ""); - assert (trim_left(" blah") == "blah"); - assert (trim_left(" \u3000 wut") == "wut"); - assert (trim_left("hey ") == "hey "); + assert (trim_left(~"") == ~""); + assert (trim_left(~"a") == ~"a"); + assert (trim_left(~" ") == ~""); + assert (trim_left(~" blah") == ~"blah"); + assert (trim_left(~" \u3000 wut") == ~"wut"); + assert (trim_left(~"hey ") == ~"hey "); } #[test] fn test_trim_right() { - assert (trim_right("") == ""); - assert (trim_right("a") == "a"); - assert (trim_right(" ") == ""); - assert (trim_right("blah ") == "blah"); - assert (trim_right("wut \u3000 ") == "wut"); - assert (trim_right(" hey") == " hey"); + assert (trim_right(~"") == ~""); + assert (trim_right(~"a") == ~"a"); + assert (trim_right(~" ") == ~""); + assert (trim_right(~"blah ") == ~"blah"); + assert (trim_right(~"wut \u3000 ") == ~"wut"); + assert (trim_right(~" hey") == ~" hey"); } #[test] fn test_trim() { - assert (trim("") == ""); - assert (trim("a") == "a"); - assert (trim(" ") == ""); - assert (trim(" blah ") == "blah"); - assert (trim("\nwut \u3000 ") == "wut"); - assert (trim(" hey dude ") == "hey dude"); + assert (trim(~"") == ~""); + assert (trim(~"a") == ~"a"); + assert (trim(~" ") == ~""); + assert (trim(~" blah ") == ~"blah"); + assert (trim(~"\nwut \u3000 ") == ~"wut"); + assert (trim(~" hey dude ") == ~"hey dude"); } #[test] fn test_is_whitespace() { - assert (is_whitespace("")); - assert (is_whitespace(" ")); - assert (is_whitespace("\u2009")); // Thin space - assert (is_whitespace(" \n\t ")); - assert (!is_whitespace(" _ ")); + assert (is_whitespace(~"")); + assert (is_whitespace(~" ")); + assert (is_whitespace(~"\u2009")); // Thin space + assert (is_whitespace(~" \n\t ")); + assert (!is_whitespace(~" _ ")); } #[test] fn test_is_ascii() { - assert (is_ascii("")); - assert (is_ascii("a")); - assert (!is_ascii("\u2009")); + assert (is_ascii(~"")); + assert (is_ascii(~"a")); + assert (!is_ascii(~"\u2009")); } #[test] fn test_shift_byte() { - let mut s = "ABC"; + let mut s = ~"ABC"; let b = unsafe { unsafe::shift_byte(s) }; - assert (s == "BC"); + assert (s == ~"BC"); assert (b == 65u8); } #[test] fn test_pop_byte() { - let mut s = "ABC"; + let mut s = ~"ABC"; let b = unsafe { unsafe::pop_byte(s) }; - assert (s == "AB"); + assert (s == ~"AB"); assert (b == 67u8); } @@ -2621,12 +2622,12 @@ mod tests { fn test_unsafe_from_bytes() { let a = ~[65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8]; let b = unsafe { unsafe::from_bytes(a) }; - assert (b == "AAAAAAA"); + assert (b == ~"AAAAAAA"); } #[test] fn test_from_bytes() { - let ss = "ศไทย中华Việt Nam"; + let ss = ~"ศไทย中华Việt Nam"; let bb = ~[0xe0_u8, 0xb8_u8, 0xa8_u8, 0xe0_u8, 0xb9_u8, 0x84_u8, 0xe0_u8, 0xb8_u8, 0x97_u8, @@ -2665,7 +2666,7 @@ mod tests { let a = ~[65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 0u8]; let b = vec::unsafe::to_ptr(a); let c = unsafe::from_buf(b); - assert (c == "AAAAAAA"); + assert (c == ~"AAAAAAA"); } } @@ -2674,12 +2675,12 @@ mod tests { #[should_fail] fn test_as_bytes_fail() { // Don't double free - as_bytes::<()>("", |_bytes| fail ); + as_bytes::<()>(~"", |_bytes| fail ); } #[test] fn test_as_buf() { - let a = "Abcdefg"; + let a = ~"Abcdefg"; let b = as_buf(a, |buf| { assert unsafe { *buf } == 65u8; 100 @@ -2689,7 +2690,7 @@ mod tests { #[test] fn test_as_buf_small() { - let a = "A"; + let a = ~"A"; let b = as_buf(a, |buf| { assert unsafe { *buf } == 65u8; 100 @@ -2700,7 +2701,7 @@ mod tests { #[test] fn test_as_buf2() { unsafe { - let s = "hello"; + let s = ~"hello"; let sb = as_buf(s, |b| b); let s_cstr = unsafe::from_buf(sb); assert (eq(s_cstr, s)); @@ -2709,10 +2710,10 @@ mod tests { #[test] fn vec_str_conversions() { - let s1: str = "All mimsy were the borogoves"; + let s1: ~str = ~"All mimsy were the borogoves"; let v: ~[u8] = bytes(s1); - let s2: str = from_bytes(v); + let s2: ~str = from_bytes(v); let mut i: uint = 0u; let n1: uint = len(s1); let n2: uint = vec::len::<u8>(v); @@ -2729,33 +2730,33 @@ mod tests { #[test] fn test_contains() { - assert contains("abcde", "bcd"); - assert contains("abcde", "abcd"); - assert contains("abcde", "bcde"); - assert contains("abcde", ""); - assert contains("", ""); - assert !contains("abcde", "def"); - assert !contains("", "a"); + assert contains(~"abcde", ~"bcd"); + assert contains(~"abcde", ~"abcd"); + assert contains(~"abcde", ~"bcde"); + assert contains(~"abcde", ~""); + assert contains(~"", ~""); + assert !contains(~"abcde", ~"def"); + assert !contains(~"", ~"a"); - let data = "ประเทศไทย中华Việt Nam"; - assert contains(data, "ประเ"); - assert contains(data, "ะเ"); - assert contains(data, "中华"); - assert !contains(data, "ไท华"); + let data = ~"ประเทศไทย中华Việt Nam"; + assert contains(data, ~"ประเ"); + assert contains(data, ~"ะเ"); + assert contains(data, ~"中华"); + assert !contains(data, ~"ไท华"); } #[test] fn test_contains_char() { - assert contains_char("abc", 'b'); - assert contains_char("a", 'a'); - assert !contains_char("abc", 'd'); - assert !contains_char("", 'a'); + assert contains_char(~"abc", 'b'); + assert contains_char(~"a", 'a'); + assert !contains_char(~"abc", 'd'); + assert !contains_char(~"", 'a'); } #[test] fn test_chars_iter() { let mut i = 0; - do chars_iter("x\u03c0y") |ch| { + do chars_iter(~"x\u03c0y") |ch| { alt check i { 0 { assert ch == 'x'; } 1 { assert ch == '\u03c0'; } @@ -2764,14 +2765,14 @@ mod tests { i += 1; } - chars_iter("", |_ch| fail ); // should not fail + chars_iter(~"", |_ch| fail ); // should not fail } #[test] fn test_bytes_iter() { let mut i = 0; - do bytes_iter("xyz") |bb| { + do bytes_iter(~"xyz") |bb| { alt check i { 0 { assert bb == 'x' as u8; } 1 { assert bb == 'y' as u8; } @@ -2780,21 +2781,21 @@ mod tests { i += 1; } - bytes_iter("", |bb| assert bb == 0u8); + bytes_iter(~"", |bb| assert bb == 0u8); } #[test] fn test_split_char_iter() { - let data = "\nMary had a little lamb\nLittle lamb\n"; + let data = ~"\nMary had a little lamb\nLittle lamb\n"; let mut ii = 0; do split_char_iter(data, ' ') |xx| { alt ii { - 0 { assert "\nMary" == xx; } - 1 { assert "had" == xx; } - 2 { assert "a" == xx; } - 3 { assert "little" == xx; } + 0 { assert ~"\nMary" == xx; } + 1 { assert ~"had" == xx; } + 2 { assert ~"a" == xx; } + 3 { assert ~"little" == xx; } _ { () } } ii += 1; @@ -2803,15 +2804,15 @@ mod tests { #[test] fn test_splitn_char_iter() { - let data = "\nMary had a little lamb\nLittle lamb\n"; + let data = ~"\nMary had a little lamb\nLittle lamb\n"; let mut ii = 0; do splitn_char_iter(data, ' ', 2u) |xx| { alt ii { - 0 { assert "\nMary" == xx; } - 1 { assert "had" == xx; } - 2 { assert "a little lamb\nLittle lamb\n" == xx; } + 0 { assert ~"\nMary" == xx; } + 1 { assert ~"had" == xx; } + 2 { assert ~"a little lamb\nLittle lamb\n" == xx; } _ { () } } ii += 1; @@ -2820,36 +2821,36 @@ mod tests { #[test] fn test_words_iter() { - let data = "\nMary had a little lamb\nLittle lamb\n"; + let data = ~"\nMary had a little lamb\nLittle lamb\n"; let mut ii = 0; do words_iter(data) |ww| { alt ii { - 0 { assert "Mary" == ww; } - 1 { assert "had" == ww; } - 2 { assert "a" == ww; } - 3 { assert "little" == ww; } + 0 { assert ~"Mary" == ww; } + 1 { assert ~"had" == ww; } + 2 { assert ~"a" == ww; } + 3 { assert ~"little" == ww; } _ { () } } ii += 1; } - words_iter("", |_x| fail); // should not fail + words_iter(~"", |_x| fail); // should not fail } #[test] fn test_lines_iter () { - let lf = "\nMary had a little lamb\nLittle lamb\n"; + let lf = ~"\nMary had a little lamb\nLittle lamb\n"; let mut ii = 0; do lines_iter(lf) |x| { alt ii { - 0 { assert "" == x; } - 1 { assert "Mary had a little lamb" == x; } - 2 { assert "Little lamb" == x; } - 3 { assert "" == x; } + 0 { assert ~"" == x; } + 1 { assert ~"Mary had a little lamb" == x; } + 2 { assert ~"Little lamb" == x; } + 3 { assert ~"" == x; } _ { () } } ii += 1; @@ -2858,31 +2859,32 @@ mod tests { #[test] fn test_map() { - assert "" == map("", |c| libc::toupper(c as c_char) as char); - assert "YMCA" == map("ymca", |c| libc::toupper(c as c_char) as char); + assert ~"" == map(~"", |c| libc::toupper(c as c_char) as char); + assert ~"YMCA" == map(~"ymca", + |c| libc::toupper(c as c_char) as char); } #[test] fn test_all() { - assert true == all("", char::is_uppercase); - assert false == all("ymca", char::is_uppercase); - assert true == all("YMCA", char::is_uppercase); - assert false == all("yMCA", char::is_uppercase); - assert false == all("YMCy", char::is_uppercase); + assert true == all(~"", char::is_uppercase); + assert false == all(~"ymca", char::is_uppercase); + assert true == all(~"YMCA", char::is_uppercase); + assert false == all(~"yMCA", char::is_uppercase); + assert false == all(~"YMCy", char::is_uppercase); } #[test] fn test_any() { - assert false == any("", char::is_uppercase); - assert false == any("ymca", char::is_uppercase); - assert true == any("YMCA", char::is_uppercase); - assert true == any("yMCA", char::is_uppercase); - assert true == any("Ymcy", char::is_uppercase); + assert false == any(~"", char::is_uppercase); + assert false == any(~"ymca", char::is_uppercase); + assert true == any(~"YMCA", char::is_uppercase); + assert true == any(~"yMCA", char::is_uppercase); + assert true == any(~"Ymcy", char::is_uppercase); } #[test] fn test_chars() { - let ss = "ศไทย中华Việt Nam"; + let ss = ~"ศไทย中华Việt Nam"; assert ~['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'] == chars(ss); } @@ -2890,13 +2892,13 @@ mod tests { #[test] fn test_utf16() { let pairs = - ~[("𐍅𐌿𐌻𐍆𐌹𐌻𐌰\n", + ~[(~"𐍅𐌿𐌻𐍆𐌹𐌻𐌰\n", ~[0xd800_u16, 0xdf45_u16, 0xd800_u16, 0xdf3f_u16, 0xd800_u16, 0xdf3b_u16, 0xd800_u16, 0xdf46_u16, 0xd800_u16, 0xdf39_u16, 0xd800_u16, 0xdf3b_u16, 0xd800_u16, 0xdf30_u16, 0x000a_u16]), - ("𐐒𐑉𐐮𐑀𐐲𐑋 𐐏𐐲𐑍\n", + (~"𐐒𐑉𐐮𐑀𐐲𐑋 𐐏𐐲𐑍\n", ~[0xd801_u16, 0xdc12_u16, 0xd801_u16, 0xdc49_u16, 0xd801_u16, 0xdc2e_u16, 0xd801_u16, 0xdc40_u16, 0xd801_u16, 0xdc32_u16, 0xd801_u16, @@ -2904,7 +2906,7 @@ mod tests { 0xd801_u16, 0xdc32_u16, 0xd801_u16, 0xdc4d_u16, 0x000a_u16]), - ("𐌀𐌖𐌋𐌄𐌑𐌉·𐌌𐌄𐌕𐌄𐌋𐌉𐌑\n", + (~"𐌀𐌖𐌋𐌄𐌑𐌉·𐌌𐌄𐌕𐌄𐌋𐌉𐌑\n", ~[0xd800_u16, 0xdf00_u16, 0xd800_u16, 0xdf16_u16, 0xd800_u16, 0xdf0b_u16, 0xd800_u16, 0xdf04_u16, 0xd800_u16, 0xdf11_u16, 0xd800_u16, 0xdf09_u16, @@ -2913,7 +2915,7 @@ mod tests { 0xdf04_u16, 0xd800_u16, 0xdf0b_u16, 0xd800_u16, 0xdf09_u16, 0xd800_u16, 0xdf11_u16, 0x000a_u16 ]), - ("𐒋𐒘𐒈𐒑𐒛𐒒 𐒕𐒓 𐒈𐒚𐒍 𐒏𐒜𐒒𐒖𐒆 𐒕𐒆\n", + (~"𐒋𐒘𐒈𐒑𐒛𐒒 𐒕𐒓 𐒈𐒚𐒍 𐒏𐒜𐒒𐒖𐒆 𐒕𐒆\n", ~[0xd801_u16, 0xdc8b_u16, 0xd801_u16, 0xdc98_u16, 0xd801_u16, 0xdc88_u16, 0xd801_u16, 0xdc91_u16, 0xd801_u16, 0xdc9b_u16, 0xd801_u16, 0xdc92_u16, @@ -2937,7 +2939,7 @@ mod tests { #[test] fn test_each_char() { - let s = "abc"; + let s = ~"abc"; let mut found_b = false; for each_char(s) |ch| { if ch == 'b' { @@ -2950,7 +2952,7 @@ mod tests { #[test] fn test_unpack_slice() { - let a = "hello"; + let a = ~"hello"; do unpack_slice(a) |buf, len| { unsafe { assert a[0] == 'h' as u8; @@ -2964,29 +2966,29 @@ mod tests { #[test] fn test_escape_unicode() { - assert escape_unicode("abc") == "\\x61\\x62\\x63"; - assert escape_unicode("a c") == "\\x61\\x20\\x63"; - assert escape_unicode("\r\n\t") == "\\x0d\\x0a\\x09"; - assert escape_unicode("'\"\\") == "\\x27\\x22\\x5c"; - assert escape_unicode("\x00\x01\xfe\xff") == "\\x00\\x01\\xfe\\xff"; - assert escape_unicode("\u0100\uffff") == "\\u0100\\uffff"; - assert escape_unicode("\U00010000\U0010ffff") == - "\\U00010000\\U0010ffff"; - assert escape_unicode("ab\ufb00") == "\\x61\\x62\\ufb00"; - assert escape_unicode("\U0001d4ea\r") == "\\U0001d4ea\\x0d"; + assert escape_unicode(~"abc") == ~"\\x61\\x62\\x63"; + assert escape_unicode(~"a c") == ~"\\x61\\x20\\x63"; + assert escape_unicode(~"\r\n\t") == ~"\\x0d\\x0a\\x09"; + assert escape_unicode(~"'\"\\") == ~"\\x27\\x22\\x5c"; + assert escape_unicode(~"\x00\x01\xfe\xff") == ~"\\x00\\x01\\xfe\\xff"; + assert escape_unicode(~"\u0100\uffff") == ~"\\u0100\\uffff"; + assert escape_unicode(~"\U00010000\U0010ffff") == + ~"\\U00010000\\U0010ffff"; + assert escape_unicode(~"ab\ufb00") == ~"\\x61\\x62\\ufb00"; + assert escape_unicode(~"\U0001d4ea\r") == ~"\\U0001d4ea\\x0d"; } #[test] fn test_escape_default() { - assert escape_default("abc") == "abc"; - assert escape_default("a c") == "a c"; - assert escape_default("\r\n\t") == "\\r\\n\\t"; - assert escape_default("'\"\\") == "\\'\\\"\\\\"; - assert escape_default("\u0100\uffff") == "\\u0100\\uffff"; - assert escape_default("\U00010000\U0010ffff") == - "\\U00010000\\U0010ffff"; - assert escape_default("ab\ufb00") == "ab\\ufb00"; - assert escape_default("\U0001d4ea\r") == "\\U0001d4ea\\r"; + assert escape_default(~"abc") == ~"abc"; + assert escape_default(~"a c") == ~"a c"; + assert escape_default(~"\r\n\t") == ~"\\r\\n\\t"; + assert escape_default(~"'\"\\") == ~"\\'\\\"\\\\"; + assert escape_default(~"\u0100\uffff") == ~"\\u0100\\uffff"; + assert escape_default(~"\U00010000\U0010ffff") == + ~"\\U00010000\\U0010ffff"; + assert escape_default(~"ab\ufb00") == ~"ab\\ufb00"; + assert escape_default(~"\U0001d4ea\r") == ~"\\U0001d4ea\\r"; } } diff --git a/src/libcore/sys.rs b/src/libcore/sys.rs index 7f3e49de551..0e5a39e859e 100644 --- a/src/libcore/sys.rs +++ b/src/libcore/sys.rs @@ -20,7 +20,7 @@ type rust_cond_lock = *libc::c_void; #[abi = "cdecl"] extern mod rustrt { fn unsupervise(); - pure fn shape_log_str(t: *sys::type_desc, data: *()) -> str; + pure fn shape_log_str(t: *sys::type_desc, data: *()) -> ~str; fn rust_create_cond_lock() -> rust_cond_lock; fn rust_destroy_cond_lock(lock: rust_cond_lock); @@ -77,7 +77,7 @@ pure fn refcount<T>(+t: @T) -> uint { } } -pure fn log_str<T>(t: T) -> str { +pure fn log_str<T>(t: T) -> ~str { unsafe { let data_ptr: *() = unsafe::reinterpret_cast(ptr::addr_of(t)); rustrt::shape_log_str(get_type_desc::<T>(), data_ptr) diff --git a/src/libcore/task.rs b/src/libcore/task.rs index 597a49305e6..40c922d9c55 100644 --- a/src/libcore/task.rs +++ b/src/libcore/task.rs @@ -519,7 +519,7 @@ fn yield() { let mut killed = false; rustrt::rust_task_yield(task_, killed); if killed && !failing() { - fail "killed"; + fail ~"killed"; } } @@ -613,20 +613,20 @@ fn spawn_raw(opts: task_opts, +f: fn~()) { fn new_task_in_new_sched(opts: sched_opts) -> *rust_task { if opts.foreign_stack_size != none { - fail "foreign_stack_size scheduler option unimplemented"; + fail ~"foreign_stack_size scheduler option unimplemented"; } let num_threads = alt opts.mode { single_threaded { 1u } thread_per_core { - fail "thread_per_core scheduling mode unimplemented" + fail ~"thread_per_core scheduling mode unimplemented" } thread_per_task { - fail "thread_per_task scheduling mode unimplemented" + fail ~"thread_per_task scheduling mode unimplemented" } manual_threads(threads) { if threads == 0u { - fail "can not create a scheduler with no threads"; + fail ~"can not create a scheduler with no threads"; } threads } @@ -980,21 +980,21 @@ fn test_spawn_listiner_bidi() { // Now the child has a port called 'po' to read from and // an environment-captured channel called 'ch'. let res = comm::recv(po); - assert res == "ping"; - comm::send(ch, "pong"); + assert res == ~"ping"; + comm::send(ch, ~"pong"); }; // Likewise, the parent has both a 'po' and 'ch' - comm::send(ch, "ping"); + comm::send(ch, ~"ping"); let res = comm::recv(po); - assert res == "pong"; + assert res == ~"pong"; } #[test] fn test_try_success() { alt do try { - "Success!" + ~"Success!" } { - result::ok("Success!") { } + result::ok(~"Success!") { } _ { fail; } } } @@ -1300,54 +1300,54 @@ fn test_unkillable_nested() { #[test] fn test_tls_multitask() unsafe { - fn my_key(+_x: @str/~) { } - local_data_set(my_key, @"parent data"/~); + fn my_key(+_x: @~str) { } + local_data_set(my_key, @~"parent data"); do task::spawn { assert local_data_get(my_key) == none; // TLS shouldn't carry over. - local_data_set(my_key, @"child data"/~); - assert *(local_data_get(my_key).get()) == "child data"; + local_data_set(my_key, @~"child data"); + assert *(local_data_get(my_key).get()) == ~"child data"; // should be cleaned up for us } // Must work multiple times - assert *(local_data_get(my_key).get()) == "parent data"; - assert *(local_data_get(my_key).get()) == "parent data"; - assert *(local_data_get(my_key).get()) == "parent data"; + assert *(local_data_get(my_key).get()) == ~"parent data"; + assert *(local_data_get(my_key).get()) == ~"parent data"; + assert *(local_data_get(my_key).get()) == ~"parent data"; } #[test] fn test_tls_overwrite() unsafe { - fn my_key(+_x: @str/~) { } - local_data_set(my_key, @"first data"/~); - local_data_set(my_key, @"next data"/~); // Shouldn't leak. - assert *(local_data_get(my_key).get()) == "next data"; + fn my_key(+_x: @~str) { } + local_data_set(my_key, @~"first data"); + local_data_set(my_key, @~"next data"); // Shouldn't leak. + assert *(local_data_get(my_key).get()) == ~"next data"; } #[test] fn test_tls_pop() unsafe { - fn my_key(+_x: @str/~) { } - local_data_set(my_key, @"weasel"/~); - assert *(local_data_pop(my_key).get()) == "weasel"; + fn my_key(+_x: @~str) { } + local_data_set(my_key, @~"weasel"); + assert *(local_data_pop(my_key).get()) == ~"weasel"; // Pop must remove the data from the map. assert local_data_pop(my_key) == none; } #[test] fn test_tls_modify() unsafe { - fn my_key(+_x: @str/~) { } + fn my_key(+_x: @~str) { } local_data_modify(my_key, |data| { alt data { - some(@val) { fail "unwelcome value: " + val } - none { some(@"first data"/~) } + some(@val) { fail ~"unwelcome value: " + val } + none { some(@~"first data") } } }); local_data_modify(my_key, |data| { alt data { - some(@"first data"/~) { some(@"next data"/~) } - some(@val) { fail "wrong value: " + val } - none { fail "missing value" } + some(@~"first data") { some(@~"next data") } + some(@val) { fail ~"wrong value: " + val } + none { fail ~"missing value" } } }); - assert *(local_data_pop(my_key).get()) == "next data"; + assert *(local_data_pop(my_key).get()) == ~"next data"; } #[test] @@ -1357,19 +1357,19 @@ fn test_tls_crust_automorestack_memorial_bug() unsafe { // jump over to the rust stack, which causes next_c_sp to get recorded as // something within a rust stack segment. Then a subsequent upcall (esp. // for logging, think vsnprintf) would run on a stack smaller than 1 MB. - fn my_key(+_x: @str/~) { } + fn my_key(+_x: @~str) { } do task::spawn { - unsafe { local_data_set(my_key, @"hax"/~); } + unsafe { local_data_set(my_key, @~"hax"); } } } #[test] fn test_tls_multiple_types() unsafe { - fn str_key(+_x: @str/~) { } + fn str_key(+_x: @~str) { } fn box_key(+_x: @@()) { } fn int_key(+_x: @int) { } do task::spawn { - local_data_set(str_key, @"string data"/~); + local_data_set(str_key, @~"string data"); local_data_set(box_key, @@()); local_data_set(int_key, @42); } @@ -1377,11 +1377,11 @@ fn test_tls_multiple_types() unsafe { #[test] fn test_tls_overwrite_multiple_types() unsafe { - fn str_key(+_x: @str/~) { } + fn str_key(+_x: @~str) { } fn box_key(+_x: @@()) { } fn int_key(+_x: @int) { } do task::spawn { - local_data_set(str_key, @"string data"/~); + local_data_set(str_key, @~"string data"); local_data_set(int_key, @42); // This could cause a segfault if overwriting-destruction is done with // the crazy polymorphic transmute rather than the provided finaliser. @@ -1393,13 +1393,13 @@ fn test_tls_overwrite_multiple_types() unsafe { #[should_fail] #[ignore(cfg(windows))] fn test_tls_cleanup_on_failure() unsafe { - fn str_key(+_x: @str/~) { } + fn str_key(+_x: @~str) { } fn box_key(+_x: @@()) { } fn int_key(+_x: @int) { } - local_data_set(str_key, @"parent data"/~); + local_data_set(str_key, @~"parent data"); local_data_set(box_key, @@()); do task::spawn { // spawn_linked - local_data_set(str_key, @"string data"/~); + local_data_set(str_key, @~"string data"); local_data_set(box_key, @@()); local_data_set(int_key, @42); fail; diff --git a/src/libcore/to_bytes.rs b/src/libcore/to_bytes.rs index 3c56a6fd4f1..0daeff81975 100644 --- a/src/libcore/to_bytes.rs +++ b/src/libcore/to_bytes.rs @@ -10,10 +10,10 @@ impl of to_bytes for @~[u8] { fn to_bytes() -> ~[u8] { copy *self } } -impl of to_bytes for str { +impl of to_bytes for ~str { fn to_bytes() -> ~[u8] { str::bytes(self) } } -impl of to_bytes for @(str/~) { +impl of to_bytes for @(~str) { fn to_bytes() -> ~[u8] { str::bytes(*self) } } diff --git a/src/libcore/to_str.rs b/src/libcore/to_str.rs index 572c028a30e..138a408435a 100644 --- a/src/libcore/to_str.rs +++ b/src/libcore/to_str.rs @@ -1,67 +1,67 @@ -iface to_str { fn to_str() -> str; } +iface to_str { fn to_str() -> ~str; } impl of to_str for int { - fn to_str() -> str { int::str(self) } + fn to_str() -> ~str { int::str(self) } } impl of to_str for i8 { - fn to_str() -> str { i8::str(self) } + fn to_str() -> ~str { i8::str(self) } } impl of to_str for i16 { - fn to_str() -> str { i16::str(self) } + fn to_str() -> ~str { i16::str(self) } } impl of to_str for i32 { - fn to_str() -> str { i32::str(self) } + fn to_str() -> ~str { i32::str(self) } } impl of to_str for i64 { - fn to_str() -> str { i64::str(self) } + fn to_str() -> ~str { i64::str(self) } } impl of to_str for uint { - fn to_str() -> str { uint::str(self) } + fn to_str() -> ~str { uint::str(self) } } impl of to_str for u8 { - fn to_str() -> str { u8::str(self) } + fn to_str() -> ~str { u8::str(self) } } impl of to_str for u16 { - fn to_str() -> str { u16::str(self) } + fn to_str() -> ~str { u16::str(self) } } impl of to_str for u32 { - fn to_str() -> str { u32::str(self) } + fn to_str() -> ~str { u32::str(self) } } impl of to_str for u64 { - fn to_str() -> str { u64::str(self) } + fn to_str() -> ~str { u64::str(self) } } impl of to_str for float { - fn to_str() -> str { float::to_str(self, 4u) } + fn to_str() -> ~str { float::to_str(self, 4u) } } impl of to_str for bool { - fn to_str() -> str { bool::to_str(self) } + fn to_str() -> ~str { bool::to_str(self) } } impl of to_str for () { - fn to_str() -> str { "()" } + fn to_str() -> ~str { ~"()" } } -impl of to_str for str { - fn to_str() -> str { self } +impl of to_str for ~str { + fn to_str() -> ~str { self } } impl <A: to_str copy, B: to_str copy> of to_str for (A, B) { - fn to_str() -> str { + fn to_str() -> ~str { let (a, b) = self; - "(" + a.to_str() + ", " + b.to_str() + ")" + ~"(" + a.to_str() + ~", " + b.to_str() + ~")" } } impl <A: to_str copy, B: to_str copy, C: to_str copy> of to_str for (A, B, C){ - fn to_str() -> str { + fn to_str() -> ~str { let (a, b, c) = self; - "(" + a.to_str() + ", " + b.to_str() + ", " + c.to_str() + ")" + ~"(" + a.to_str() + ~", " + b.to_str() + ~", " + c.to_str() + ~")" } } impl <A: to_str> of to_str for ~[A] { - fn to_str() -> str { - let mut acc = "[", first = true; + fn to_str() -> ~str { + let mut acc = ~"[", first = true; for vec::each(self) |elt| { if first { first = false; } - else { str::push_str(acc, ", "); } + else { str::push_str(acc, ~", "); } str::push_str(acc, elt.to_str()); } str::push_char(acc, ']'); @@ -70,47 +70,47 @@ impl <A: to_str> of to_str for ~[A] { } impl <A: to_str> of to_str for @A { - fn to_str() -> str { "@" + (*self).to_str() } + fn to_str() -> ~str { ~"@" + (*self).to_str() } } impl <A: to_str> of to_str for ~A { - fn to_str() -> str { "~" + (*self).to_str() } + fn to_str() -> ~str { ~"~" + (*self).to_str() } } #[cfg(test)] mod tests { #[test] fn test_simple_types() { - assert 1.to_str() == "1"; - assert (-1).to_str() == "-1"; - assert 200u.to_str() == "200"; - assert 2u8.to_str() == "2"; - assert true.to_str() == "true"; - assert false.to_str() == "false"; - assert ().to_str() == "()"; - assert "hi".to_str() == "hi"; + assert 1.to_str() == ~"1"; + assert (-1).to_str() == ~"-1"; + assert 200u.to_str() == ~"200"; + assert 2u8.to_str() == ~"2"; + assert true.to_str() == ~"true"; + assert false.to_str() == ~"false"; + assert ().to_str() == ~"()"; + assert (~"hi").to_str() == ~"hi"; } #[test] fn test_tuple_types() { - assert (1, 2).to_str() == "(1, 2)"; - assert ("a", "b", false).to_str() == "(a, b, false)"; - assert ((), ((), 100)).to_str() == "((), ((), 100))"; + assert (1, 2).to_str() == ~"(1, 2)"; + assert (~"a", ~"b", false).to_str() == ~"(a, b, false)"; + assert ((), ((), 100)).to_str() == ~"((), ((), 100))"; } #[test] #[ignore] fn test_vectors() { let x: ~[int] = ~[]; - assert x.to_str() == "~[]"; - assert (~[1]).to_str() == "~[1]"; - assert (~[1, 2, 3]).to_str() == "~[1, 2, 3]"; + assert x.to_str() == ~"~[]"; + assert (~[1]).to_str() == ~"~[1]"; + assert (~[1, 2, 3]).to_str() == ~"~[1, 2, 3]"; assert (~[~[], ~[1], ~[1, 1]]).to_str() == - "~[~[], ~[1], ~[1, 1]]"; + ~"~[~[], ~[1], ~[1, 1]]"; } #[test] fn test_pointer_types() { - assert (@1).to_str() == "@1"; - assert (~(true, false)).to_str() == "~(true, false)"; + assert (@1).to_str() == ~"@1"; + assert (~(true, false)).to_str() == ~"~(true, false)"; } } diff --git a/src/libcore/tuple.rs b/src/libcore/tuple.rs index d50ee4ac687..fe6f15f5d69 100644 --- a/src/libcore/tuple.rs +++ b/src/libcore/tuple.rs @@ -22,7 +22,7 @@ pure fn swap<T:copy, U:copy>(pair: (T, U)) -> (U, T) { #[test] fn test_tuple() { assert first((948, 4039.48)) == 948; - assert second((34.5, "foo")) == "foo"; + assert second((34.5, ~"foo")) == ~"foo"; assert swap(('a', 2)) == (2, 'a'); } diff --git a/src/libcore/uint-template.rs b/src/libcore/uint-template.rs index 0433cd7ce30..7c4244efd9b 100644 --- a/src/libcore/uint-template.rs +++ b/src/libcore/uint-template.rs @@ -121,10 +121,10 @@ impl times of iter::times for T { } /// Parse a string to an int -fn from_str(s: str) -> option<T> { parse_buf(str::bytes(s), 10u) } +fn from_str(s: ~str) -> option<T> { parse_buf(str::bytes(s), 10u) } /// Parse a string as an unsigned integer. -fn from_str_radix(buf: str, radix: u64) -> option<u64> { +fn from_str_radix(buf: ~str, radix: u64) -> option<u64> { if str::len(buf) == 0u { ret none; } let mut i = str::len(buf) - 1u; let mut power = 1u64, n = 0u64; @@ -146,7 +146,7 @@ fn from_str_radix(buf: str, radix: u64) -> option<u64> { * * Fails if `radix` < 2 or `radix` > 16 */ -fn to_str(num: T, radix: uint) -> str { +fn to_str(num: T, radix: uint) -> ~str { do to_str_bytes(false, num, radix) |slice| { do vec::unpack_slice(slice) |p, len| { unsafe { str::unsafe::from_buf_len(p, len) } @@ -220,46 +220,46 @@ fn to_str_bytes<U>(neg: bool, num: T, radix: uint, } /// Convert to a string -fn str(i: T) -> str { ret to_str(i, 10u); } +fn str(i: T) -> ~str { ret to_str(i, 10u); } #[test] fn test_to_str() { - assert to_str(0 as T, 10u) == "0"; - assert to_str(1 as T, 10u) == "1"; - assert to_str(2 as T, 10u) == "2"; - assert to_str(11 as T, 10u) == "11"; - assert to_str(11 as T, 16u) == "b"; - assert to_str(255 as T, 16u) == "ff"; - assert to_str(0xff as T, 10u) == "255"; + assert to_str(0 as T, 10u) == ~"0"; + assert to_str(1 as T, 10u) == ~"1"; + assert to_str(2 as T, 10u) == ~"2"; + assert to_str(11 as T, 10u) == ~"11"; + assert to_str(11 as T, 16u) == ~"b"; + assert to_str(255 as T, 16u) == ~"ff"; + assert to_str(0xff as T, 10u) == ~"255"; } #[test] #[ignore] fn test_from_str() { - assert from_str("0") == some(0u as T); - assert from_str("3") == some(3u as T); - assert from_str("10") == some(10u as T); - assert from_str("123456789") == some(123456789u as T); - assert from_str("00100") == some(100u as T); - - assert from_str("") == none; - assert from_str(" ") == none; - assert from_str("x") == none; + assert from_str(~"0") == some(0u as T); + assert from_str(~"3") == some(3u as T); + assert from_str(~"10") == some(10u as T); + assert from_str(~"123456789") == some(123456789u as T); + assert from_str(~"00100") == some(100u as T); + + assert from_str(~"") == none; + assert from_str(~" ") == none; + assert from_str(~"x") == none; } #[test] #[ignore] fn test_parse_buf() { import str::bytes; - assert parse_buf(bytes("123"), 10u) == some(123u as T); - assert parse_buf(bytes("1001"), 2u) == some(9u as T); - assert parse_buf(bytes("123"), 8u) == some(83u as T); - assert parse_buf(bytes("123"), 16u) == some(291u as T); - assert parse_buf(bytes("ffff"), 16u) == some(65535u as T); - assert parse_buf(bytes("z"), 36u) == some(35u as T); - - assert parse_buf(str::bytes("Z"), 10u) == none; - assert parse_buf(str::bytes("_"), 2u) == none; + assert parse_buf(bytes(~"123"), 10u) == some(123u as T); + assert parse_buf(bytes(~"1001"), 2u) == some(9u as T); + assert parse_buf(bytes(~"123"), 8u) == some(83u as T); + assert parse_buf(bytes(~"123"), 16u) == some(291u as T); + assert parse_buf(bytes(~"ffff"), 16u) == some(65535u as T); + assert parse_buf(bytes(~"z"), 36u) == some(35u as T); + + assert parse_buf(str::bytes(~"Z"), 10u) == none; + assert parse_buf(str::bytes(~"_"), 2u) == none; } #[test] diff --git a/src/libcore/unsafe.rs b/src/libcore/unsafe.rs index e148d979b34..343fca55813 100644 --- a/src/libcore/unsafe.rs +++ b/src/libcore/unsafe.rs @@ -58,13 +58,13 @@ mod tests { #[test] fn test_bump_box_refcount() { unsafe { - let box = @"box box box"/~; // refcount 1 + let box = @~"box box box"; // refcount 1 bump_box_refcount(box); // refcount 2 let ptr: *int = transmute(box); // refcount 2 - let _box1: @str/~ = reinterpret_cast(ptr); - let _box2: @str/~ = reinterpret_cast(ptr); - assert *_box1 == "box box box"; - assert *_box2 == "box box box"; + let _box1: @~str = reinterpret_cast(ptr); + let _box2: @~str = reinterpret_cast(ptr); + assert *_box1 == ~"box box box"; + assert *_box2 == ~"box box box"; // Will destroy _box1 and _box2. Without the bump, this would // use-after-free. With too many bumps, it would leak. } @@ -83,7 +83,7 @@ mod tests { #[test] fn test_transmute2() { unsafe { - assert transmute("L") == ~[76u8, 0u8]; + assert transmute(~"L") == ~[76u8, 0u8]; } } } diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs index c08a93cd63a..475f1557610 100644 --- a/src/libcore/vec.rs +++ b/src/libcore/vec.rs @@ -239,7 +239,7 @@ pure fn init<T: copy>(v: &[const T]) -> ~[T] { /// Returns the last element of the slice `v`, failing if the slice is empty. pure fn last<T: copy>(v: &[const T]) -> T { - if len(v) == 0u { fail "last_unsafe: empty vector" } + if len(v) == 0u { fail ~"last_unsafe: empty vector" } v[len(v) - 1u] } diff --git a/src/libstd/base64.rs b/src/libstd/base64.rs index 3ca34c4b756..e2c8ad31344 100644 --- a/src/libstd/base64.rs +++ b/src/libstd/base64.rs @@ -1,17 +1,17 @@ import io::{reader, reader_util}; iface to_base64 { - fn to_base64() -> str; + fn to_base64() -> ~str; } impl of to_base64 for ~[u8] { - fn to_base64() -> str { + fn to_base64() -> ~str { let chars = str::chars( - "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" + ~"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" ); let len = self.len(); - let mut s = ""; + let mut s = ~""; str::reserve(s, ((len + 3u) / 4u) * 3u); let mut i = 0u; @@ -52,8 +52,8 @@ impl of to_base64 for ~[u8] { } } -impl of to_base64 for str { - fn to_base64() -> str { +impl of to_base64 for ~str { + fn to_base64() -> ~str { str::bytes(self).to_base64() } } @@ -64,7 +64,7 @@ iface from_base64 { impl of from_base64 for ~[u8] { fn from_base64() -> ~[u8] { - if self.len() % 4u != 0u { fail "invalid base64 length"; } + if self.len() % 4u != 0u { fail ~"invalid base64 length"; } let len = self.len(); let mut padding = 0u; @@ -107,11 +107,11 @@ impl of from_base64 for ~[u8] { ret copy r; } _ { - fail "invalid base64 padding"; + fail ~"invalid base64 padding"; } } } else { - fail "invalid base64 character"; + fail ~"invalid base64 character"; } i += 1u; @@ -126,7 +126,7 @@ impl of from_base64 for ~[u8] { } } -impl of from_base64 for str { +impl of from_base64 for ~str { fn from_base64() -> ~[u8] { str::bytes(self).from_base64() } @@ -136,23 +136,23 @@ impl of from_base64 for str { mod tests { #[test] fn test_to_base64() { - assert "".to_base64() == ""; - assert "f".to_base64() == "Zg=="; - assert "fo".to_base64() == "Zm8="; - assert "foo".to_base64() == "Zm9v"; - assert "foob".to_base64() == "Zm9vYg=="; - assert "fooba".to_base64() == "Zm9vYmE="; - assert "foobar".to_base64() == "Zm9vYmFy"; + assert (~"").to_base64() == ~""; + assert (~"f").to_base64() == ~"Zg=="; + assert (~"fo").to_base64() == ~"Zm8="; + assert (~"foo").to_base64() == ~"Zm9v"; + assert (~"foob").to_base64() == ~"Zm9vYg=="; + assert (~"fooba").to_base64() == ~"Zm9vYmE="; + assert (~"foobar").to_base64() == ~"Zm9vYmFy"; } #[test] fn test_from_base64() { - assert "".from_base64() == str::bytes(""); - assert "Zg==".from_base64() == str::bytes("f"); - assert "Zm8=".from_base64() == str::bytes("fo"); - assert "Zm9v".from_base64() == str::bytes("foo"); - assert "Zm9vYg==".from_base64() == str::bytes("foob"); - assert "Zm9vYmE=".from_base64() == str::bytes("fooba"); - assert "Zm9vYmFy".from_base64() == str::bytes("foobar"); + assert (~"").from_base64() == str::bytes(~""); + assert (~"Zg==").from_base64() == str::bytes(~"f"); + assert (~"Zm8=").from_base64() == str::bytes(~"fo"); + assert (~"Zm9v").from_base64() == str::bytes(~"foo"); + assert (~"Zm9vYg==").from_base64() == str::bytes(~"foob"); + assert (~"Zm9vYmE=").from_base64() == str::bytes(~"fooba"); + assert (~"Zm9vYmFy").from_base64() == str::bytes(~"foobar"); } } diff --git a/src/libstd/bitv.rs b/src/libstd/bitv.rs index f6c7b573f65..3816e415b96 100644 --- a/src/libstd/bitv.rs +++ b/src/libstd/bitv.rs @@ -213,9 +213,9 @@ fn each_storage(v: bitv, op: fn(&uint) -> bool) { * The resulting string has the same length as the bitvector, and each * character is either '0' or '1'. */ -fn to_str(v: bitv) -> str { - let mut rs = ""; - for each(v) |i| { if i { rs += "1"; } else { rs += "0"; } } +fn to_str(v: bitv) -> ~str { + let mut rs = ~""; + for each(v) |i| { if i { rs += ~"1"; } else { rs += ~"0"; } } ret rs; } @@ -243,10 +243,10 @@ mod tests { #[test] fn test_to_str() { let zerolen = bitv(0u, false); - assert to_str(zerolen) == ""; + assert to_str(zerolen) == ~""; let eightbits = bitv(8u, false); - assert to_str(eightbits) == "00000000"; + assert to_str(eightbits) == ~"00000000"; } #[test] diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs index 69a4920a4ae..5f833a20e32 100644 --- a/src/libstd/ebml.rs +++ b/src/libstd/ebml.rs @@ -127,7 +127,7 @@ fn with_doc_data<T>(d: doc, f: fn(x: &[u8]) -> T) -> T { ret f(vec::slice::<u8>(*d.data, d.start, d.end)); } -fn doc_as_str(d: doc) -> str { ret str::from_bytes(doc_data(d)); } +fn doc_as_str(d: doc) -> ~str { ret str::from_bytes(doc_data(d)); } fn doc_as_u8(d: doc) -> u8 { assert d.end == d.start + 1u; @@ -271,7 +271,7 @@ impl writer for writer { self.wr_tagged_bytes(tag_id, &[v as u8]); } - fn wr_tagged_str(tag_id: uint, v: str) { + fn wr_tagged_str(tag_id: uint, v: ~str) { // Lame: can't use str::as_bytes() here because the resulting // vector is NULL-terminated. Annoyingly, the underlying // writer interface doesn't permit us to write a slice of a @@ -286,7 +286,7 @@ impl writer for writer { self.writer.write(b); } - fn wr_str(s: str) { + fn wr_str(s: ~str) { #debug["Write str: %?", s]; self.writer.write(str::bytes(s)); } @@ -320,7 +320,7 @@ impl serializer of serialization::serializer for ebml::writer { self.wr_tagged_u32(t as uint, v as u32); } - fn _emit_label(label: str) { + fn _emit_label(label: ~str) { // There are various strings that we have access to, such as // the name of a record field, which do not actually appear in // the serialized EBML (normally). This is just for @@ -345,17 +345,17 @@ impl serializer of serialization::serializer for ebml::writer { fn emit_bool(v: bool) { self.wr_tagged_u8(es_bool as uint, v as u8) } // FIXME (#2742): implement these - fn emit_f64(_v: f64) { fail "Unimplemented: serializing an f64"; } - fn emit_f32(_v: f32) { fail "Unimplemented: serializing an f32"; } - fn emit_float(_v: float) { fail "Unimplemented: serializing a float"; } + fn emit_f64(_v: f64) { fail ~"Unimplemented: serializing an f64"; } + fn emit_f32(_v: f32) { fail ~"Unimplemented: serializing an f32"; } + fn emit_float(_v: float) { fail ~"Unimplemented: serializing a float"; } - fn emit_str(v: str) { self.wr_tagged_str(es_str as uint, v) } + fn emit_str(v: ~str) { self.wr_tagged_str(es_str as uint, v) } - fn emit_enum(name: str, f: fn()) { + fn emit_enum(name: ~str, f: fn()) { self._emit_label(name); self.wr_tag(es_enum as uint, f) } - fn emit_enum_variant(_v_name: str, v_id: uint, _cnt: uint, f: fn()) { + fn emit_enum_variant(_v_name: ~str, v_id: uint, _cnt: uint, f: fn()) { self._emit_tagged_uint(es_enum_vid, v_id); self.wr_tag(es_enum_body as uint, f) } @@ -375,7 +375,7 @@ impl serializer of serialization::serializer for ebml::writer { fn emit_box(f: fn()) { f() } fn emit_uniq(f: fn()) { f() } fn emit_rec(f: fn()) { f() } - fn emit_rec_field(f_name: str, _f_idx: uint, f: fn()) { + fn emit_rec_field(f_name: ~str, _f_idx: uint, f: fn()) { self._emit_label(f_name); f() } @@ -391,7 +391,7 @@ fn ebml_deserializer(d: ebml::doc) -> ebml_deserializer { } impl deserializer of serialization::deserializer for ebml_deserializer { - fn _check_label(lbl: str) { + fn _check_label(lbl: ~str) { if self.pos < self.parent.end { let {tag: r_tag, doc: r_doc} = ebml::doc_at(self.parent.data, self.pos); @@ -408,7 +408,7 @@ impl deserializer of serialization::deserializer for ebml_deserializer { fn next_doc(exp_tag: ebml_serializer_tag) -> ebml::doc { #debug[". next_doc(exp_tag=%?)", exp_tag]; if self.pos >= self.parent.end { - fail "no more documents in current node!"; + fail ~"no more documents in current node!"; } let {tag: r_tag, doc: r_doc} = ebml::doc_at(self.parent.data, self.pos); @@ -472,14 +472,14 @@ impl deserializer of serialization::deserializer for ebml_deserializer { fn read_bool() -> bool { ebml::doc_as_u8(self.next_doc(es_bool)) as bool } - fn read_f64() -> f64 { fail "read_f64()"; } - fn read_f32() -> f32 { fail "read_f32()"; } - fn read_float() -> float { fail "read_float()"; } + fn read_f64() -> f64 { fail ~"read_f64()"; } + fn read_f32() -> f32 { fail ~"read_f32()"; } + fn read_float() -> float { fail ~"read_float()"; } - fn read_str() -> str { ebml::doc_as_str(self.next_doc(es_str)) } + fn read_str() -> ~str { ebml::doc_as_str(self.next_doc(es_str)) } // Compound types: - fn read_enum<T:copy>(name: str, f: fn() -> T) -> T { + fn read_enum<T:copy>(name: ~str, f: fn() -> T) -> T { #debug["read_enum(%s)", name]; self._check_label(name); self.push_doc(self.next_doc(es_enum), f) @@ -528,7 +528,7 @@ impl deserializer of serialization::deserializer for ebml_deserializer { f() } - fn read_rec_field<T:copy>(f_name: str, f_idx: uint, f: fn() -> T) -> T { + fn read_rec_field<T:copy>(f_name: ~str, f_idx: uint, f: fn() -> T) -> T { #debug["read_rec_field(%s, idx=%u)", f_name, f_idx]; self._check_label(f_name); f() @@ -556,13 +556,13 @@ fn test_option_int() { } fn serialize_0<S: serialization::serializer>(s: S, v: option<int>) { - do s.emit_enum("core::option::t") { + do s.emit_enum(~"core::option::t") { alt v { none { - s.emit_enum_variant("core::option::none", 0u, 0u, || { } ); + s.emit_enum_variant(~"core::option::none", 0u, 0u, || { } ); } some(v0) { - do s.emit_enum_variant("core::option::some", 1u, 1u) { + do s.emit_enum_variant(~"core::option::some", 1u, 1u) { s.emit_enum_variant_arg(0u, || serialize_1(s, v0)); } } @@ -575,7 +575,7 @@ fn test_option_int() { } fn deserialize_0<S: serialization::deserializer>(s: S) -> option<int> { - do s.read_enum("core::option::t") { + do s.read_enum(~"core::option::t") { do s.read_enum_variant |i| { alt check i { 0u { none } diff --git a/src/libstd/getopts.rs b/src/libstd/getopts.rs index e6df8e1d898..8ba2dc16b76 100644 --- a/src/libstd/getopts.rs +++ b/src/libstd/getopts.rs @@ -84,7 +84,7 @@ export opt_maybe_str; export opt_default; export result; //NDM -enum name { long(str), short(char), } +enum name { long(~str), short(char), } enum hasarg { yes, no, maybe, } @@ -93,29 +93,29 @@ enum occur { req, optional, multi, } /// A description of a possible option type opt = {name: name, hasarg: hasarg, occur: occur}; -fn mkname(nm: str) -> name { +fn mkname(nm: ~str) -> name { ret if str::len(nm) == 1u { short(str::char_at(nm, 0u)) } else { long(nm) }; } /// Create an option that is required and takes an argument -fn reqopt(name: str) -> opt { +fn reqopt(name: ~str) -> opt { ret {name: mkname(name), hasarg: yes, occur: req}; } /// Create an option that is optional and takes an argument -fn optopt(name: str) -> opt { +fn optopt(name: ~str) -> opt { ret {name: mkname(name), hasarg: yes, occur: optional}; } /// Create an option that is optional and does not take an argument -fn optflag(name: str) -> opt { +fn optflag(name: ~str) -> opt { ret {name: mkname(name), hasarg: no, occur: optional}; } /// Create an option that is optional and takes an optional argument -fn optflagopt(name: str) -> opt { +fn optflagopt(name: ~str) -> opt { ret {name: mkname(name), hasarg: maybe, occur: optional}; } @@ -123,23 +123,23 @@ fn optflagopt(name: str) -> opt { * Create an option that is optional, takes an argument, and may occur * multiple times */ -fn optmulti(name: str) -> opt { +fn optmulti(name: ~str) -> opt { ret {name: mkname(name), hasarg: yes, occur: multi}; } -enum optval { val(str), given, } +enum optval { val(~str), given, } /** * The result of checking command line arguments. Contains a vector * of matches and a vector of free strings. */ -type match = {opts: ~[opt], vals: ~[~[optval]], free: ~[str]}; +type match = {opts: ~[opt], vals: ~[~[optval]], free: ~[~str]}; -fn is_arg(arg: str) -> bool { +fn is_arg(arg: ~str) -> bool { ret str::len(arg) > 1u && arg[0] == '-' as u8; } -fn name_str(nm: name) -> str { +fn name_str(nm: name) -> ~str { ret alt nm { short(ch) { str::from_char(ch) } long(s) { s } }; } @@ -152,24 +152,26 @@ fn find_opt(opts: ~[opt], nm: name) -> option<uint> { * expected format. Pass this value to <fail_str> to get an error message. */ enum fail_ { - argument_missing(str), - unrecognized_option(str), - option_missing(str), - option_duplicated(str), - unexpected_argument(str), + argument_missing(~str), + unrecognized_option(~str), + option_missing(~str), + option_duplicated(~str), + unexpected_argument(~str), } /// Convert a `fail_` enum into an error string -fn fail_str(f: fail_) -> str { +fn fail_str(f: fail_) -> ~str { ret alt f { - argument_missing(nm) { "Argument to option '" + nm + "' missing." } - unrecognized_option(nm) { "Unrecognized option: '" + nm + "'." } - option_missing(nm) { "Required option '" + nm + "' missing." } + argument_missing(nm) { + ~"Argument to option '" + nm + ~"' missing." + } + unrecognized_option(nm) { ~"Unrecognized option: '" + nm + ~"'." } + option_missing(nm) { ~"Required option '" + nm + ~"' missing." } option_duplicated(nm) { - "Option '" + nm + "' given more than once." + ~"Option '" + nm + ~"' given more than once." } unexpected_argument(nm) { - "Option " + nm + " does not take an argument." + ~"Option " + nm + ~" does not take an argument." } }; } @@ -187,11 +189,11 @@ type result = result::result<match, fail_>; * `opt_str`, etc. to interrogate results. Returns `err(fail_)` on failure. * Use <fail_str> to get an error message. */ -fn getopts(args: ~[str], opts: ~[opt]) -> result unsafe { +fn getopts(args: ~[~str], opts: ~[opt]) -> result unsafe { let n_opts = vec::len::<opt>(opts); fn f(_x: uint) -> ~[optval] { ret ~[]; } let vals = vec::to_mut(vec::from_fn(n_opts, f)); - let mut free: ~[str] = ~[]; + let mut free: ~[~str] = ~[]; let l = vec::len(args); let mut i = 0u; while i < l { @@ -199,13 +201,13 @@ fn getopts(args: ~[str], opts: ~[opt]) -> result unsafe { let curlen = str::len(cur); if !is_arg(cur) { vec::push(free, cur); - } else if str::eq(cur, "--") { + } else if str::eq(cur, ~"--") { let mut j = i + 1u; while j < l { vec::push(free, args[j]); j += 1u; } break; } else { let mut names; - let mut i_arg = option::none::<str>; + let mut i_arg = option::none::<~str>; if cur[1] == '-' as u8 { let tail = str::slice(cur, 2u, curlen); let tail_eq = str::splitn_char(tail, '=', 1u); @@ -215,7 +217,7 @@ fn getopts(args: ~[str], opts: ~[opt]) -> result unsafe { names = ~[long(tail_eq[0])]; i_arg = - option::some::<str>(tail_eq[1]); + option::some::<~str>(tail_eq[1]); } } else { let mut j = 1u; @@ -264,13 +266,13 @@ fn getopts(args: ~[str], opts: ~[opt]) -> result unsafe { }; alt opts[optid].hasarg { no { - if !option::is_none::<str>(i_arg) { + if !option::is_none::<~str>(i_arg) { ret err(unexpected_argument(name_str(nm))); } vec::push(vals[optid], given); } maybe { - if !option::is_none::<str>(i_arg) { + if !option::is_none::<~str>(i_arg) { vec::push(vals[optid], val(option::get(i_arg))); } else if name_pos < vec::len::<name>(names) || i + 1u == l || is_arg(args[i + 1u]) { @@ -278,9 +280,9 @@ fn getopts(args: ~[str], opts: ~[opt]) -> result unsafe { } else { i += 1u; vec::push(vals[optid], val(args[i])); } } yes { - if !option::is_none::<str>(i_arg) { + if !option::is_none::<~str>(i_arg) { vec::push(vals[optid], - val(option::get::<str>(i_arg))); + val(option::get::<~str>(i_arg))); } else if i + 1u == l { ret err(argument_missing(name_str(nm))); } else { i += 1u; vec::push(vals[optid], val(args[i])); } @@ -309,22 +311,22 @@ fn getopts(args: ~[str], opts: ~[opt]) -> result unsafe { ret ok({opts: opts, vals: vec::from_mut(vals), free: free}); } -fn opt_vals(m: match, nm: str) -> ~[optval] { +fn opt_vals(m: match, nm: ~str) -> ~[optval] { ret alt find_opt(m.opts, mkname(nm)) { some(id) { m.vals[id] } none { #error("No option '%s' defined", nm); fail } }; } -fn opt_val(m: match, nm: str) -> optval { ret opt_vals(m, nm)[0]; } +fn opt_val(m: match, nm: ~str) -> optval { ret opt_vals(m, nm)[0]; } /// Returns true if an option was matched -fn opt_present(m: match, nm: str) -> bool { +fn opt_present(m: match, nm: ~str) -> bool { ret vec::len::<optval>(opt_vals(m, nm)) > 0u; } /// Returns true if any of several options were matched -fn opts_present(m: match, names: ~[str]) -> bool { +fn opts_present(m: match, names: ~[~str]) -> bool { for vec::each(names) |nm| { alt find_opt(m.opts, mkname(nm)) { some(_) { ret true; } @@ -341,7 +343,7 @@ fn opts_present(m: match, names: ~[str]) -> bool { * Fails if the option was not matched or if the match did not take an * argument */ -fn opt_str(m: match, nm: str) -> str { +fn opt_str(m: match, nm: ~str) -> ~str { ret alt opt_val(m, nm) { val(s) { s } _ { fail } }; } @@ -351,7 +353,7 @@ fn opt_str(m: match, nm: str) -> str { * Fails if the no option was provided from the given list, or if the no such * option took an argument */ -fn opts_str(m: match, names: ~[str]) -> str { +fn opts_str(m: match, names: ~[~str]) -> ~str { for vec::each(names) |nm| { alt opt_val(m, nm) { val(s) { ret s } @@ -368,8 +370,8 @@ fn opts_str(m: match, names: ~[str]) -> str { * * Used when an option accepts multiple values. */ -fn opt_strs(m: match, nm: str) -> ~[str] { - let mut acc: ~[str] = ~[]; +fn opt_strs(m: match, nm: ~str) -> ~[~str] { + let mut acc: ~[~str] = ~[]; for vec::each(opt_vals(m, nm)) |v| { alt v { val(s) { vec::push(acc, s); } _ { } } } @@ -377,10 +379,10 @@ fn opt_strs(m: match, nm: str) -> ~[str] { } /// Returns the string argument supplied to a matching option or none -fn opt_maybe_str(m: match, nm: str) -> option<str> { +fn opt_maybe_str(m: match, nm: ~str) -> option<~str> { let vals = opt_vals(m, nm); - if vec::len::<optval>(vals) == 0u { ret none::<str>; } - ret alt vals[0] { val(s) { some::<str>(s) } _ { none::<str> } }; + if vec::len::<optval>(vals) == 0u { ret none::<~str>; } + ret alt vals[0] { val(s) { some::<~str>(s) } _ { none::<~str> } }; } @@ -391,10 +393,10 @@ fn opt_maybe_str(m: match, nm: str) -> option<str> { * present but no argument was provided, and the argument if the option was * present and an argument was provided. */ -fn opt_default(m: match, nm: str, def: str) -> option<str> { +fn opt_default(m: match, nm: ~str, def: ~str) -> option<~str> { let vals = opt_vals(m, nm); - if vec::len::<optval>(vals) == 0u { ret none::<str>; } - ret alt vals[0] { val(s) { some::<str>(s) } _ { some::<str>(def) } } + if vec::len::<optval>(vals) == 0u { ret none::<~str>; } + ret alt vals[0] { val(s) { some::<~str>(s) } _ { some::<~str>(def) } } } #[cfg(test)] @@ -424,21 +426,21 @@ mod tests { // Tests for reqopt #[test] fn test_reqopt_long() { - let args = ~["--test=20"]; - let opts = ~[reqopt("test")]; + let args = ~[~"--test=20"]; + let opts = ~[reqopt(~"test")]; let rs = getopts(args, opts); alt check rs { ok(m) { - assert (opt_present(m, "test")); - assert (opt_str(m, "test") == "20"); + assert (opt_present(m, ~"test")); + assert (opt_str(m, ~"test") == ~"20"); } } } #[test] fn test_reqopt_long_missing() { - let args = ~["blah"]; - let opts = ~[reqopt("test")]; + let args = ~[~"blah"]; + let opts = ~[reqopt(~"test")]; let rs = getopts(args, opts); alt rs { err(f) { check_fail_type(f, option_missing_); } @@ -448,8 +450,8 @@ mod tests { #[test] fn test_reqopt_long_no_arg() { - let args = ~["--test"]; - let opts = ~[reqopt("test")]; + let args = ~[~"--test"]; + let opts = ~[reqopt(~"test")]; let rs = getopts(args, opts); alt rs { err(f) { check_fail_type(f, argument_missing_); } @@ -459,8 +461,8 @@ mod tests { #[test] fn test_reqopt_long_multi() { - let args = ~["--test=20", "--test=30"]; - let opts = ~[reqopt("test")]; + let args = ~[~"--test=20", ~"--test=30"]; + let opts = ~[reqopt(~"test")]; let rs = getopts(args, opts); alt rs { err(f) { check_fail_type(f, option_duplicated_); } @@ -470,13 +472,13 @@ mod tests { #[test] fn test_reqopt_short() { - let args = ~["-t", "20"]; - let opts = ~[reqopt("t")]; + let args = ~[~"-t", ~"20"]; + let opts = ~[reqopt(~"t")]; let rs = getopts(args, opts); alt rs { ok(m) { - assert (opt_present(m, "t")); - assert (opt_str(m, "t") == "20"); + assert (opt_present(m, ~"t")); + assert (opt_str(m, ~"t") == ~"20"); } _ { fail; } } @@ -484,8 +486,8 @@ mod tests { #[test] fn test_reqopt_short_missing() { - let args = ~["blah"]; - let opts = ~[reqopt("t")]; + let args = ~[~"blah"]; + let opts = ~[reqopt(~"t")]; let rs = getopts(args, opts); alt rs { err(f) { check_fail_type(f, option_missing_); } @@ -495,8 +497,8 @@ mod tests { #[test] fn test_reqopt_short_no_arg() { - let args = ~["-t"]; - let opts = ~[reqopt("t")]; + let args = ~[~"-t"]; + let opts = ~[reqopt(~"t")]; let rs = getopts(args, opts); alt rs { err(f) { check_fail_type(f, argument_missing_); } @@ -506,8 +508,8 @@ mod tests { #[test] fn test_reqopt_short_multi() { - let args = ~["-t", "20", "-t", "30"]; - let opts = ~[reqopt("t")]; + let args = ~[~"-t", ~"20", ~"-t", ~"30"]; + let opts = ~[reqopt(~"t")]; let rs = getopts(args, opts); alt rs { err(f) { check_fail_type(f, option_duplicated_); } @@ -519,13 +521,13 @@ mod tests { // Tests for optopt #[test] fn test_optopt_long() { - let args = ~["--test=20"]; - let opts = ~[optopt("test")]; + let args = ~[~"--test=20"]; + let opts = ~[optopt(~"test")]; let rs = getopts(args, opts); alt rs { ok(m) { - assert (opt_present(m, "test")); - assert (opt_str(m, "test") == "20"); + assert (opt_present(m, ~"test")); + assert (opt_str(m, ~"test") == ~"20"); } _ { fail; } } @@ -533,19 +535,19 @@ mod tests { #[test] fn test_optopt_long_missing() { - let args = ~["blah"]; - let opts = ~[optopt("test")]; + let args = ~[~"blah"]; + let opts = ~[optopt(~"test")]; let rs = getopts(args, opts); alt rs { - ok(m) { assert (!opt_present(m, "test")); } + ok(m) { assert (!opt_present(m, ~"test")); } _ { fail; } } } #[test] fn test_optopt_long_no_arg() { - let args = ~["--test"]; - let opts = ~[optopt("test")]; + let args = ~[~"--test"]; + let opts = ~[optopt(~"test")]; let rs = getopts(args, opts); alt rs { err(f) { check_fail_type(f, argument_missing_); } @@ -555,8 +557,8 @@ mod tests { #[test] fn test_optopt_long_multi() { - let args = ~["--test=20", "--test=30"]; - let opts = ~[optopt("test")]; + let args = ~[~"--test=20", ~"--test=30"]; + let opts = ~[optopt(~"test")]; let rs = getopts(args, opts); alt rs { err(f) { check_fail_type(f, option_duplicated_); } @@ -566,13 +568,13 @@ mod tests { #[test] fn test_optopt_short() { - let args = ~["-t", "20"]; - let opts = ~[optopt("t")]; + let args = ~[~"-t", ~"20"]; + let opts = ~[optopt(~"t")]; let rs = getopts(args, opts); alt rs { ok(m) { - assert (opt_present(m, "t")); - assert (opt_str(m, "t") == "20"); + assert (opt_present(m, ~"t")); + assert (opt_str(m, ~"t") == ~"20"); } _ { fail; } } @@ -580,19 +582,19 @@ mod tests { #[test] fn test_optopt_short_missing() { - let args = ~["blah"]; - let opts = ~[optopt("t")]; + let args = ~[~"blah"]; + let opts = ~[optopt(~"t")]; let rs = getopts(args, opts); alt rs { - ok(m) { assert (!opt_present(m, "t")); } + ok(m) { assert (!opt_present(m, ~"t")); } _ { fail; } } } #[test] fn test_optopt_short_no_arg() { - let args = ~["-t"]; - let opts = ~[optopt("t")]; + let args = ~[~"-t"]; + let opts = ~[optopt(~"t")]; let rs = getopts(args, opts); alt rs { err(f) { check_fail_type(f, argument_missing_); } @@ -602,8 +604,8 @@ mod tests { #[test] fn test_optopt_short_multi() { - let args = ~["-t", "20", "-t", "30"]; - let opts = ~[optopt("t")]; + let args = ~[~"-t", ~"20", ~"-t", ~"30"]; + let opts = ~[optopt(~"t")]; let rs = getopts(args, opts); alt rs { err(f) { check_fail_type(f, option_duplicated_); } @@ -615,30 +617,30 @@ mod tests { // Tests for optflag #[test] fn test_optflag_long() { - let args = ~["--test"]; - let opts = ~[optflag("test")]; + let args = ~[~"--test"]; + let opts = ~[optflag(~"test")]; let rs = getopts(args, opts); alt rs { - ok(m) { assert (opt_present(m, "test")); } + ok(m) { assert (opt_present(m, ~"test")); } _ { fail; } } } #[test] fn test_optflag_long_missing() { - let args = ~["blah"]; - let opts = ~[optflag("test")]; + let args = ~[~"blah"]; + let opts = ~[optflag(~"test")]; let rs = getopts(args, opts); alt rs { - ok(m) { assert (!opt_present(m, "test")); } + ok(m) { assert (!opt_present(m, ~"test")); } _ { fail; } } } #[test] fn test_optflag_long_arg() { - let args = ~["--test=20"]; - let opts = ~[optflag("test")]; + let args = ~[~"--test=20"]; + let opts = ~[optflag(~"test")]; let rs = getopts(args, opts); alt rs { err(f) { @@ -651,8 +653,8 @@ mod tests { #[test] fn test_optflag_long_multi() { - let args = ~["--test", "--test"]; - let opts = ~[optflag("test")]; + let args = ~[~"--test", ~"--test"]; + let opts = ~[optflag(~"test")]; let rs = getopts(args, opts); alt rs { err(f) { check_fail_type(f, option_duplicated_); } @@ -662,36 +664,36 @@ mod tests { #[test] fn test_optflag_short() { - let args = ~["-t"]; - let opts = ~[optflag("t")]; + let args = ~[~"-t"]; + let opts = ~[optflag(~"t")]; let rs = getopts(args, opts); alt rs { - ok(m) { assert (opt_present(m, "t")); } + ok(m) { assert (opt_present(m, ~"t")); } _ { fail; } } } #[test] fn test_optflag_short_missing() { - let args = ~["blah"]; - let opts = ~[optflag("t")]; + let args = ~[~"blah"]; + let opts = ~[optflag(~"t")]; let rs = getopts(args, opts); alt rs { - ok(m) { assert (!opt_present(m, "t")); } + ok(m) { assert (!opt_present(m, ~"t")); } _ { fail; } } } #[test] fn test_optflag_short_arg() { - let args = ~["-t", "20"]; - let opts = ~[optflag("t")]; + let args = ~[~"-t", ~"20"]; + let opts = ~[optflag(~"t")]; let rs = getopts(args, opts); alt rs { ok(m) { // The next variable after the flag is just a free argument - assert (m.free[0] == "20"); + assert (m.free[0] == ~"20"); } _ { fail; } } @@ -699,8 +701,8 @@ mod tests { #[test] fn test_optflag_short_multi() { - let args = ~["-t", "-t"]; - let opts = ~[optflag("t")]; + let args = ~[~"-t", ~"-t"]; + let opts = ~[optflag(~"t")]; let rs = getopts(args, opts); alt rs { err(f) { check_fail_type(f, option_duplicated_); } @@ -712,13 +714,13 @@ mod tests { // Tests for optmulti #[test] fn test_optmulti_long() { - let args = ~["--test=20"]; - let opts = ~[optmulti("test")]; + let args = ~[~"--test=20"]; + let opts = ~[optmulti(~"test")]; let rs = getopts(args, opts); alt rs { ok(m) { - assert (opt_present(m, "test")); - assert (opt_str(m, "test") == "20"); + assert (opt_present(m, ~"test")); + assert (opt_str(m, ~"test") == ~"20"); } _ { fail; } } @@ -726,19 +728,19 @@ mod tests { #[test] fn test_optmulti_long_missing() { - let args = ~["blah"]; - let opts = ~[optmulti("test")]; + let args = ~[~"blah"]; + let opts = ~[optmulti(~"test")]; let rs = getopts(args, opts); alt rs { - ok(m) { assert (!opt_present(m, "test")); } + ok(m) { assert (!opt_present(m, ~"test")); } _ { fail; } } } #[test] fn test_optmulti_long_no_arg() { - let args = ~["--test"]; - let opts = ~[optmulti("test")]; + let args = ~[~"--test"]; + let opts = ~[optmulti(~"test")]; let rs = getopts(args, opts); alt rs { err(f) { check_fail_type(f, argument_missing_); } @@ -748,15 +750,15 @@ mod tests { #[test] fn test_optmulti_long_multi() { - let args = ~["--test=20", "--test=30"]; - let opts = ~[optmulti("test")]; + let args = ~[~"--test=20", ~"--test=30"]; + let opts = ~[optmulti(~"test")]; let rs = getopts(args, opts); alt rs { ok(m) { - assert (opt_present(m, "test")); - assert (opt_str(m, "test") == "20"); - assert (opt_strs(m, "test")[0] == "20"); - assert (opt_strs(m, "test")[1] == "30"); + assert (opt_present(m, ~"test")); + assert (opt_str(m, ~"test") == ~"20"); + assert (opt_strs(m, ~"test")[0] == ~"20"); + assert (opt_strs(m, ~"test")[1] == ~"30"); } _ { fail; } } @@ -764,13 +766,13 @@ mod tests { #[test] fn test_optmulti_short() { - let args = ~["-t", "20"]; - let opts = ~[optmulti("t")]; + let args = ~[~"-t", ~"20"]; + let opts = ~[optmulti(~"t")]; let rs = getopts(args, opts); alt rs { ok(m) { - assert (opt_present(m, "t")); - assert (opt_str(m, "t") == "20"); + assert (opt_present(m, ~"t")); + assert (opt_str(m, ~"t") == ~"20"); } _ { fail; } } @@ -778,19 +780,19 @@ mod tests { #[test] fn test_optmulti_short_missing() { - let args = ~["blah"]; - let opts = ~[optmulti("t")]; + let args = ~[~"blah"]; + let opts = ~[optmulti(~"t")]; let rs = getopts(args, opts); alt rs { - ok(m) { assert (!opt_present(m, "t")); } + ok(m) { assert (!opt_present(m, ~"t")); } _ { fail; } } } #[test] fn test_optmulti_short_no_arg() { - let args = ~["-t"]; - let opts = ~[optmulti("t")]; + let args = ~[~"-t"]; + let opts = ~[optmulti(~"t")]; let rs = getopts(args, opts); alt rs { err(f) { check_fail_type(f, argument_missing_); } @@ -800,15 +802,15 @@ mod tests { #[test] fn test_optmulti_short_multi() { - let args = ~["-t", "20", "-t", "30"]; - let opts = ~[optmulti("t")]; + let args = ~[~"-t", ~"20", ~"-t", ~"30"]; + let opts = ~[optmulti(~"t")]; let rs = getopts(args, opts); alt rs { ok(m) { - assert (opt_present(m, "t")); - assert (opt_str(m, "t") == "20"); - assert (opt_strs(m, "t")[0] == "20"); - assert (opt_strs(m, "t")[1] == "30"); + assert (opt_present(m, ~"t")); + assert (opt_str(m, ~"t") == ~"20"); + assert (opt_strs(m, ~"t")[0] == ~"20"); + assert (opt_strs(m, ~"t")[1] == ~"30"); } _ { fail; } } @@ -816,8 +818,8 @@ mod tests { #[test] fn test_unrecognized_option_long() { - let args = ~["--untest"]; - let opts = ~[optmulti("t")]; + let args = ~[~"--untest"]; + let opts = ~[optmulti(~"t")]; let rs = getopts(args, opts); alt rs { err(f) { check_fail_type(f, unrecognized_option_); } @@ -827,8 +829,8 @@ mod tests { #[test] fn test_unrecognized_option_short() { - let args = ~["-t"]; - let opts = ~[optmulti("test")]; + let args = ~[~"-t"]; + let opts = ~[optmulti(~"test")]; let rs = getopts(args, opts); alt rs { err(f) { check_fail_type(f, unrecognized_option_); } @@ -839,27 +841,28 @@ mod tests { #[test] fn test_combined() { let args = - ~["prog", "free1", "-s", "20", "free2", "--flag", "--long=30", - "-f", "-m", "40", "-m", "50", "-n", "-A B", "-n", "-60 70"]; + ~[~"prog", ~"free1", ~"-s", ~"20", ~"free2", + ~"--flag", ~"--long=30", ~"-f", ~"-m", ~"40", + ~"-m", ~"50", ~"-n", ~"-A B", ~"-n", ~"-60 70"]; let opts = - ~[optopt("s"), optflag("flag"), reqopt("long"), - optflag("f"), optmulti("m"), optmulti("n"), - optopt("notpresent")]; + ~[optopt(~"s"), optflag(~"flag"), reqopt(~"long"), + optflag(~"f"), optmulti(~"m"), optmulti(~"n"), + optopt(~"notpresent")]; let rs = getopts(args, opts); alt rs { ok(m) { - assert (m.free[0] == "prog"); - assert (m.free[1] == "free1"); - assert (opt_str(m, "s") == "20"); - assert (m.free[2] == "free2"); - assert (opt_present(m, "flag")); - assert (opt_str(m, "long") == "30"); - assert (opt_present(m, "f")); - assert (opt_strs(m, "m")[0] == "40"); - assert (opt_strs(m, "m")[1] == "50"); - assert (opt_strs(m, "n")[0] == "-A B"); - assert (opt_strs(m, "n")[1] == "-60 70"); - assert (!opt_present(m, "notpresent")); + assert (m.free[0] == ~"prog"); + assert (m.free[1] == ~"free1"); + assert (opt_str(m, ~"s") == ~"20"); + assert (m.free[2] == ~"free2"); + assert (opt_present(m, ~"flag")); + assert (opt_str(m, ~"long") == ~"30"); + assert (opt_present(m, ~"f")); + assert (opt_strs(m, ~"m")[0] == ~"40"); + assert (opt_strs(m, ~"m")[1] == ~"50"); + assert (opt_strs(m, ~"n")[0] == ~"-A B"); + assert (opt_strs(m, ~"n")[1] == ~"-60 70"); + assert (!opt_present(m, ~"notpresent")); } _ { fail; } } @@ -867,35 +870,35 @@ mod tests { #[test] fn test_multi() { - let args = ~["-e", "foo", "--encrypt", "foo"]; - let opts = ~[optopt("e"), optopt("encrypt")]; + let args = ~[~"-e", ~"foo", ~"--encrypt", ~"foo"]; + let opts = ~[optopt(~"e"), optopt(~"encrypt")]; let match = alt getopts(args, opts) { result::ok(m) { m } result::err(f) { fail; } }; - assert opts_present(match, ~["e"]); - assert opts_present(match, ~["encrypt"]); - assert opts_present(match, ~["encrypt", "e"]); - assert opts_present(match, ~["e", "encrypt"]); - assert !opts_present(match, ~["thing"]); + assert opts_present(match, ~[~"e"]); + assert opts_present(match, ~[~"encrypt"]); + assert opts_present(match, ~[~"encrypt", ~"e"]); + assert opts_present(match, ~[~"e", ~"encrypt"]); + assert !opts_present(match, ~[~"thing"]); assert !opts_present(match, ~[]); - assert opts_str(match, ~["e"]) == "foo"; - assert opts_str(match, ~["encrypt"]) == "foo"; - assert opts_str(match, ~["e", "encrypt"]) == "foo"; - assert opts_str(match, ~["encrypt", "e"]) == "foo"; + assert opts_str(match, ~[~"e"]) == ~"foo"; + assert opts_str(match, ~[~"encrypt"]) == ~"foo"; + assert opts_str(match, ~[~"e", ~"encrypt"]) == ~"foo"; + assert opts_str(match, ~[~"encrypt", ~"e"]) == ~"foo"; } #[test] fn test_nospace() { - let args = ~["-Lfoo"]; - let opts = ~[optmulti("L")]; + let args = ~[~"-Lfoo"]; + let opts = ~[optmulti(~"L")]; let match = alt getopts(args, opts) { result::ok(m) { m } result::err(f) { fail; } }; - assert opts_present(match, ~["L"]); - assert opts_str(match, ~["L"]) == "foo"; + assert opts_present(match, ~[~"L"]); + assert opts_str(match, ~[~"L"]) == ~"foo"; } } diff --git a/src/libstd/json.rs b/src/libstd/json.rs index eab42a52b59..f8194204626 100644 --- a/src/libstd/json.rs +++ b/src/libstd/json.rs @@ -29,17 +29,17 @@ export null; /// Represents a json value enum json { num(float), - string(@str/~), + string(@~str), boolean(bool), list(@~[json]), - dict(map::hashmap<str, json>), + dict(map::hashmap<~str, json>), null, } type error = { line: uint, col: uint, - msg: @str/~, + msg: @~str, }; /// Serializes a json value into a io::writer @@ -50,14 +50,14 @@ fn to_writer(wr: io::writer, j: json) { wr.write_str(escape_str(*s)); } boolean(b) { - wr.write_str(if b { "true" } else { "false" }); + wr.write_str(if b { ~"true" } else { ~"false" }); } list(v) { wr.write_char('['); let mut first = true; for (*v).each |item| { if !first { - wr.write_str(", "); + wr.write_str(~", "); } first = false; to_writer(wr, item); @@ -66,51 +66,51 @@ fn to_writer(wr: io::writer, j: json) { } dict(d) { if d.size() == 0u { - wr.write_str("{}"); + wr.write_str(~"{}"); ret; } - wr.write_str("{ "); + wr.write_str(~"{ "); let mut first = true; for d.each |key, value| { if !first { - wr.write_str(", "); + wr.write_str(~", "); } first = false; wr.write_str(escape_str(key)); - wr.write_str(": "); + wr.write_str(~": "); to_writer(wr, value); }; - wr.write_str(" }"); + wr.write_str(~" }"); } null { - wr.write_str("null"); + wr.write_str(~"null"); } } } -fn escape_str(s: str) -> str { - let mut escaped = "\""; +fn escape_str(s: ~str) -> ~str { + let mut escaped = ~"\""; do str::chars_iter(s) |c| { alt c { - '"' { escaped += "\\\""; } - '\\' { escaped += "\\\\"; } - '\x08' { escaped += "\\b"; } - '\x0c' { escaped += "\\f"; } - '\n' { escaped += "\\n"; } - '\r' { escaped += "\\r"; } - '\t' { escaped += "\\t"; } + '"' { escaped += ~"\\\""; } + '\\' { escaped += ~"\\\\"; } + '\x08' { escaped += ~"\\b"; } + '\x0c' { escaped += ~"\\f"; } + '\n' { escaped += ~"\\n"; } + '\r' { escaped += ~"\\r"; } + '\t' { escaped += ~"\\t"; } _ { escaped += str::from_char(c); } } }; - escaped += "\""; + escaped += ~"\""; escaped } /// Serializes a json value into a string -fn to_str(j: json) -> str { +fn to_str(j: json) -> ~str { io::with_str_writer(|wr| to_writer(wr, j)) } @@ -140,7 +140,7 @@ impl parser for parser { self.ch } - fn error<T>(+msg: str) -> result<T, error> { + fn error<T>(+msg: ~str) -> result<T, error> { err({ line: self.line, col: self.col, msg: @msg }) } @@ -153,7 +153,7 @@ impl parser for parser { if self.eof() { ok(value) } else { - self.error("trailing characters") + self.error(~"trailing characters") } } e { e } @@ -163,12 +163,12 @@ impl parser for parser { fn parse_value() -> result<json, error> { self.parse_whitespace(); - if self.eof() { ret self.error("EOF while parsing value"); } + if self.eof() { ret self.error(~"EOF while parsing value"); } alt self.ch { - 'n' { self.parse_ident("ull", null) } - 't' { self.parse_ident("rue", boolean(true)) } - 'f' { self.parse_ident("alse", boolean(false)) } + 'n' { self.parse_ident(~"ull", null) } + 't' { self.parse_ident(~"rue", boolean(true)) } + 'f' { self.parse_ident(~"alse", boolean(false)) } '0' to '9' | '-' { self.parse_number() } '"' { alt self.parse_str() { @@ -178,7 +178,7 @@ impl parser for parser { } '[' { self.parse_list() } '{' { self.parse_object() } - _ { self.error("invalid syntax") } + _ { self.error(~"invalid syntax") } } } @@ -186,12 +186,12 @@ impl parser for parser { while char::is_whitespace(self.ch) { self.bump(); } } - fn parse_ident(ident: str, value: json) -> result<json, error> { + fn parse_ident(ident: ~str, value: json) -> result<json, error> { if str::all(ident, |c| c == self.next_char()) { self.bump(); ok(value) } else { - self.error("invalid syntax") + self.error(~"invalid syntax") } } @@ -234,7 +234,7 @@ impl parser for parser { // There can be only one leading '0'. alt self.ch { - '0' to '9' { ret self.error("invalid number"); } + '0' to '9' { ret self.error(~"invalid number"); } _ {} } } @@ -251,7 +251,7 @@ impl parser for parser { } } } - _ { ret self.error("invalid number"); } + _ { ret self.error(~"invalid number"); } } ok(res) @@ -263,7 +263,7 @@ impl parser for parser { // Make sure a digit follows the decimal place. alt self.ch { '0' to '9' {} - _ { ret self.error("invalid number"); } + _ { ret self.error(~"invalid number"); } } let mut res = res; @@ -299,7 +299,7 @@ impl parser for parser { // Make sure a digit follows the exponent place. alt self.ch { '0' to '9' {} - _ { ret self.error("invalid number"); } + _ { ret self.error(~"invalid number"); } } while !self.eof() { @@ -324,9 +324,9 @@ impl parser for parser { ok(res) } - fn parse_str() -> result<@str/~, error> { + fn parse_str() -> result<@~str, error> { let mut escape = false; - let mut res = ""; + let mut res = ~""; while !self.eof() { self.bump(); @@ -351,19 +351,19 @@ impl parser for parser { n = n * 10u + (self.ch as uint) - ('0' as uint); } - _ { ret self.error("invalid \\u escape"); } + _ { ret self.error(~"invalid \\u escape"); } } i += 1u; } // Error out if we didn't parse 4 digits. if i != 4u { - ret self.error("invalid \\u escape"); + ret self.error(~"invalid \\u escape"); } str::push_char(res, n as char); } - _ { ret self.error("invalid escape"); } + _ { ret self.error(~"invalid escape"); } } escape = false; } else if self.ch == '\\' { @@ -377,7 +377,7 @@ impl parser for parser { } } - self.error("EOF while parsing string") + self.error(~"EOF while parsing string") } fn parse_list() -> result<json, error> { @@ -399,13 +399,13 @@ impl parser for parser { self.parse_whitespace(); if self.eof() { - ret self.error("EOF while parsing list"); + ret self.error(~"EOF while parsing list"); } alt self.ch { ',' { self.bump(); } ']' { self.bump(); ret ok(list(@values)); } - _ { ret self.error("expected `,` or `]`"); } + _ { ret self.error(~"expected `,` or `]`"); } } }; } @@ -425,7 +425,7 @@ impl parser for parser { self.parse_whitespace(); if self.ch != '"' { - ret self.error("key must be a string"); + ret self.error(~"key must be a string"); } let key = alt self.parse_str() { @@ -437,7 +437,7 @@ impl parser for parser { if self.ch != ':' { if self.eof() { break; } - ret self.error("expected `:`"); + ret self.error(~"expected `:`"); } self.bump(); @@ -452,12 +452,12 @@ impl parser for parser { '}' { self.bump(); ret ok(dict(values)); } _ { if self.eof() { break; } - ret self.error("expected `,` or `}`"); + ret self.error(~"expected `,` or `}`"); } } } - ret self.error("EOF while parsing object"); + ret self.error(~"EOF while parsing object"); } } @@ -474,7 +474,7 @@ fn from_reader(rdr: io::reader) -> result<json, error> { } /// Deserializes a json value from a string -fn from_str(s: str) -> result<json, error> { +fn from_str(s: ~str) -> result<json, error> { io::with_str_reader(s, from_reader) } @@ -575,11 +575,11 @@ impl of to_json for bool { fn to_json() -> json { boolean(self) } } -impl of to_json for str { +impl of to_json for ~str { fn to_json() -> json { string(@copy self) } } -impl of to_json for @str/~ { +impl of to_json for @~str { fn to_json() -> json { string(self) } } @@ -602,7 +602,7 @@ impl <A: to_json> of to_json for ~[A] { fn to_json() -> json { list(@self.map(|elt| elt.to_json())) } } -impl <A: to_json copy> of to_json for hashmap<str, A> { +impl <A: to_json copy> of to_json for hashmap<~str, A> { fn to_json() -> json { let d = map::str_hash(); for self.each() |key, value| { @@ -622,18 +622,18 @@ impl <A: to_json> of to_json for option<A> { } impl of to_str::to_str for json { - fn to_str() -> str { to_str(self) } + fn to_str() -> ~str { to_str(self) } } impl of to_str::to_str for error { - fn to_str() -> str { + fn to_str() -> ~str { #fmt("%u:%u: %s", self.line, self.col, *self.msg) } } #[cfg(test)] mod tests { - fn mk_dict(items: ~[(str, json)]) -> json { + fn mk_dict(items: ~[(~str, json)]) -> json { let d = map::str_hash(); do vec::iter(items) |item| { @@ -646,229 +646,230 @@ mod tests { #[test] fn test_write_null() { - assert to_str(null) == "null"; + assert to_str(null) == ~"null"; } #[test] fn test_write_num() { - assert to_str(num(3f)) == "3"; - assert to_str(num(3.1f)) == "3.1"; - assert to_str(num(-1.5f)) == "-1.5"; - assert to_str(num(0.5f)) == "0.5"; + assert to_str(num(3f)) == ~"3"; + assert to_str(num(3.1f)) == ~"3.1"; + assert to_str(num(-1.5f)) == ~"-1.5"; + assert to_str(num(0.5f)) == ~"0.5"; } #[test] fn test_write_str() { - assert to_str(string(@""/~)) == "\"\""/~; - assert to_str(string(@"foo"/~)) == "\"foo\""/~; + assert to_str(string(@~"")) == ~"\"\""; + assert to_str(string(@~"foo")) == ~"\"foo\""; } #[test] fn test_write_bool() { - assert to_str(boolean(true)) == "true"; - assert to_str(boolean(false)) == "false"; + assert to_str(boolean(true)) == ~"true"; + assert to_str(boolean(false)) == ~"false"; } #[test] fn test_write_list() { - assert to_str(list(@~[])) == "[]"; - assert to_str(list(@~[boolean(true)])) == "[true]"; + assert to_str(list(@~[])) == ~"[]"; + assert to_str(list(@~[boolean(true)])) == ~"[true]"; assert to_str(list(@~[ boolean(false), null, - list(@~[string(@"foo\nbar"/~), num(3.5f)]) - ])) == "[false, null, [\"foo\\nbar\", 3.5]]"; + list(@~[string(@~"foo\nbar"), num(3.5f)]) + ])) == ~"[false, null, [\"foo\\nbar\", 3.5]]"; } #[test] fn test_write_dict() { - assert to_str(mk_dict(~[])) == "{}"; - assert to_str(mk_dict(~[("a", boolean(true))])) == "{ \"a\": true }"; + assert to_str(mk_dict(~[])) == ~"{}"; + assert to_str(mk_dict(~[(~"a", boolean(true))])) + == ~"{ \"a\": true }"; assert to_str(mk_dict(~[ - ("a", boolean(true)), - ("b", list(@~[ - mk_dict(~[("c", string(@"\x0c\r"/~))]), - mk_dict(~[("d", string(@""/~))]) + (~"a", boolean(true)), + (~"b", list(@~[ + mk_dict(~[(~"c", string(@~"\x0c\r"))]), + mk_dict(~[(~"d", string(@~""))]) ])) ])) == - "{ " + - "\"a\": true, " + - "\"b\": [" + - "{ \"c\": \"\\f\\r\" }, " + - "{ \"d\": \"\" }" + - "]" + - " }"; + ~"{ " + + ~"\"a\": true, " + + ~"\"b\": [" + + ~"{ \"c\": \"\\f\\r\" }, " + + ~"{ \"d\": \"\" }" + + ~"]" + + ~" }"; } #[test] fn test_trailing_characters() { - assert from_str("nulla") == - err({line: 1u, col: 5u, msg: @"trailing characters"/~}); - assert from_str("truea") == - err({line: 1u, col: 5u, msg: @"trailing characters"/~}); - assert from_str("falsea") == - err({line: 1u, col: 6u, msg: @"trailing characters"/~}); - assert from_str("1a") == - err({line: 1u, col: 2u, msg: @"trailing characters"/~}); - assert from_str("[]a") == - err({line: 1u, col: 3u, msg: @"trailing characters"/~}); - assert from_str("{}a") == - err({line: 1u, col: 3u, msg: @"trailing characters"/~}); + assert from_str(~"nulla") == + err({line: 1u, col: 5u, msg: @~"trailing characters"}); + assert from_str(~"truea") == + err({line: 1u, col: 5u, msg: @~"trailing characters"}); + assert from_str(~"falsea") == + err({line: 1u, col: 6u, msg: @~"trailing characters"}); + assert from_str(~"1a") == + err({line: 1u, col: 2u, msg: @~"trailing characters"}); + assert from_str(~"[]a") == + err({line: 1u, col: 3u, msg: @~"trailing characters"}); + assert from_str(~"{}a") == + err({line: 1u, col: 3u, msg: @~"trailing characters"}); } #[test] fn test_read_identifiers() { - assert from_str("n") == - err({line: 1u, col: 2u, msg: @"invalid syntax"/~}); - assert from_str("nul") == - err({line: 1u, col: 4u, msg: @"invalid syntax"/~}); + assert from_str(~"n") == + err({line: 1u, col: 2u, msg: @~"invalid syntax"}); + assert from_str(~"nul") == + err({line: 1u, col: 4u, msg: @~"invalid syntax"}); - assert from_str("t") == - err({line: 1u, col: 2u, msg: @"invalid syntax"/~}); - assert from_str("truz") == - err({line: 1u, col: 4u, msg: @"invalid syntax"/~}); + assert from_str(~"t") == + err({line: 1u, col: 2u, msg: @~"invalid syntax"}); + assert from_str(~"truz") == + err({line: 1u, col: 4u, msg: @~"invalid syntax"}); - assert from_str("f") == - err({line: 1u, col: 2u, msg: @"invalid syntax"/~}); - assert from_str("faz") == - err({line: 1u, col: 3u, msg: @"invalid syntax"/~}); + assert from_str(~"f") == + err({line: 1u, col: 2u, msg: @~"invalid syntax"}); + assert from_str(~"faz") == + err({line: 1u, col: 3u, msg: @~"invalid syntax"}); - assert from_str("null") == ok(null); - assert from_str("true") == ok(boolean(true)); - assert from_str("false") == ok(boolean(false)); - assert from_str(" null ") == ok(null); - assert from_str(" true ") == ok(boolean(true)); - assert from_str(" false ") == ok(boolean(false)); + assert from_str(~"null") == ok(null); + assert from_str(~"true") == ok(boolean(true)); + assert from_str(~"false") == ok(boolean(false)); + assert from_str(~" null ") == ok(null); + assert from_str(~" true ") == ok(boolean(true)); + assert from_str(~" false ") == ok(boolean(false)); } #[test] fn test_read_num() { - assert from_str("+") == - err({line: 1u, col: 1u, msg: @"invalid syntax"/~}); - assert from_str(".") == - err({line: 1u, col: 1u, msg: @"invalid syntax"/~}); - - assert from_str("-") == - err({line: 1u, col: 2u, msg: @"invalid number"/~}); - assert from_str("00") == - err({line: 1u, col: 2u, msg: @"invalid number"/~}); - assert from_str("1.") == - err({line: 1u, col: 3u, msg: @"invalid number"/~}); - assert from_str("1e") == - err({line: 1u, col: 3u, msg: @"invalid number"/~}); - assert from_str("1e+") == - err({line: 1u, col: 4u, msg: @"invalid number"/~}); - - assert from_str("3") == ok(num(3f)); - assert from_str("3.1") == ok(num(3.1f)); - assert from_str("-1.2") == ok(num(-1.2f)); - assert from_str("0.4") == ok(num(0.4f)); - assert from_str("0.4e5") == ok(num(0.4e5f)); - assert from_str("0.4e+15") == ok(num(0.4e15f)); - assert from_str("0.4e-01") == ok(num(0.4e-01f)); - assert from_str(" 3 ") == ok(num(3f)); + assert from_str(~"+") == + err({line: 1u, col: 1u, msg: @~"invalid syntax"}); + assert from_str(~".") == + err({line: 1u, col: 1u, msg: @~"invalid syntax"}); + + assert from_str(~"-") == + err({line: 1u, col: 2u, msg: @~"invalid number"}); + assert from_str(~"00") == + err({line: 1u, col: 2u, msg: @~"invalid number"}); + assert from_str(~"1.") == + err({line: 1u, col: 3u, msg: @~"invalid number"}); + assert from_str(~"1e") == + err({line: 1u, col: 3u, msg: @~"invalid number"}); + assert from_str(~"1e+") == + err({line: 1u, col: 4u, msg: @~"invalid number"}); + + assert from_str(~"3") == ok(num(3f)); + assert from_str(~"3.1") == ok(num(3.1f)); + assert from_str(~"-1.2") == ok(num(-1.2f)); + assert from_str(~"0.4") == ok(num(0.4f)); + assert from_str(~"0.4e5") == ok(num(0.4e5f)); + assert from_str(~"0.4e+15") == ok(num(0.4e15f)); + assert from_str(~"0.4e-01") == ok(num(0.4e-01f)); + assert from_str(~" 3 ") == ok(num(3f)); } #[test] fn test_read_str() { - assert from_str("\"") == - err({line: 1u, col: 2u, msg: @"EOF while parsing string"/~}); - assert from_str("\"lol") == - err({line: 1u, col: 5u, msg: @"EOF while parsing string"/~}); + assert from_str(~"\"") == + err({line: 1u, col: 2u, msg: @~"EOF while parsing string"}); + assert from_str(~"\"lol") == + err({line: 1u, col: 5u, msg: @~"EOF while parsing string"}); - assert from_str("\"\"") == ok(string(@""/~)); - assert from_str("\"foo\"") == ok(string(@"foo"/~)); - assert from_str("\"\\\"\"") == ok(string(@"\""/~)); - assert from_str("\"\\b\"") == ok(string(@"\x08"/~)); - assert from_str("\"\\n\"") == ok(string(@"\n"/~)); - assert from_str("\"\\r\"") == ok(string(@"\r"/~)); - assert from_str("\"\\t\"") == ok(string(@"\t"/~)); - assert from_str(" \"foo\" ") == ok(string(@"foo"/~)); + assert from_str(~"\"\"") == ok(string(@~"")); + assert from_str(~"\"foo\"") == ok(string(@~"foo")); + assert from_str(~"\"\\\"\"") == ok(string(@~"\"")); + assert from_str(~"\"\\b\"") == ok(string(@~"\x08")); + assert from_str(~"\"\\n\"") == ok(string(@~"\n")); + assert from_str(~"\"\\r\"") == ok(string(@~"\r")); + assert from_str(~"\"\\t\"") == ok(string(@~"\t")); + assert from_str(~" \"foo\" ") == ok(string(@~"foo")); } #[test] fn test_read_list() { - assert from_str("[") == - err({line: 1u, col: 2u, msg: @"EOF while parsing value"/~}); - assert from_str("[1") == - err({line: 1u, col: 3u, msg: @"EOF while parsing list"/~}); - assert from_str("[1,") == - err({line: 1u, col: 4u, msg: @"EOF while parsing value"/~}); - assert from_str("[1,]") == - err({line: 1u, col: 4u, msg: @"invalid syntax"/~}); - assert from_str("[6 7]") == - err({line: 1u, col: 4u, msg: @"expected `,` or `]`"/~}); - - assert from_str("[]") == ok(list(@~[])); - assert from_str("[ ]") == ok(list(@~[])); - assert from_str("[true]") == ok(list(@~[boolean(true)])); - assert from_str("[ false ]") == ok(list(@~[boolean(false)])); - assert from_str("[null]") == ok(list(@~[null])); - assert from_str("[3, 1]") == ok(list(@~[num(3f), num(1f)])); - assert from_str("\n[3, 2]\n") == ok(list(@~[num(3f), num(2f)])); - assert from_str("[2, [4, 1]]") == + assert from_str(~"[") == + err({line: 1u, col: 2u, msg: @~"EOF while parsing value"}); + assert from_str(~"[1") == + err({line: 1u, col: 3u, msg: @~"EOF while parsing list"}); + assert from_str(~"[1,") == + err({line: 1u, col: 4u, msg: @~"EOF while parsing value"}); + assert from_str(~"[1,]") == + err({line: 1u, col: 4u, msg: @~"invalid syntax"}); + assert from_str(~"[6 7]") == + err({line: 1u, col: 4u, msg: @~"expected `,` or `]`"}); + + assert from_str(~"[]") == ok(list(@~[])); + assert from_str(~"[ ]") == ok(list(@~[])); + assert from_str(~"[true]") == ok(list(@~[boolean(true)])); + assert from_str(~"[ false ]") == ok(list(@~[boolean(false)])); + assert from_str(~"[null]") == ok(list(@~[null])); + assert from_str(~"[3, 1]") == ok(list(@~[num(3f), num(1f)])); + assert from_str(~"\n[3, 2]\n") == ok(list(@~[num(3f), num(2f)])); + assert from_str(~"[2, [4, 1]]") == ok(list(@~[num(2f), list(@~[num(4f), num(1f)])])); } #[test] fn test_read_dict() { - assert from_str("{") == - err({line: 1u, col: 2u, msg: @"EOF while parsing object"/~}); - assert from_str("{ ") == - err({line: 1u, col: 3u, msg: @"EOF while parsing object"/~}); - assert from_str("{1") == - err({line: 1u, col: 2u, msg: @"key must be a string"/~}); - assert from_str("{ \"a\"") == - err({line: 1u, col: 6u, msg: @"EOF while parsing object"/~}); - assert from_str("{\"a\"") == - err({line: 1u, col: 5u, msg: @"EOF while parsing object"/~}); - assert from_str("{\"a\" ") == - err({line: 1u, col: 6u, msg: @"EOF while parsing object"/~}); - - assert from_str("{\"a\" 1") == - err({line: 1u, col: 6u, msg: @"expected `:`"/~}); - assert from_str("{\"a\":") == - err({line: 1u, col: 6u, msg: @"EOF while parsing value"/~}); - assert from_str("{\"a\":1") == - err({line: 1u, col: 7u, msg: @"EOF while parsing object"/~}); - assert from_str("{\"a\":1 1") == - err({line: 1u, col: 8u, msg: @"expected `,` or `}`"/~}); - assert from_str("{\"a\":1,") == - err({line: 1u, col: 8u, msg: @"EOF while parsing object"/~}); - - assert eq(result::get(from_str("{}")), mk_dict(~[])); - assert eq(result::get(from_str("{\"a\": 3}")), - mk_dict(~[("a", num(3.0f))])); - - assert eq(result::get(from_str("{ \"a\": null, \"b\" : true }")), + assert from_str(~"{") == + err({line: 1u, col: 2u, msg: @~"EOF while parsing object"}); + assert from_str(~"{ ") == + err({line: 1u, col: 3u, msg: @~"EOF while parsing object"}); + assert from_str(~"{1") == + err({line: 1u, col: 2u, msg: @~"key must be a string"}); + assert from_str(~"{ \"a\"") == + err({line: 1u, col: 6u, msg: @~"EOF while parsing object"}); + assert from_str(~"{\"a\"") == + err({line: 1u, col: 5u, msg: @~"EOF while parsing object"}); + assert from_str(~"{\"a\" ") == + err({line: 1u, col: 6u, msg: @~"EOF while parsing object"}); + + assert from_str(~"{\"a\" 1") == + err({line: 1u, col: 6u, msg: @~"expected `:`"}); + assert from_str(~"{\"a\":") == + err({line: 1u, col: 6u, msg: @~"EOF while parsing value"}); + assert from_str(~"{\"a\":1") == + err({line: 1u, col: 7u, msg: @~"EOF while parsing object"}); + assert from_str(~"{\"a\":1 1") == + err({line: 1u, col: 8u, msg: @~"expected `,` or `}`"}); + assert from_str(~"{\"a\":1,") == + err({line: 1u, col: 8u, msg: @~"EOF while parsing object"}); + + assert eq(result::get(from_str(~"{}")), mk_dict(~[])); + assert eq(result::get(from_str(~"{\"a\": 3}")), + mk_dict(~[(~"a", num(3.0f))])); + + assert eq(result::get(from_str(~"{ \"a\": null, \"b\" : true }")), mk_dict(~[ - ("a", null), - ("b", boolean(true))])); - assert eq(result::get(from_str("\n{ \"a\": null, \"b\" : true }\n")), + (~"a", null), + (~"b", boolean(true))])); + assert eq(result::get(from_str(~"\n{ \"a\": null, \"b\" : true }\n")), mk_dict(~[ - ("a", null), - ("b", boolean(true))])); - assert eq(result::get(from_str("{\"a\" : 1.0 ,\"b\": [ true ]}")), + (~"a", null), + (~"b", boolean(true))])); + assert eq(result::get(from_str(~"{\"a\" : 1.0 ,\"b\": [ true ]}")), mk_dict(~[ - ("a", num(1.0)), - ("b", list(@~[boolean(true)])) + (~"a", num(1.0)), + (~"b", list(@~[boolean(true)])) ])); assert eq(result::get(from_str( - "{" + - "\"a\": 1.0, " + - "\"b\": [" + - "true," + - "\"foo\\nbar\", " + - "{ \"c\": {\"d\": null} } " + - "]" + - "}")), + ~"{" + + ~"\"a\": 1.0, " + + ~"\"b\": [" + + ~"true," + + ~"\"foo\\nbar\", " + + ~"{ \"c\": {\"d\": null} } " + + ~"]" + + ~"}")), mk_dict(~[ - ("a", num(1.0f)), - ("b", list(@~[ + (~"a", num(1.0f)), + (~"b", list(@~[ boolean(true), - string(@"foo\nbar"/~), + string(@~"foo\nbar"), mk_dict(~[ - ("c", mk_dict(~[("d", null)])) + (~"c", mk_dict(~[(~"d", null)])) ]) ])) ])); @@ -876,7 +877,7 @@ mod tests { #[test] fn test_multiline_errors() { - assert from_str("{\n \"foo\":\n \"bar\"") == - err({line: 3u, col: 8u, msg: @"EOF while parsing object"/~}); + assert from_str(~"{\n \"foo\":\n \"bar\"") == + err({line: 3u, col: 8u, msg: @~"EOF while parsing object"}); } } diff --git a/src/libstd/list.rs b/src/libstd/list.rs index 3a7b0ffd79a..46bb01250fe 100644 --- a/src/libstd/list.rs +++ b/src/libstd/list.rs @@ -85,7 +85,7 @@ fn len<T>(ls: @list<T>) -> uint { pure fn tail<T: copy>(ls: @list<T>) -> @list<T> { alt *ls { cons(_, tl) { ret tl; } - nil { fail "list empty" } + nil { fail ~"list empty" } } } diff --git a/src/libstd/map.rs b/src/libstd/map.rs index cc88a91bcf2..bce843224d1 100644 --- a/src/libstd/map.rs +++ b/src/libstd/map.rs @@ -237,7 +237,7 @@ mod chained { } fn get(k: K) -> V { - self.find(k).expect("Key not found in table") + self.find(k).expect(~"Key not found in table") } fn [](k: K) -> V { @@ -305,13 +305,13 @@ fn hashmap<K: const, V: copy>(hasher: hashfn<K>, eqer: eqfn<K>) } /// Construct a hashmap for string keys -fn str_hash<V: copy>() -> hashmap<str, V> { +fn str_hash<V: copy>() -> hashmap<~str, V> { ret hashmap(str::hash, str::eq); } /// Construct a hashmap for boxed string keys -fn box_str_hash<V: copy>() -> hashmap<@str/~, V> { - ret hashmap(|x: @str/~| str::hash(*x), |x,y| str::eq(*x,*y)); +fn box_str_hash<V: copy>() -> hashmap<@~str, V> { + ret hashmap(|x: @~str| str::hash(*x), |x,y| str::eq(*x,*y)); } /// Construct a hashmap for byte string keys @@ -356,7 +356,7 @@ fn hash_from_vec<K: const copy, V: copy>(hasher: hashfn<K>, eqer: eqfn<K>, } /// Construct a hashmap from a vector with string keys -fn hash_from_strs<V: copy>(items: ~[(str, V)]) -> hashmap<str, V> { +fn hash_from_strs<V: copy>(items: ~[(~str, V)]) -> hashmap<~str, V> { hash_from_vec(str::hash, str::eq, items) } @@ -385,8 +385,8 @@ mod tests { fn uint_id(&&x: uint) -> uint { x } let hasher_uint: map::hashfn<uint> = uint_id; let eqer_uint: map::eqfn<uint> = eq_uint; - let hasher_str: map::hashfn<str> = str::hash; - let eqer_str: map::eqfn<str> = str::eq; + let hasher_str: map::hashfn<~str> = str::hash; + let eqer_str: map::eqfn<~str> = str::eq; #debug("uint -> uint"); let hm_uu: map::hashmap<uint, uint> = map::hashmap::<uint, uint>(hasher_uint, eqer_uint); @@ -400,49 +400,49 @@ mod tests { assert (hm_uu.get(12u) == 14u); assert (!hm_uu.insert(12u, 12u)); assert (hm_uu.get(12u) == 12u); - let ten: str = "ten"; - let eleven: str = "eleven"; - let twelve: str = "twelve"; + let ten: ~str = ~"ten"; + let eleven: ~str = ~"eleven"; + let twelve: ~str = ~"twelve"; #debug("str -> uint"); - let hm_su: map::hashmap<str, uint> = - map::hashmap::<str, uint>(hasher_str, eqer_str); - assert (hm_su.insert("ten", 12u)); + let hm_su: map::hashmap<~str, uint> = + map::hashmap::<~str, uint>(hasher_str, eqer_str); + assert (hm_su.insert(~"ten", 12u)); assert (hm_su.insert(eleven, 13u)); - assert (hm_su.insert("twelve", 14u)); + assert (hm_su.insert(~"twelve", 14u)); assert (hm_su.get(eleven) == 13u); - assert (hm_su.get("eleven") == 13u); - assert (hm_su.get("twelve") == 14u); - assert (hm_su.get("ten") == 12u); - assert (!hm_su.insert("twelve", 14u)); - assert (hm_su.get("twelve") == 14u); - assert (!hm_su.insert("twelve", 12u)); - assert (hm_su.get("twelve") == 12u); + assert (hm_su.get(~"eleven") == 13u); + assert (hm_su.get(~"twelve") == 14u); + assert (hm_su.get(~"ten") == 12u); + assert (!hm_su.insert(~"twelve", 14u)); + assert (hm_su.get(~"twelve") == 14u); + assert (!hm_su.insert(~"twelve", 12u)); + assert (hm_su.get(~"twelve") == 12u); #debug("uint -> str"); - let hm_us: map::hashmap<uint, str> = - map::hashmap::<uint, str>(hasher_uint, eqer_uint); - assert (hm_us.insert(10u, "twelve")); - assert (hm_us.insert(11u, "thirteen")); - assert (hm_us.insert(12u, "fourteen")); - assert (str::eq(hm_us.get(11u), "thirteen")); - assert (str::eq(hm_us.get(12u), "fourteen")); - assert (str::eq(hm_us.get(10u), "twelve")); - assert (!hm_us.insert(12u, "fourteen")); - assert (str::eq(hm_us.get(12u), "fourteen")); - assert (!hm_us.insert(12u, "twelve")); - assert (str::eq(hm_us.get(12u), "twelve")); + let hm_us: map::hashmap<uint, ~str> = + map::hashmap::<uint, ~str>(hasher_uint, eqer_uint); + assert (hm_us.insert(10u, ~"twelve")); + assert (hm_us.insert(11u, ~"thirteen")); + assert (hm_us.insert(12u, ~"fourteen")); + assert (str::eq(hm_us.get(11u), ~"thirteen")); + assert (str::eq(hm_us.get(12u), ~"fourteen")); + assert (str::eq(hm_us.get(10u), ~"twelve")); + assert (!hm_us.insert(12u, ~"fourteen")); + assert (str::eq(hm_us.get(12u), ~"fourteen")); + assert (!hm_us.insert(12u, ~"twelve")); + assert (str::eq(hm_us.get(12u), ~"twelve")); #debug("str -> str"); - let hm_ss: map::hashmap<str, str> = - map::hashmap::<str, str>(hasher_str, eqer_str); - assert (hm_ss.insert(ten, "twelve")); - assert (hm_ss.insert(eleven, "thirteen")); - assert (hm_ss.insert(twelve, "fourteen")); - assert (str::eq(hm_ss.get("eleven"), "thirteen")); - assert (str::eq(hm_ss.get("twelve"), "fourteen")); - assert (str::eq(hm_ss.get("ten"), "twelve")); - assert (!hm_ss.insert("twelve", "fourteen")); - assert (str::eq(hm_ss.get("twelve"), "fourteen")); - assert (!hm_ss.insert("twelve", "twelve")); - assert (str::eq(hm_ss.get("twelve"), "twelve")); + let hm_ss: map::hashmap<~str, ~str> = + map::hashmap::<~str, ~str>(hasher_str, eqer_str); + assert (hm_ss.insert(ten, ~"twelve")); + assert (hm_ss.insert(eleven, ~"thirteen")); + assert (hm_ss.insert(twelve, ~"fourteen")); + assert (str::eq(hm_ss.get(~"eleven"), ~"thirteen")); + assert (str::eq(hm_ss.get(~"twelve"), ~"fourteen")); + assert (str::eq(hm_ss.get(~"ten"), ~"twelve")); + assert (!hm_ss.insert(~"twelve", ~"fourteen")); + assert (str::eq(hm_ss.get(~"twelve"), ~"fourteen")); + assert (!hm_ss.insert(~"twelve", ~"twelve")); + assert (str::eq(hm_ss.get(~"twelve"), ~"twelve")); #debug("*** finished test_simple"); } @@ -484,10 +484,10 @@ mod tests { i += 1u; } #debug("str -> str"); - let hasher_str: map::hashfn<str> = str::hash; - let eqer_str: map::eqfn<str> = str::eq; - let hm_ss: map::hashmap<str, str> = - map::hashmap::<str, str>(hasher_str, eqer_str); + let hasher_str: map::hashfn<~str> = str::hash; + let eqer_str: map::eqfn<~str> = str::eq; + let hm_ss: map::hashmap<~str, ~str> = + map::hashmap::<~str, ~str>(hasher_str, eqer_str); i = 0u; while i < num_to_insert { assert hm_ss.insert(uint::to_str(i, 2u), uint::to_str(i * i, 2u)); @@ -602,27 +602,27 @@ mod tests { #[test] fn test_contains_key() { - let key = "k"; - let map = map::hashmap::<str, str>(str::hash, str::eq); + let key = ~"k"; + let map = map::hashmap::<~str, ~str>(str::hash, str::eq); assert (!map.contains_key(key)); - map.insert(key, "val"); + map.insert(key, ~"val"); assert (map.contains_key(key)); } #[test] fn test_find() { - let key = "k"; - let map = map::hashmap::<str, str>(str::hash, str::eq); + let key = ~"k"; + let map = map::hashmap::<~str, ~str>(str::hash, str::eq); assert (option::is_none(map.find(key))); - map.insert(key, "val"); - assert (option::get(map.find(key)) == "val"); + map.insert(key, ~"val"); + assert (option::get(map.find(key)) == ~"val"); } #[test] fn test_clear() { - let key = "k"; - let map = map::hashmap::<str, str>(str::hash, str::eq); - map.insert(key, "val"); + let key = ~"k"; + let map = map::hashmap::<~str, ~str>(str::hash, str::eq); + map.insert(key, ~"val"); assert (map.size() == 1); assert (map.contains_key(key)); map.clear(); @@ -633,13 +633,13 @@ mod tests { #[test] fn test_hash_from_vec() { let map = map::hash_from_strs(~[ - ("a", 1), - ("b", 2), - ("c", 3) + (~"a", 1), + (~"b", 2), + (~"c", 3) ]); assert map.size() == 3u; - assert map.get("a") == 1; - assert map.get("b") == 2; - assert map.get("c") == 3; + assert map.get(~"a") == 1; + assert map.get(~"b") == 2; + assert map.get(~"c") == 3; } } diff --git a/src/libstd/md4.rs b/src/libstd/md4.rs index d7bd7ed811a..134091dfd1d 100644 --- a/src/libstd/md4.rs +++ b/src/libstd/md4.rs @@ -82,17 +82,17 @@ fn md4(msg: ~[u8]) -> {a: u32, b: u32, c: u32, d: u32} { ret {a: a, b: b, c: c, d: d}; } -fn md4_str(msg: ~[u8]) -> str { +fn md4_str(msg: ~[u8]) -> ~str { let {a, b, c, d} = md4(msg); fn app(a: u32, b: u32, c: u32, d: u32, f: fn(u32)) { f(a); f(b); f(c); f(d); } - let mut result = ""; + let mut result = ~""; do app(a, b, c, d) |u| { let mut i = 0u32; while i < 4u32 { let byte = (u >> (i * 8u32)) as u8; - if byte <= 16u8 { result += "0"; } + if byte <= 16u8 { result += ~"0"; } result += uint::to_str(byte as uint, 16u); i += 1u32; } @@ -100,19 +100,19 @@ fn md4_str(msg: ~[u8]) -> str { result } -fn md4_text(msg: str) -> str { md4_str(str::bytes(msg)) } +fn md4_text(msg: ~str) -> ~str { md4_str(str::bytes(msg)) } #[test] fn test_md4() { - assert md4_text("") == "31d6cfe0d16ae931b73c59d7e0c089c0"; - assert md4_text("a") == "bde52cb31de33e46245e05fbdbd6fb24"; - assert md4_text("abc") == "a448017aaf21d8525fc10ae87aa6729d"; - assert md4_text("message digest") == "d9130a8164549fe818874806e1c7014b"; - assert md4_text("abcdefghijklmnopqrstuvwxyz") == - "d79e1c308aa5bbcdeea8ed63df412da9"; - assert md4_text("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123\ - 456789") == "043f8582f241db351ce627e153e7f0e4"; - assert md4_text("12345678901234567890123456789012345678901234567890123456\ - 789012345678901234567890") == - "e33b4ddc9c38f2199c3e7b164fcc0536"; + assert md4_text(~"") == ~"31d6cfe0d16ae931b73c59d7e0c089c0"; + assert md4_text(~"a") == ~"bde52cb31de33e46245e05fbdbd6fb24"; + assert md4_text(~"abc") == ~"a448017aaf21d8525fc10ae87aa6729d"; + assert md4_text(~"message digest") == ~"d9130a8164549fe818874806e1c7014b"; + assert md4_text(~"abcdefghijklmnopqrstuvwxyz") == + ~"d79e1c308aa5bbcdeea8ed63df412da9"; + assert md4_text(~"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\ + 0123456789") == ~"043f8582f241db351ce627e153e7f0e4"; + assert md4_text(~"1234567890123456789012345678901234567890123456789\ + 0123456789012345678901234567890") == + ~"e33b4ddc9c38f2199c3e7b164fcc0536"; } diff --git a/src/libstd/net_ip.rs b/src/libstd/net_ip.rs index abb548655d4..a78b6a5f172 100644 --- a/src/libstd/net_ip.rs +++ b/src/libstd/net_ip.rs @@ -36,7 +36,7 @@ enum ip_addr { /// Human-friendly feedback on why a parse_addr attempt failed type parse_addr_err = { - err_msg: str + err_msg: ~str }; /** @@ -46,13 +46,13 @@ type parse_addr_err = { * * * ip - a `std::net::ip::ip_addr` */ -fn format_addr(ip: ip_addr) -> str { +fn format_addr(ip: ip_addr) -> ~str { alt ip { ipv4(addr) { unsafe { let result = uv_ip4_name(&addr); - if result == "" { - fail "failed to convert inner sockaddr_in address to str" + if result == ~"" { + fail ~"failed to convert inner sockaddr_in address to str" } result } @@ -60,8 +60,8 @@ fn format_addr(ip: ip_addr) -> str { ipv6(addr) { unsafe { let result = uv_ip6_name(&addr); - if result == "" { - fail "failed to convert inner sockaddr_in address to str" + if result == ~"" { + fail ~"failed to convert inner sockaddr_in address to str" } result } @@ -88,7 +88,7 @@ enum ip_get_addr_err { * a vector of `ip_addr` results, in the case of success, or an error * object in the case of failure */ -fn get_addr(++node: str, iotask: iotask) +fn get_addr(++node: ~str, iotask: iotask) -> result::result<~[ip_addr], ip_get_addr_err> unsafe { do comm::listen |output_ch| { do str::unpack_slice(node) |node_ptr, len| { @@ -137,7 +137,7 @@ mod v4 { * * * an `ip_addr` of the `ipv4` variant */ - fn parse_addr(ip: str) -> ip_addr { + fn parse_addr(ip: ~str) -> ip_addr { alt try_parse_addr(ip) { result::ok(addr) { copy(addr) } result::err(err_data) { @@ -154,7 +154,7 @@ mod v4 { *((ptr::addr_of(self)) as *u32) } } - fn parse_to_ipv4_rep(ip: str) -> result::result<ipv4_rep, str> { + fn parse_to_ipv4_rep(ip: ~str) -> result::result<ipv4_rep, ~str> { let parts = vec::map(str::split_char(ip, '.'), |s| { alt uint::from_str(s) { some(n) if n <= 255u { n } @@ -172,7 +172,7 @@ mod v4 { c: parts[2] as u8, d: parts[3] as u8}) } } - fn try_parse_addr(ip: str) -> result::result<ip_addr,parse_addr_err> { + fn try_parse_addr(ip: ~str) -> result::result<ip_addr,parse_addr_err> { unsafe { let INADDR_NONE = ll::get_INADDR_NONE(); let ip_rep_result = parse_to_ipv4_rep(ip); @@ -196,7 +196,7 @@ mod v4 { if result::get(ref_ip_rep_result).as_u32() == INADDR_NONE && !input_is_inaddr_none { ret result::err( - {err_msg: "uv_ip4_name produced invalid result."}) + {err_msg: ~"uv_ip4_name produced invalid result."}) } else { result::ok(ipv4(copy(new_addr))) @@ -220,7 +220,7 @@ mod v6 { * * * an `ip_addr` of the `ipv6` variant */ - fn parse_addr(ip: str) -> ip_addr { + fn parse_addr(ip: ~str) -> ip_addr { alt try_parse_addr(ip) { result::ok(addr) { copy(addr) } result::err(err_data) { @@ -228,7 +228,7 @@ mod v6 { } } } - fn try_parse_addr(ip: str) -> result::result<ip_addr,parse_addr_err> { + fn try_parse_addr(ip: ~str) -> result::result<ip_addr,parse_addr_err> { unsafe { // need to figure out how to establish a parse failure.. let new_addr = uv_ip6_addr(ip, 22); @@ -237,7 +237,7 @@ mod v6 { ip, reparsed_name)); // '::' appears to be uv_ip6_name() returns for bogus // parses.. - if ip != "::" && reparsed_name == "::" { + if ip != ~"::" && reparsed_name == ~"::" { result::err({err_msg:#fmt("failed to parse '%s'", ip)}) } @@ -254,7 +254,7 @@ type get_addr_data = { extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int, res: *addrinfo) unsafe { - log(debug, "in get_addr_cb"); + log(debug, ~"in get_addr_cb"); let handle_data = get_data_for_req(handle) as *get_addr_data; if status == 0i32 { @@ -272,8 +272,8 @@ extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int, *ll::addrinfo_as_sockaddr_in6(curr_addr)))) } else { - log(debug, "curr_addr is not of family AF_INET or "+ - "AF_INET6. Error."); + log(debug, ~"curr_addr is not of family AF_INET or "+ + ~"AF_INET6. Error."); (*handle_data).output_ch.send( result::err(get_addr_unknown_error)); break; @@ -282,7 +282,7 @@ extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int, let next_addr = ll::get_next_addrinfo(curr_addr); if next_addr == ptr::null::<addrinfo>() as *addrinfo { - log(debug, "null next_addr encountered. no mas"); + log(debug, ~"null next_addr encountered. no mas"); break; } else { @@ -295,33 +295,33 @@ extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int, (*handle_data).output_ch.send(result::ok(out_vec)); } else { - log(debug, "addrinfo pointer is NULL"); + log(debug, ~"addrinfo pointer is NULL"); (*handle_data).output_ch.send( result::err(get_addr_unknown_error)); } } else { - log(debug, "status != 0 error in get_addr_cb"); + log(debug, ~"status != 0 error in get_addr_cb"); (*handle_data).output_ch.send( result::err(get_addr_unknown_error)); } if res != (ptr::null::<addrinfo>()) { uv_freeaddrinfo(res); } - log(debug, "leaving get_addr_cb"); + log(debug, ~"leaving get_addr_cb"); } #[cfg(test)] mod test { #[test] fn test_ip_ipv4_parse_and_format_ip() { - let localhost_str = "127.0.0.1"; + let localhost_str = ~"127.0.0.1"; assert (format_addr(v4::parse_addr(localhost_str)) == localhost_str) } #[test] fn test_ip_ipv6_parse_and_format_ip() { - let localhost_str = "::1"; + let localhost_str = ~"::1"; let format_result = format_addr(v6::parse_addr(localhost_str)); log(debug, #fmt("results: expected: '%s' actual: '%s'", localhost_str, format_result)); @@ -329,7 +329,7 @@ mod test { } #[test] fn test_ip_ipv4_bad_parse() { - alt v4::try_parse_addr("b4df00d") { + alt v4::try_parse_addr(~"b4df00d") { result::err(err_info) { log(debug, #fmt("got error as expected %?", err_info)); assert true; @@ -342,7 +342,7 @@ mod test { #[test] #[ignore(target_os="win32")] fn test_ip_ipv6_bad_parse() { - alt v6::try_parse_addr("::,~2234k;") { + alt v6::try_parse_addr(~"::,~2234k;") { result::err(err_info) { log(debug, #fmt("got error as expected %?", err_info)); assert true; @@ -355,11 +355,11 @@ mod test { #[test] #[ignore(reason = "valgrind says it's leaky")] fn test_ip_get_addr() { - let localhost_name = "localhost"; + let localhost_name = ~"localhost"; let iotask = uv::global_loop::get(); let ga_result = get_addr(localhost_name, iotask); if result::is_err(ga_result) { - fail "got err result from net::ip::get_addr();" + fail ~"got err result from net::ip::get_addr();" } // note really sure how to realiably test/assert // this.. mostly just wanting to see it work, atm. @@ -369,10 +369,10 @@ mod test { for vec::each(results) |r| { let ipv_prefix = alt r { ipv4(_) { - "IPv4" + ~"IPv4" } ipv6(_) { - "IPv6" + ~"IPv6" } }; log(debug, #fmt("test_get_addr: result %s: '%s'", @@ -385,7 +385,7 @@ mod test { #[test] #[ignore(reason = "valgrind says it's leaky")] fn test_ip_get_addr_bad_input() { - let localhost_name = "sjkl234m,./sdf"; + let localhost_name = ~"sjkl234m,./sdf"; let iotask = uv::global_loop::get(); let ga_result = get_addr(localhost_name, iotask); assert result::is_err(ga_result); diff --git a/src/libstd/net_tcp.rs b/src/libstd/net_tcp.rs index 17ffae1b5f4..31b8841933b 100644 --- a/src/libstd/net_tcp.rs +++ b/src/libstd/net_tcp.rs @@ -62,8 +62,8 @@ class tcp_socket_buf { /// Contains raw, string-based, error information returned from libuv type tcp_err_data = { - err_name: str, - err_msg: str + err_name: ~str, + err_msg: ~str }; /// Details returned as part of a `result::err` result from `tcp::listen` enum tcp_listen_err_data { @@ -71,7 +71,7 @@ enum tcp_listen_err_data { * Some unplanned-for error. The first and second fields correspond * to libuv's `err_name` and `err_msg` fields, respectively. */ - generic_listen_err(str, str), + generic_listen_err(~str, ~str), /** * Failed to bind to the requested IP/Port, because it is already in use. * @@ -98,7 +98,7 @@ enum tcp_connect_err_data { * Some unplanned-for error. The first and second fields correspond * to libuv's `err_name` and `err_msg` fields, respectively. */ - generic_connect_err(str, str), + generic_connect_err(~str, ~str), /// Invalid IP or invalid port connection_refused } @@ -147,15 +147,15 @@ fn connect(-input_ip: ip::ip_addr, port: uint, log(debug, #fmt("stream_handle_ptr outside interact %?", stream_handle_ptr)); do iotask::interact(iotask) |loop_ptr| { - log(debug, "in interact cb for tcp client connect.."); + log(debug, ~"in interact cb for tcp client connect.."); log(debug, #fmt("stream_handle_ptr in interact %?", stream_handle_ptr)); alt uv::ll::tcp_init( loop_ptr, stream_handle_ptr) { 0i32 { - log(debug, "tcp_init successful"); + log(debug, ~"tcp_init successful"); alt input_ip { ipv4 { - log(debug, "dealing w/ ipv4 connection.."); + log(debug, ~"dealing w/ ipv4 connection.."); let connect_req_ptr = ptr::addr_of((*socket_data_ptr).connect_req); let addr_str = ip::format_addr(input_ip); @@ -186,7 +186,7 @@ fn connect(-input_ip: ip::ip_addr, port: uint, }; alt connect_result { 0i32 { - log(debug, "tcp_connect successful"); + log(debug, ~"tcp_connect successful"); // reusable data that we'll have for the // duration.. uv::ll::set_data_for_uv_handle(stream_handle_ptr, @@ -196,7 +196,7 @@ fn connect(-input_ip: ip::ip_addr, port: uint, // outcome.. uv::ll::set_data_for_req(connect_req_ptr, conn_data_ptr); - log(debug, "leaving tcp_connect interact cb..."); + log(debug, ~"leaving tcp_connect interact cb..."); // let tcp_connect_on_connect_cb send on // the result_ch, now.. } @@ -224,17 +224,17 @@ fn connect(-input_ip: ip::ip_addr, port: uint, }; alt comm::recv(result_po) { conn_success { - log(debug, "tcp::connect - received success on result_po"); + log(debug, ~"tcp::connect - received success on result_po"); result::ok(tcp_socket(socket_data)) } conn_failure(err_data) { comm::recv(closed_signal_po); - log(debug, "tcp::connect - received failure on result_po"); + log(debug, ~"tcp::connect - received failure on result_po"); // still have to free the malloc'd stream handle.. rustrt::rust_uv_current_kernel_free(stream_handle_ptr as *libc::c_void); let tcp_conn_err = alt err_data.err_name { - "ECONNREFUSED" { connection_refused } + ~"ECONNREFUSED" { connection_refused } _ { generic_connect_err(err_data.err_name, err_data.err_msg) } }; result::err(tcp_conn_err) @@ -497,31 +497,31 @@ fn accept(new_conn: tcp_new_connection) // the rules here because this always has to be // called within the context of a listen() new_connect_cb // callback (or it will likely fail and drown your cat) - log(debug, "in interact cb for tcp::accept"); + log(debug, ~"in interact cb for tcp::accept"); let loop_ptr = uv::ll::get_loop_for_uv_handle( server_handle_ptr); alt uv::ll::tcp_init(loop_ptr, client_stream_handle_ptr) { 0i32 { - log(debug, "uv_tcp_init successful for client stream"); + log(debug, ~"uv_tcp_init successful for client stream"); alt uv::ll::accept( server_handle_ptr as *libc::c_void, client_stream_handle_ptr as *libc::c_void) { 0i32 { - log(debug, "successfully accepted client connection"); + log(debug, ~"successfully accepted client connection"); uv::ll::set_data_for_uv_handle(client_stream_handle_ptr, client_socket_data_ptr as *libc::c_void); comm::send(result_ch, none); } _ { - log(debug, "failed to accept client conn"); + log(debug, ~"failed to accept client conn"); comm::send(result_ch, some( uv::ll::get_last_err_data(loop_ptr).to_tcp_err())); } } } _ { - log(debug, "failed to init client stream"); + log(debug, ~"failed to init client stream"); comm::send(result_ch, some( uv::ll::get_last_err_data(loop_ptr).to_tcp_err())); } @@ -642,21 +642,21 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint, comm::send(setup_ch, none); } _ { - log(debug, "failure to uv_listen()"); + log(debug, ~"failure to uv_listen()"); let err_data = uv::ll::get_last_err_data(loop_ptr); comm::send(setup_ch, some(err_data)); } } } _ { - log(debug, "failure to uv_tcp_bind"); + log(debug, ~"failure to uv_tcp_bind"); let err_data = uv::ll::get_last_err_data(loop_ptr); comm::send(setup_ch, some(err_data)); } } } _ { - log(debug, "failure to uv_tcp_init"); + log(debug, ~"failure to uv_tcp_init"); let err_data = uv::ll::get_last_err_data(loop_ptr); comm::send(setup_ch, some(err_data)); } @@ -674,12 +674,12 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint, }; stream_closed_po.recv(); alt err_data.err_name { - "EACCES" { - log(debug, "Got EACCES error"); + ~"EACCES" { + log(debug, ~"Got EACCES error"); result::err(access_denied) } - "EADDRINUSE" { - log(debug, "Got EADDRINUSE error"); + ~"EADDRINUSE" { + log(debug, ~"Got EADDRINUSE error"); result::err(address_in_use) } _ { @@ -855,13 +855,13 @@ fn tear_down_socket_data(socket_data: @tcp_socket_data) unsafe { log(debug, #fmt("about to free socket_data at %?", socket_data)); rustrt::rust_uv_current_kernel_free(stream_handle_ptr as *libc::c_void); - log(debug, "exiting dtor for tcp_socket"); + log(debug, ~"exiting dtor for tcp_socket"); } // shared implementation for tcp::read fn read_common_impl(socket_data: *tcp_socket_data, timeout_msecs: uint) -> result::result<~[u8],tcp_err_data> unsafe { - log(debug, "starting tcp::read"); + log(debug, ~"starting tcp::read"); let iotask = (*socket_data).iotask; let rs_result = read_start_common_impl(socket_data); if result::is_err(rs_result) { @@ -869,26 +869,26 @@ fn read_common_impl(socket_data: *tcp_socket_data, timeout_msecs: uint) result::err(err_data) } else { - log(debug, "tcp::read before recv_timeout"); + log(debug, ~"tcp::read before recv_timeout"); let read_result = if timeout_msecs > 0u { timer::recv_timeout( iotask, timeout_msecs, result::get(rs_result)) } else { some(comm::recv(result::get(rs_result))) }; - log(debug, "tcp::read after recv_timeout"); + log(debug, ~"tcp::read after recv_timeout"); alt read_result { none { - log(debug, "tcp::read: timed out.."); + log(debug, ~"tcp::read: timed out.."); let err_data = { - err_name: "TIMEOUT", - err_msg: "req timed out" + err_name: ~"TIMEOUT", + err_msg: ~"req timed out" }; read_stop_common_impl(socket_data); result::err(err_data) } some(data_result) { - log(debug, "tcp::read got data"); + log(debug, ~"tcp::read got data"); read_stop_common_impl(socket_data); data_result } @@ -903,14 +903,14 @@ fn read_stop_common_impl(socket_data: *tcp_socket_data) -> let stop_po = comm::port::<option<tcp_err_data>>(); let stop_ch = comm::chan(stop_po); do iotask::interact((*socket_data).iotask) |loop_ptr| { - log(debug, "in interact cb for tcp::read_stop"); + log(debug, ~"in interact cb for tcp::read_stop"); alt uv::ll::read_stop(stream_handle_ptr as *uv::ll::uv_stream_t) { 0i32 { - log(debug, "successfully called uv_read_stop"); + log(debug, ~"successfully called uv_read_stop"); comm::send(stop_ch, none); } _ { - log(debug, "failure in calling uv_read_stop"); + log(debug, ~"failure in calling uv_read_stop"); let err_data = uv::ll::get_last_err_data(loop_ptr); comm::send(stop_ch, some(err_data.to_tcp_err())); } @@ -933,18 +933,18 @@ fn read_start_common_impl(socket_data: *tcp_socket_data) let stream_handle_ptr = (*socket_data).stream_handle_ptr; let start_po = comm::port::<option<uv::ll::uv_err_data>>(); let start_ch = comm::chan(start_po); - log(debug, "in tcp::read_start before interact loop"); + log(debug, ~"in tcp::read_start before interact loop"); do iotask::interact((*socket_data).iotask) |loop_ptr| { log(debug, #fmt("in tcp::read_start interact cb %?", loop_ptr)); alt uv::ll::read_start(stream_handle_ptr as *uv::ll::uv_stream_t, on_alloc_cb, on_tcp_read_cb) { 0i32 { - log(debug, "success doing uv_read_start"); + log(debug, ~"success doing uv_read_start"); comm::send(start_ch, none); } _ { - log(debug, "error attempting uv_read_start"); + log(debug, ~"error attempting uv_read_start"); let err_data = uv::ll::get_last_err_data(loop_ptr); comm::send(start_ch, some(err_data)); } @@ -985,11 +985,11 @@ fn write_common_impl(socket_data_ptr: *tcp_socket_data, write_buf_vec_ptr, tcp_write_complete_cb) { 0i32 { - log(debug, "uv_write() invoked successfully"); + log(debug, ~"uv_write() invoked successfully"); uv::ll::set_data_for_req(write_req_ptr, write_data_ptr); } _ { - log(debug, "error invoking uv_write()"); + log(debug, ~"error invoking uv_write()"); let err_data = uv::ll::get_last_err_data(loop_ptr); comm::send((*write_data_ptr).result_ch, tcp_write_error(err_data.to_tcp_err())); @@ -1113,13 +1113,13 @@ extern fn on_tcp_read_cb(stream: *uv::ll::uv_stream_t, } } uv::ll::free_base_of_buf(buf); - log(debug, "exiting on_tcp_read_cb"); + log(debug, ~"exiting on_tcp_read_cb"); } extern fn on_alloc_cb(handle: *libc::c_void, ++suggested_size: size_t) -> uv::ll::uv_buf_t unsafe { - log(debug, "tcp read on_alloc_cb!"); + log(debug, ~"tcp read on_alloc_cb!"); let char_ptr = uv::ll::malloc_buf_base_of(suggested_size); log(debug, #fmt("tcp read on_alloc_cb h: %? char_ptr: %u sugsize: %u", handle, @@ -1137,7 +1137,7 @@ extern fn tcp_socket_dtor_close_cb(handle: *uv::ll::uv_tcp_t) unsafe { as *tcp_socket_close_data; let closed_ch = (*data).closed_ch; comm::send(closed_ch, ()); - log(debug, "tcp_socket_dtor_close_cb exiting.."); + log(debug, ~"tcp_socket_dtor_close_cb exiting.."); } extern fn tcp_write_complete_cb(write_req: *uv::ll::uv_write_t, @@ -1145,14 +1145,14 @@ extern fn tcp_write_complete_cb(write_req: *uv::ll::uv_write_t, let write_data_ptr = uv::ll::get_data_for_req(write_req) as *write_req_data; if status == 0i32 { - log(debug, "successful write complete"); + log(debug, ~"successful write complete"); comm::send((*write_data_ptr).result_ch, tcp_write_success); } else { let stream_handle_ptr = uv::ll::get_stream_handle_from_write_req( write_req); let loop_ptr = uv::ll::get_loop_for_uv_handle(stream_handle_ptr); let err_data = uv::ll::get_last_err_data(loop_ptr); - log(debug, "failure to write"); + log(debug, ~"failure to write"); comm::send((*write_data_ptr).result_ch, tcp_write_error(err_data)); } } @@ -1187,11 +1187,11 @@ extern fn tcp_connect_on_connect_cb(connect_req_ptr: *uv::ll::uv_connect_t, uv::ll::get_stream_handle_from_connect_req(connect_req_ptr); alt status { 0i32 { - log(debug, "successful tcp connection!"); + log(debug, ~"successful tcp connection!"); comm::send(result_ch, conn_success); } _ { - log(debug, "error in tcp_connect_on_connect_cb"); + log(debug, ~"error in tcp_connect_on_connect_cb"); let loop_ptr = uv::ll::get_loop_for_uv_handle(tcp_stream_ptr); let err_data = uv::ll::get_last_err_data(loop_ptr); log(debug, #fmt("err_data %? %?", err_data.err_name, @@ -1202,7 +1202,7 @@ extern fn tcp_connect_on_connect_cb(connect_req_ptr: *uv::ll::uv_connect_t, uv::ll::close(tcp_stream_ptr, stream_error_close_cb); } } - log(debug, "leaving tcp_connect_on_connect_cb"); + log(debug, ~"leaving tcp_connect_on_connect_cb"); } enum conn_attempt { @@ -1287,12 +1287,12 @@ mod test { } fn impl_gl_tcp_ipv4_server_and_client() { let hl_loop = uv::global_loop::get(); - let server_ip = "127.0.0.1"; + let server_ip = ~"127.0.0.1"; let server_port = 8888u; - let expected_req = "ping"; - let expected_resp = "pong"; + let expected_req = ~"ping"; + let expected_resp = ~"pong"; - let server_result_po = comm::port::<str>(); + let server_result_po = comm::port::<~str>(); let server_result_ch = comm::chan(server_result_po); let cont_po = comm::port::<()>(); @@ -1312,7 +1312,7 @@ mod test { }; comm::recv(cont_po); // client - log(debug, "server started, firing up client.."); + log(debug, ~"server started, firing up client.."); let actual_resp_result = do comm::listen |client_ch| { run_tcp_test_client( server_ip, @@ -1333,11 +1333,11 @@ mod test { } fn impl_gl_tcp_ipv4_client_error_connection_refused() { let hl_loop = uv::global_loop::get(); - let server_ip = "127.0.0.1"; + let server_ip = ~"127.0.0.1"; let server_port = 8889u; - let expected_req = "ping"; + let expected_req = ~"ping"; // client - log(debug, "firing up client.."); + log(debug, ~"firing up client.."); let actual_resp_result = do comm::listen |client_ch| { run_tcp_test_client( server_ip, @@ -1350,18 +1350,18 @@ mod test { connection_refused { } _ { - fail "unknown error.. expected connection_refused" + fail ~"unknown error.. expected connection_refused" } } } fn impl_gl_tcp_ipv4_server_address_in_use() { let hl_loop = uv::global_loop::get(); - let server_ip = "127.0.0.1"; + let server_ip = ~"127.0.0.1"; let server_port = 8890u; - let expected_req = "ping"; - let expected_resp = "pong"; + let expected_req = ~"ping"; + let expected_resp = ~"pong"; - let server_result_po = comm::port::<str>(); + let server_result_po = comm::port::<~str>(); let server_result_ch = comm::chan(server_result_po); let cont_po = comm::port::<()>(); @@ -1386,7 +1386,7 @@ mod test { server_port, hl_loop); // client.. just doing this so that the first server tears down - log(debug, "server started, firing up client.."); + log(debug, ~"server started, firing up client.."); do comm::listen |client_ch| { run_tcp_test_client( server_ip, @@ -1400,14 +1400,14 @@ mod test { assert true; } _ { - fail "expected address_in_use listen error,"+ - "but got a different error varient. check logs."; + fail ~"expected address_in_use listen error,"+ + ~"but got a different error varient. check logs."; } } } fn impl_gl_tcp_ipv4_server_access_denied() { let hl_loop = uv::global_loop::get(); - let server_ip = "127.0.0.1"; + let server_ip = ~"127.0.0.1"; let server_port = 80u; // this one should fail.. let listen_err = run_tcp_test_server_fail( @@ -1419,19 +1419,19 @@ mod test { assert true; } _ { - fail "expected address_in_use listen error,"+ - "but got a different error varient. check logs."; + fail ~"expected address_in_use listen error,"+ + ~"but got a different error varient. check logs."; } } } fn impl_gl_tcp_ipv4_server_client_reader_writer() { let iotask = uv::global_loop::get(); - let server_ip = "127.0.0.1"; + let server_ip = ~"127.0.0.1"; let server_port = 8891u; - let expected_req = "ping"; - let expected_resp = "pong"; + let expected_req = ~"ping"; + let expected_resp = ~"pong"; - let server_result_po = comm::port::<str>(); + let server_result_po = comm::port::<~str>(); let server_result_ch = comm::chan(server_result_po); let cont_po = comm::port::<()>(); @@ -1474,7 +1474,7 @@ mod test { assert str::contains(actual_resp, expected_resp); } - fn buf_write(+w: io::writer, val: str) { + fn buf_write(+w: io::writer, val: ~str) { log(debug, #fmt("BUF_WRITE: val len %?", str::len(val))); do str::byte_slice(val) |b_slice| { log(debug, #fmt("BUF_WRITE: b_slice len %?", @@ -1483,17 +1483,17 @@ mod test { } } - fn buf_read(+r: io::reader, len: uint) -> str { + fn buf_read(+r: io::reader, len: uint) -> ~str { let new_bytes = r.read_bytes(len); log(debug, #fmt("in buf_read.. new_bytes len: %?", vec::len(new_bytes))); str::from_bytes(new_bytes) } - fn run_tcp_test_server(server_ip: str, server_port: uint, resp: str, - server_ch: comm::chan<str>, + fn run_tcp_test_server(server_ip: ~str, server_port: uint, resp: ~str, + server_ch: comm::chan<~str>, cont_ch: comm::chan<()>, - iotask: iotask) -> str { + iotask: iotask) -> ~str { let server_ip_addr = ip::v4::parse_addr(server_ip); let listen_result = listen(server_ip_addr, server_port, 128u, iotask, // on_establish_cb -- called when listener is set up @@ -1505,55 +1505,55 @@ mod test { // risky to run this on the loop, but some users // will want the POWER |new_conn, kill_ch| { - log(debug, "SERVER: new connection!"); + log(debug, ~"SERVER: new connection!"); do comm::listen |cont_ch| { do task::spawn_sched(task::manual_threads(1u)) { - log(debug, "SERVER: starting worker for new req"); + log(debug, ~"SERVER: starting worker for new req"); let accept_result = accept(new_conn); - log(debug, "SERVER: after accept()"); + log(debug, ~"SERVER: after accept()"); if result::is_err(accept_result) { - log(debug, "SERVER: error accept connection"); + log(debug, ~"SERVER: error accept connection"); let err_data = result::get_err(accept_result); comm::send(kill_ch, some(err_data)); log(debug, - "SERVER/WORKER: send on err cont ch"); + ~"SERVER/WORKER: send on err cont ch"); cont_ch.send(()); } else { log(debug, - "SERVER/WORKER: send on cont ch"); + ~"SERVER/WORKER: send on cont ch"); cont_ch.send(()); let sock = result::unwrap(accept_result); - log(debug, "SERVER: successfully accepted"+ - "connection!"); + log(debug, ~"SERVER: successfully accepted"+ + ~"connection!"); let received_req_bytes = read(sock, 0u); alt received_req_bytes { result::ok(data) { - log(debug, "SERVER: got REQ str::from_bytes.."); + log(debug, ~"SERVER: got REQ str::from_bytes.."); log(debug, #fmt("SERVER: REQ data len: %?", vec::len(data))); server_ch.send( str::from_bytes(data)); - log(debug, "SERVER: before write"); + log(debug, ~"SERVER: before write"); tcp_write_single(sock, str::bytes(resp)); - log(debug, "SERVER: after write.. die"); + log(debug, ~"SERVER: after write.. die"); comm::send(kill_ch, none); } result::err(err_data) { log(debug, #fmt("SERVER: error recvd: %s %s", err_data.err_name, err_data.err_msg)); comm::send(kill_ch, some(err_data)); - server_ch.send(""); + server_ch.send(~""); } } - log(debug, "SERVER: worker spinning down"); + log(debug, ~"SERVER: worker spinning down"); } } - log(debug, "SERVER: waiting to recv on cont_ch"); + log(debug, ~"SERVER: waiting to recv on cont_ch"); cont_ch.recv() }; - log(debug, "SERVER: recv'd on cont_ch..leaving listen cb"); + log(debug, ~"SERVER: recv'd on cont_ch..leaving listen cb"); }); // err check on listen_result if result::is_err(listen_result) { @@ -1563,10 +1563,10 @@ mod test { name, msg); } access_denied { - fail "SERVER: exited abnormally, got access denied.."; + fail ~"SERVER: exited abnormally, got access denied.."; } address_in_use { - fail "SERVER: exited abnormally, got address in use..."; + fail ~"SERVER: exited abnormally, got address in use..."; } } } @@ -1575,7 +1575,7 @@ mod test { ret_val } - fn run_tcp_test_server_fail(server_ip: str, server_port: uint, + fn run_tcp_test_server_fail(server_ip: ~str, server_port: uint, iotask: iotask) -> tcp_listen_err_data { let server_ip_addr = ip::v4::parse_addr(server_ip); let listen_result = listen(server_ip_addr, server_port, 128u, iotask, @@ -1593,20 +1593,20 @@ mod test { result::get_err(listen_result) } else { - fail "SERVER: did not fail as expected" + fail ~"SERVER: did not fail as expected" } } - fn run_tcp_test_client(server_ip: str, server_port: uint, resp: str, - client_ch: comm::chan<str>, - iotask: iotask) -> result::result<str, + fn run_tcp_test_client(server_ip: ~str, server_port: uint, resp: ~str, + client_ch: comm::chan<~str>, + iotask: iotask) -> result::result<~str, tcp_connect_err_data> { let server_ip_addr = ip::v4::parse_addr(server_ip); - log(debug, "CLIENT: starting.."); + log(debug, ~"CLIENT: starting.."); let connect_result = connect(server_ip_addr, server_port, iotask); if result::is_err(connect_result) { - log(debug, "CLIENT: failed to connect"); + log(debug, ~"CLIENT: failed to connect"); let err_data = result::get_err(connect_result); err(err_data) } @@ -1616,8 +1616,8 @@ mod test { tcp_write_single(sock, resp_bytes); let read_result = sock.read(0u); if read_result.is_err() { - log(debug, "CLIENT: failure to read"); - ok("") + log(debug, ~"CLIENT: failure to read"); + ok(~"") } else { client_ch.send(str::from_bytes(read_result.get())); @@ -1633,12 +1633,12 @@ mod test { let write_result_future = sock.write_future(val); let write_result = write_result_future.get(); if result::is_err(write_result) { - log(debug, "tcp_write_single: write failed!"); + log(debug, ~"tcp_write_single: write failed!"); let err_data = result::get_err(write_result); log(debug, #fmt("tcp_write_single err name: %s msg: %s", err_data.err_name, err_data.err_msg)); // meh. torn on what to do here. - fail "tcp_write_single failed"; + fail ~"tcp_write_single failed"; } } } diff --git a/src/libstd/par.rs b/src/libstd/par.rs index 9bf6a021282..ce78bc945db 100644 --- a/src/libstd/par.rs +++ b/src/libstd/par.rs @@ -31,7 +31,7 @@ fn map_slices<A: copy send, B: copy send>( let len = xs.len(); if len < min_granularity { - log(info, "small slice"); + log(info, ~"small slice"); // This is a small vector, fall back on the normal map. ~[f()(0u, xs)] } @@ -42,7 +42,7 @@ fn map_slices<A: copy send, B: copy send>( let mut futures = ~[]; let mut base = 0u; - log(info, "spawning tasks"); + log(info, ~"spawning tasks"); while base < len { let end = uint::min(len, base + items_per_task); // FIXME: why is the ::<A, ()> annotation required here? (#2617) @@ -66,7 +66,7 @@ fn map_slices<A: copy send, B: copy send>( }; base += items_per_task; } - log(info, "tasks spawned"); + log(info, ~"tasks spawned"); log(info, #fmt("num_tasks: %?", (num_tasks, futures.len()))); assert(num_tasks == futures.len()); diff --git a/src/libstd/prettyprint.rs b/src/libstd/prettyprint.rs index 497ed8f0c06..dbeb5ab6381 100644 --- a/src/libstd/prettyprint.rs +++ b/src/libstd/prettyprint.rs @@ -4,7 +4,7 @@ import serialization::serializer; impl of serializer for writer { fn emit_nil() { - self.write_str("()") + self.write_str(~"()") } fn emit_uint(v: uint) { @@ -63,68 +63,68 @@ impl of serializer for writer { self.write_str(#fmt["%?_f32", v]); } - fn emit_str(v: str) { + fn emit_str(v: ~str) { self.write_str(#fmt["%?", v]); } - fn emit_enum(_name: str, f: fn()) { + fn emit_enum(_name: ~str, f: fn()) { f(); } - fn emit_enum_variant(v_name: str, _v_id: uint, sz: uint, f: fn()) { + fn emit_enum_variant(v_name: ~str, _v_id: uint, sz: uint, f: fn()) { self.write_str(v_name); - if sz > 0u { self.write_str("("); } + if sz > 0u { self.write_str(~"("); } f(); - if sz > 0u { self.write_str(")"); } + if sz > 0u { self.write_str(~")"); } } fn emit_enum_variant_arg(idx: uint, f: fn()) { - if idx > 0u { self.write_str(", "); } + if idx > 0u { self.write_str(~", "); } f(); } fn emit_vec(_len: uint, f: fn()) { - self.write_str("["); + self.write_str(~"["); f(); - self.write_str("]"); + self.write_str(~"]"); } fn emit_vec_elt(idx: uint, f: fn()) { - if idx > 0u { self.write_str(", "); } + if idx > 0u { self.write_str(~", "); } f(); } fn emit_box(f: fn()) { - self.write_str("@"); + self.write_str(~"@"); f(); } fn emit_uniq(f: fn()) { - self.write_str("~"); + self.write_str(~"~"); f(); } fn emit_rec(f: fn()) { - self.write_str("{"); + self.write_str(~"{"); f(); - self.write_str("}"); + self.write_str(~"}"); } - fn emit_rec_field(f_name: str, f_idx: uint, f: fn()) { - if f_idx > 0u { self.write_str(", "); } + fn emit_rec_field(f_name: ~str, f_idx: uint, f: fn()) { + if f_idx > 0u { self.write_str(~", "); } self.write_str(f_name); - self.write_str(": "); + self.write_str(~": "); f(); } fn emit_tup(_sz: uint, f: fn()) { - self.write_str("("); + self.write_str(~"("); f(); - self.write_str(")"); + self.write_str(~")"); } fn emit_tup_elt(idx: uint, f: fn()) { - if idx > 0u { self.write_str(", "); } + if idx > 0u { self.write_str(~", "); } f(); } } \ No newline at end of file diff --git a/src/libstd/rope.rs b/src/libstd/rope.rs index 917adfaaecd..dbca5ae4e76 100644 --- a/src/libstd/rope.rs +++ b/src/libstd/rope.rs @@ -53,7 +53,7 @@ fn empty() -> rope { * * this operation does not copy the string; * * the function runs in linear time. */ -fn of_str(str: @str/~) -> rope { +fn of_str(str: @~str) -> rope { ret of_substr(str, 0u, str::len(*str)); } @@ -79,7 +79,7 @@ fn of_str(str: @str/~) -> rope { * * this function does _not_ check the validity of the substring; * * this function fails if `byte_offset` or `byte_len` do not match `str`. */ -fn of_substr(str: @str/~, byte_offset: uint, byte_len: uint) -> rope { +fn of_substr(str: @~str, byte_offset: uint, byte_len: uint) -> rope { if byte_len == 0u { ret node::empty; } if byte_offset + byte_len > str::len(*str) { fail; } ret node::content(node::of_substr(str, byte_offset, byte_len)); @@ -107,7 +107,7 @@ fn append_char(rope: rope, char: char) -> rope { * * * this function executes in near-linear time */ -fn append_str(rope: rope, str: @str/~) -> rope { +fn append_str(rope: rope, str: @~str) -> rope { ret append_rope(rope, of_str(str)) } @@ -127,7 +127,7 @@ fn prepend_char(rope: rope, char: char) -> rope { * # Performance note * * this function executes in near-linear time */ -fn prepend_str(rope: rope, str: @str/~) -> rope { +fn prepend_str(rope: rope, str: @~str) -> rope { ret append_rope(of_str(str), rope) } @@ -567,7 +567,7 @@ mod node { byte_offset: uint, byte_len: uint, char_len: uint, - content: @str/~ + content: @~str }; /** @@ -627,7 +627,7 @@ mod node { * Performance note: The complexity of this function is linear in * the length of `str`. */ - fn of_str(str: @str/~) -> @node { + fn of_str(str: @~str) -> @node { ret of_substr(str, 0u, str::len(*str)); } @@ -648,7 +648,7 @@ mod node { * Behavior is undefined if `byte_start` or `byte_len` do not represent * valid positions in `str` */ - fn of_substr(str: @str/~, byte_start: uint, byte_len: uint) -> @node { + fn of_substr(str: @~str, byte_start: uint, byte_len: uint) -> @node { ret of_substr_unsafer(str, byte_start, byte_len, str::count_chars(*str, byte_start, byte_len)); } @@ -674,7 +674,7 @@ mod node { * * Behavior is undefined if `char_len` does not accurately represent the * number of chars between byte_start and byte_start+byte_len */ - fn of_substr_unsafer(str: @str/~, byte_start: uint, byte_len: uint, + fn of_substr_unsafer(str: @~str, byte_start: uint, byte_len: uint, char_len: uint) -> @node { assert(byte_start + byte_len <= str::len(*str)); let candidate = @leaf({ @@ -799,7 +799,7 @@ mod node { ret forest[0]; } - fn serialize_node(node: @node) -> str unsafe { + fn serialize_node(node: @node) -> ~str unsafe { let mut buf = vec::to_mut(vec::from_elem(byte_len(node), 0u8)); let mut offset = 0u;//Current position in the buffer let it = leaf_iterator::start(node); @@ -1237,11 +1237,11 @@ mod node { mod tests { //Utility function, used for sanity check - fn rope_to_string(r: rope) -> str { + fn rope_to_string(r: rope) -> ~str { alt(r) { - node::empty { ret "" } + node::empty { ret ~"" } node::content(x) { - let str = @mut ""; + let str = @mut ~""; fn aux(str: @mut str, node: @node::node) unsafe { alt(*node) { node::leaf(x) { @@ -1270,7 +1270,7 @@ mod tests { #[test] fn of_string1() { - let sample = @"0123456789ABCDE"/~; + let sample = @~"0123456789ABCDE"; let r = of_str(sample); assert char_len(r) == str::char_len(*sample); @@ -1279,7 +1279,7 @@ mod tests { #[test] fn of_string2() { - let buf = @ mut "1234567890"; + let buf = @ mut ~"1234567890"; let mut i = 0; while i < 10 { *buf = *buf + *buf; i+=1;} let sample = @*buf; @@ -1310,7 +1310,7 @@ mod tests { #[test] fn iter1() { - let buf = @ mut "1234567890"; + let buf = @ mut ~"1234567890"; let mut i = 0; while i < 10 { *buf = *buf + *buf; i+=1;} let sample = @*buf; @@ -1330,7 +1330,7 @@ mod tests { #[test] fn bal1() { - let init = @"1234567890"/~; + let init = @~"1234567890"; let buf = @mut * init; let mut i = 0; while i < 8 { *buf = *buf + *buf; i+=1;} @@ -1352,7 +1352,7 @@ mod tests { #[ignore] fn char_at1() { //Generate a large rope - let mut r = of_str(@"123456789"/~); + let mut r = of_str(@~"123456789"); for uint::range(0u, 10u) |_i| { r = append_rope(r, r); } @@ -1384,7 +1384,7 @@ mod tests { #[test] fn concat1() { //Generate a reasonable rope - let chunk = of_str(@"123456789"/~); + let chunk = of_str(@~"123456789"); let mut r = empty(); for uint::range(0u, 10u) |_i| { r = append_rope(r, chunk); diff --git a/src/libstd/serialization.rs b/src/libstd/serialization.rs index aafe31ec011..ba20ff88e3d 100644 --- a/src/libstd/serialization.rs +++ b/src/libstd/serialization.rs @@ -23,18 +23,18 @@ iface serializer { fn emit_float(v: float); fn emit_f64(v: f64); fn emit_f32(v: f32); - fn emit_str(v: str); + fn emit_str(v: ~str); // Compound types: - fn emit_enum(name: str, f: fn()); - fn emit_enum_variant(v_name: str, v_id: uint, sz: uint, f: fn()); + fn emit_enum(name: ~str, f: fn()); + fn emit_enum_variant(v_name: ~str, v_id: uint, sz: uint, f: fn()); fn emit_enum_variant_arg(idx: uint, f: fn()); fn emit_vec(len: uint, f: fn()); fn emit_vec_elt(idx: uint, f: fn()); fn emit_box(f: fn()); fn emit_uniq(f: fn()); fn emit_rec(f: fn()); - fn emit_rec_field(f_name: str, f_idx: uint, f: fn()); + fn emit_rec_field(f_name: ~str, f_idx: uint, f: fn()); fn emit_tup(sz: uint, f: fn()); fn emit_tup_elt(idx: uint, f: fn()); } @@ -58,14 +58,14 @@ iface deserializer { fn read_bool() -> bool; - fn read_str() -> str; + fn read_str() -> ~str; fn read_f64() -> f64; fn read_f32() -> f32; fn read_float() -> float; // Compound types: - fn read_enum<T:copy>(name: str, f: fn() -> T) -> T; + fn read_enum<T:copy>(name: ~str, f: fn() -> T) -> T; fn read_enum_variant<T:copy>(f: fn(uint) -> T) -> T; fn read_enum_variant_arg<T:copy>(idx: uint, f: fn() -> T) -> T; fn read_vec<T:copy>(f: fn(uint) -> T) -> T; @@ -73,7 +73,7 @@ iface deserializer { fn read_box<T:copy>(f: fn() -> T) -> T; fn read_uniq<T:copy>(f: fn() -> T) -> T; fn read_rec<T:copy>(f: fn() -> T) -> T; - fn read_rec_field<T:copy>(f_name: str, f_idx: uint, f: fn() -> T) -> T; + fn read_rec_field<T:copy>(f_name: ~str, f_idx: uint, f: fn() -> T) -> T; fn read_tup<T:copy>(sz: uint, f: fn() -> T) -> T; fn read_tup_elt<T:copy>(idx: uint, f: fn() -> T) -> T; } @@ -193,11 +193,11 @@ fn deserialize_i64<D: deserializer>(d: D) -> i64 { d.read_i64() } -fn serialize_str<S: serializer>(s: S, v: str) { +fn serialize_str<S: serializer>(s: S, v: ~str) { s.emit_str(v); } -fn deserialize_str<D: deserializer>(d: D) -> str { +fn deserialize_str<D: deserializer>(d: D) -> ~str { d.read_str() } @@ -234,15 +234,15 @@ fn deserialize_bool<D: deserializer>(d: D) -> bool { } fn serialize_option<S: serializer,T>(s: S, v: option<T>, st: fn(T)) { - do s.emit_enum("option") { + do s.emit_enum(~"option") { alt v { none { - do s.emit_enum_variant("none", 0u, 0u) { + do s.emit_enum_variant(~"none", 0u, 0u) { } } some(v) { - do s.emit_enum_variant("some", 1u, 1u) { + do s.emit_enum_variant(~"some", 1u, 1u) { do s.emit_enum_variant_arg(0u) { st(v) } @@ -254,7 +254,7 @@ fn serialize_option<S: serializer,T>(s: S, v: option<T>, st: fn(T)) { fn deserialize_option<D: deserializer,T: copy>(d: D, st: fn() -> T) -> option<T> { - do d.read_enum("option") { + do d.read_enum(~"option") { do d.read_enum_variant |i| { alt check i { 0u { // none diff --git a/src/libstd/sha1.rs b/src/libstd/sha1.rs index dc136af639a..71f8fff2857 100644 --- a/src/libstd/sha1.rs +++ b/src/libstd/sha1.rs @@ -24,7 +24,7 @@ iface sha1 { /// Provide message input as bytes fn input(~[u8]); /// Provide message input as string - fn input_str(str); + fn input_str(~str); /** * Read the digest as a vector of 20 bytes. After calling this no further * input may be provided until reset is called. @@ -34,7 +34,7 @@ iface sha1 { * Read the digest as a hex string. After calling this no further * input may be provided until reset is called. */ - fn result_str() -> str; + fn result_str() -> ~str; /// Reset the SHA-1 state for reuse fn reset(); } @@ -232,11 +232,11 @@ fn sha1() -> sha1 { self.computed = false; } fn input(msg: ~[u8]) { add_input(self, msg); } - fn input_str(msg: str) { add_input(self, str::bytes(msg)); } + fn input_str(msg: ~str) { add_input(self, str::bytes(msg)); } fn result() -> ~[u8] { ret mk_result(self); } - fn result_str() -> str { + fn result_str() -> ~str { let r = mk_result(self); - let mut s = ""; + let mut s = ~""; for vec::each(r) |b| { s += uint::to_str(b as uint, 16u); } ret s; } @@ -260,18 +260,18 @@ mod tests { #[test] fn test() unsafe { - type test = {input: str, output: ~[u8]}; + type test = {input: ~str, output: ~[u8]}; - fn a_million_letter_a() -> str { + fn a_million_letter_a() -> ~str { let mut i = 0; - let mut rs = ""; - while i < 100000 { str::push_str(rs, "aaaaaaaaaa"); i += 1; } + let mut rs = ~""; + while i < 100000 { str::push_str(rs, ~"aaaaaaaaaa"); i += 1; } ret rs; } // Test messages from FIPS 180-1 let fips_180_1_tests: ~[test] = - ~[{input: "abc", + ~[{input: ~"abc", output: ~[0xA9u8, 0x99u8, 0x3Eu8, 0x36u8, 0x47u8, 0x06u8, 0x81u8, 0x6Au8, @@ -279,8 +279,8 @@ mod tests { 0x78u8, 0x50u8, 0xC2u8, 0x6Cu8, 0x9Cu8, 0xD0u8, 0xD8u8, 0x9Du8]}, {input: - "abcdbcdecdefdefgefghfghighij" + - "hijkijkljklmklmnlmnomnopnopq", + ~"abcdbcdecdefdefgefghfghighij" + + ~"hijkijkljklmklmnlmnomnopnopq", output: ~[0x84u8, 0x98u8, 0x3Eu8, 0x44u8, 0x1Cu8, 0x3Bu8, 0xD2u8, 0x6Eu8, @@ -297,14 +297,14 @@ mod tests { // Examples from wikipedia let wikipedia_tests: ~[test] = - ~[{input: "The quick brown fox jumps over the lazy dog", + ~[{input: ~"The quick brown fox jumps over the lazy dog", output: ~[0x2fu8, 0xd4u8, 0xe1u8, 0xc6u8, 0x7au8, 0x2du8, 0x28u8, 0xfcu8, 0xedu8, 0x84u8, 0x9eu8, 0xe1u8, 0xbbu8, 0x76u8, 0xe7u8, 0x39u8, 0x1bu8, 0x93u8, 0xebu8, 0x12u8]}, - {input: "The quick brown fox jumps over the lazy cog", + {input: ~"The quick brown fox jumps over the lazy cog", output: ~[0xdeu8, 0x9fu8, 0x2cu8, 0x7fu8, 0xd2u8, 0x5eu8, 0x1bu8, 0x3au8, diff --git a/src/libstd/tempfile.rs b/src/libstd/tempfile.rs index 536f633f8a7..b6f5c81f57e 100644 --- a/src/libstd/tempfile.rs +++ b/src/libstd/tempfile.rs @@ -5,7 +5,7 @@ import option::{none, some}; import rand; import core::rand::extensions; -fn mkdtemp(prefix: str, suffix: str) -> option<str> { +fn mkdtemp(prefix: ~str, suffix: ~str) -> option<~str> { let r = rand::rng(); let mut i = 0u; while (i < 1000u) { @@ -20,11 +20,11 @@ fn mkdtemp(prefix: str, suffix: str) -> option<str> { #[test] fn test_mkdtemp() { - let r = mkdtemp("./", "foobar"); + let r = mkdtemp(~"./", ~"foobar"); alt r { some(p) { os::remove_dir(p); - assert(str::ends_with(p, "foobar")); + assert(str::ends_with(p, ~"foobar")); } _ { assert(false); } } diff --git a/src/libstd/term.rs b/src/libstd/term.rs index 24d0442dfe2..aa2d52822be 100644 --- a/src/libstd/term.rs +++ b/src/libstd/term.rs @@ -33,9 +33,9 @@ fn reset(writer: io::writer) { /// Returns true if the terminal supports color fn color_supported() -> bool { - let supported_terms = ~["xterm-color", "xterm", - "screen-bce", "xterm-256color"]; - ret alt os::getenv("TERM") { + let supported_terms = ~[~"xterm-color", ~"xterm", + ~"screen-bce", ~"xterm-256color"]; + ret alt os::getenv(~"TERM") { option::some(env) { for vec::each(supported_terms) |term| { if str::eq(term, env) { ret true; } diff --git a/src/libstd/test.rs b/src/libstd/test.rs index a4acc097ab2..d42bca74508 100644 --- a/src/libstd/test.rs +++ b/src/libstd/test.rs @@ -30,7 +30,7 @@ extern mod rustrt { // paths; i.e. it should be a series of identifiers seperated by double // colons. This way if some test runner wants to arrange the tests // hierarchically it may. -type test_name = str; +type test_name = ~str; // A function that runs a test. If the function returns successfully, // the test succeeds; if the function fails then the test fails. We @@ -49,24 +49,24 @@ type test_desc = { // The default console test runner. It accepts the command line // arguments and a vector of test_descs (generated at compile time). -fn test_main(args: ~[str], tests: ~[test_desc]) { +fn test_main(args: ~[~str], tests: ~[test_desc]) { let opts = alt parse_opts(args) { either::left(o) { o } either::right(m) { fail m } }; - if !run_tests_console(opts, tests) { fail "Some tests failed"; } + if !run_tests_console(opts, tests) { fail ~"Some tests failed"; } } -type test_opts = {filter: option<str>, run_ignored: bool, - logfile: option<str>}; +type test_opts = {filter: option<~str>, run_ignored: bool, + logfile: option<~str>}; -type opt_res = either<test_opts, str>; +type opt_res = either<test_opts, ~str>; // Parses command line arguments into test options -fn parse_opts(args: ~[str]) -> opt_res { +fn parse_opts(args: ~[~str]) -> opt_res { let args_ = vec::tail(args); - let opts = ~[getopts::optflag("ignored"), getopts::optopt("logfile")]; + let opts = ~[getopts::optflag(~"ignored"), getopts::optopt(~"logfile")]; let match = alt getopts::getopts(args_, opts) { ok(m) { m } @@ -78,8 +78,8 @@ fn parse_opts(args: ~[str]) -> opt_res { option::some(match.free[0]) } else { option::none }; - let run_ignored = getopts::opt_present(match, "ignored"); - let logfile = getopts::opt_maybe_str(match, "logfile"); + let run_ignored = getopts::opt_present(match, ~"ignored"); + let logfile = getopts::opt_maybe_str(match, ~"logfile"); let test_opts = {filter: filter, run_ignored: run_ignored, logfile: logfile}; @@ -107,7 +107,7 @@ fn run_tests_console(opts: test_opts, alt event { te_filtered(filtered_tests) { st.total = vec::len(filtered_tests); - let noun = if st.total != 1u { "tests" } else { "test" }; + let noun = if st.total != 1u { ~"tests" } else { ~"test" }; st.out.write_line(#fmt["\nrunning %u %s", st.total, noun]); } te_wait(test) { st.out.write_str(#fmt["test %s ... ", test.name]); } @@ -122,18 +122,18 @@ fn run_tests_console(opts: test_opts, tr_ok { st.passed += 1u; write_ok(st.out, st.use_color); - st.out.write_line(""); + st.out.write_line(~""); } tr_failed { st.failed += 1u; write_failed(st.out, st.use_color); - st.out.write_line(""); + st.out.write_line(~""); vec::push(st.failures, copy test); } tr_ignored { st.ignored += 1u; write_ignored(st.out, st.use_color); - st.out.write_line(""); + st.out.write_line(~""); } } } @@ -184,25 +184,25 @@ fn run_tests_console(opts: test_opts, fn write_log(out: io::writer, result: test_result, test: test_desc) { out.write_line(#fmt("%s %s", alt result { - tr_ok { "ok" } - tr_failed { "failed" } - tr_ignored { "ignored" } + tr_ok { ~"ok" } + tr_failed { ~"failed" } + tr_ignored { ~"ignored" } }, test.name)); } fn write_ok(out: io::writer, use_color: bool) { - write_pretty(out, "ok", term::color_green, use_color); + write_pretty(out, ~"ok", term::color_green, use_color); } fn write_failed(out: io::writer, use_color: bool) { - write_pretty(out, "FAILED", term::color_red, use_color); + write_pretty(out, ~"FAILED", term::color_red, use_color); } fn write_ignored(out: io::writer, use_color: bool) { - write_pretty(out, "ignored", term::color_yellow, use_color); + write_pretty(out, ~"ignored", term::color_yellow, use_color); } - fn write_pretty(out: io::writer, word: str, color: u8, use_color: bool) { + fn write_pretty(out: io::writer, word: ~str, color: u8, use_color: bool) { if use_color && term::color_supported() { term::fg(out, color); } @@ -214,7 +214,7 @@ fn run_tests_console(opts: test_opts, } fn print_failures(st: console_test_state) { - st.out.write_line("\nfailures:"); + st.out.write_line(~"\nfailures:"); let failures = copy st.failures; let failures = vec::map(failures, |test| test.name); let failures = sort::merge_sort(str::le, failures); @@ -229,14 +229,14 @@ fn should_sort_failures_before_printing_them() { let writer = io::mem_buffer_writer(buffer); let test_a = { - name: "a", + name: ~"a", fn: fn~() { }, ignore: false, should_fail: false }; let test_b = { - name: "b", + name: ~"b", fn: fn~() { }, ignore: false, should_fail: false @@ -256,8 +256,8 @@ fn should_sort_failures_before_printing_them() { let s = io::mem_buffer_str(buffer); - let apos = option::get(str::find_str(s, "a")); - let bpos = option::get(str::find_str(s, "b")); + let apos = option::get(str::find_str(s, ~"a")); + let bpos = option::get(str::find_str(s, ~"b")); assert apos < bpos; } @@ -339,10 +339,10 @@ fn filter_tests(opts: test_opts, let filter_str = alt opts.filter { option::some(f) { f } - option::none { "" } + option::none { ~"" } }; - fn filter_fn(test: test_desc, filter_str: str) -> + fn filter_fn(test: test_desc, filter_str: ~str) -> option<test_desc> { if str::contains(test.name, filter_str) { ret option::some(copy test); @@ -419,7 +419,7 @@ mod tests { fn do_not_run_ignored_tests() { fn f() { fail; } let desc = { - name: "whatever", + name: ~"whatever", fn: f, ignore: true, should_fail: false @@ -435,7 +435,7 @@ mod tests { fn ignored_tests_result_in_ignored() { fn f() { } let desc = { - name: "whatever", + name: ~"whatever", fn: f, ignore: true, should_fail: false @@ -452,7 +452,7 @@ mod tests { fn test_should_fail() { fn f() { fail; } let desc = { - name: "whatever", + name: ~"whatever", fn: f, ignore: false, should_fail: true @@ -468,7 +468,7 @@ mod tests { fn test_should_fail_but_succeeds() { fn f() { } let desc = { - name: "whatever", + name: ~"whatever", fn: f, ignore: false, should_fail: true @@ -482,17 +482,17 @@ mod tests { #[test] fn first_free_arg_should_be_a_filter() { - let args = ~["progname", "filter"]; + let args = ~[~"progname", ~"filter"]; let opts = alt parse_opts(args) { either::left(o) { o } - _ { fail "Malformed arg in first_free_arg_should_be_a_filter"; } }; - assert (str::eq("filter", option::get(opts.filter))); + _ { fail ~"Malformed arg in first_free_arg_should_be_a_filter"; } }; + assert (str::eq(~"filter", option::get(opts.filter))); } #[test] fn parse_ignored_flag() { - let args = ~["progname", "filter", "--ignored"]; + let args = ~[~"progname", ~"filter", ~"--ignored"]; let opts = alt parse_opts(args) { either::left(o) { o } - _ { fail "Malformed arg in parse_ignored_flag"; } }; + _ { fail ~"Malformed arg in parse_ignored_flag"; } }; assert (opts.run_ignored); } @@ -504,12 +504,12 @@ mod tests { let opts = {filter: option::none, run_ignored: true, logfile: option::none}; let tests = - ~[{name: "1", fn: fn~() { }, ignore: true, should_fail: false}, - {name: "2", fn: fn~() { }, ignore: false, should_fail: false}]; + ~[{name: ~"1", fn: fn~() { }, ignore: true, should_fail: false}, + {name: ~"2", fn: fn~() { }, ignore: false, should_fail: false}]; let filtered = filter_tests(opts, tests); assert (vec::len(filtered) == 1u); - assert (filtered[0].name == "1"); + assert (filtered[0].name == ~"1"); assert (filtered[0].ignore == false); } @@ -519,12 +519,12 @@ mod tests { logfile: option::none}; let names = - ~["sha1::test", "int::test_to_str", "int::test_pow", - "test::do_not_run_ignored_tests", - "test::ignored_tests_result_in_ignored", - "test::first_free_arg_should_be_a_filter", - "test::parse_ignored_flag", "test::filter_for_ignored_option", - "test::sort_tests"]; + ~[~"sha1::test", ~"int::test_to_str", ~"int::test_pow", + ~"test::do_not_run_ignored_tests", + ~"test::ignored_tests_result_in_ignored", + ~"test::first_free_arg_should_be_a_filter", + ~"test::parse_ignored_flag", ~"test::filter_for_ignored_option", + ~"test::sort_tests"]; let tests = { let testfn = fn~() { }; @@ -539,11 +539,13 @@ mod tests { let filtered = filter_tests(opts, tests); let expected = - ~["int::test_pow", "int::test_to_str", "sha1::test", - "test::do_not_run_ignored_tests", "test::filter_for_ignored_option", - "test::first_free_arg_should_be_a_filter", - "test::ignored_tests_result_in_ignored", "test::parse_ignored_flag", - "test::sort_tests"]; + ~[~"int::test_pow", ~"int::test_to_str", ~"sha1::test", + ~"test::do_not_run_ignored_tests", + ~"test::filter_for_ignored_option", + ~"test::first_free_arg_should_be_a_filter", + ~"test::ignored_tests_result_in_ignored", + ~"test::parse_ignored_flag", + ~"test::sort_tests"]; let pairs = vec::zip(expected, filtered); diff --git a/src/libstd/time.rs b/src/libstd/time.rs index 3f3749cb064..553592b10bd 100644 --- a/src/libstd/time.rs +++ b/src/libstd/time.rs @@ -76,7 +76,7 @@ type tm = { tm_yday: i32, // days since January 1 ~[0-365] tm_isdst: i32, // Daylight Savings Time flag tm_gmtoff: i32, // offset from UTC in seconds - tm_zone: str, // timezone abbreviation + tm_zone: ~str, // timezone abbreviation tm_nsec: i32, // nanoseconds }; @@ -92,7 +92,7 @@ fn empty_tm() -> tm { tm_yday: 0_i32, tm_isdst: 0_i32, tm_gmtoff: 0_i32, - tm_zone: "", + tm_zone: ~"", tm_nsec: 0_i32, } } @@ -124,7 +124,7 @@ fn now() -> tm { } /// Parses the time from the string according to the format string. -fn strptime(s: str, format: str) -> result<tm, str> { +fn strptime(s: ~str, format: ~str) -> result<tm, ~str> { type tm_mut = { mut tm_sec: i32, mut tm_min: i32, @@ -136,11 +136,11 @@ fn strptime(s: str, format: str) -> result<tm, str> { mut tm_yday: i32, mut tm_isdst: i32, mut tm_gmtoff: i32, - mut tm_zone: str, + mut tm_zone: ~str, mut tm_nsec: i32, }; - fn match_str(s: str, pos: uint, needle: str) -> bool { + fn match_str(s: ~str, pos: uint, needle: ~str) -> bool { let mut i = pos; for str::each(needle) |ch| { if s[i] != ch { @@ -151,7 +151,7 @@ fn strptime(s: str, format: str) -> result<tm, str> { ret true; } - fn match_strs(s: str, pos: uint, strs: ~[(str, i32)]) + fn match_strs(s: ~str, pos: uint, strs: ~[(~str, i32)]) -> option<(i32, uint)> { let mut i = 0u; let len = vec::len(strs); @@ -167,7 +167,7 @@ fn strptime(s: str, format: str) -> result<tm, str> { none } - fn match_digits(s: str, pos: uint, digits: uint, ws: bool) + fn match_digits(s: ~str, pos: uint, digits: uint, ws: bool) -> option<(i32, uint)> { let mut pos = pos; let mut value = 0_i32; @@ -190,7 +190,7 @@ fn strptime(s: str, format: str) -> result<tm, str> { some((value, pos)) } - fn parse_char(s: str, pos: uint, c: char) -> result<uint, str> { + fn parse_char(s: ~str, pos: uint, c: char) -> result<uint, ~str> { let {ch, next} = str::char_range_at(s, pos); if c == ch { @@ -202,73 +202,73 @@ fn strptime(s: str, format: str) -> result<tm, str> { } } - fn parse_type(s: str, pos: uint, ch: char, tm: tm_mut) - -> result<uint, str> { + fn parse_type(s: ~str, pos: uint, ch: char, tm: tm_mut) + -> result<uint, ~str> { alt ch { 'A' { alt match_strs(s, pos, ~[ - ("Sunday", 0_i32), - ("Monday", 1_i32), - ("Tuesday", 2_i32), - ("Wednesday", 3_i32), - ("Thursday", 4_i32), - ("Friday", 5_i32), - ("Saturday", 6_i32) + (~"Sunday", 0_i32), + (~"Monday", 1_i32), + (~"Tuesday", 2_i32), + (~"Wednesday", 3_i32), + (~"Thursday", 4_i32), + (~"Friday", 5_i32), + (~"Saturday", 6_i32) ]) { some(item) { let (v, pos) = item; tm.tm_wday = v; ok(pos) } - none { err("Invalid day") } + none { err(~"Invalid day") } } } 'a' { alt match_strs(s, pos, ~[ - ("Sun", 0_i32), - ("Mon", 1_i32), - ("Tue", 2_i32), - ("Wed", 3_i32), - ("Thu", 4_i32), - ("Fri", 5_i32), - ("Sat", 6_i32) + (~"Sun", 0_i32), + (~"Mon", 1_i32), + (~"Tue", 2_i32), + (~"Wed", 3_i32), + (~"Thu", 4_i32), + (~"Fri", 5_i32), + (~"Sat", 6_i32) ]) { some(item) { let (v, pos) = item; tm.tm_wday = v; ok(pos) } - none { err("Invalid day") } + none { err(~"Invalid day") } } } 'B' { alt match_strs(s, pos, ~[ - ("January", 0_i32), - ("February", 1_i32), - ("March", 2_i32), - ("April", 3_i32), - ("May", 4_i32), - ("June", 5_i32), - ("July", 6_i32), - ("August", 7_i32), - ("September", 8_i32), - ("October", 9_i32), - ("November", 10_i32), - ("December", 11_i32) + (~"January", 0_i32), + (~"February", 1_i32), + (~"March", 2_i32), + (~"April", 3_i32), + (~"May", 4_i32), + (~"June", 5_i32), + (~"July", 6_i32), + (~"August", 7_i32), + (~"September", 8_i32), + (~"October", 9_i32), + (~"November", 10_i32), + (~"December", 11_i32) ]) { some(item) { let (v, pos) = item; tm.tm_mon = v; ok(pos) } - none { err("Invalid month") } + none { err(~"Invalid month") } } } 'b' | 'h' { alt match_strs(s, pos, ~[ - ("Jan", 0_i32), - ("Feb", 1_i32), - ("Mar", 2_i32), - ("Apr", 3_i32), - ("May", 4_i32), - ("Jun", 5_i32), - ("Jul", 6_i32), - ("Aug", 7_i32), - ("Sep", 8_i32), - ("Oct", 9_i32), - ("Nov", 10_i32), - ("Dec", 11_i32) + (~"Jan", 0_i32), + (~"Feb", 1_i32), + (~"Mar", 2_i32), + (~"Apr", 3_i32), + (~"May", 4_i32), + (~"Jun", 5_i32), + (~"Jul", 6_i32), + (~"Aug", 7_i32), + (~"Sep", 8_i32), + (~"Oct", 9_i32), + (~"Nov", 10_i32), + (~"Dec", 11_i32) ]) { some(item) { let (v, pos) = item; tm.tm_mon = v; ok(pos) } - none { err("Invalid month") } + none { err(~"Invalid month") } } } 'C' { @@ -278,7 +278,7 @@ fn strptime(s: str, format: str) -> result<tm, str> { tm.tm_year += (v * 100_i32) - 1900_i32; ok(pos) } - none { err("Invalid year") } + none { err(~"Invalid year") } } } 'c' { @@ -302,13 +302,13 @@ fn strptime(s: str, format: str) -> result<tm, str> { 'd' { alt match_digits(s, pos, 2u, false) { some(item) { let (v, pos) = item; tm.tm_mday = v; ok(pos) } - none { err("Invalid day of the month") } + none { err(~"Invalid day of the month") } } } 'e' { alt match_digits(s, pos, 2u, true) { some(item) { let (v, pos) = item; tm.tm_mday = v; ok(pos) } - none { err("Invalid day of the month") } + none { err(~"Invalid day of the month") } } } 'F' { @@ -322,7 +322,7 @@ fn strptime(s: str, format: str) -> result<tm, str> { // FIXME (#2350): range check. alt match_digits(s, pos, 2u, false) { some(item) { let (v, pos) = item; tm.tm_hour = v; ok(pos) } - none { err("Invalid hour") } + none { err(~"Invalid hour") } } } 'I' { @@ -333,7 +333,7 @@ fn strptime(s: str, format: str) -> result<tm, str> { tm.tm_hour = if v == 12_i32 { 0_i32 } else { v }; ok(pos) } - none { err("Invalid hour") } + none { err(~"Invalid hour") } } } 'j' { @@ -344,14 +344,14 @@ fn strptime(s: str, format: str) -> result<tm, str> { tm.tm_yday = v - 1_i32; ok(pos) } - none { err("Invalid year") } + none { err(~"Invalid year") } } } 'k' { // FIXME (#2350): range check. alt match_digits(s, pos, 2u, true) { some(item) { let (v, pos) = item; tm.tm_hour = v; ok(pos) } - none { err("Invalid hour") } + none { err(~"Invalid hour") } } } 'l' { @@ -362,14 +362,14 @@ fn strptime(s: str, format: str) -> result<tm, str> { tm.tm_hour = if v == 12_i32 { 0_i32 } else { v }; ok(pos) } - none { err("Invalid hour") } + none { err(~"Invalid hour") } } } 'M' { // FIXME (#2350): range check. alt match_digits(s, pos, 2u, false) { some(item) { let (v, pos) = item; tm.tm_min = v; ok(pos) } - none { err("Invalid minute") } + none { err(~"Invalid minute") } } } 'm' { @@ -380,20 +380,20 @@ fn strptime(s: str, format: str) -> result<tm, str> { tm.tm_mon = v - 1_i32; ok(pos) } - none { err("Invalid month") } + none { err(~"Invalid month") } } } 'n' { parse_char(s, pos, '\n') } 'P' { - alt match_strs(s, pos, ~[("am", 0_i32), ("pm", 12_i32)]) { + alt match_strs(s, pos, ~[(~"am", 0_i32), (~"pm", 12_i32)]) { some(item) { let (v, pos) = item; tm.tm_hour += v; ok(pos) } - none { err("Invalid hour") } + none { err(~"Invalid hour") } } } 'p' { - alt match_strs(s, pos, ~[("AM", 0_i32), ("PM", 12_i32)]) { + alt match_strs(s, pos, ~[(~"AM", 0_i32), (~"PM", 12_i32)]) { some(item) { let (v, pos) = item; tm.tm_hour += v; ok(pos) } - none { err("Invalid hour") } + none { err(~"Invalid hour") } } } 'R' { @@ -418,7 +418,7 @@ fn strptime(s: str, format: str) -> result<tm, str> { tm.tm_sec = v; ok(pos) } - none { err("Invalid second") } + none { err(~"Invalid second") } } } //'s' {} @@ -438,7 +438,7 @@ fn strptime(s: str, format: str) -> result<tm, str> { tm.tm_wday = v; ok(pos) } - none { err("Invalid weekday") } + none { err(~"Invalid weekday") } } } 'v' { @@ -453,7 +453,7 @@ fn strptime(s: str, format: str) -> result<tm, str> { // FIXME (#2350): range check. alt match_digits(s, pos, 1u, false) { some(item) { let (v, pos) = item; tm.tm_wday = v; ok(pos) } - none { err("Invalid weekday") } + none { err(~"Invalid weekday") } } } //'X' {} @@ -466,7 +466,7 @@ fn strptime(s: str, format: str) -> result<tm, str> { tm.tm_year = v - 1900_i32; ok(pos) } - none { err("Invalid weekday") } + none { err(~"Invalid weekday") } } } 'y' { @@ -477,13 +477,13 @@ fn strptime(s: str, format: str) -> result<tm, str> { tm.tm_year = v - 1900_i32; ok(pos) } - none { err("Invalid weekday") } + none { err(~"Invalid weekday") } } } 'Z' { - if match_str(s, pos, "UTC") || match_str(s, pos, "GMT") { + if match_str(s, pos, ~"UTC") || match_str(s, pos, ~"GMT") { tm.tm_gmtoff = 0_i32; - tm.tm_zone = "UTC"; + tm.tm_zone = ~"UTC"; ok(pos + 3u) } else { // It's odd, but to maintain compatibility with c's @@ -508,15 +508,15 @@ fn strptime(s: str, format: str) -> result<tm, str> { let (v, pos) = item; if v == 0_i32 { tm.tm_gmtoff = 0_i32; - tm.tm_zone = "UTC"; + tm.tm_zone = ~"UTC"; } ok(pos) } - none { err("Invalid zone offset") } + none { err(~"Invalid zone offset") } } } else { - err("Invalid zone offset") + err(~"Invalid zone offset") } } '%' { parse_char(s, pos, '%') } @@ -538,12 +538,12 @@ fn strptime(s: str, format: str) -> result<tm, str> { mut tm_yday: 0_i32, mut tm_isdst: 0_i32, mut tm_gmtoff: 0_i32, - mut tm_zone: "", + mut tm_zone: ~"", mut tm_nsec: 0_i32, }; let mut pos = 0u; let len = str::len(s); - let mut result = err("Invalid time"); + let mut result = err(~"Invalid time"); while !rdr.eof() && pos < len { let {ch, next} = str::char_range_at(s, pos); @@ -581,62 +581,62 @@ fn strptime(s: str, format: str) -> result<tm, str> { } } -fn strftime(format: str, tm: tm) -> str { - fn parse_type(ch: char, tm: tm) -> str { +fn strftime(format: ~str, tm: tm) -> ~str { + fn parse_type(ch: char, tm: tm) -> ~str { //FIXME (#2350): Implement missing types. alt check ch { 'A' { alt check tm.tm_wday as int { - 0 { "Sunday" } - 1 { "Monday" } - 2 { "Tuesday" } - 3 { "Wednesday" } - 4 { "Thursday" } - 5 { "Friday" } - 6 { "Saturday" } + 0 { ~"Sunday" } + 1 { ~"Monday" } + 2 { ~"Tuesday" } + 3 { ~"Wednesday" } + 4 { ~"Thursday" } + 5 { ~"Friday" } + 6 { ~"Saturday" } } } 'a' { alt check tm.tm_wday as int { - 0 { "Sun" } - 1 { "Mon" } - 2 { "Tue" } - 3 { "Wed" } - 4 { "Thu" } - 5 { "Fri" } - 6 { "Sat" } + 0 { ~"Sun" } + 1 { ~"Mon" } + 2 { ~"Tue" } + 3 { ~"Wed" } + 4 { ~"Thu" } + 5 { ~"Fri" } + 6 { ~"Sat" } } } 'B' { alt check tm.tm_mon as int { - 0 { "January" } - 1 { "February" } - 2 { "March" } - 3 { "April" } - 4 { "May" } - 5 { "June" } - 6 { "July" } - 7 { "August" } - 8 { "September" } - 9 { "October" } - 10 { "November" } - 11 { "December" } + 0 { ~"January" } + 1 { ~"February" } + 2 { ~"March" } + 3 { ~"April" } + 4 { ~"May" } + 5 { ~"June" } + 6 { ~"July" } + 7 { ~"August" } + 8 { ~"September" } + 9 { ~"October" } + 10 { ~"November" } + 11 { ~"December" } } } 'b' | 'h' { alt check tm.tm_mon as int { - 0 { "Jan" } - 1 { "Feb" } - 2 { "Mar" } - 3 { "Apr" } - 4 { "May" } - 5 { "Jun" } - 6 { "Jul" } - 7 { "Aug" } - 8 { "Sep" } - 9 { "Oct" } - 10 { "Nov" } - 11 { "Dec" } + 0 { ~"Jan" } + 1 { ~"Feb" } + 2 { ~"Mar" } + 3 { ~"Apr" } + 4 { ~"May" } + 5 { ~"Jun" } + 6 { ~"Jul" } + 7 { ~"Aug" } + 8 { ~"Sep" } + 9 { ~"Oct" } + 10 { ~"Nov" } + 11 { ~"Dec" } } } 'C' { #fmt("%02d", (tm.tm_year as int + 1900) / 100) } @@ -681,9 +681,9 @@ fn strftime(format: str, tm: tm) -> str { } 'M' { #fmt("%02d", tm.tm_min as int) } 'm' { #fmt("%02d", tm.tm_mon as int + 1) } - 'n' { "\n" } - 'P' { if tm.tm_hour as int < 12 { "am" } else { "pm" } } - 'p' { if tm.tm_hour as int < 12 { "AM" } else { "PM" } } + 'n' { ~"\n" } + 'P' { if tm.tm_hour as int < 12 { ~"am" } else { ~"pm" } } + 'p' { if tm.tm_hour as int < 12 { ~"AM" } else { ~"PM" } } 'R' { #fmt("%s:%s", parse_type('H', tm), @@ -704,7 +704,7 @@ fn strftime(format: str, tm: tm) -> str { parse_type('M', tm), parse_type('S', tm)) } - 't' { "\t" } + 't' { ~"\t" } //'U' {} 'u' { let i = tm.tm_wday as int; @@ -732,11 +732,11 @@ fn strftime(format: str, tm: tm) -> str { #fmt("%c%02d%02d", sign, h as int, m as int) } //'+' {} - '%' { "%" } + '%' { ~"%" } } } - let mut buf = ""; + let mut buf = ~""; do io::with_str_reader(format) |rdr| { while !rdr.eof() { @@ -776,10 +776,10 @@ impl tm for tm { * Return a string of the current time in the form * "Thu Jan 1 00:00:00 1970". */ - fn ctime() -> str { self.strftime("%c") } + fn ctime() -> ~str { self.strftime(~"%c") } /// Formats the time according to the format string. - fn strftime(format: str) -> str { strftime(format, self) } + fn strftime(format: ~str) -> ~str { strftime(format, self) } /** * Returns a time string formatted according to RFC 822. @@ -787,11 +787,11 @@ impl tm for tm { * local: "Thu, 22 Mar 2012 07:53:18 PST" * utc: "Thu, 22 Mar 2012 14:53:18 UTC" */ - fn rfc822() -> str { + fn rfc822() -> ~str { if self.tm_gmtoff == 0_i32 { - self.strftime("%a, %d %b %Y %T GMT") + self.strftime(~"%a, %d %b %Y %T GMT") } else { - self.strftime("%a, %d %b %Y %T %Z") + self.strftime(~"%a, %d %b %Y %T %Z") } } @@ -801,8 +801,8 @@ impl tm for tm { * local: "Thu, 22 Mar 2012 07:53:18 -0700" * utc: "Thu, 22 Mar 2012 14:53:18 -0000" */ - fn rfc822z() -> str { - self.strftime("%a, %d %b %Y %T %z") + fn rfc822z() -> ~str { + self.strftime(~"%a, %d %b %Y %T %z") } /** @@ -811,11 +811,11 @@ impl tm for tm { * local: "2012-02-22T07:53:18-07:00" * utc: "2012-02-22T14:53:18Z" */ - fn rfc3339() -> str { + fn rfc3339() -> ~str { if self.tm_gmtoff == 0_i32 { - self.strftime("%Y-%m-%dT%H:%M:%SZ") + self.strftime(~"%Y-%m-%dT%H:%M:%SZ") } else { - let s = self.strftime("%Y-%m-%dT%H:%M:%S"); + let s = self.strftime(~"%Y-%m-%dT%H:%M:%S"); let sign = if self.tm_gmtoff > 0_i32 { '+' } else { '-' }; let mut m = i32::abs(self.tm_gmtoff) / 60_i32; let h = m / 60_i32; @@ -835,15 +835,15 @@ mod tests { const some_future_date: i64 = 1577836800i64; // 2020-01-01T00:00:00Z let tv1 = get_time(); - log(debug, "tv1=" + uint::str(tv1.sec as uint) + " sec + " - + uint::str(tv1.nsec as uint) + " nsec"); + log(debug, ~"tv1=" + uint::str(tv1.sec as uint) + ~" sec + " + + uint::str(tv1.nsec as uint) + ~" nsec"); assert tv1.sec > some_recent_date; assert tv1.nsec < 1000000000i32; let tv2 = get_time(); - log(debug, "tv2=" + uint::str(tv2.sec as uint) + " sec + " - + uint::str(tv2.nsec as uint) + " nsec"); + log(debug, ~"tv2=" + uint::str(tv2.sec as uint) + ~" sec + " + + uint::str(tv2.nsec as uint) + ~" nsec"); assert tv2.sec >= tv1.sec; assert tv2.sec < some_future_date; @@ -858,22 +858,22 @@ mod tests { let s0 = precise_time_s(); let ns1 = precise_time_ns(); - log(debug, "s0=" + float::to_str(s0, 9u) + " sec"); + log(debug, ~"s0=" + float::to_str(s0, 9u) + ~" sec"); assert s0 > 0.; let ns0 = (s0 * 1000000000.) as u64; - log(debug, "ns0=" + u64::str(ns0) + " ns"); + log(debug, ~"ns0=" + u64::str(ns0) + ~" ns"); - log(debug, "ns1=" + u64::str(ns1) + " ns"); + log(debug, ~"ns1=" + u64::str(ns1) + ~" ns"); assert ns1 >= ns0; let ns2 = precise_time_ns(); - log(debug, "ns2=" + u64::str(ns2) + " ns"); + log(debug, ~"ns2=" + u64::str(ns2) + ~" ns"); assert ns2 >= ns1; } #[test] fn test_at_utc() { - os::setenv("TZ", "America/Los_Angeles"); + os::setenv(~"TZ", ~"America/Los_Angeles"); tzset(); let time = { sec: 1234567890_i64, nsec: 54321_i32 }; @@ -889,13 +889,13 @@ mod tests { assert utc.tm_yday == 43_i32; assert utc.tm_isdst == 0_i32; assert utc.tm_gmtoff == 0_i32; - assert utc.tm_zone == "UTC"; + assert utc.tm_zone == ~"UTC"; assert utc.tm_nsec == 54321_i32; } #[test] fn test_at() { - os::setenv("TZ", "America/Los_Angeles"); + os::setenv(~"TZ", ~"America/Los_Angeles"); tzset(); let time = { sec: 1234567890_i64, nsec: 54321_i32 }; @@ -917,14 +917,14 @@ mod tests { // FIXME (#2350): We should probably standardize on the timezone // abbreviation. let zone = local.tm_zone; - assert zone == "PST" || zone == "Pacific Standard Time"; + assert zone == ~"PST" || zone == ~"Pacific Standard Time"; assert local.tm_nsec == 54321_i32; } #[test] fn test_to_timespec() { - os::setenv("TZ", "America/Los_Angeles"); + os::setenv(~"TZ", ~"America/Los_Angeles"); tzset(); let time = { sec: 1234567890_i64, nsec: 54321_i32 }; @@ -936,7 +936,7 @@ mod tests { #[test] fn test_conversions() { - os::setenv("TZ", "America/Los_Angeles"); + os::setenv(~"TZ", ~"America/Los_Angeles"); tzset(); let time = { sec: 1234567890_i64, nsec: 54321_i32 }; @@ -953,10 +953,10 @@ mod tests { #[test] fn test_strptime() { - os::setenv("TZ", "America/Los_Angeles"); + os::setenv(~"TZ", ~"America/Los_Angeles"); tzset(); - alt strptime("", "") { + alt strptime(~"", ~"") { ok(tm) { assert tm.tm_sec == 0_i32; assert tm.tm_min == 0_i32; @@ -967,17 +967,18 @@ mod tests { assert tm.tm_wday == 0_i32; assert tm.tm_isdst== 0_i32; assert tm.tm_gmtoff == 0_i32; - assert tm.tm_zone == ""; + assert tm.tm_zone == ~""; assert tm.tm_nsec == 0_i32; } err(_) {} } - let format = "%a %b %e %T %Y"; - assert strptime("", format) == err("Invalid time"); - assert strptime("Fri Feb 13 15:31:30", format) == err("Invalid time"); + let format = ~"%a %b %e %T %Y"; + assert strptime(~"", format) == err(~"Invalid time"); + assert strptime(~"Fri Feb 13 15:31:30", format) + == err(~"Invalid time"); - alt strptime("Fri Feb 13 15:31:30 2009", format) { + alt strptime(~"Fri Feb 13 15:31:30 2009", format) { err(e) { fail e } ok(tm) { assert tm.tm_sec == 30_i32; @@ -990,12 +991,12 @@ mod tests { assert tm.tm_yday == 0_i32; assert tm.tm_isdst == 0_i32; assert tm.tm_gmtoff == 0_i32; - assert tm.tm_zone == ""; + assert tm.tm_zone == ~""; assert tm.tm_nsec == 0_i32; } } - fn test(s: str, format: str) -> bool { + fn test(s: ~str, format: ~str) -> bool { alt strptime(s, format) { ok(tm) { tm.strftime(format) == s } err(e) { fail e } @@ -1003,103 +1004,103 @@ mod tests { } [ - "Sunday", - "Monday", - "Tuesday", - "Wednesday", - "Thursday", - "Friday", - "Saturday" - ]/_.iter(|day| assert test(day, "%A")); + ~"Sunday", + ~"Monday", + ~"Tuesday", + ~"Wednesday", + ~"Thursday", + ~"Friday", + ~"Saturday" + ]/_.iter(|day| assert test(day, ~"%A")); [ - "Sun", - "Mon", - "Tue", - "Wed", - "Thu", - "Fri", - "Sat" - ]/_.iter(|day| assert test(day, "%a")); + ~"Sun", + ~"Mon", + ~"Tue", + ~"Wed", + ~"Thu", + ~"Fri", + ~"Sat" + ]/_.iter(|day| assert test(day, ~"%a")); [ - "January", - "February", - "March", - "April", - "May", - "June", - "July", - "August", - "September", - "October", - "November", - "December" - ]/_.iter(|day| assert test(day, "%B")); + ~"January", + ~"February", + ~"March", + ~"April", + ~"May", + ~"June", + ~"July", + ~"August", + ~"September", + ~"October", + ~"November", + ~"December" + ]/_.iter(|day| assert test(day, ~"%B")); [ - "Jan", - "Feb", - "Mar", - "Apr", - "May", - "Jun", - "Jul", - "Aug", - "Sep", - "Oct", - "Nov", - "Dec" - ]/_.iter(|day| assert test(day, "%b")); - - assert test("19", "%C"); - assert test("Fri Feb 13 23:31:30 2009", "%c"); - assert test("02/13/09", "%D"); - assert test("03", "%d"); - assert test("13", "%d"); - assert test(" 3", "%e"); - assert test("13", "%e"); - assert test("2009-02-13", "%F"); - assert test("03", "%H"); - assert test("13", "%H"); - assert test("03", "%I"); // FIXME (#2350): flesh out - assert test("11", "%I"); // FIXME (#2350): flesh out - assert test("044", "%j"); - assert test(" 3", "%k"); - assert test("13", "%k"); - assert test(" 1", "%l"); - assert test("11", "%l"); - assert test("03", "%M"); - assert test("13", "%M"); - assert test("\n", "%n"); - assert test("am", "%P"); - assert test("pm", "%P"); - assert test("AM", "%p"); - assert test("PM", "%p"); - assert test("23:31", "%R"); - assert test("11:31:30 AM", "%r"); - assert test("11:31:30 PM", "%r"); - assert test("03", "%S"); - assert test("13", "%S"); - assert test("15:31:30", "%T"); - assert test("\t", "%t"); - assert test("1", "%u"); - assert test("7", "%u"); - assert test("13-Feb-2009", "%v"); - assert test("0", "%w"); - assert test("6", "%w"); - assert test("2009", "%Y"); - assert test("09", "%y"); - assert strptime("UTC", "%Z").get().tm_zone == "UTC"; - assert strptime("PST", "%Z").get().tm_zone == ""; - assert strptime("-0000", "%z").get().tm_gmtoff == 0_i32; - assert strptime("-0800", "%z").get().tm_gmtoff == 0_i32; - assert test("%", "%%"); + ~"Jan", + ~"Feb", + ~"Mar", + ~"Apr", + ~"May", + ~"Jun", + ~"Jul", + ~"Aug", + ~"Sep", + ~"Oct", + ~"Nov", + ~"Dec" + ]/_.iter(|day| assert test(day, ~"%b")); + + assert test(~"19", ~"%C"); + assert test(~"Fri Feb 13 23:31:30 2009", ~"%c"); + assert test(~"02/13/09", ~"%D"); + assert test(~"03", ~"%d"); + assert test(~"13", ~"%d"); + assert test(~" 3", ~"%e"); + assert test(~"13", ~"%e"); + assert test(~"2009-02-13", ~"%F"); + assert test(~"03", ~"%H"); + assert test(~"13", ~"%H"); + assert test(~"03", ~"%I"); // FIXME (#2350): flesh out + assert test(~"11", ~"%I"); // FIXME (#2350): flesh out + assert test(~"044", ~"%j"); + assert test(~" 3", ~"%k"); + assert test(~"13", ~"%k"); + assert test(~" 1", ~"%l"); + assert test(~"11", ~"%l"); + assert test(~"03", ~"%M"); + assert test(~"13", ~"%M"); + assert test(~"\n", ~"%n"); + assert test(~"am", ~"%P"); + assert test(~"pm", ~"%P"); + assert test(~"AM", ~"%p"); + assert test(~"PM", ~"%p"); + assert test(~"23:31", ~"%R"); + assert test(~"11:31:30 AM", ~"%r"); + assert test(~"11:31:30 PM", ~"%r"); + assert test(~"03", ~"%S"); + assert test(~"13", ~"%S"); + assert test(~"15:31:30", ~"%T"); + assert test(~"\t", ~"%t"); + assert test(~"1", ~"%u"); + assert test(~"7", ~"%u"); + assert test(~"13-Feb-2009", ~"%v"); + assert test(~"0", ~"%w"); + assert test(~"6", ~"%w"); + assert test(~"2009", ~"%Y"); + assert test(~"09", ~"%y"); + assert strptime(~"UTC", ~"%Z").get().tm_zone == ~"UTC"; + assert strptime(~"PST", ~"%Z").get().tm_zone == ~""; + assert strptime(~"-0000", ~"%z").get().tm_gmtoff == 0_i32; + assert strptime(~"-0800", ~"%z").get().tm_gmtoff == 0_i32; + assert test(~"%", ~"%%"); } #[test] fn test_ctime() { - os::setenv("TZ", "America/Los_Angeles"); + os::setenv(~"TZ", ~"America/Los_Angeles"); tzset(); let time = { sec: 1234567890_i64, nsec: 54321_i32 }; @@ -1108,81 +1109,81 @@ mod tests { #error("test_ctime: %? %?", utc.ctime(), local.ctime()); - assert utc.ctime() == "Fri Feb 13 23:31:30 2009"; - assert local.ctime() == "Fri Feb 13 15:31:30 2009"; + assert utc.ctime() == ~"Fri Feb 13 23:31:30 2009"; + assert local.ctime() == ~"Fri Feb 13 15:31:30 2009"; } #[test] fn test_strftime() { - os::setenv("TZ", "America/Los_Angeles"); + os::setenv(~"TZ", ~"America/Los_Angeles"); tzset(); let time = { sec: 1234567890_i64, nsec: 54321_i32 }; let utc = at_utc(time); let local = at(time); - assert local.strftime("") == ""; - assert local.strftime("%A") == "Friday"; - assert local.strftime("%a") == "Fri"; - assert local.strftime("%B") == "February"; - assert local.strftime("%b") == "Feb"; - assert local.strftime("%C") == "20"; - assert local.strftime("%c") == "Fri Feb 13 15:31:30 2009"; - assert local.strftime("%D") == "02/13/09"; - assert local.strftime("%d") == "13"; - assert local.strftime("%e") == "13"; - assert local.strftime("%F") == "2009-02-13"; + assert local.strftime(~"") == ~""; + assert local.strftime(~"%A") == ~"Friday"; + assert local.strftime(~"%a") == ~"Fri"; + assert local.strftime(~"%B") == ~"February"; + assert local.strftime(~"%b") == ~"Feb"; + assert local.strftime(~"%C") == ~"20"; + assert local.strftime(~"%c") == ~"Fri Feb 13 15:31:30 2009"; + assert local.strftime(~"%D") == ~"02/13/09"; + assert local.strftime(~"%d") == ~"13"; + assert local.strftime(~"%e") == ~"13"; + assert local.strftime(~"%F") == ~"2009-02-13"; // assert local.strftime("%G") == "2009"; // assert local.strftime("%g") == "09"; - assert local.strftime("%H") == "15"; - assert local.strftime("%I") == "03"; - assert local.strftime("%j") == "044"; - assert local.strftime("%k") == "15"; - assert local.strftime("%l") == " 3"; - assert local.strftime("%M") == "31"; - assert local.strftime("%m") == "02"; - assert local.strftime("%n") == "\n"; - assert local.strftime("%P") == "pm"; - assert local.strftime("%p") == "PM"; - assert local.strftime("%R") == "15:31"; - assert local.strftime("%r") == "03:31:30 PM"; - assert local.strftime("%S") == "30"; - assert local.strftime("%s") == "1234567890"; - assert local.strftime("%T") == "15:31:30"; - assert local.strftime("%t") == "\t"; + assert local.strftime(~"%H") == ~"15"; + assert local.strftime(~"%I") == ~"03"; + assert local.strftime(~"%j") == ~"044"; + assert local.strftime(~"%k") == ~"15"; + assert local.strftime(~"%l") == ~" 3"; + assert local.strftime(~"%M") == ~"31"; + assert local.strftime(~"%m") == ~"02"; + assert local.strftime(~"%n") == ~"\n"; + assert local.strftime(~"%P") == ~"pm"; + assert local.strftime(~"%p") == ~"PM"; + assert local.strftime(~"%R") == ~"15:31"; + assert local.strftime(~"%r") == ~"03:31:30 PM"; + assert local.strftime(~"%S") == ~"30"; + assert local.strftime(~"%s") == ~"1234567890"; + assert local.strftime(~"%T") == ~"15:31:30"; + assert local.strftime(~"%t") == ~"\t"; // assert local.strftime("%U") == "06"; - assert local.strftime("%u") == "5"; + assert local.strftime(~"%u") == ~"5"; // assert local.strftime("%V") == "07"; - assert local.strftime("%v") == "13-Feb-2009"; + assert local.strftime(~"%v") == ~"13-Feb-2009"; // assert local.strftime("%W") == "06"; - assert local.strftime("%w") == "5"; + assert local.strftime(~"%w") == ~"5"; // handle "%X" // handle "%x" - assert local.strftime("%Y") == "2009"; - assert local.strftime("%y") == "09"; + assert local.strftime(~"%Y") == ~"2009"; + assert local.strftime(~"%y") == ~"09"; // FIXME (#2350): We should probably standardize on the timezone // abbreviation. - let zone = local.strftime("%Z"); - assert zone == "PST" || zone == "Pacific Standard Time"; + let zone = local.strftime(~"%Z"); + assert zone == ~"PST" || zone == ~"Pacific Standard Time"; - assert local.strftime("%z") == "-0800"; - assert local.strftime("%%") == "%"; + assert local.strftime(~"%z") == ~"-0800"; + assert local.strftime(~"%%") == ~"%"; // FIXME (#2350): We should probably standardize on the timezone // abbreviation. let rfc822 = local.rfc822(); - let prefix = "Fri, 13 Feb 2009 15:31:30 "; - assert rfc822 == prefix + "PST" || - rfc822 == prefix + "Pacific Standard Time"; - - assert local.ctime() == "Fri Feb 13 15:31:30 2009"; - assert local.rfc822z() == "Fri, 13 Feb 2009 15:31:30 -0800"; - assert local.rfc3339() == "2009-02-13T15:31:30-08:00"; - - assert utc.ctime() == "Fri Feb 13 23:31:30 2009"; - assert utc.rfc822() == "Fri, 13 Feb 2009 23:31:30 GMT"; - assert utc.rfc822z() == "Fri, 13 Feb 2009 23:31:30 -0000"; - assert utc.rfc3339() == "2009-02-13T23:31:30Z"; + let prefix = ~"Fri, 13 Feb 2009 15:31:30 "; + assert rfc822 == prefix + ~"PST" || + rfc822 == prefix + ~"Pacific Standard Time"; + + assert local.ctime() == ~"Fri Feb 13 15:31:30 2009"; + assert local.rfc822z() == ~"Fri, 13 Feb 2009 15:31:30 -0800"; + assert local.rfc3339() == ~"2009-02-13T15:31:30-08:00"; + + assert utc.ctime() == ~"Fri Feb 13 23:31:30 2009"; + assert utc.rfc822() == ~"Fri, 13 Feb 2009 23:31:30 GMT"; + assert utc.rfc822z() == ~"Fri, 13 Feb 2009 23:31:30 -0000"; + assert utc.rfc3339() == ~"2009-02-13T23:31:30Z"; } } diff --git a/src/libstd/timer.rs b/src/libstd/timer.rs index 87d7dd67577..b72e2c47539 100644 --- a/src/libstd/timer.rs +++ b/src/libstd/timer.rs @@ -41,12 +41,13 @@ fn delayed_send<T: copy send>(iotask: iotask, } else { let error_msg = uv::ll::get_last_err_info(loop_ptr); - fail "timer::delayed_send() start failed: "+error_msg; + fail ~"timer::delayed_send() start failed: " + + error_msg; } } else { let error_msg = uv::ll::get_last_err_info(loop_ptr); - fail "timer::delayed_send() init failed: "+error_msg; + fail ~"timer::delayed_send() init failed: "+error_msg; } }; // delayed_send_cb has been processed by libuv @@ -128,7 +129,7 @@ extern fn delayed_send_cb(handle: *uv::ll::uv_timer_t, else { let loop_ptr = uv::ll::get_loop_for_uv_handle(handle); let error_msg = uv::ll::get_last_err_info(loop_ptr); - fail "timer::sleep() init failed: "+error_msg; + fail ~"timer::sleep() init failed: "+error_msg; } } @@ -232,7 +233,7 @@ mod test { for iter::repeat(times as uint) { let expected = rand::rng().gen_str(16u); - let test_po = comm::port::<str>(); + let test_po = comm::port::<~str>(); let test_ch = comm::chan(test_po); do task::spawn() { diff --git a/src/libstd/treemap.rs b/src/libstd/treemap.rs index 1a3626e4660..3def5fbd0d1 100644 --- a/src/libstd/treemap.rs +++ b/src/libstd/treemap.rs @@ -132,13 +132,13 @@ mod tests { fn u8_map() { let m = treemap(); - let k1 = str::bytes("foo"); - let k2 = str::bytes("bar"); + let k1 = str::bytes(~"foo"); + let k2 = str::bytes(~"bar"); - insert(m, k1, "foo"); - insert(m, k2, "bar"); + insert(m, k1, ~"foo"); + insert(m, k2, ~"bar"); - assert (find(m, k2) == some("bar")); - assert (find(m, k1) == some("foo")); + assert (find(m, k2) == some(~"bar")); + assert (find(m, k1) == some(~"foo")); } } diff --git a/src/libstd/uv_global_loop.rs b/src/libstd/uv_global_loop.rs index 53769757f62..4a7962a977f 100644 --- a/src/libstd/uv_global_loop.rs +++ b/src/libstd/uv_global_loop.rs @@ -118,16 +118,16 @@ mod test { } extern fn simple_timer_cb(timer_ptr: *ll::uv_timer_t, _status: libc::c_int) unsafe { - log(debug, "in simple timer cb"); + log(debug, ~"in simple timer cb"); ll::timer_stop(timer_ptr); let hl_loop = get_gl(); do iotask::interact(hl_loop) |_loop_ptr| { - log(debug, "closing timer"); + log(debug, ~"closing timer"); ll::close(timer_ptr, simple_timer_close_cb); - log(debug, "about to deref exit_ch_ptr"); - log(debug, "after msg sent on deref'd exit_ch"); + log(debug, ~"about to deref exit_ch_ptr"); + log(debug, ~"after msg sent on deref'd exit_ch"); }; - log(debug, "exiting simple timer cb"); + log(debug, ~"exiting simple timer cb"); } fn impl_uv_hl_simple_timer(iotask: iotask) unsafe { @@ -139,7 +139,7 @@ mod test { let timer_handle = ll::timer_t(); let timer_ptr = ptr::addr_of(timer_handle); do iotask::interact(iotask) |loop_ptr| { - log(debug, "user code inside interact loop!!!"); + log(debug, ~"user code inside interact loop!!!"); let init_status = ll::timer_init(loop_ptr, timer_ptr); if(init_status == 0i32) { ll::set_data_for_uv_handle( @@ -150,15 +150,15 @@ mod test { if(start_status == 0i32) { } else { - fail "failure on ll::timer_start()"; + fail ~"failure on ll::timer_start()"; } } else { - fail "failure on ll::timer_init()"; + fail ~"failure on ll::timer_init()"; } }; comm::recv(exit_po); - log(debug, "global_loop timer test: msg recv on exit_po, done.."); + log(debug, ~"global_loop timer test: msg recv on exit_po, done.."); } #[test] @@ -192,7 +192,7 @@ mod test { for iter::repeat(cycles) { comm::recv(exit_po); }; - log(debug, "test_stress_gl_uv_global_loop_high_level_global_timer"+ - " exiting sucessfully!"); + log(debug, ~"test_stress_gl_uv_global_loop_high_level_global_timer"+ + ~" exiting sucessfully!"); } } diff --git a/src/libstd/uv_iotask.rs b/src/libstd/uv_iotask.rs index e38fae0fa72..d049c6f7c7b 100644 --- a/src/libstd/uv_iotask.rs +++ b/src/libstd/uv_iotask.rs @@ -114,10 +114,10 @@ fn run_loop(iotask_ch: chan<iotask>) unsafe { }); iotask_ch.send(iotask); - log(debug, "about to run uv loop"); + log(debug, ~"about to run uv loop"); // enter the loop... this blocks until the loop is done.. ll::run(loop_ptr); - log(debug, "uv loop ended"); + log(debug, ~"uv loop ended"); ll::loop_delete(loop_ptr); } @@ -157,7 +157,7 @@ extern fn wake_up_cb(async_handle: *ll::uv_async_t, } fn begin_teardown(data: *iotask_loop_data) unsafe { - log(debug, "iotask begin_teardown() called, close async_handle"); + log(debug, ~"iotask begin_teardown() called, close async_handle"); let async_handle = (*data).async_handle; ll::close(async_handle as *c_void, tear_down_close_cb); } @@ -250,9 +250,9 @@ mod test { for iter::repeat(7u) { comm::recv(work_exit_po); }; - log(debug, "sending teardown_loop msg.."); + log(debug, ~"sending teardown_loop msg.."); exit(iotask); comm::recv(exit_po); - log(debug, "after recv on exit_po.. exiting.."); + log(debug, ~"after recv on exit_po.. exiting.."); } } diff --git a/src/libstd/uv_ll.rs b/src/libstd/uv_ll.rs index 8407a18c549..56365514da9 100644 --- a/src/libstd/uv_ll.rs +++ b/src/libstd/uv_ll.rs @@ -793,7 +793,7 @@ unsafe fn buf_init(++input: *u8, len: uint) -> uv_buf_t { // yuck :/ rustrt::rust_uv_buf_init(out_buf_ptr, input, len as size_t); //let result = rustrt::rust_uv_buf_init_2(input, len as size_t); - log(debug, "after rust_uv_buf_init"); + log(debug, ~"after rust_uv_buf_init"); let res_base = get_base_from_buf(out_buf); let res_len = get_len_from_buf(out_buf); //let res_base = get_base_from_buf(result); @@ -803,21 +803,21 @@ unsafe fn buf_init(++input: *u8, len: uint) -> uv_buf_t { ret out_buf; //ret result; } -unsafe fn ip4_addr(ip: str, port: int) +unsafe fn ip4_addr(ip: ~str, port: int) -> sockaddr_in { do str::as_c_str(ip) |ip_buf| { rustrt::rust_uv_ip4_addr(ip_buf as *u8, port as libc::c_int) } } -unsafe fn ip6_addr(ip: str, port: int) +unsafe fn ip6_addr(ip: ~str, port: int) -> sockaddr_in6 { do str::as_c_str(ip) |ip_buf| { rustrt::rust_uv_ip6_addr(ip_buf as *u8, port as libc::c_int) } } -unsafe fn ip4_name(src: &sockaddr_in) -> str { +unsafe fn ip4_name(src: &sockaddr_in) -> ~str { // ipv4 addr max size: 15 + 1 trailing null byte let dst: ~[u8] = ~[0u8,0u8,0u8,0u8,0u8,0u8,0u8,0u8, 0u8,0u8,0u8,0u8,0u8,0u8,0u8,0u8]; @@ -834,7 +834,7 @@ unsafe fn ip4_name(src: &sockaddr_in) -> str { str::unsafe::from_buf(dst_buf) } } -unsafe fn ip6_name(src: &sockaddr_in6) -> str { +unsafe fn ip6_name(src: &sockaddr_in6) -> ~str { // ipv6 addr max size: 45 + 1 trailing null byte let dst: ~[u8] = ~[0u8,0u8,0u8,0u8,0u8,0u8,0u8,0u8, 0u8,0u8,0u8,0u8,0u8,0u8,0u8,0u8, @@ -854,7 +854,7 @@ unsafe fn ip6_name(src: &sockaddr_in6) -> str { str::unsafe::from_buf(dst_buf) } _ { - "" + ~"" } } } @@ -961,7 +961,7 @@ unsafe fn free_base_of_buf(buf: uv_buf_t) { rustrt::rust_uv_free_base_of_buf(buf); } -unsafe fn get_last_err_info(uv_loop: *libc::c_void) -> str { +unsafe fn get_last_err_info(uv_loop: *libc::c_void) -> ~str { let err = last_error(uv_loop); let err_ptr = ptr::addr_of(err); let err_name = str::unsafe::from_c_str(err_name(err_ptr)); @@ -979,8 +979,8 @@ unsafe fn get_last_err_data(uv_loop: *libc::c_void) -> uv_err_data { } type uv_err_data = { - err_name: str, - err_msg: str + err_name: ~str, + err_msg: ~str }; unsafe fn is_ipv4_addrinfo(input: *addrinfo) -> bool { @@ -1013,7 +1013,7 @@ mod test { type request_wrapper = { write_req: *uv_write_t, req_buf: *~[uv_buf_t], - read_chan: *comm::chan<str> + read_chan: *comm::chan<~str> }; extern fn after_close_cb(handle: *libc::c_void) { @@ -1024,7 +1024,7 @@ mod test { extern fn on_alloc_cb(handle: *libc::c_void, ++suggested_size: libc::size_t) -> uv_buf_t unsafe { - log(debug, "on_alloc_cb!"); + log(debug, ~"on_alloc_cb!"); let char_ptr = malloc_buf_base_of(suggested_size); log(debug, #fmt("on_alloc_cb h: %? char_ptr: %u sugsize: %u", handle, @@ -1056,15 +1056,15 @@ mod test { } else if (nread == -1) { // err .. possibly EOF - log(debug, "read: eof!"); + log(debug, ~"read: eof!"); } else { // nread == 0 .. do nothing, just free buf as below - log(debug, "read: do nothing!"); + log(debug, ~"read: do nothing!"); } // when we're done free_base_of_buf(buf); - log(debug, "CLIENT exiting on_read_cb"); + log(debug, ~"CLIENT exiting on_read_cb"); } extern fn on_write_complete_cb(write_req: *uv_write_t, @@ -1086,7 +1086,7 @@ mod test { let stream = get_stream_handle_from_connect_req(connect_req_ptr); if (status == 0i32) { - log(debug, "on_connect_cb: in status=0 if.."); + log(debug, ~"on_connect_cb: in status=0 if.."); let client_data = get_data_for_req( connect_req_ptr as *libc::c_void) as *request_wrapper; @@ -1107,11 +1107,11 @@ mod test { log(debug, err_msg); assert false; } - log(debug, "finishing on_connect_cb"); + log(debug, ~"finishing on_connect_cb"); } - fn impl_uv_tcp_request(ip: str, port: int, req_str: str, - client_chan: *comm::chan<str>) unsafe { + fn impl_uv_tcp_request(ip: ~str, port: int, req_str: ~str, + client_chan: *comm::chan<~str>) unsafe { let test_loop = loop_new(); let tcp_handle = tcp_t(); let tcp_handle_ptr = ptr::addr_of(tcp_handle); @@ -1143,9 +1143,9 @@ mod test { let tcp_init_result = tcp_init( test_loop as *libc::c_void, tcp_handle_ptr); if (tcp_init_result == 0i32) { - log(debug, "sucessful tcp_init_result"); + log(debug, ~"sucessful tcp_init_result"); - log(debug, "building addr..."); + log(debug, ~"building addr..."); let addr = ip4_addr(ip, port); // FIXME ref #2064 let addr_ptr = ptr::addr_of(addr); @@ -1167,17 +1167,17 @@ mod test { set_data_for_uv_handle( tcp_handle_ptr as *libc::c_void, ptr::addr_of(client_data) as *libc::c_void); - log(debug, "before run tcp req loop"); + log(debug, ~"before run tcp req loop"); run(test_loop); - log(debug, "after run tcp req loop"); + log(debug, ~"after run tcp req loop"); } else { - log(debug, "tcp_connect() failure"); + log(debug, ~"tcp_connect() failure"); assert false; } } else { - log(debug, "tcp_init() failure"); + log(debug, ~"tcp_init() failure"); assert false; } loop_delete(test_loop); @@ -1191,7 +1191,8 @@ mod test { extern fn client_stream_after_close_cb(handle: *libc::c_void) unsafe { - log(debug, "SERVER: closed client stream, now closing server stream"); + log(debug, + ~"SERVER: closed client stream, now closing server stream"); let client_data = get_data_for_uv_handle( handle) as *tcp_server_data; @@ -1202,7 +1203,7 @@ mod test { extern fn after_server_resp_write(req: *uv_write_t) unsafe { let client_stream_ptr = get_stream_handle_from_write_req(req); - log(debug, "SERVER: resp sent... closing client stream"); + log(debug, ~"SERVER: resp sent... closing client stream"); close(client_stream_ptr as *libc::c_void, client_stream_after_close_cb) } @@ -1231,8 +1232,8 @@ mod test { let server_kill_msg = (*client_data).server_kill_msg; let write_req = (*client_data).server_write_req; if (str::contains(request_str, server_kill_msg)) { - log(debug, "SERVER: client req contains kill_msg!"); - log(debug, "SERVER: sending response to client"); + log(debug, ~"SERVER: client req contains kill_msg!"); + log(debug, ~"SERVER: sending response to client"); read_stop(client_stream_ptr); let server_chan = *((*client_data).server_chan); comm::send(server_chan, request_str); @@ -1244,7 +1245,7 @@ mod test { log(debug, #fmt("SERVER: resp write result: %d", write_result as int)); if (write_result != 0i32) { - log(debug, "bad result for server resp write()"); + log(debug, ~"bad result for server resp write()"); log(debug, get_last_err_info( get_loop_for_uv_handle(client_stream_ptr as *libc::c_void))); @@ -1252,26 +1253,26 @@ mod test { } } else { - log(debug, "SERVER: client req !contain kill_msg!"); + log(debug, ~"SERVER: client req !contain kill_msg!"); } } else if (nread == -1) { // err .. possibly EOF - log(debug, "read: eof!"); + log(debug, ~"read: eof!"); } else { // nread == 0 .. do nothing, just free buf as below - log(debug, "read: do nothing!"); + log(debug, ~"read: do nothing!"); } // when we're done free_base_of_buf(buf); - log(debug, "SERVER exiting on_read_cb"); + log(debug, ~"SERVER exiting on_read_cb"); } extern fn server_connection_cb(server_stream_ptr: *uv_stream_t, status: libc::c_int) unsafe { - log(debug, "client connecting!"); + log(debug, ~"client connecting!"); let test_loop = get_loop_for_uv_handle( server_stream_ptr as *libc::c_void); if status != 0i32 { @@ -1289,7 +1290,7 @@ mod test { client_stream_ptr as *libc::c_void, server_data as *libc::c_void); if (client_init_result == 0i32) { - log(debug, "successfully initialized client stream"); + log(debug, ~"successfully initialized client stream"); let accept_result = accept(server_stream_ptr as *libc::c_void, client_stream_ptr as @@ -1301,7 +1302,7 @@ mod test { on_alloc_cb, on_server_read_cb); if (read_result == 0i32) { - log(debug, "successful server read start"); + log(debug, ~"successful server read start"); } else { log(debug, #fmt("server_connection_cb: bad read:%d", @@ -1325,9 +1326,9 @@ mod test { type tcp_server_data = { client: *uv_tcp_t, server: *uv_tcp_t, - server_kill_msg: str, + server_kill_msg: ~str, server_resp_buf: *~[uv_buf_t], - server_chan: *comm::chan<str>, + server_chan: *comm::chan<~str>, server_write_req: *uv_write_t }; @@ -1354,11 +1355,11 @@ mod test { close(async_handle as *libc::c_void, async_close_cb); } - fn impl_uv_tcp_server(server_ip: str, + fn impl_uv_tcp_server(server_ip: ~str, server_port: int, - kill_server_msg: str, - server_resp_msg: str, - server_chan: *comm::chan<str>, + kill_server_msg: ~str, + server_resp_msg: ~str, + server_chan: *comm::chan<~str>, continue_chan: *comm::chan<bool>) unsafe { let test_loop = loop_new(); let tcp_server = tcp_t(); @@ -1408,7 +1409,7 @@ mod test { let bind_result = tcp_bind(tcp_server_ptr, server_addr_ptr); if (bind_result == 0i32) { - log(debug, "successful uv_tcp_bind, listening"); + log(debug, ~"successful uv_tcp_bind, listening"); // uv_listen() let listen_result = listen(tcp_server_ptr as @@ -1428,7 +1429,7 @@ mod test { async_send(continue_async_handle_ptr); // uv_run() run(test_loop); - log(debug, "server uv::run() has returned"); + log(debug, ~"server uv::run() has returned"); } else { log(debug, #fmt("uv_async_init failure: %d", @@ -1459,15 +1460,15 @@ mod test { // this is the impl for a test that is (maybe) ran on a // per-platform/arch basis below fn impl_uv_tcp_server_and_request() unsafe { - let bind_ip = "0.0.0.0"; - let request_ip = "127.0.0.1"; + let bind_ip = ~"0.0.0.0"; + let request_ip = ~"127.0.0.1"; let port = 8887; - let kill_server_msg = "does a dog have buddha nature?"; - let server_resp_msg = "mu!"; - let client_port = comm::port::<str>(); - let client_chan = comm::chan::<str>(client_port); - let server_port = comm::port::<str>(); - let server_chan = comm::chan::<str>(server_port); + let kill_server_msg = ~"does a dog have buddha nature?"; + let server_resp_msg = ~"mu!"; + let client_port = comm::port::<~str>(); + let client_chan = comm::chan::<~str>(client_port); + let server_port = comm::port::<~str>(); + let server_chan = comm::chan::<~str>(server_port); let continue_port = comm::port::<bool>(); let continue_chan = comm::chan::<bool>(continue_port); @@ -1482,9 +1483,9 @@ mod test { }; // block until the server up is.. possibly a race? - log(debug, "before receiving on server continue_port"); + log(debug, ~"before receiving on server continue_port"); comm::recv(continue_port); - log(debug, "received on continue port, set up tcp client"); + log(debug, ~"received on continue port, set up tcp client"); do task::spawn_sched(task::manual_threads(1u)) { impl_uv_tcp_request(request_ip, port, diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 095038f02e3..30535b45529 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -32,7 +32,7 @@ fn deserialize_span<D>(_d: D) -> span { type spanned<T> = {node: T, span: span}; #[auto_serialize] -type ident = @str/~; +type ident = @~str; // Functions may or may not have names. #[auto_serialize] @@ -428,11 +428,11 @@ type lit = spanned<lit_>; #[auto_serialize] enum lit_ { - lit_str(@str/~), + lit_str(@~str), lit_int(i64, int_ty), lit_uint(u64, uint_ty), lit_int_unsuffixed(i64), - lit_float(@str/~, float_ty), + lit_float(@~str, float_ty), lit_nil, lit_bool(bool), } diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs index a5ae45d54ee..7f1899792d7 100644 --- a/src/libsyntax/ast_map.rs +++ b/src/libsyntax/ast_map.rs @@ -10,7 +10,7 @@ enum path_elt { path_mod(ident), path_name(ident) } type path = ~[path_elt]; /* FIXMEs that say "bad" are as per #2543 */ -fn path_to_str_with_sep(p: path, sep: str) -> str { +fn path_to_str_with_sep(p: path, sep: ~str) -> ~str { let strs = do vec::map(p) |e| { alt e { path_mod(s) { /* FIXME (#2543) */ copy *s } @@ -20,7 +20,7 @@ fn path_to_str_with_sep(p: path, sep: str) -> str { str::connect(strs, sep) } -fn path_ident_to_str(p: path, i: ident) -> str { +fn path_ident_to_str(p: path, i: ident) -> ~str { if vec::is_empty(p) { /* FIXME (#2543) */ copy *i } else { @@ -28,8 +28,8 @@ fn path_ident_to_str(p: path, i: ident) -> str { } } -fn path_to_str(p: path) -> str { - path_to_str_with_sep(p, "::") +fn path_to_str(p: path) -> ~str { + path_to_str_with_sep(p, ~"::") } enum ast_node { @@ -267,7 +267,7 @@ fn map_expr(ex: @expr, cx: ctx, v: vt) { visit::visit_expr(ex, cx, v); } -fn node_id_to_str(map: map, id: node_id) -> str { +fn node_id_to_str(map: map, id: node_id) -> ~str { alt map.find(id) { none { #fmt["unknown node (id=%d)", id] diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index cfaa7103a58..556239769da 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -21,11 +21,11 @@ pure fn mk_sp(lo: uint, hi: uint) -> span { // make this a const, once the compiler supports it pure fn dummy_sp() -> span { ret mk_sp(0u, 0u); } -pure fn path_name(p: @path) -> str { path_name_i(p.idents) } +pure fn path_name(p: @path) -> ~str { path_name_i(p.idents) } -pure fn path_name_i(idents: ~[ident]) -> str { +pure fn path_name_i(idents: ~[ident]) -> ~str { // FIXME: Bad copies (#2543 -- same for everything else that says "bad") - str::connect(idents.map(|i|*i), "::") + str::connect(idents.map(|i|*i), ~"::") } pure fn path_to_ident(p: @path) -> ident { vec::last(p.idents) } @@ -45,7 +45,7 @@ pure fn stmt_id(s: stmt) -> node_id { fn variant_def_ids(d: def) -> {enm: def_id, var: def_id} { alt d { def_variant(enum_id, var_id) { ret {enm: enum_id, var: var_id}; } - _ { fail "non-variant in variant_def_ids"; } } + _ { fail ~"non-variant in variant_def_ids"; } } } pure fn def_id_of_def(d: def) -> def_id { @@ -63,26 +63,26 @@ pure fn def_id_of_def(d: def) -> def_id { } } -pure fn binop_to_str(op: binop) -> str { +pure fn binop_to_str(op: binop) -> ~str { alt op { - add { ret "+"; } - subtract { ret "-"; } - mul { ret "*"; } - div { ret "/"; } - rem { ret "%"; } - and { ret "&&"; } - or { ret "||"; } - bitxor { ret "^"; } - bitand { ret "&"; } - bitor { ret "|"; } - shl { ret "<<"; } - shr { ret ">>"; } - eq { ret "=="; } - lt { ret "<"; } - le { ret "<="; } - ne { ret "!="; } - ge { ret ">="; } - gt { ret ">"; } + add { ret ~"+"; } + subtract { ret ~"-"; } + mul { ret ~"*"; } + div { ret ~"/"; } + rem { ret ~"%"; } + and { ret ~"&&"; } + or { ret ~"||"; } + bitxor { ret ~"^"; } + bitand { ret ~"&"; } + bitor { ret ~"|"; } + shl { ret ~"<<"; } + shr { ret ~">>"; } + eq { ret ~"=="; } + lt { ret ~"<"; } + le { ret ~"<="; } + ne { ret ~"!="; } + ge { ret ~">="; } + gt { ret ~">"; } } } @@ -98,13 +98,13 @@ pure fn is_shift_binop(b: binop) -> bool { } } -pure fn unop_to_str(op: unop) -> str { +pure fn unop_to_str(op: unop) -> ~str { alt op { - box(mt) { if mt == m_mutbl { ret "@mut "; } ret "@"; } - uniq(mt) { if mt == m_mutbl { ret "~mut "; } ret "~"; } - deref { ret "*"; } - not { ret "!"; } - neg { ret "-"; } + box(mt) { if mt == m_mutbl { ret ~"@mut "; } ret ~"@"; } + uniq(mt) { if mt == m_mutbl { ret ~"~mut "; } ret ~"~"; } + deref { ret ~"*"; } + not { ret ~"!"; } + neg { ret ~"-"; } } } @@ -112,11 +112,11 @@ pure fn is_path(e: @expr) -> bool { ret alt e.node { expr_path(_) { true } _ { false } }; } -pure fn int_ty_to_str(t: int_ty) -> str { +pure fn int_ty_to_str(t: int_ty) -> ~str { alt t { - ty_char { "u8" } // ??? - ty_i { "" } ty_i8 { "i8" } ty_i16 { "i16" } - ty_i32 { "i32" } ty_i64 { "i64" } + ty_char { ~"u8" } // ??? + ty_i { ~"" } ty_i8 { ~"i8" } ty_i16 { ~"i16" } + ty_i32 { ~"i32" } ty_i64 { ~"i64" } } } @@ -129,10 +129,10 @@ pure fn int_ty_max(t: int_ty) -> u64 { } } -pure fn uint_ty_to_str(t: uint_ty) -> str { +pure fn uint_ty_to_str(t: uint_ty) -> ~str { alt t { - ty_u { "u" } ty_u8 { "u8" } ty_u16 { "u16" } - ty_u32 { "u32" } ty_u64 { "u64" } + ty_u { ~"u" } ty_u8 { ~"u8" } ty_u16 { ~"u16" } + ty_u32 { ~"u32" } ty_u64 { ~"u64" } } } @@ -145,8 +145,8 @@ pure fn uint_ty_max(t: uint_ty) -> u64 { } } -pure fn float_ty_to_str(t: float_ty) -> str { - alt t { ty_f { "" } ty_f32 { "f32" } ty_f64 { "f64" } } +pure fn float_ty_to_str(t: float_ty) -> ~str { + alt t { ty_f { ~"" } ty_f32 { ~"f32" } ty_f64 { ~"f64" } } } fn is_exported(i: ident, m: _mod) -> bool { @@ -191,7 +191,7 @@ fn is_exported(i: ident, m: _mod) -> bool { if id.node.name == i { ret true; } } } else { - fail "export of path-qualified list"; + fail ~"export of path-qualified list"; } } @@ -381,7 +381,7 @@ fn dtor_dec() -> fn_decl { let nil_t = @{id: 0, node: ty_nil, span: dummy_sp()}; // dtor has one argument, of type () {inputs: ~[{mode: ast::expl(ast::by_ref), - ty: nil_t, ident: @"_"/~, id: 0}], + ty: nil_t, ident: @~"_", id: 0}], output: nil_t, purity: impure_fn, cf: return_val, constraints: ~[]} } diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs index 114daa900aa..859bc70bfd6 100644 --- a/src/libsyntax/attr.rs +++ b/src/libsyntax/attr.rs @@ -49,7 +49,8 @@ export require_unique_names; /* Constructors */ -fn mk_name_value_item_str(+name: ast::ident, +value: str) -> @ast::meta_item { +fn mk_name_value_item_str(+name: ast::ident, +value: ~str) -> + @ast::meta_item { let value_lit = dummy_spanned(ast::lit_str(@value)); ret mk_name_value_item(name, value_lit); } @@ -73,11 +74,11 @@ fn mk_attr(item: @ast::meta_item) -> ast::attribute { is_sugared_doc: false}); } -fn mk_sugared_doc_attr(text: str, lo: uint, hi: uint) -> ast::attribute { +fn mk_sugared_doc_attr(text: ~str, lo: uint, hi: uint) -> ast::attribute { let lit = spanned(lo, hi, ast::lit_str(@text)); let attr = { style: doc_comment_style(text), - value: spanned(lo, hi, ast::meta_name_value(@"doc"/~, lit)), + value: spanned(lo, hi, ast::meta_name_value(@~"doc", lit)), is_sugared_doc: true }; ret spanned(lo, hi, attr); @@ -97,7 +98,7 @@ fn attr_metas(attrs: ~[ast::attribute]) -> ~[@ast::meta_item] { fn desugar_doc_attr(attr: ast::attribute) -> ast::attribute { if attr.node.is_sugared_doc { let comment = get_meta_item_value_str(@attr.node.value).get(); - let meta = mk_name_value_item_str(@"doc"/~, + let meta = mk_name_value_item_str(@~"doc", strip_doc_comment_decoration(*comment)); ret mk_attr(meta); } else { @@ -124,7 +125,7 @@ fn get_meta_item_name(meta: @ast::meta_item) -> ast::ident { * Gets the string value if the meta_item is a meta_name_value variant * containing a string, otherwise none */ -fn get_meta_item_value_str(meta: @ast::meta_item) -> option<@str/~> { +fn get_meta_item_value_str(meta: @ast::meta_item) -> option<@~str> { alt meta.node { ast::meta_name_value(_, v) { alt v.node { @@ -154,7 +155,7 @@ fn get_meta_item_list(meta: @ast::meta_item) -> option<~[@ast::meta_item]> { */ fn get_name_value_str_pair( item: @ast::meta_item -) -> option<(ast::ident, @str/~)> { +) -> option<(ast::ident, @~str)> { alt attr::get_meta_item_value_str(item) { some(value) { let name = attr::get_meta_item_name(item); @@ -168,7 +169,7 @@ fn get_name_value_str_pair( /* Searching */ /// Search a list of attributes and return only those with a specific name -fn find_attrs_by_name(attrs: ~[ast::attribute], +name: str) -> +fn find_attrs_by_name(attrs: ~[ast::attribute], +name: ~str) -> ~[ast::attribute] { let filter = ( fn@(a: ast::attribute) -> option<ast::attribute> { @@ -181,7 +182,7 @@ fn find_attrs_by_name(attrs: ~[ast::attribute], +name: str) -> } /// Searcha list of meta items and return only those with a specific name -fn find_meta_items_by_name(metas: ~[@ast::meta_item], +name: str) -> +fn find_meta_items_by_name(metas: ~[@ast::meta_item], +name: ~str) -> ~[@ast::meta_item] { let filter = fn@(&&m: @ast::meta_item) -> option<@ast::meta_item> { if *get_meta_item_name(m) == name { @@ -224,22 +225,22 @@ fn eq(a: @ast::meta_item, b: @ast::meta_item) -> bool { // FIXME (#607): Needs implementing // This involves probably sorting the list by name and // meta_item variant - fail "unimplemented meta_item variant" + fail ~"unimplemented meta_item variant" } } } -fn contains_name(metas: ~[@ast::meta_item], +name: str) -> bool { +fn contains_name(metas: ~[@ast::meta_item], +name: ~str) -> bool { let matches = find_meta_items_by_name(metas, name); ret vec::len(matches) > 0u; } -fn attrs_contains_name(attrs: ~[ast::attribute], +name: str) -> bool { +fn attrs_contains_name(attrs: ~[ast::attribute], +name: ~str) -> bool { vec::is_not_empty(find_attrs_by_name(attrs, name)) } -fn first_attr_value_str_by_name(attrs: ~[ast::attribute], +name: str) - -> option<@str/~> { +fn first_attr_value_str_by_name(attrs: ~[ast::attribute], +name: ~str) + -> option<@~str> { let mattrs = find_attrs_by_name(attrs, name); if vec::len(mattrs) > 0u { ret get_meta_item_value_str(attr_meta(mattrs[0])); @@ -249,7 +250,7 @@ fn first_attr_value_str_by_name(attrs: ~[ast::attribute], +name: str) fn last_meta_item_by_name( items: ~[@ast::meta_item], - +name: str + +name: ~str ) -> option<@ast::meta_item> { let items = attr::find_meta_items_by_name(items, name); vec::last_opt(items) @@ -257,8 +258,8 @@ fn last_meta_item_by_name( fn last_meta_item_value_str_by_name( items: ~[@ast::meta_item], - +name: str -) -> option<@str/~> { + +name: ~str +) -> option<@~str> { alt last_meta_item_by_name(items, name) { some(item) { alt attr::get_meta_item_value_str(item) { @@ -272,7 +273,7 @@ fn last_meta_item_value_str_by_name( fn last_meta_item_list_by_name( items: ~[@ast::meta_item], - +name: str + +name: ~str ) -> option<~[@ast::meta_item]> { alt last_meta_item_by_name(items, name) { some(item) { @@ -319,7 +320,7 @@ fn remove_meta_items_by_name(items: ~[@ast::meta_item], name: ast::ident) -> fn find_linkage_attrs(attrs: ~[ast::attribute]) -> ~[ast::attribute] { let mut found = ~[]; - for find_attrs_by_name(attrs, "link").each |attr| { + for find_attrs_by_name(attrs, ~"link").each |attr| { alt attr.node.value.node { ast::meta_list(_, _) { vec::push(found, attr) } _ { #debug("ignoring link attribute that has incorrect type"); } @@ -340,22 +341,22 @@ fn find_linkage_metas(attrs: ~[ast::attribute]) -> ~[@ast::meta_item] { } } -fn foreign_abi(attrs: ~[ast::attribute]) -> either<str, ast::foreign_abi> { - ret alt attr::first_attr_value_str_by_name(attrs, "abi") { +fn foreign_abi(attrs: ~[ast::attribute]) -> either<~str, ast::foreign_abi> { + ret alt attr::first_attr_value_str_by_name(attrs, ~"abi") { option::none { either::right(ast::foreign_abi_cdecl) } - option::some(@"rust-intrinsic"/~) { + option::some(@~"rust-intrinsic") { either::right(ast::foreign_abi_rust_intrinsic) } - option::some(@"cdecl"/~) { + option::some(@~"cdecl") { either::right(ast::foreign_abi_cdecl) } - option::some(@"stdcall"/~) { + option::some(@~"stdcall") { either::right(ast::foreign_abi_stdcall) } option::some(t) { - either::left("unsupported abi: " + *t) + either::left(~"unsupported abi: " + *t) } }; } @@ -371,9 +372,9 @@ fn find_inline_attr(attrs: ~[ast::attribute]) -> inline_attr { // FIXME (#2809)---validate the usage of #[inline] and #[inline(always)] do vec::foldl(ia_none, attrs) |ia,attr| { alt attr.node.value.node { - ast::meta_word(@"inline"/~) { ia_hint } - ast::meta_list(@"inline"/~, items) { - if !vec::is_empty(find_meta_items_by_name(items, "always")) { + ast::meta_word(@~"inline") { ia_hint } + ast::meta_list(@~"inline", items) { + if !vec::is_empty(find_meta_items_by_name(items, ~"always")) { ia_always } else { ia_hint diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs index 867d2d7e45a..76625d3f918 100644 --- a/src/libsyntax/codemap.rs +++ b/src/libsyntax/codemap.rs @@ -28,7 +28,7 @@ export loc; export get_filemap; export new_codemap; -type filename = str; +type filename = ~str; type file_pos = {ch: uint, byte: uint}; @@ -41,11 +41,11 @@ type file_pos = {ch: uint, byte: uint}; enum file_substr { fss_none, fss_internal(span), - fss_external({filename: str, line: uint, col: uint}) + fss_external({filename: ~str, line: uint, col: uint}) } type filemap = - @{name: filename, substr: file_substr, src: @str/~, + @{name: filename, substr: file_substr, src: @~str, start_pos: file_pos, mut lines: ~[file_pos]}; type codemap = @{files: dvec<filemap>}; @@ -55,7 +55,7 @@ type loc = {file: filemap, line: uint, col: uint}; fn new_codemap() -> codemap { @{files: dvec()} } fn new_filemap_w_substr(+filename: filename, +substr: file_substr, - src: @str/~, + src: @~str, start_pos_ch: uint, start_pos_byte: uint) -> filemap { ret @{name: filename, substr: substr, src: src, @@ -63,14 +63,14 @@ fn new_filemap_w_substr(+filename: filename, +substr: file_substr, mut lines: ~[{ch: start_pos_ch, byte: start_pos_byte}]}; } -fn new_filemap(+filename: filename, src: @str/~, +fn new_filemap(+filename: filename, src: @~str, start_pos_ch: uint, start_pos_byte: uint) -> filemap { ret new_filemap_w_substr(filename, fss_none, src, start_pos_ch, start_pos_byte); } -fn mk_substr_filename(cm: codemap, sp: span) -> str +fn mk_substr_filename(cm: codemap, sp: span) -> ~str { let pos = lookup_char_pos(cm, sp.lo); ret #fmt("<%s:%u:%u>", pos.file.name, pos.line, pos.col); @@ -121,7 +121,7 @@ fn lookup_byte_pos(map: codemap, pos: uint) -> loc { } fn lookup_char_pos_adj(map: codemap, pos: uint) - -> {filename: str, line: uint, col: uint, file: option<filemap>} + -> {filename: ~str, line: uint, col: uint, file: option<filemap>} { let loc = lookup_char_pos(map, pos); alt (loc.file.substr) { @@ -158,19 +158,19 @@ fn adjust_span(map: codemap, sp: span) -> span { enum expn_info_ { expanded_from({call_site: span, - callie: {name: str, span: option<span>}}) + callie: {name: ~str, span: option<span>}}) } type expn_info = option<@expn_info_>; type span = {lo: uint, hi: uint, expn_info: expn_info}; -fn span_to_str_no_adj(sp: span, cm: codemap) -> str { +fn span_to_str_no_adj(sp: span, cm: codemap) -> ~str { let lo = lookup_char_pos(cm, sp.lo); let hi = lookup_char_pos(cm, sp.hi); ret #fmt("%s:%u:%u: %u:%u", lo.file.name, lo.line, lo.col, hi.line, hi.col) } -fn span_to_str(sp: span, cm: codemap) -> str { +fn span_to_str(sp: span, cm: codemap) -> ~str { let lo = lookup_char_pos_adj(cm, sp.lo); let hi = lookup_char_pos_adj(cm, sp.hi); ret #fmt("%s:%u:%u: %u:%u", lo.filename, @@ -194,7 +194,7 @@ fn span_to_lines(sp: span, cm: codemap::codemap) -> @file_lines { ret @{file: lo.file, lines: lines}; } -fn get_line(fm: filemap, line: int) -> str unsafe { +fn get_line(fm: filemap, line: int) -> ~str unsafe { let begin: uint = fm.lines[line].byte - fm.start_pos.byte; let end = alt str::find_char_from(*fm.src, '\n', begin) { some(e) { e } @@ -213,20 +213,20 @@ fn lookup_byte_offset(cm: codemap::codemap, chpos: uint) {fm: fm, pos: line_offset + col_offset} } -fn span_to_snippet(sp: span, cm: codemap::codemap) -> str { +fn span_to_snippet(sp: span, cm: codemap::codemap) -> ~str { let begin = lookup_byte_offset(cm, sp.lo); let end = lookup_byte_offset(cm, sp.hi); assert begin.fm == end.fm; ret str::slice(*begin.fm.src, begin.pos, end.pos); } -fn get_snippet(cm: codemap::codemap, fidx: uint, lo: uint, hi: uint) -> str +fn get_snippet(cm: codemap::codemap, fidx: uint, lo: uint, hi: uint) -> ~str { let fm = cm.files[fidx]; ret str::slice(*fm.src, lo, hi) } -fn get_filemap(cm: codemap, filename: str) -> filemap { +fn get_filemap(cm: codemap, filename: ~str) -> filemap { for cm.files.each |fm| { if fm.name == filename { ret fm; } } //XXjdm the following triggers a mismatched type bug // (or expected function, found _|_) diff --git a/src/libsyntax/diagnostic.rs b/src/libsyntax/diagnostic.rs index 377d0864151..cda49de8dd0 100644 --- a/src/libsyntax/diagnostic.rs +++ b/src/libsyntax/diagnostic.rs @@ -10,30 +10,30 @@ export ice_msg; export expect; type emitter = fn@(cmsp: option<(codemap::codemap, span)>, - msg: str, lvl: level); + msg: ~str, lvl: level); iface span_handler { - fn span_fatal(sp: span, msg: str) -> !; - fn span_err(sp: span, msg: str); - fn span_warn(sp: span, msg: str); - fn span_note(sp: span, msg: str); - fn span_bug(sp: span, msg: str) -> !; - fn span_unimpl(sp: span, msg: str) -> !; + fn span_fatal(sp: span, msg: ~str) -> !; + fn span_err(sp: span, msg: ~str); + fn span_warn(sp: span, msg: ~str); + fn span_note(sp: span, msg: ~str); + fn span_bug(sp: span, msg: ~str) -> !; + fn span_unimpl(sp: span, msg: ~str) -> !; fn handler() -> handler; } iface handler { - fn fatal(msg: str) -> !; - fn err(msg: str); + fn fatal(msg: ~str) -> !; + fn err(msg: ~str); fn bump_err_count(); fn has_errors() -> bool; fn abort_if_errors(); - fn warn(msg: str); - fn note(msg: str); - fn bug(msg: str) -> !; - fn unimpl(msg: str) -> !; - fn emit(cmsp: option<(codemap::codemap, span)>, msg: str, lvl: level); + fn warn(msg: ~str); + fn note(msg: ~str); + fn bug(msg: ~str) -> !; + fn unimpl(msg: ~str) -> !; + fn emit(cmsp: option<(codemap::codemap, span)>, msg: ~str, lvl: level); } type handler_t = @{ @@ -47,25 +47,25 @@ type codemap_t = @{ }; impl codemap_span_handler of span_handler for codemap_t { - fn span_fatal(sp: span, msg: str) -> ! { + fn span_fatal(sp: span, msg: ~str) -> ! { self.handler.emit(some((self.cm, sp)), msg, fatal); fail; } - fn span_err(sp: span, msg: str) { + fn span_err(sp: span, msg: ~str) { self.handler.emit(some((self.cm, sp)), msg, error); self.handler.bump_err_count(); } - fn span_warn(sp: span, msg: str) { + fn span_warn(sp: span, msg: ~str) { self.handler.emit(some((self.cm, sp)), msg, warning); } - fn span_note(sp: span, msg: str) { + fn span_note(sp: span, msg: ~str) { self.handler.emit(some((self.cm, sp)), msg, note); } - fn span_bug(sp: span, msg: str) -> ! { + fn span_bug(sp: span, msg: ~str) -> ! { self.span_fatal(sp, ice_msg(msg)); } - fn span_unimpl(sp: span, msg: str) -> ! { - self.span_bug(sp, "unimplemented " + msg); + fn span_unimpl(sp: span, msg: ~str) -> ! { + self.span_bug(sp, ~"unimplemented " + msg); } fn handler() -> handler { self.handler @@ -73,11 +73,11 @@ impl codemap_span_handler of span_handler for codemap_t { } impl codemap_handler of handler for handler_t { - fn fatal(msg: str) -> ! { + fn fatal(msg: ~str) -> ! { self.emit(none, msg, fatal); fail; } - fn err(msg: str) { + fn err(msg: ~str) { self.emit(none, msg, error); self.bump_err_count(); } @@ -89,28 +89,28 @@ impl codemap_handler of handler for handler_t { let s; alt self.err_count { 0u { ret; } - 1u { s = "aborting due to previous error"; } + 1u { s = ~"aborting due to previous error"; } _ { s = #fmt["aborting due to %u previous errors", self.err_count]; } } self.fatal(s); } - fn warn(msg: str) { + fn warn(msg: ~str) { self.emit(none, msg, warning); } - fn note(msg: str) { + fn note(msg: ~str) { self.emit(none, msg, note); } - fn bug(msg: str) -> ! { + fn bug(msg: ~str) -> ! { self.fatal(ice_msg(msg)); } - fn unimpl(msg: str) -> ! { self.bug("unimplemented " + msg); } - fn emit(cmsp: option<(codemap::codemap, span)>, msg: str, lvl: level) { + fn unimpl(msg: ~str) -> ! { self.bug(~"unimplemented " + msg); } + fn emit(cmsp: option<(codemap::codemap, span)>, msg: ~str, lvl: level) { self.emit(cmsp, msg, lvl); } } -fn ice_msg(msg: str) -> str { +fn ice_msg(msg: ~str) -> ~str { #fmt["internal compiler error: %s", msg] } @@ -124,7 +124,7 @@ fn mk_handler(emitter: option<emitter>) -> handler { some(e) { e } none { let f = fn@(cmsp: option<(codemap::codemap, span)>, - msg: str, t: level) { + msg: ~str, t: level) { emit(cmsp, msg, t); }; f @@ -144,12 +144,12 @@ enum level { note, } -fn diagnosticstr(lvl: level) -> str { +fn diagnosticstr(lvl: level) -> ~str { alt lvl { - fatal { "error" } - error { "error" } - warning { "warning" } - note { "note" } + fatal { ~"error" } + error { ~"error" } + warning { ~"warning" } + note { ~"note" } } } @@ -162,7 +162,7 @@ fn diagnosticcolor(lvl: level) -> u8 { } } -fn print_diagnostic(topic: str, lvl: level, msg: str) { +fn print_diagnostic(topic: ~str, lvl: level, msg: ~str) { if str::is_not_empty(topic) { io::stderr().write_str(#fmt["%s ", topic]); } @@ -177,7 +177,7 @@ fn print_diagnostic(topic: str, lvl: level, msg: str) { } fn emit(cmsp: option<(codemap::codemap, span)>, - msg: str, lvl: level) { + msg: ~str, lvl: level) { alt cmsp { some((cm, sp)) { let sp = codemap::adjust_span(cm,sp); @@ -188,7 +188,7 @@ fn emit(cmsp: option<(codemap::codemap, span)>, print_macro_backtrace(cm, sp); } none { - print_diagnostic("", lvl, msg); + print_diagnostic(~"", lvl, msg); } } } @@ -209,16 +209,16 @@ fn highlight_lines(cm: codemap::codemap, sp: span, // Print the offending lines for display_lines.each |line| { io::stderr().write_str(#fmt["%s:%u ", fm.name, line + 1u]); - let s = codemap::get_line(fm, line as int) + "\n"; + let s = codemap::get_line(fm, line as int) + ~"\n"; io::stderr().write_str(s); } if elided { let last_line = display_lines[vec::len(display_lines) - 1u]; let s = #fmt["%s:%u ", fm.name, last_line + 1u]; let mut indent = str::len(s); - let mut out = ""; - while indent > 0u { out += " "; indent -= 1u; } - out += "...\n"; + let mut out = ~""; + while indent > 0u { out += ~" "; indent -= 1u; } + out += ~"...\n"; io::stderr().write_str(out); } @@ -234,34 +234,34 @@ fn highlight_lines(cm: codemap::codemap, sp: span, // indent past |name:## | and the 0-offset column location let mut left = str::len(fm.name) + digits + lo.col + 3u; - let mut s = ""; + let mut s = ~""; while left > 0u { str::push_char(s, ' '); left -= 1u; } - s += "^"; + s += ~"^"; let hi = codemap::lookup_char_pos(cm, sp.hi); if hi.col != lo.col { // the ^ already takes up one space let mut width = hi.col - lo.col - 1u; while width > 0u { str::push_char(s, '~'); width -= 1u; } } - io::stderr().write_str(s + "\n"); + io::stderr().write_str(s + ~"\n"); } } fn print_macro_backtrace(cm: codemap::codemap, sp: span) { do option::iter (sp.expn_info) |ei| { - let ss = option::map_default(ei.callie.span, @""/~, + let ss = option::map_default(ei.callie.span, @~"", |span| @codemap::span_to_str(span, cm)); print_diagnostic(*ss, note, #fmt("in expansion of #%s", ei.callie.name)); let ss = codemap::span_to_str(ei.call_site, cm); - print_diagnostic(ss, note, "expansion site"); + print_diagnostic(ss, note, ~"expansion site"); print_macro_backtrace(cm, ei.call_site); } } fn expect<T: copy>(diag: span_handler, - opt: option<T>, msg: fn() -> str) -> T { + opt: option<T>, msg: fn() -> ~str) -> T { alt opt { some(t) { t } none { diag.handler().bug(msg()); } diff --git a/src/libsyntax/ext/auto_serialize.rs b/src/libsyntax/ext/auto_serialize.rs index d3286fbc80f..ac2829643be 100644 --- a/src/libsyntax/ext/auto_serialize.rs +++ b/src/libsyntax/ext/auto_serialize.rs @@ -84,15 +84,15 @@ mod syntax { export parse; } -type ser_tps_map = map::hashmap<str, fn@(@ast::expr) -> ~[@ast::stmt]>; -type deser_tps_map = map::hashmap<str, fn@() -> @ast::expr>; +type ser_tps_map = map::hashmap<~str, fn@(@ast::expr) -> ~[@ast::stmt]>; +type deser_tps_map = map::hashmap<~str, fn@() -> @ast::expr>; fn expand(cx: ext_ctxt, span: span, _mitem: ast::meta_item, in_items: ~[@ast::item]) -> ~[@ast::item] { fn not_auto_serialize(a: ast::attribute) -> bool { - attr::get_attr_name(a) != @"auto_serialize"/~ + attr::get_attr_name(a) != @~"auto_serialize" } fn filter_attrs(item: @ast::item) -> @ast::item { @@ -114,7 +114,7 @@ fn expand(cx: ext_ctxt, } _ { - cx.span_err(span, "#[auto_serialize] can only be \ + cx.span_err(span, ~"#[auto_serialize] can only be \ applied to type and enum \ definitions"); ~[in_item] @@ -125,11 +125,11 @@ fn expand(cx: ext_ctxt, impl helpers for ext_ctxt { fn helper_path(base_path: @ast::path, - helper_name: str) -> @ast::path { + helper_name: ~str) -> @ast::path { let head = vec::init(base_path.idents); let tail = vec::last(base_path.idents); self.path(base_path.span, - vec::append(head, ~[@(helper_name + "_" + *tail)])) + vec::append(head, ~[@(helper_name + ~"_" + *tail)])) } fn path(span: span, strs: ~[ast::ident]) -> @ast::path { @@ -154,7 +154,7 @@ impl helpers for ext_ctxt { let args = do vec::map(input_tys) |ty| { {mode: ast::expl(ast::by_ref), ty: ty, - ident: @""/~, + ident: @~"", id: self.next_id()} }; @@ -219,7 +219,7 @@ impl helpers for ext_ctxt { ast::expr_alt(v, arms, ast::alt_exhaustive))) } - fn lit_str(span: span, s: @str/~) -> @ast::expr { + fn lit_str(span: span, s: @~str) -> @ast::expr { self.expr( span, ast::expr_vstore( @@ -297,7 +297,7 @@ fn ser_path(cx: ext_ctxt, tps: ser_tps_map, path: @ast::path, cx.expr( path.span, ast::expr_path( - cx.helper_path(path, "serialize"))); + cx.helper_path(path, ~"serialize"))); let ty_args = do vec::map(path.types) |ty| { let sv_stmts = ser_ty(cx, tps, ty, cx.clone(s), #ast{ __v }); @@ -354,7 +354,7 @@ fn is_vec_or_str(ty: @ast::ty) -> bool { // This may be wrong if the user has shadowed (!) str ast::ty_path(@{span: _, global: _, idents: ids, rp: none, types: _}, _) - if ids == ~[@"str"/~] { true } + if ids == ~[@~"str"] { true } _ { false } } } @@ -392,7 +392,7 @@ fn ser_ty(cx: ext_ctxt, tps: ser_tps_map, } ast::ty_ptr(_) | ast::ty_rptr(_, _) { - cx.span_err(ty.span, "cannot serialize pointer types"); + cx.span_err(ty.span, ~"cannot serialize pointer types"); ~[] } @@ -414,7 +414,7 @@ fn ser_ty(cx: ext_ctxt, tps: ser_tps_map, } ast::ty_fn(_, _) { - cx.span_err(ty.span, "cannot serialize function types"); + cx.span_err(ty.span, ~"cannot serialize function types"); ~[] } @@ -471,12 +471,12 @@ fn ser_ty(cx: ext_ctxt, tps: ser_tps_map, } ast::ty_mac(_) { - cx.span_err(ty.span, "cannot serialize macro types"); + cx.span_err(ty.span, ~"cannot serialize macro types"); ~[] } ast::ty_infer { - cx.span_err(ty.span, "cannot serialize inferred types"); + cx.span_err(ty.span, ~"cannot serialize inferred types"); ~[] } @@ -503,7 +503,7 @@ fn ser_ty(cx: ext_ctxt, tps: ser_tps_map, } ast::ty_vstore(_, _) { - cx.span_unimpl(ty.span, "serialization for vstore types"); + cx.span_unimpl(ty.span, ~"serialization for vstore types"); } } @@ -525,7 +525,7 @@ fn mk_ser_fn(cx: ext_ctxt, span: span, name: ast::ident, ty: cx.ty_fn(span, ~[cx.ty_path(span, ~[tp.ident], ~[])], cx.ty_nil(span)), - ident: @("__s" + *tp.ident), + ident: @(~"__s" + *tp.ident), id: cx.next_id()}); #debug["tp_inputs = %?", tp_inputs]; @@ -533,12 +533,12 @@ fn mk_ser_fn(cx: ext_ctxt, span: span, name: ast::ident, let ser_inputs: ~[ast::arg] = vec::append(~[{mode: ast::expl(ast::by_ref), - ty: cx.ty_path(span, ~[@"__S"/~], ~[]), - ident: @"__s"/~, + ty: cx.ty_path(span, ~[@~"__S"], ~[]), + ident: @~"__s", id: cx.next_id()}, {mode: ast::expl(ast::by_ref), ty: v_ty, - ident: @"__v"/~, + ident: @~"__v", id: cx.next_id()}], tp_inputs); @@ -556,12 +556,12 @@ fn mk_ser_fn(cx: ext_ctxt, span: span, name: ast::ident, let ser_bnds = @~[ ast::bound_trait(cx.ty_path(span, - ~[@"std"/~, @"serialization"/~, - @"serializer"/~], + ~[@~"std", @~"serialization", + @~"serializer"], ~[]))]; let ser_tps: ~[ast::ty_param] = - vec::append(~[{ident: @"__S"/~, + vec::append(~[{ident: @~"__S", id: cx.next_id(), bounds: ser_bnds}], vec::map(tps, |tp| cx.clone_ty_param(tp))); @@ -573,7 +573,7 @@ fn mk_ser_fn(cx: ext_ctxt, span: span, name: ast::ident, let ser_blk = cx.blk(span, f(cx, tps_map, #ast{ __s }, #ast{ __v })); - @{ident: @("serialize_" + *name), + @{ident: @(~"serialize_" + *name), attrs: ~[], id: cx.next_id(), node: ast::item_fn({inputs: ser_inputs, @@ -598,7 +598,7 @@ fn deser_path(cx: ext_ctxt, tps: deser_tps_map, path: @ast::path, cx.expr( path.span, ast::expr_path( - cx.helper_path(path, "deserialize"))); + cx.helper_path(path, ~"deserialize"))); let ty_args = do vec::map(path.types) |ty| { let dv_expr = deser_ty(cx, tps, ty, cx.clone(d)); @@ -726,7 +726,7 @@ fn deser_ty(cx: ext_ctxt, tps: deser_tps_map, } ast::ty_vstore(_, _) { - cx.span_unimpl(ty.span, "deserialization for vstore types"); + cx.span_unimpl(ty.span, ~"deserialization for vstore types"); } } } @@ -746,15 +746,15 @@ fn mk_deser_fn(cx: ext_ctxt, span: span, ty: cx.ty_fn(span, ~[], cx.ty_path(span, ~[tp.ident], ~[])), - ident: @("__d" + *tp.ident), + ident: @(~"__d" + *tp.ident), id: cx.next_id()}); #debug["tp_inputs = %?", tp_inputs]; let deser_inputs: ~[ast::arg] = vec::append(~[{mode: ast::expl(ast::by_ref), - ty: cx.ty_path(span, ~[@"__D"/~], ~[]), - ident: @"__d"/~, + ty: cx.ty_path(span, ~[@~"__D"], ~[]), + ident: @~"__d", id: cx.next_id()}], tp_inputs); @@ -772,11 +772,11 @@ fn mk_deser_fn(cx: ext_ctxt, span: span, let deser_bnds = @~[ ast::bound_trait(cx.ty_path( span, - ~[@"std"/~, @"serialization"/~, @"deserializer"/~], + ~[@~"std", @~"serialization", @~"deserializer"], ~[]))]; let deser_tps: ~[ast::ty_param] = - vec::append(~[{ident: @"__D"/~, + vec::append(~[{ident: @~"__D", id: cx.next_id(), bounds: deser_bnds}], vec::map(tps, |tp| { @@ -788,7 +788,7 @@ fn mk_deser_fn(cx: ext_ctxt, span: span, let deser_blk = cx.expr_blk(f(cx, tps_map, #ast(expr){__d})); - @{ident: @("deserialize_" + *name), + @{ident: @(~"deserialize_" + *name), attrs: ~[], id: cx.next_id(), node: ast::item_fn({inputs: deser_inputs, diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs index 7b08b18596e..b7d17a9d652 100644 --- a/src/libsyntax/ext/base.rs +++ b/src/libsyntax/ext/base.rs @@ -42,47 +42,47 @@ enum syntax_extension { // A temporary hard-coded map of methods for expanding syntax extension // AST nodes into full ASTs -fn syntax_expander_table() -> hashmap<str, syntax_extension> { +fn syntax_expander_table() -> hashmap<~str, syntax_extension> { fn builtin(f: syntax_expander_) -> syntax_extension {normal({expander: f, span: none})} fn builtin_item_tt(f: syntax_expander_tt_item_) -> syntax_extension { item_tt({expander: f, span: none}) } let syntax_expanders = str_hash::<syntax_extension>(); - syntax_expanders.insert("macro", + syntax_expanders.insert(~"macro", macro_defining(ext::simplext::add_new_extension)); - syntax_expanders.insert("macro_rules", + syntax_expanders.insert(~"macro_rules", builtin_item_tt( ext::tt::macro_rules::add_new_extension)); - syntax_expanders.insert("fmt", builtin(ext::fmt::expand_syntax_ext)); - syntax_expanders.insert("auto_serialize", + syntax_expanders.insert(~"fmt", builtin(ext::fmt::expand_syntax_ext)); + syntax_expanders.insert(~"auto_serialize", item_decorator(ext::auto_serialize::expand)); - syntax_expanders.insert("env", builtin(ext::env::expand_syntax_ext)); - syntax_expanders.insert("concat_idents", + syntax_expanders.insert(~"env", builtin(ext::env::expand_syntax_ext)); + syntax_expanders.insert(~"concat_idents", builtin(ext::concat_idents::expand_syntax_ext)); - syntax_expanders.insert("ident_to_str", + syntax_expanders.insert(~"ident_to_str", builtin(ext::ident_to_str::expand_syntax_ext)); - syntax_expanders.insert("log_syntax", + syntax_expanders.insert(~"log_syntax", builtin(ext::log_syntax::expand_syntax_ext)); - syntax_expanders.insert("ast", + syntax_expanders.insert(~"ast", builtin(ext::qquote::expand_ast)); - syntax_expanders.insert("line", + syntax_expanders.insert(~"line", builtin(ext::source_util::expand_line)); - syntax_expanders.insert("col", + syntax_expanders.insert(~"col", builtin(ext::source_util::expand_col)); - syntax_expanders.insert("file", + syntax_expanders.insert(~"file", builtin(ext::source_util::expand_file)); - syntax_expanders.insert("stringify", + syntax_expanders.insert(~"stringify", builtin(ext::source_util::expand_stringify)); - syntax_expanders.insert("include", + syntax_expanders.insert(~"include", builtin(ext::source_util::expand_include)); - syntax_expanders.insert("include_str", + syntax_expanders.insert(~"include_str", builtin(ext::source_util::expand_include_str)); - syntax_expanders.insert("include_bin", + syntax_expanders.insert(~"include_bin", builtin(ext::source_util::expand_include_bin)); - syntax_expanders.insert("mod", + syntax_expanders.insert(~"mod", builtin(ext::source_util::expand_mod)); - syntax_expanders.insert("proto", + syntax_expanders.insert(~"proto", builtin_item_tt(ext::pipes::expand_proto)); ret syntax_expanders; } @@ -98,11 +98,11 @@ iface ext_ctxt { fn mod_path() -> ~[ast::ident]; fn bt_push(ei: codemap::expn_info_); fn bt_pop(); - fn span_fatal(sp: span, msg: str) -> !; - fn span_err(sp: span, msg: str); - fn span_unimpl(sp: span, msg: str) -> !; - fn span_bug(sp: span, msg: str) -> !; - fn bug(msg: str) -> !; + fn span_fatal(sp: span, msg: ~str) -> !; + fn span_err(sp: span, msg: ~str); + fn span_unimpl(sp: span, msg: ~str) -> !; + fn span_bug(sp: span, msg: ~str) -> !; + fn bug(msg: ~str) -> !; fn next_id() -> ast::node_id; } @@ -137,26 +137,26 @@ fn mk_ctxt(parse_sess: parse::parse_sess, some(@expanded_from({call_site: {expn_info: prev, _}, _})) { self.backtrace = prev } - _ { self.bug("tried to pop without a push"); } + _ { self.bug(~"tried to pop without a push"); } } } - fn span_fatal(sp: span, msg: str) -> ! { + fn span_fatal(sp: span, msg: ~str) -> ! { self.print_backtrace(); self.parse_sess.span_diagnostic.span_fatal(sp, msg); } - fn span_err(sp: span, msg: str) { + fn span_err(sp: span, msg: ~str) { self.print_backtrace(); self.parse_sess.span_diagnostic.span_err(sp, msg); } - fn span_unimpl(sp: span, msg: str) -> ! { + fn span_unimpl(sp: span, msg: ~str) -> ! { self.print_backtrace(); self.parse_sess.span_diagnostic.span_unimpl(sp, msg); } - fn span_bug(sp: span, msg: str) -> ! { + fn span_bug(sp: span, msg: ~str) -> ! { self.print_backtrace(); self.parse_sess.span_diagnostic.span_bug(sp, msg); } - fn bug(msg: str) -> ! { + fn bug(msg: ~str) -> ! { self.print_backtrace(); self.parse_sess.span_diagnostic.handler().bug(msg); } @@ -173,7 +173,7 @@ fn mk_ctxt(parse_sess: parse::parse_sess, ret imp as ext_ctxt } -fn expr_to_str(cx: ext_ctxt, expr: @ast::expr, error: str) -> str { +fn expr_to_str(cx: ext_ctxt, expr: @ast::expr, error: ~str) -> ~str { alt expr.node { ast::expr_lit(l) { alt l.node { @@ -185,7 +185,7 @@ fn expr_to_str(cx: ext_ctxt, expr: @ast::expr, error: str) -> str { } } -fn expr_to_ident(cx: ext_ctxt, expr: @ast::expr, error: str) -> ast::ident { +fn expr_to_ident(cx: ext_ctxt, expr: @ast::expr, error: ~str) -> ast::ident { alt expr.node { ast::expr_path(p) { if vec::len(p.types) > 0u || vec::len(p.idents) != 1u { @@ -197,12 +197,12 @@ fn expr_to_ident(cx: ext_ctxt, expr: @ast::expr, error: str) -> ast::ident { } fn get_mac_args_no_max(cx: ext_ctxt, sp: span, arg: ast::mac_arg, - min: uint, name: str) -> ~[@ast::expr] { + min: uint, name: ~str) -> ~[@ast::expr] { ret get_mac_args(cx, sp, arg, min, none, name); } fn get_mac_args(cx: ext_ctxt, sp: span, arg: ast::mac_arg, - min: uint, max: option<uint>, name: str) -> ~[@ast::expr] { + min: uint, max: option<uint>, name: ~str) -> ~[@ast::expr] { alt arg { some(expr) { alt expr.node { @@ -235,7 +235,7 @@ fn get_mac_body(cx: ext_ctxt, sp: span, args: ast::mac_body) { alt (args) { some(body) {body} - none {cx.span_fatal(sp, "missing macro body")} + none {cx.span_fatal(sp, ~"missing macro body")} } } diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs index a2ed799819c..5eca1e8e17c 100644 --- a/src/libsyntax/ext/build.rs +++ b/src/libsyntax/ext/build.rs @@ -77,11 +77,11 @@ fn mk_fixed_vec_e(cx: ext_ctxt, sp: span, exprs: ~[@ast::expr]) -> @ast::expr { mk_vstore_e(cx, sp, mk_base_vec_e(cx, sp, exprs), ast::vstore_fixed(none)) } -fn mk_base_str(cx: ext_ctxt, sp: span, s: str) -> @ast::expr { +fn mk_base_str(cx: ext_ctxt, sp: span, s: ~str) -> @ast::expr { let lit = ast::lit_str(@s); ret mk_lit(cx, sp, lit); } -fn mk_uniq_str(cx: ext_ctxt, sp: span, s: str) -> @ast::expr { +fn mk_uniq_str(cx: ext_ctxt, sp: span, s: ~str) -> @ast::expr { mk_vstore_e(cx, sp, mk_base_str(cx, sp, s), ast::vstore_uniq) } diff --git a/src/libsyntax/ext/concat_idents.rs b/src/libsyntax/ext/concat_idents.rs index f5d13df75d6..b3545cc635d 100644 --- a/src/libsyntax/ext/concat_idents.rs +++ b/src/libsyntax/ext/concat_idents.rs @@ -2,10 +2,10 @@ import base::*; fn expand_syntax_ext(cx: ext_ctxt, sp: codemap::span, arg: ast::mac_arg, _body: ast::mac_body) -> @ast::expr { - let args = get_mac_args_no_max(cx,sp,arg,1u,"concat_idents"); - let mut res = ""; + let args = get_mac_args_no_max(cx,sp,arg,1u,~"concat_idents"); + let mut res = ~""; for args.each |e| { - res += *expr_to_ident(cx, e, "expected an ident"); + res += *expr_to_ident(cx, e, ~"expected an ident"); } ret @{id: cx.next_id(), diff --git a/src/libsyntax/ext/env.rs b/src/libsyntax/ext/env.rs index 26f5bbc7715..e03fc2ce47b 100644 --- a/src/libsyntax/ext/env.rs +++ b/src/libsyntax/ext/env.rs @@ -10,14 +10,14 @@ export expand_syntax_ext; fn expand_syntax_ext(cx: ext_ctxt, sp: codemap::span, arg: ast::mac_arg, _body: ast::mac_body) -> @ast::expr { - let args = get_mac_args(cx, sp, arg, 1u, option::some(1u), "env"); + let args = get_mac_args(cx, sp, arg, 1u, option::some(1u), ~"env"); // FIXME (#2248): if this was more thorough it would manufacture an // option<str> rather than just an maybe-empty string. - let var = expr_to_str(cx, args[0], "#env requires a string"); + let var = expr_to_str(cx, args[0], ~"#env requires a string"); alt os::getenv(var) { - option::none { ret mk_uniq_str(cx, sp, ""); } + option::none { ret mk_uniq_str(cx, sp, ~""); } option::some(s) { ret mk_uniq_str(cx, sp, s); } } } diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index 05c7e6f1c5a..2a41afc9743 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -10,7 +10,7 @@ import parse::{parser, parse_expr_from_source_str, new_parser_from_tt}; import codemap::{span, expanded_from}; -fn expand_expr(exts: hashmap<str, syntax_extension>, cx: ext_ctxt, +fn expand_expr(exts: hashmap<~str, syntax_extension>, cx: ext_ctxt, e: expr_, s: span, fld: ast_fold, orig: fn@(expr_, span, ast_fold) -> (expr_, span)) -> (expr_, span) @@ -54,7 +54,7 @@ fn expand_expr(exts: hashmap<str, syntax_extension>, cx: ext_ctxt, } some(item_tt(*)) { cx.span_fatal(pth.span, - "cannot use item macros in this context"); + ~"cannot use item macros in this context"); } } } @@ -91,14 +91,14 @@ fn expand_expr(exts: hashmap<str, syntax_extension>, cx: ext_ctxt, } } - _ { cx.span_bug(mac.span, "naked syntactic bit") } + _ { cx.span_bug(mac.span, ~"naked syntactic bit") } } } _ { orig(e, s, fld) } }; } -fn expand_mod_items(exts: hashmap<str, syntax_extension>, cx: ext_ctxt, +fn expand_mod_items(exts: hashmap<~str, syntax_extension>, cx: ext_ctxt, module: ast::_mod, fld: ast_fold, orig: fn@(ast::_mod, ast_fold) -> ast::_mod) -> ast::_mod @@ -133,7 +133,7 @@ fn expand_mod_items(exts: hashmap<str, syntax_extension>, cx: ext_ctxt, } /* record module we enter for `#mod` */ -fn expand_item(exts: hashmap<str, syntax_extension>, +fn expand_item(exts: hashmap<~str, syntax_extension>, cx: ext_ctxt, &&it: @ast::item, fld: ast_fold, orig: fn@(&&@ast::item, ast_fold) -> option<@ast::item>) -> option<@ast::item> @@ -160,7 +160,7 @@ fn expand_item(exts: hashmap<str, syntax_extension>, } } -fn expand_item_mac(exts: hashmap<str, syntax_extension>, +fn expand_item_mac(exts: hashmap<~str, syntax_extension>, cx: ext_ctxt, &&it: @ast::item, fld: ast_fold) -> option<@ast::item> { alt it.node { @@ -179,7 +179,7 @@ fn expand_item_mac(exts: hashmap<str, syntax_extension>, let maybe_it = alt expanded { mr_item(it) { fld.fold_item(it) } mr_expr(e) { cx.span_fatal(pth.span, - "expr macro in item position: " + + ~"expr macro in item position: " + *extname) } mr_def(mdef) { exts.insert(*mdef.ident, mdef.ext); @@ -194,7 +194,7 @@ fn expand_item_mac(exts: hashmap<str, syntax_extension>, } } _ { - cx.span_bug(it.span, "invalid item macro invocation"); + cx.span_bug(it.span, ~"invalid item macro invocation"); } } } @@ -209,9 +209,9 @@ fn new_span(cx: ext_ctxt, sp: span) -> span { // is substantially more mature, these should move from here, into a // compiled part of libcore at very least. -fn core_macros() -> str { +fn core_macros() -> ~str { ret -"{ +~"{ #macro([#error[f, ...], log(core::error, #fmt[f, ...])]); #macro([#warn[f, ...], log(core::warn, #fmt[f, ...])]); #macro([#info[f, ...], log(core::info, #fmt[f, ...])]); @@ -231,7 +231,7 @@ fn expand_crate(parse_sess: parse::parse_sess, new_span: |a|new_span(cx, a) with *afp}; let f = make_fold(f_pre); - let cm = parse_expr_from_source_str("<core-macros>", + let cm = parse_expr_from_source_str(~"<core-macros>", @core_macros(), cfg, parse_sess); diff --git a/src/libsyntax/ext/fmt.rs b/src/libsyntax/ext/fmt.rs index 16357ec7e26..53b5db8b6a6 100644 --- a/src/libsyntax/ext/fmt.rs +++ b/src/libsyntax/ext/fmt.rs @@ -13,17 +13,17 @@ export expand_syntax_ext; fn expand_syntax_ext(cx: ext_ctxt, sp: span, arg: ast::mac_arg, _body: ast::mac_body) -> @ast::expr { - let args = get_mac_args_no_max(cx, sp, arg, 1u, "fmt"); + let args = get_mac_args_no_max(cx, sp, arg, 1u, ~"fmt"); let fmt = expr_to_str(cx, args[0], - "first argument to #fmt must be a string literal."); + ~"first argument to #fmt must be a string literal."); let fmtspan = args[0].span; #debug("Format string:"); log(debug, fmt); - fn parse_fmt_err_(cx: ext_ctxt, sp: span, msg: str) -> ! { + fn parse_fmt_err_(cx: ext_ctxt, sp: span, msg: ~str) -> ! { cx.span_fatal(sp, msg); } - let parse_fmt_err = fn@(s: str) -> ! { + let parse_fmt_err = fn@(s: ~str) -> ! { parse_fmt_err_(cx, fmtspan, s) }; let pieces = parse_fmt_string(fmt, parse_fmt_err); @@ -38,7 +38,7 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span, pieces: ~[piece], args: ~[@ast::expr]) -> @ast::expr { fn make_path_vec(_cx: ext_ctxt, ident: ast::ident) -> ~[ast::ident] { - ret ~[@"extfmt"/~, @"rt"/~, ident]; + ret ~[@~"extfmt", @~"rt", ident]; } fn make_rt_path_expr(cx: ext_ctxt, sp: span, ident: ast::ident) -> @ast::expr { @@ -50,14 +50,14 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span, fn make_rt_conv_expr(cx: ext_ctxt, sp: span, cnv: conv) -> @ast::expr { fn make_flags(cx: ext_ctxt, sp: span, flags: ~[flag]) -> @ast::expr { - let mut tmp_expr = make_rt_path_expr(cx, sp, @"flag_none"/~); + let mut tmp_expr = make_rt_path_expr(cx, sp, @~"flag_none"); for flags.each |f| { let fstr = alt f { - flag_left_justify { "flag_left_justify" } - flag_left_zero_pad { "flag_left_zero_pad" } - flag_space_for_sign { "flag_space_for_sign" } - flag_sign_always { "flag_sign_always" } - flag_alternate { "flag_alternate" } + flag_left_justify { ~"flag_left_justify" } + flag_left_zero_pad { ~"flag_left_zero_pad" } + flag_space_for_sign { ~"flag_space_for_sign" } + flag_sign_always { ~"flag_sign_always" } + flag_alternate { ~"flag_alternate" } }; tmp_expr = mk_binary(cx, sp, ast::bitor, tmp_expr, make_rt_path_expr(cx, sp, @fstr)); @@ -67,15 +67,15 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span, fn make_count(cx: ext_ctxt, sp: span, cnt: count) -> @ast::expr { alt cnt { count_implied { - ret make_rt_path_expr(cx, sp, @"count_implied"/~); + ret make_rt_path_expr(cx, sp, @~"count_implied"); } count_is(c) { let count_lit = mk_int(cx, sp, c); - let count_is_path = make_path_vec(cx, @"count_is"/~); + let count_is_path = make_path_vec(cx, @~"count_is"); let count_is_args = ~[count_lit]; ret mk_call(cx, sp, count_is_path, count_is_args); } - _ { cx.span_unimpl(sp, "unimplemented #fmt conversion"); } + _ { cx.span_unimpl(sp, ~"unimplemented #fmt conversion"); } } } fn make_ty(cx: ext_ctxt, sp: span, t: ty) -> @ast::expr { @@ -83,13 +83,13 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span, alt t { ty_hex(c) { alt c { - case_upper { rt_type = "ty_hex_upper"; } - case_lower { rt_type = "ty_hex_lower"; } + case_upper { rt_type = ~"ty_hex_upper"; } + case_lower { rt_type = ~"ty_hex_lower"; } } } - ty_bits { rt_type = "ty_bits"; } - ty_octal { rt_type = "ty_octal"; } - _ { rt_type = "ty_default"; } + ty_bits { rt_type = ~"ty_bits"; } + ty_octal { rt_type = ~"ty_octal"; } + _ { rt_type = ~"ty_default"; } } ret make_rt_path_expr(cx, sp, @rt_type); } @@ -97,10 +97,10 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span, width_expr: @ast::expr, precision_expr: @ast::expr, ty_expr: @ast::expr) -> @ast::expr { ret mk_rec_e(cx, sp, - ~[{ident: @"flags"/~, ex: flags_expr}, - {ident: @"width"/~, ex: width_expr}, - {ident: @"precision"/~, ex: precision_expr}, - {ident: @"ty"/~, ex: ty_expr}]); + ~[{ident: @~"flags", ex: flags_expr}, + {ident: @~"width", ex: width_expr}, + {ident: @~"precision", ex: precision_expr}, + {ident: @~"ty", ex: ty_expr}]); } let rt_conv_flags = make_flags(cx, sp, cnv.flags); let rt_conv_width = make_count(cx, sp, cnv.width); @@ -109,9 +109,9 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span, ret make_conv_rec(cx, sp, rt_conv_flags, rt_conv_width, rt_conv_precision, rt_conv_ty); } - fn make_conv_call(cx: ext_ctxt, sp: span, conv_type: str, cnv: conv, + fn make_conv_call(cx: ext_ctxt, sp: span, conv_type: ~str, cnv: conv, arg: @ast::expr) -> @ast::expr { - let fname = "conv_" + conv_type; + let fname = ~"conv_" + conv_type; let path = make_path_vec(cx, @fname); let cnv_expr = make_rt_conv_expr(cx, sp, cnv); let args = ~[cnv_expr, arg]; @@ -131,7 +131,7 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span, _ { ret false; } } } - let unsupported = "conversion not supported in #fmt string"; + let unsupported = ~"conversion not supported in #fmt string"; alt cnv.param { option::none { } _ { cx.span_unimpl(sp, unsupported); } @@ -142,15 +142,15 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span, flag_sign_always { if !is_signed_type(cnv) { cx.span_fatal(sp, - "+ flag only valid in " + - "signed #fmt conversion"); + ~"+ flag only valid in " + + ~"signed #fmt conversion"); } } flag_space_for_sign { if !is_signed_type(cnv) { cx.span_fatal(sp, - "space flag only valid in " + - "signed #fmt conversions"); + ~"space flag only valid in " + + ~"signed #fmt conversions"); } } flag_left_zero_pad { } @@ -168,27 +168,27 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span, _ { cx.span_unimpl(sp, unsupported); } } alt cnv.ty { - ty_str { ret make_conv_call(cx, arg.span, "str", cnv, arg); } + ty_str { ret make_conv_call(cx, arg.span, ~"str", cnv, arg); } ty_int(sign) { alt sign { - signed { ret make_conv_call(cx, arg.span, "int", cnv, arg); } + signed { ret make_conv_call(cx, arg.span, ~"int", cnv, arg); } unsigned { - ret make_conv_call(cx, arg.span, "uint", cnv, arg); + ret make_conv_call(cx, arg.span, ~"uint", cnv, arg); } } } - ty_bool { ret make_conv_call(cx, arg.span, "bool", cnv, arg); } - ty_char { ret make_conv_call(cx, arg.span, "char", cnv, arg); } - ty_hex(_) { ret make_conv_call(cx, arg.span, "uint", cnv, arg); } - ty_bits { ret make_conv_call(cx, arg.span, "uint", cnv, arg); } - ty_octal { ret make_conv_call(cx, arg.span, "uint", cnv, arg); } - ty_float { ret make_conv_call(cx, arg.span, "float", cnv, arg); } - ty_poly { ret make_conv_call(cx, arg.span, "poly", cnv, arg); } + ty_bool { ret make_conv_call(cx, arg.span, ~"bool", cnv, arg); } + ty_char { ret make_conv_call(cx, arg.span, ~"char", cnv, arg); } + ty_hex(_) { ret make_conv_call(cx, arg.span, ~"uint", cnv, arg); } + ty_bits { ret make_conv_call(cx, arg.span, ~"uint", cnv, arg); } + ty_octal { ret make_conv_call(cx, arg.span, ~"uint", cnv, arg); } + ty_float { ret make_conv_call(cx, arg.span, ~"float", cnv, arg); } + ty_poly { ret make_conv_call(cx, arg.span, ~"poly", cnv, arg); } } } fn log_conv(c: conv) { alt c.param { - some(p) { log(debug, "param: " + int::to_str(p, 10u)); } + some(p) { log(debug, ~"param: " + int::to_str(p, 10u)); } _ { #debug("param: none"); } } for c.flags.each |f| { @@ -202,20 +202,20 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span, } alt c.width { count_is(i) { log(debug, - "width: count is " + int::to_str(i, 10u)); } + ~"width: count is " + int::to_str(i, 10u)); } count_is_param(i) { log(debug, - "width: count is param " + int::to_str(i, 10u)); + ~"width: count is param " + int::to_str(i, 10u)); } count_is_next_param { #debug("width: count is next param"); } count_implied { #debug("width: count is implied"); } } alt c.precision { count_is(i) { log(debug, - "prec: count is " + int::to_str(i, 10u)); } + ~"prec: count is " + int::to_str(i, 10u)); } count_is_param(i) { log(debug, - "prec: count is param " + int::to_str(i, 10u)); + ~"prec: count is param " + int::to_str(i, 10u)); } count_is_next_param { #debug("prec: count is next param"); } count_implied { #debug("prec: count is implied"); } @@ -255,8 +255,8 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span, n += 1u; if n >= nargs { cx.span_fatal(sp, - "not enough arguments to #fmt " + - "for the given format string"); + ~"not enough arguments to #fmt " + + ~"for the given format string"); } #debug("Building conversion:"); log_conv(conv); @@ -275,7 +275,7 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span, } let arg_vec = mk_fixed_vec_e(cx, fmt_sp, piece_exprs); - ret mk_call(cx, fmt_sp, ~[@"str"/~, @"concat"/~], ~[arg_vec]); + ret mk_call(cx, fmt_sp, ~[@~"str", @~"concat"], ~[arg_vec]); } // // Local Variables: diff --git a/src/libsyntax/ext/ident_to_str.rs b/src/libsyntax/ext/ident_to_str.rs index 233089b9874..54f97912f3d 100644 --- a/src/libsyntax/ext/ident_to_str.rs +++ b/src/libsyntax/ext/ident_to_str.rs @@ -4,8 +4,8 @@ import option; fn expand_syntax_ext(cx: ext_ctxt, sp: codemap::span, arg: ast::mac_arg, _body: ast::mac_body) -> @ast::expr { - let args = get_mac_args(cx,sp,arg,1u,option::some(1u),"ident_to_str"); + let args = get_mac_args(cx,sp,arg,1u,option::some(1u),~"ident_to_str"); ret mk_uniq_str(cx, sp, *expr_to_ident(cx, args[0u], - "expected an ident")); + ~"expected an ident")); } diff --git a/src/libsyntax/ext/log_syntax.rs b/src/libsyntax/ext/log_syntax.rs index 06941fc5d38..70d83b164c8 100644 --- a/src/libsyntax/ext/log_syntax.rs +++ b/src/libsyntax/ext/log_syntax.rs @@ -3,11 +3,11 @@ import io::writer_util; fn expand_syntax_ext(cx: ext_ctxt, sp: codemap::span, arg: ast::mac_arg, _body: ast::mac_body) -> @ast::expr { - let args = get_mac_args_no_max(cx,sp,arg,0u,"log_syntax"); + let args = get_mac_args_no_max(cx,sp,arg,0u,~"log_syntax"); cx.print_backtrace(); io::stdout().write_line( str::connect(vec::map(args, - |&&ex| print::pprust::expr_to_str(ex)), ", ") + |&&ex| print::pprust::expr_to_str(ex)), ~", ") ); //trivial expression diff --git a/src/libsyntax/ext/pipes/ast_builder.rs b/src/libsyntax/ext/pipes/ast_builder.rs index fda557f15b6..cb0abe9e8e5 100644 --- a/src/libsyntax/ext/pipes/ast_builder.rs +++ b/src/libsyntax/ext/pipes/ast_builder.rs @@ -7,7 +7,7 @@ import ast::{ident, node_id}; import codemap::span; import ext::base::mk_ctxt; -fn ident(s: str) -> ast::ident { +fn ident(s: ~str) -> ast::ident { @(copy s) } diff --git a/src/libsyntax/ext/pipes/parse_proto.rs b/src/libsyntax/ext/pipes/parse_proto.rs index 4a3c9e4afec..cf29c409e6b 100644 --- a/src/libsyntax/ext/pipes/parse_proto.rs +++ b/src/libsyntax/ext/pipes/parse_proto.rs @@ -28,8 +28,8 @@ impl proto_parser for parser { }; self.bump(); let dir = alt dir { - @"send"/~ { send } - @"recv"/~ { recv } + @~"send" { send } + @~"recv" { recv } _ { fail } }; diff --git a/src/libsyntax/ext/pipes/pipec.rs b/src/libsyntax/ext/pipes/pipec.rs index e55900968e8..9406458d1ac 100644 --- a/src/libsyntax/ext/pipes/pipec.rs +++ b/src/libsyntax/ext/pipes/pipec.rs @@ -23,10 +23,10 @@ enum direction { } impl of to_str for direction { - fn to_str() -> str { + fn to_str() -> ~str { alt self { - send { "send" } - recv { "recv" } + send { ~"send" } + recv { ~"recv" } } } } @@ -68,35 +68,35 @@ impl methods for message { message(id, tys, this, next, next_tys) { let next = this.proto.get_state(next); assert next_tys.len() == next.ty_params.len(); - let arg_names = tys.mapi(|i, _ty| @("x_" + i.to_str())); + let arg_names = tys.mapi(|i, _ty| @(~"x_" + i.to_str())); let args_ast = (arg_names, tys).map( |n, t| cx.arg_mode(n, t, ast::by_copy) ); let args_ast = vec::append( - ~[cx.arg_mode(@"pipe"/~, + ~[cx.arg_mode(@~"pipe", cx.ty_path(path(this.data_name()) .add_tys(cx.ty_vars(this.ty_params))), ast::by_copy)], args_ast); let pat = alt (this.dir, next.dir) { - (send, send) { "(c, s)" } - (send, recv) { "(s, c)" } - (recv, send) { "(s, c)" } - (recv, recv) { "(c, s)" } + (send, send) { ~"(c, s)" } + (send, recv) { ~"(s, c)" } + (recv, send) { ~"(s, c)" } + (recv, recv) { ~"(c, s)" } }; let mut body = #fmt("{ let %s = pipes::entangle();\n", pat); body += #fmt("let message = %s::%s(%s);\n", *this.proto.name, *self.name(), - str::connect(vec::append_one(arg_names, @"s"/~) + str::connect(vec::append_one(arg_names, @~"s") .map(|x| *x), - ", ")); + ~", ")); body += #fmt("pipes::send(pipe, message);\n"); - body += "c }"; + body += ~"c }"; let body = cx.parse_expr(body); @@ -127,7 +127,7 @@ impl methods for state { self.messages.push(message(name, data, self, next, next_tys)); } - fn filename() -> str { + fn filename() -> ~str { (*self).proto.filename() } @@ -158,8 +158,8 @@ impl methods for state { let next_name = next.data_name(); let dir = alt this.dir { - send { @"server"/~ } - recv { @"client"/~ } + send { @~"server" } + recv { @~"client" } }; let v = cx.variant(name, @@ -190,7 +190,7 @@ impl methods for state { cx.item_ty_poly( self.data_name(), cx.ty_path( - (@"pipes"/~ + @(dir.to_str() + "_packet"/~)) + (@~"pipes" + @(dir.to_str() + ~"_packet")) .add_ty(cx.ty_path( (self.proto.name + self.data_name()) .add_tys(cx.ty_vars(self.ty_params))))), @@ -236,17 +236,17 @@ impl methods for protocol { state } - fn filename() -> str { - "proto://" + *self.name + fn filename() -> ~str { + ~"proto://" + *self.name } fn gen_init(cx: ext_ctxt) -> @ast::item { let start_state = self.states[0]; let body = alt start_state.dir { - send { cx.parse_expr("pipes::entangle()") } + send { cx.parse_expr(~"pipes::entangle()") } recv { - cx.parse_expr("{ \ + cx.parse_expr(~"{ \ let (s, c) = pipes::entangle(); \ (c, s) \ }") @@ -281,10 +281,10 @@ impl methods for protocol { } vec::push(items, - cx.item_mod(@"client"/~, + cx.item_mod(@~"client", client_states)); vec::push(items, - cx.item_mod(@"server"/~, + cx.item_mod(@~"server", server_states)); cx.item_mod(self.name, items) @@ -293,49 +293,49 @@ impl methods for protocol { iface to_source { // Takes a thing and generates a string containing rust code for it. - fn to_source() -> str; + fn to_source() -> ~str; } impl of to_source for @ast::item { - fn to_source() -> str { + fn to_source() -> ~str { item_to_str(self) } } impl of to_source for ~[@ast::item] { - fn to_source() -> str { - str::connect(self.map(|i| i.to_source()), "\n\n") + fn to_source() -> ~str { + str::connect(self.map(|i| i.to_source()), ~"\n\n") } } impl of to_source for @ast::ty { - fn to_source() -> str { + fn to_source() -> ~str { ty_to_str(self) } } impl of to_source for ~[@ast::ty] { - fn to_source() -> str { - str::connect(self.map(|i| i.to_source()), ", ") + fn to_source() -> ~str { + str::connect(self.map(|i| i.to_source()), ~", ") } } impl of to_source for ~[ast::ty_param] { - fn to_source() -> str { + fn to_source() -> ~str { pprust::typarams_to_str(self) } } impl of to_source for @ast::expr { - fn to_source() -> str { + fn to_source() -> ~str { pprust::expr_to_str(self) } } impl parse_utils for ext_ctxt { - fn parse_item(s: str) -> @ast::item { + fn parse_item(s: ~str) -> @ast::item { let res = parse::parse_item_from_source_str( - "***protocol expansion***", + ~"***protocol expansion***", @(copy s), self.cfg(), ~[], @@ -350,9 +350,9 @@ impl parse_utils for ext_ctxt { } } - fn parse_expr(s: str) -> @ast::expr { + fn parse_expr(s: ~str) -> @ast::expr { parse::parse_expr_from_source_str( - "***protocol expansion***", + ~"***protocol expansion***", @(copy s), self.cfg(), self.parse_sess()) diff --git a/src/libsyntax/ext/qquote.rs b/src/libsyntax/ext/qquote.rs index 77e67f6da20..4fd896e65bb 100644 --- a/src/libsyntax/ext/qquote.rs +++ b/src/libsyntax/ext/qquote.rs @@ -16,7 +16,7 @@ import codemap::span; type aq_ctxt = @{lo: uint, gather: dvec<{lo: uint, hi: uint, e: @ast::expr, - constr: str}>}; + constr: ~str}>}; enum fragment { from_expr(@ast::expr), from_ty(@ast::ty) @@ -27,7 +27,7 @@ iface qq_helper { fn visit(aq_ctxt, vt<aq_ctxt>); fn extract_mac() -> option<ast::mac_>; fn mk_parse_fn(ext_ctxt,span) -> @ast::expr; - fn get_fold_fn() -> str; + fn get_fold_fn() -> ~str; } impl of qq_helper for @ast::crate { @@ -36,9 +36,9 @@ impl of qq_helper for @ast::crate { fn extract_mac() -> option<ast::mac_> {fail} fn mk_parse_fn(cx: ext_ctxt, sp: span) -> @ast::expr { mk_path(cx, sp, - ~[@"syntax"/~, @"ext"/~, @"qquote"/~, @"parse_crate"/~]) + ~[@~"syntax", @~"ext", @~"qquote", @~"parse_crate"]) } - fn get_fold_fn() -> str {"fold_crate"} + fn get_fold_fn() -> ~str {~"fold_crate"} } impl of qq_helper for @ast::expr { fn span() -> span {self.span} @@ -51,9 +51,9 @@ impl of qq_helper for @ast::expr { } fn mk_parse_fn(cx: ext_ctxt, sp: span) -> @ast::expr { mk_path(cx, sp, - ~[@"syntax"/~, @"ext"/~, @"qquote"/~, @"parse_expr"/~]) + ~[@~"syntax", @~"ext", @~"qquote", @~"parse_expr"]) } - fn get_fold_fn() -> str {"fold_expr"} + fn get_fold_fn() -> ~str {~"fold_expr"} } impl of qq_helper for @ast::ty { fn span() -> span {self.span} @@ -66,9 +66,9 @@ impl of qq_helper for @ast::ty { } fn mk_parse_fn(cx: ext_ctxt, sp: span) -> @ast::expr { mk_path(cx, sp, - ~[@"syntax"/~, @"ext"/~, @"qquote"/~, @"parse_ty"/~]) + ~[@~"syntax", @~"ext", @~"qquote", @~"parse_ty"]) } - fn get_fold_fn() -> str {"fold_ty"} + fn get_fold_fn() -> ~str {~"fold_ty"} } impl of qq_helper for @ast::item { fn span() -> span {self.span} @@ -76,9 +76,9 @@ impl of qq_helper for @ast::item { fn extract_mac() -> option<ast::mac_> {fail} fn mk_parse_fn(cx: ext_ctxt, sp: span) -> @ast::expr { mk_path(cx, sp, - ~[@"syntax"/~, @"ext"/~, @"qquote"/~, @"parse_item"/~]) + ~[@~"syntax", @~"ext", @~"qquote", @~"parse_item"]) } - fn get_fold_fn() -> str {"fold_item"} + fn get_fold_fn() -> ~str {~"fold_item"} } impl of qq_helper for @ast::stmt { fn span() -> span {self.span} @@ -86,24 +86,24 @@ impl of qq_helper for @ast::stmt { fn extract_mac() -> option<ast::mac_> {fail} fn mk_parse_fn(cx: ext_ctxt, sp: span) -> @ast::expr { mk_path(cx, sp, - ~[@"syntax"/~, @"ext"/~, @"qquote"/~, @"parse_stmt"/~]) + ~[@~"syntax", @~"ext", @~"qquote", @~"parse_stmt"]) } - fn get_fold_fn() -> str {"fold_stmt"} + fn get_fold_fn() -> ~str {~"fold_stmt"} } impl of qq_helper for @ast::pat { fn span() -> span {self.span} fn visit(cx: aq_ctxt, v: vt<aq_ctxt>) {visit_pat(self, cx, v);} fn extract_mac() -> option<ast::mac_> {fail} fn mk_parse_fn(cx: ext_ctxt, sp: span) -> @ast::expr { - mk_path(cx, sp, ~[@"syntax"/~, @"ext"/~, @"qquote"/~, @"parse_pat"/~]) + mk_path(cx, sp, ~[@~"syntax", @~"ext", @~"qquote", @~"parse_pat"]) } - fn get_fold_fn() -> str {"fold_pat"} + fn get_fold_fn() -> ~str {~"fold_pat"} } fn gather_anti_quotes<N: qq_helper>(lo: uint, node: N) -> aq_ctxt { - let v = @{visit_expr: |node, &&cx, v| visit_aq(node, "from_expr", cx, v), - visit_ty: |node, &&cx, v| visit_aq(node, "from_ty", cx, v) + let v = @{visit_expr: |node, &&cx, v| visit_aq(node, ~"from_expr", cx, v), + visit_ty: |node, &&cx, v| visit_aq(node, ~"from_ty", cx, v) with *default_visitor()}; let cx = @{lo:lo, gather: dvec()}; node.visit(cx, mk_vt(v)); @@ -115,7 +115,7 @@ fn gather_anti_quotes<N: qq_helper>(lo: uint, node: N) -> aq_ctxt ret cx; } -fn visit_aq<T:qq_helper>(node: T, constr: str, &&cx: aq_ctxt, v: vt<aq_ctxt>) +fn visit_aq<T:qq_helper>(node: T, constr: ~str, &&cx: aq_ctxt, v: vt<aq_ctxt>) { alt (node.extract_mac()) { some(mac_aq(sp, e)) { @@ -134,35 +134,35 @@ fn expand_ast(ecx: ext_ctxt, _sp: span, arg: ast::mac_arg, body: ast::mac_body) -> @ast::expr { - let mut what = "expr"; + let mut what = ~"expr"; do option::iter(arg) |arg| { let args: ~[@ast::expr] = alt arg.node { ast::expr_vec(elts, _) { elts } _ { ecx.span_fatal - (_sp, "#ast requires arguments of the form `~[...]`.") + (_sp, ~"#ast requires arguments of the form `~[...]`.") } }; if vec::len::<@ast::expr>(args) != 1u { - ecx.span_fatal(_sp, "#ast requires exactly one arg"); + ecx.span_fatal(_sp, ~"#ast requires exactly one arg"); } alt (args[0].node) { ast::expr_path(@{idents: id, _}) if vec::len(id) == 1u {what = *id[0]} - _ {ecx.span_fatal(args[0].span, "expected an identifier");} + _ {ecx.span_fatal(args[0].span, ~"expected an identifier");} } } let body = get_mac_body(ecx,_sp,body); ret alt what { - "crate" {finish(ecx, body, parse_crate)} - "expr" {finish(ecx, body, parse_expr)} - "ty" {finish(ecx, body, parse_ty)} - "item" {finish(ecx, body, parse_item)} - "stmt" {finish(ecx, body, parse_stmt)} - "pat" {finish(ecx, body, parse_pat)} - _ {ecx.span_fatal(_sp, "unsupported ast type")} + ~"crate" {finish(ecx, body, parse_crate)} + ~"expr" {finish(ecx, body, parse_expr)} + ~"ty" {finish(ecx, body, parse_ty)} + ~"item" {finish(ecx, body, parse_item)} + ~"stmt" {finish(ecx, body, parse_stmt)} + ~"pat" {finish(ecx, body, parse_pat)} + _ {ecx.span_fatal(_sp, ~"unsupported ast type")} }; } @@ -175,7 +175,7 @@ fn parse_pat(p: parser) -> @ast::pat { p.parse_pat() } fn parse_item(p: parser) -> @ast::item { alt p.parse_item(~[], ast::public) { some(item) { item } - none { fail "parse_item: parsing an item failed"; } + none { fail ~"parse_item: parsing an item failed"; } } } @@ -203,7 +203,7 @@ fn finish<T: qq_helper> // ^^ check that the spans are non-overlapping } - let mut str2 = ""; + let mut str2 = ~""; enum state {active, skip(uint), blank}; let mut state = active; let mut i = 0u, j = 0u; @@ -233,19 +233,19 @@ fn finish<T: qq_helper> let cx = ecx; let cfg_call = || mk_call_( - cx, sp, mk_access(cx, sp, ~[@"ext_cx"/~], @"cfg"/~), ~[]); + cx, sp, mk_access(cx, sp, ~[@~"ext_cx"], @~"cfg"), ~[]); let parse_sess_call = || mk_call_( - cx, sp, mk_access(cx, sp, ~[@"ext_cx"/~], @"parse_sess"/~), ~[]); + cx, sp, mk_access(cx, sp, ~[@~"ext_cx"], @~"parse_sess"), ~[]); let pcall = mk_call(cx,sp, - ~[@"syntax"/~, @"parse"/~, @"parser"/~, - @"parse_from_source_str"/~], + ~[@~"syntax", @~"parse", @~"parser", + @~"parse_from_source_str"], ~[node.mk_parse_fn(cx,sp), mk_uniq_str(cx,sp, fname), mk_call(cx,sp, - ~[@"syntax"/~,@"ext"/~, - @"qquote"/~, @"mk_file_substr"/~], + ~[@~"syntax",@~"ext", + @~"qquote", @~"mk_file_substr"], ~[mk_uniq_str(cx,sp, loc.file.name), mk_uint(cx,sp, loc.line), mk_uint(cx,sp, loc.col)]), @@ -257,15 +257,15 @@ fn finish<T: qq_helper> let mut rcall = pcall; if (g_len > 0u) { rcall = mk_call(cx,sp, - ~[@"syntax"/~, @"ext"/~, @"qquote"/~, @"replace"/~], + ~[@~"syntax", @~"ext", @~"qquote", @~"replace"], ~[pcall, mk_uniq_vec_e(cx,sp, qcx.gather.map_to_vec(|g| { mk_call(cx,sp, - ~[@"syntax"/~, @"ext"/~, - @"qquote"/~, @g.constr], + ~[@~"syntax", @~"ext", + @~"qquote", @g.constr], ~[g.e])})), mk_path(cx,sp, - ~[@"syntax"/~, @"ext"/~, @"qquote"/~, + ~[@~"syntax", @~"ext", @~"qquote", @node.get_fold_fn()])]); } ret rcall; @@ -326,10 +326,11 @@ fn print_expr(expr: @ast::expr) { let pp = pprust::rust_printer(stdout); pprust::print_expr(pp, expr); pp::eof(pp.s); - stdout.write_str("\n"); + stdout.write_str(~"\n"); } -fn mk_file_substr(fname: str, line: uint, col: uint) -> codemap::file_substr { +fn mk_file_substr(fname: ~str, line: uint, col: uint) -> + codemap::file_substr { codemap::fss_external({filename: fname, line: line, col: col}) } diff --git a/src/libsyntax/ext/simplext.rs b/src/libsyntax/ext/simplext.rs index 6ccbabd748e..333c510b7cd 100644 --- a/src/libsyntax/ext/simplext.rs +++ b/src/libsyntax/ext/simplext.rs @@ -35,29 +35,29 @@ enum matchable { } /* for when given an incompatible bit of AST */ -fn match_error(cx: ext_ctxt, m: matchable, expected: str) -> ! { +fn match_error(cx: ext_ctxt, m: matchable, expected: ~str) -> ! { alt m { match_expr(x) { cx.span_fatal(x.span, - "this argument is an expr, expected " + expected); + ~"this argument is an expr, expected " + expected); } match_path(x) { cx.span_fatal(x.span, - "this argument is a path, expected " + expected); + ~"this argument is a path, expected " + expected); } match_ident(x) { cx.span_fatal(x.span, - "this argument is an ident, expected " + expected); + ~"this argument is an ident, expected " + expected); } match_ty(x) { cx.span_fatal(x.span, - "this argument is a type, expected " + expected); + ~"this argument is a type, expected " + expected); } match_block(x) { cx.span_fatal(x.span, - "this argument is a block, expected " + expected); + ~"this argument is a block, expected " + expected); } - match_exact { cx.bug("what is a match_exact doing in a bindings?"); } + match_exact { cx.bug(~"what is a match_exact doing in a bindings?"); } } } @@ -80,7 +80,7 @@ fn elts_to_ell(cx: ext_ctxt, elts: ~[@expr]) -> alt m.node { ast::mac_ellipsis { if res != none { - cx.span_fatal(m.span, "only one ellipsis allowed"); + cx.span_fatal(m.span, ~"only one ellipsis allowed"); } res = some({pre: vec::slice(elts, 0u, idx - 1u), @@ -234,8 +234,8 @@ fn follow_for_trans(cx: ext_ctxt, mmaybe: option<arb_depth<matchable>>, ret alt follow(m, idx_path) { seq(_, sp) { cx.span_fatal(sp, - "syntax matched under ... but not " + - "used that way.") + ~"syntax matched under ... but not " + + ~"used that way.") } leaf(m) { ret some(m) } } @@ -302,8 +302,8 @@ fn transcribe_exprs(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint], alt repeat { none { cx.span_fatal(repeat_me.span, - "'...' surrounds an expression without any" + - " repeating syntax variables"); + ~"'...' surrounds an expression without any" + + ~" repeating syntax variables"); } some({rep_count: rc, _}) { /* Whew, we now know how how many times to repeat */ @@ -331,7 +331,7 @@ fn transcribe_ident(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint], &&i: ident, _fld: ast_fold) -> ident { ret alt follow_for_trans(cx, b.find(i), idx_path) { some(match_ident(a_id)) { a_id.node } - some(m) { match_error(cx, m, "an identifier") } + some(m) { match_error(cx, m, ~"an identifier") } none { i } } } @@ -347,7 +347,7 @@ fn transcribe_path(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint], rp: none, types: ~[]} } some(match_path(a_pth)) { *a_pth } - some(m) { match_error(cx, m, "a path") } + some(m) { match_error(cx, m, ~"a path") } none { p } } } @@ -374,7 +374,7 @@ fn transcribe_expr(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint], } some(match_path(a_pth)) { (expr_path(a_pth), s) } some(match_expr(a_exp)) { (a_exp.node, a_exp.span) } - some(m) { match_error(cx, m, "an expression") } + some(m) { match_error(cx, m, ~"an expression") } none { orig(e, s, fld) } } } @@ -393,7 +393,7 @@ fn transcribe_type(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint], some(id) { alt follow_for_trans(cx, b.find(id), idx_path) { some(match_ty(ty)) { (ty.node, ty.span) } - some(m) { match_error(cx, m, "a type") } + some(m) { match_error(cx, m, ~"a type") } none { orig(t, s, fld) } } } @@ -424,7 +424,7 @@ fn transcribe_block(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint], // possibly allow promotion of ident/path/expr to blocks? some(m) { - match_error(cx, m, "a block") + match_error(cx, m, ~"a block") } none { orig(blk, s, fld) } } @@ -455,12 +455,12 @@ fn p_t_s_rec(cx: ext_ctxt, m: matchable, s: selector, b: binders) { if vec::len(post) > 0u { cx.span_unimpl(e.span, - "matching after `...` not yet supported"); + ~"matching after `...` not yet supported"); } } {pre: pre, rep: none, post: post} { if post != ~[] { - cx.bug("elts_to_ell provided an invalid result"); + cx.bug(~"elts_to_ell provided an invalid result"); } p_t_s_r_length(cx, vec::len(pre), false, s, b); p_t_s_r_actual_vector(cx, pre, false, s, b); @@ -478,7 +478,7 @@ fn p_t_s_rec(cx: ext_ctxt, m: matchable, s: selector, b: binders) { match_expr(e) { if e == pat { some(leaf(match_exact)) } else { none } } - _ { cx.bug("broken traversal in p_t_s_r") } + _ { cx.bug(~"broken traversal in p_t_s_r") } } } b.literal_ast_matchers.push(|x| select(cx, x, e)); @@ -486,7 +486,7 @@ fn p_t_s_rec(cx: ext_ctxt, m: matchable, s: selector, b: binders) { } } _ { - cx.bug("undocumented invariant in p_t_s_rec"); + cx.bug(~"undocumented invariant in p_t_s_rec"); } } } @@ -517,11 +517,11 @@ fn p_t_s_r_path(cx: ext_ctxt, p: @path, s: selector, b: binders) { fn select(cx: ext_ctxt, m: matchable) -> match_result { ret alt m { match_expr(e) { some(leaf(specialize_match(m))) } - _ { cx.bug("broken traversal in p_t_s_r") } + _ { cx.bug(~"broken traversal in p_t_s_r") } } } if b.real_binders.contains_key(p_id) { - cx.span_fatal(p.span, "duplicate binding identifier"); + cx.span_fatal(p.span, ~"duplicate binding identifier"); } b.real_binders.insert(p_id, compose_sels(s, |x| select(cx, x))); } @@ -546,16 +546,16 @@ fn p_t_s_r_mac(cx: ext_ctxt, mac: ast::mac, s: selector, b: binders) { match_expr(e) { alt e.node { expr_mac(mac) { fn_m(mac) } _ { none } } } - _ { cx.bug("broken traversal in p_t_s_r") } + _ { cx.bug(~"broken traversal in p_t_s_r") } } } - fn no_des(cx: ext_ctxt, sp: span, syn: str) -> ! { - cx.span_fatal(sp, "destructuring " + syn + " is not yet supported"); + fn no_des(cx: ext_ctxt, sp: span, syn: ~str) -> ! { + cx.span_fatal(sp, ~"destructuring " + syn + ~" is not yet supported"); } alt mac.node { - ast::mac_ellipsis { cx.span_fatal(mac.span, "misused `...`"); } - ast::mac_invoc(_, _, _) { no_des(cx, mac.span, "macro calls"); } - ast::mac_invoc_tt(_, _) { no_des(cx, mac.span, "macro calls"); } + ast::mac_ellipsis { cx.span_fatal(mac.span, ~"misused `...`"); } + ast::mac_invoc(_, _, _) { no_des(cx, mac.span, ~"macro calls"); } + ast::mac_invoc_tt(_, _) { no_des(cx, mac.span, ~"macro calls"); } ast::mac_embed_type(ty) { alt ty.node { ast::ty_path(pth, _) { @@ -571,10 +571,10 @@ fn p_t_s_r_mac(cx: ext_ctxt, mac: ast::mac, s: selector, b: binders) { let final_step = |x| select_pt_1(cx, x, select_pt_2); b.real_binders.insert(id, compose_sels(s, final_step)); } - none { no_des(cx, pth.span, "under `#<>`"); } + none { no_des(cx, pth.span, ~"under `#<>`"); } } } - _ { no_des(cx, ty.span, "under `#<>`"); } + _ { no_des(cx, ty.span, ~"under `#<>`"); } } } ast::mac_embed_block(blk) { @@ -591,11 +591,11 @@ fn p_t_s_r_mac(cx: ext_ctxt, mac: ast::mac, s: selector, b: binders) { let final_step = |x| select_pt_1(cx, x, select_pt_2); b.real_binders.insert(id, compose_sels(s, final_step)); } - none { no_des(cx, blk.span, "under `#{}`"); } + none { no_des(cx, blk.span, ~"under `#{}`"); } } } - ast::mac_aq(_,_) { no_des(cx, mac.span, "antiquotes"); } - ast::mac_var(_) { no_des(cx, mac.span, "antiquote variables"); } + ast::mac_aq(_,_) { no_des(cx, mac.span, ~"antiquotes"); } + ast::mac_var(_) { no_des(cx, mac.span, ~"antiquote variables"); } } } @@ -621,7 +621,7 @@ fn p_t_s_r_ellipses(cx: ext_ctxt, repeat_me: @expr, offset: uint, s: selector, _ { none } } } - _ { cx.bug("broken traversal in p_t_s_r") } + _ { cx.bug(~"broken traversal in p_t_s_r") } } } p_t_s_rec(cx, match_expr(repeat_me), @@ -666,7 +666,7 @@ fn p_t_s_r_actual_vector(cx: ext_ctxt, elts: ~[@expr], _repeat_after: bool, _ { none } } } - _ { cx.bug("broken traversal in p_t_s_r") } + _ { cx.bug(~"broken traversal in p_t_s_r") } } } p_t_s_rec(cx, match_expr(elts[idx]), @@ -677,17 +677,17 @@ fn p_t_s_r_actual_vector(cx: ext_ctxt, elts: ~[@expr], _repeat_after: bool, fn add_new_extension(cx: ext_ctxt, sp: span, arg: ast::mac_arg, _body: ast::mac_body) -> base::macro_def { - let args = get_mac_args_no_max(cx, sp, arg, 0u, "macro"); + let args = get_mac_args_no_max(cx, sp, arg, 0u, ~"macro"); - let mut macro_name: option<@str/~> = none; + let mut macro_name: option<@~str> = none; let mut clauses: ~[@clause] = ~[]; for args.each |arg| { alt arg.node { expr_vec(elts, mutbl) { if vec::len(elts) != 2u { cx.span_fatal((*arg).span, - "extension clause must consist of ~[" + - "macro invocation, expansion body]"); + ~"extension clause must consist of ~[" + + ~"macro invocation, expansion body]"); } @@ -702,21 +702,21 @@ fn add_new_extension(cx: ext_ctxt, sp: span, arg: ast::mac_arg, some(other_id) { if id != other_id { cx.span_fatal(pth.span, - "macro name must be " + - "consistent"); + ~"macro name must be " + + ~"consistent"); } } } } none { cx.span_fatal(pth.span, - "macro name must not be a path"); + ~"macro name must not be a path"); } } let arg = alt invoc_arg { some(arg) { arg } none { cx.span_fatal(mac.span, - "macro must have arguments")} + ~"macro must have arguments")} }; vec::push(clauses, @{params: pattern_to_selectors(cx, arg), @@ -726,21 +726,21 @@ fn add_new_extension(cx: ext_ctxt, sp: span, arg: ast::mac_arg, // the macro arg situation) } _ { - cx.span_bug(mac.span, "undocumented invariant in \ + cx.span_bug(mac.span, ~"undocumented invariant in \ add_extension"); } } } _ { cx.span_fatal(elts[0u].span, - "extension clause must" + - " start with a macro invocation."); + ~"extension clause must" + + ~" start with a macro invocation."); } } } _ { cx.span_fatal((*arg).span, - "extension must be ~[clause, " + " ...]"); + ~"extension must be ~[clause, " + ~" ...]"); } } } @@ -751,8 +751,8 @@ fn add_new_extension(cx: ext_ctxt, sp: span, arg: ast::mac_arg, alt macro_name { some(id) { id } none { - cx.span_fatal(sp, "macro definition must have " + - "at least one clause") + cx.span_fatal(sp, ~"macro definition must have " + + ~"at least one clause") } }, ext: normal({expander: ext, span: some(option::get(arg).span)})}; @@ -762,7 +762,7 @@ fn add_new_extension(cx: ext_ctxt, sp: span, arg: ast::mac_arg, clauses: ~[@clause]) -> @expr { let arg = alt arg { some(arg) { arg } - none { cx.span_fatal(sp, "macro must have arguments")} + none { cx.span_fatal(sp, ~"macro must have arguments")} }; for clauses.each |c| { alt use_selectors_to_bind(c.params, arg) { @@ -770,7 +770,7 @@ fn add_new_extension(cx: ext_ctxt, sp: span, arg: ast::mac_arg, none { again; } } } - cx.span_fatal(sp, "no clauses match macro invocation"); + cx.span_fatal(sp, ~"no clauses match macro invocation"); } } diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs index 3ba1a7b159e..ff7fedde34e 100644 --- a/src/libsyntax/ext/source_util.rs +++ b/src/libsyntax/ext/source_util.rs @@ -16,7 +16,7 @@ export expand_include_bin; /* #line(): expands to the current line number */ fn expand_line(cx: ext_ctxt, sp: span, arg: ast::mac_arg, _body: ast::mac_body) -> @ast::expr { - get_mac_args(cx, sp, arg, 0u, option::some(0u), "line"); + get_mac_args(cx, sp, arg, 0u, option::some(0u), ~"line"); let loc = codemap::lookup_char_pos(cx.codemap(), sp.lo); ret mk_uint(cx, sp, loc.line); } @@ -24,7 +24,7 @@ fn expand_line(cx: ext_ctxt, sp: span, arg: ast::mac_arg, /* #col(): expands to the current column number */ fn expand_col(cx: ext_ctxt, sp: span, arg: ast::mac_arg, _body: ast::mac_body) -> @ast::expr { - get_mac_args(cx, sp, arg, 0u, option::some(0u), "col"); + get_mac_args(cx, sp, arg, 0u, option::some(0u), ~"col"); let loc = codemap::lookup_char_pos(cx.codemap(), sp.lo); ret mk_uint(cx, sp, loc.col); } @@ -34,7 +34,7 @@ fn expand_col(cx: ext_ctxt, sp: span, arg: ast::mac_arg, * out if we wanted. */ fn expand_file(cx: ext_ctxt, sp: span, arg: ast::mac_arg, _body: ast::mac_body) -> @ast::expr { - get_mac_args(cx, sp, arg, 0u, option::some(0u), "file"); + get_mac_args(cx, sp, arg, 0u, option::some(0u), ~"file"); let { file: @{ name: filename, _ }, _ } = codemap::lookup_char_pos(cx.codemap(), sp.lo); ret mk_uniq_str(cx, sp, filename); @@ -42,21 +42,21 @@ fn expand_file(cx: ext_ctxt, sp: span, arg: ast::mac_arg, fn expand_stringify(cx: ext_ctxt, sp: span, arg: ast::mac_arg, _body: ast::mac_body) -> @ast::expr { - let args = get_mac_args(cx, sp, arg, 1u, option::some(1u), "stringify"); + let args = get_mac_args(cx, sp, arg, 1u, option::some(1u), ~"stringify"); ret mk_uniq_str(cx, sp, pprust::expr_to_str(args[0])); } fn expand_mod(cx: ext_ctxt, sp: span, arg: ast::mac_arg, _body: ast::mac_body) -> @ast::expr { - get_mac_args(cx, sp, arg, 0u, option::some(0u), "file"); + get_mac_args(cx, sp, arg, 0u, option::some(0u), ~"file"); ret mk_uniq_str(cx, sp, - str::connect(cx.mod_path().map(|x|*x), "::")); + str::connect(cx.mod_path().map(|x|*x), ~"::")); } fn expand_include(cx: ext_ctxt, sp: span, arg: ast::mac_arg, _body: ast::mac_body) -> @ast::expr { - let args = get_mac_args(cx, sp, arg, 1u, option::some(1u), "include"); - let file = expr_to_str(cx, args[0], "#include_str requires a string"); + let args = get_mac_args(cx, sp, arg, 1u, option::some(1u), ~"include"); + let file = expr_to_str(cx, args[0], ~"#include_str requires a string"); let p = parse::new_parser_from_file(cx.parse_sess(), cx.cfg(), res_rel_file(cx, sp, file), parse::parser::SOURCE_FILE); @@ -65,9 +65,9 @@ fn expand_include(cx: ext_ctxt, sp: span, arg: ast::mac_arg, fn expand_include_str(cx: ext_ctxt, sp: codemap::span, arg: ast::mac_arg, _body: ast::mac_body) -> @ast::expr { - let args = get_mac_args(cx,sp,arg,1u,option::some(1u),"include_str"); + let args = get_mac_args(cx,sp,arg,1u,option::some(1u),~"include_str"); - let file = expr_to_str(cx, args[0], "#include_str requires a string"); + let file = expr_to_str(cx, args[0], ~"#include_str requires a string"); let res = io::read_whole_file_str(res_rel_file(cx, sp, file)); alt res { @@ -82,9 +82,9 @@ fn expand_include_str(cx: ext_ctxt, sp: codemap::span, arg: ast::mac_arg, fn expand_include_bin(cx: ext_ctxt, sp: codemap::span, arg: ast::mac_arg, _body: ast::mac_body) -> @ast::expr { - let args = get_mac_args(cx,sp,arg,1u,option::some(1u),"include_bin"); + let args = get_mac_args(cx,sp,arg,1u,option::some(1u),~"include_bin"); - let file = expr_to_str(cx, args[0], "#include_bin requires a string"); + let file = expr_to_str(cx, args[0], ~"#include_bin requires a string"); alt io::read_whole_file(res_rel_file(cx, sp, file)) { result::ok(src) { diff --git a/src/libsyntax/ext/tt/earley_parser.rs b/src/libsyntax/ext/tt/earley_parser.rs index f830330e182..3f604aafb3d 100644 --- a/src/libsyntax/ext/tt/earley_parser.rs +++ b/src/libsyntax/ext/tt/earley_parser.rs @@ -83,7 +83,7 @@ fn nameize(p_s: parse_sess, ms: ~[matcher], res: ~[@arb_depth]) } {node: mtc_bb(bind_name, _, idx), span: sp} { if ret_val.contains_key(bind_name) { - p_s.span_diagnostic.span_fatal(sp, "Duplicated bind name: " + p_s.span_diagnostic.span_fatal(sp, ~"Duplicated bind name: " + *bind_name) } ret_val.insert(bind_name, res[idx]); @@ -97,7 +97,7 @@ fn nameize(p_s: parse_sess, ms: ~[matcher], res: ~[@arb_depth]) enum parse_result { success(hashmap<ident, @arb_depth>), - failure(codemap::span, str) + failure(codemap::span, ~str) } fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher]) @@ -207,9 +207,9 @@ fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher]) nameize(sess, ms, vec::map(eof_eis[0u].matches, |dv| dv.pop()))); } else if eof_eis.len() > 1u { - ret failure(sp, "Ambiguity: multiple successful parses"); + ret failure(sp, ~"Ambiguity: multiple successful parses"); } else { - ret failure(sp, "Unexpected end of macro invocation"); + ret failure(sp, ~"Unexpected end of macro invocation"); } } else { if (bb_eis.len() > 0u && next_eis.len() > 0u) @@ -217,13 +217,13 @@ fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher]) let nts = str::connect(vec::map(bb_eis, |ei| { alt ei.elts[ei.idx].node { mtc_bb(_,name,_) { *name } _ { fail; } } - }), " or "); + }), ~" or "); ret failure(sp, #fmt[ "Local ambiguity: multiple parsing options: \ built-in NTs %s or %u other options.", nts, next_eis.len()]); } else if (bb_eis.len() == 0u && next_eis.len() == 0u) { - ret failure(sp, "No rules expected the token " + ret failure(sp, ~"No rules expected the token " + to_str(*rdr.interner(), tok)); } else if (next_eis.len() > 0u) { /* Now process the next token */ @@ -259,32 +259,32 @@ fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher]) } } -fn parse_nt(p: parser, name: str) -> whole_nt { +fn parse_nt(p: parser, name: ~str) -> whole_nt { alt name { - "item" { alt p.parse_item(~[], ast::public) { + ~"item" { alt p.parse_item(~[], ast::public) { some(i) { token::w_item(i) } - none { p.fatal("expected an item keyword") } + none { p.fatal(~"expected an item keyword") } }} - "block" { token::w_block(p.parse_block()) } - "stmt" { token::w_stmt(p.parse_stmt(~[])) } - "pat" { token::w_pat(p.parse_pat()) } - "expr" { token::w_expr(p.parse_expr()) } - "ty" { token::w_ty(p.parse_ty(false /* no need to disambiguate*/)) } + ~"block" { token::w_block(p.parse_block()) } + ~"stmt" { token::w_stmt(p.parse_stmt(~[])) } + ~"pat" { token::w_pat(p.parse_pat()) } + ~"expr" { token::w_expr(p.parse_expr()) } + ~"ty" { token::w_ty(p.parse_ty(false /* no need to disambiguate*/)) } // this could be handled like a token, since it is one - "ident" { alt copy p.token { + ~"ident" { alt copy p.token { token::IDENT(sn,b) { p.bump(); token::w_ident(sn,b) } - _ { p.fatal("expected ident, found " + _ { p.fatal(~"expected ident, found " + token::to_str(*p.reader.interner(), copy p.token)) } } } - "path" { token::w_path(p.parse_path_with_tps(false)) } - "tt" { + ~"path" { token::w_path(p.parse_path_with_tps(false)) } + ~"tt" { p.quote_depth += 1u; //but in theory, non-quoted tts might be useful let res = token::w_tt(@p.parse_token_tree()); p.quote_depth -= 1u; res } - "mtcs" { token::w_mtcs(p.parse_matchers()) } - _ { p.fatal("Unsupported builtin nonterminal parser: " + name)} + ~"mtcs" { token::w_mtcs(p.parse_matchers()) } + _ { p.fatal(~"Unsupported builtin nonterminal parser: " + name)} } } diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs index b454dcfc0be..7bed3107f53 100644 --- a/src/libsyntax/ext/tt/macro_rules.rs +++ b/src/libsyntax/ext/tt/macro_rules.rs @@ -18,9 +18,9 @@ fn add_new_extension(cx: ext_ctxt, sp: span, name: ident, let argument_gram = ~[ ms(mtc_rep(~[ - ms(mtc_bb(@"lhs"/~,@"mtcs"/~, 0u)), + ms(mtc_bb(@~"lhs",@~"mtcs", 0u)), ms(mtc_tok(FAT_ARROW)), - ms(mtc_bb(@"rhs"/~,@"tt"/~, 1u)), + ms(mtc_bb(@~"rhs",@~"tt", 1u)), ], some(SEMI), false))]; let arg_reader = new_tt_reader(cx.parse_sess().span_diagnostic, @@ -31,20 +31,20 @@ fn add_new_extension(cx: ext_ctxt, sp: span, name: ident, failure(sp, msg) { cx.span_fatal(sp, msg); } }; - let lhses = alt arguments.get(@"lhs"/~) { + let lhses = alt arguments.get(@~"lhs") { @seq(s, sp) { s } - _ { cx.span_bug(sp, "wrong-structured lhs") } + _ { cx.span_bug(sp, ~"wrong-structured lhs") } }; - let rhses = alt arguments.get(@"rhs"/~) { + let rhses = alt arguments.get(@~"rhs") { @seq(s, sp) { s } - _ { cx.span_bug(sp, "wrong-structured rhs") } + _ { cx.span_bug(sp, ~"wrong-structured rhs") } }; fn generic_extension(cx: ext_ctxt, sp: span, arg: ~[ast::token_tree], lhses: ~[@arb_depth], rhses: ~[@arb_depth]) -> mac_result { let mut best_fail_spot = {lo: 0u, hi: 0u, expn_info: none}; - let mut best_fail_msg = "internal error: ran no matchers"; + let mut best_fail_msg = ~"internal error: ran no matchers"; let s_d = cx.parse_sess().span_diagnostic; let itr = cx.parse_sess().interner; @@ -57,7 +57,7 @@ fn add_new_extension(cx: ext_ctxt, sp: span, name: ident, success(m) { let rhs = alt rhses[i] { @leaf(w_tt(@tt)) { tt } - _ { cx.span_bug(sp, "bad thing in rhs") } + _ { cx.span_bug(sp, ~"bad thing in rhs") } }; let trncbr = new_tt_reader(s_d, itr, some(m), ~[rhs]); let p = parser(cx.parse_sess(), cx.cfg(), @@ -71,7 +71,7 @@ fn add_new_extension(cx: ext_ctxt, sp: span, name: ident, } } } - _ { cx.bug("non-matcher found in parsed lhses"); } + _ { cx.bug(~"non-matcher found in parsed lhses"); } } } cx.span_fatal(best_fail_spot, best_fail_msg); diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs index df0c39bb266..a9bc124b605 100644 --- a/src/libsyntax/ext/tt/transcribe.rs +++ b/src/libsyntax/ext/tt/transcribe.rs @@ -25,7 +25,7 @@ type tt_frame = @{ type tt_reader = @{ sp_diag: span_handler, - interner: @interner<@str/~>, + interner: @interner<@~str>, mut cur: tt_frame, /* for MBE-style macro transcription */ interpolations: std::map::hashmap<ident, @arb_depth>, @@ -39,7 +39,7 @@ type tt_reader = @{ /** This can do Macro-By-Example transcription. On the other hand, if * `src` contains no `tt_dotdotdot`s and `tt_interpolate`s, `interp` can (and * should) be none. */ -fn new_tt_reader(sp_diag: span_handler, itr: @interner<@str/~>, +fn new_tt_reader(sp_diag: span_handler, itr: @interner<@~str>, interp: option<std::map::hashmap<ident,@arb_depth>>, src: ~[ast::token_tree]) -> tt_reader { @@ -93,7 +93,7 @@ fn lookup_cur_ad(r: tt_reader, name: ident) -> @arb_depth { lookup_cur_ad_by_ad(r, r.interpolations.get(name)) } enum lis { - lis_unconstrained, lis_constraint(uint, ident), lis_contradiction(str) + lis_unconstrained, lis_constraint(uint, ident), lis_contradiction(~str) } fn lockstep_iter_size(&&t: token_tree, &&r: tt_reader) -> lis { @@ -183,7 +183,7 @@ fn tt_next_token(&&r: tt_reader) -> {tok: token, sp: span} { lis_unconstrained { r.sp_diag.span_fatal( sp, /* blame macro writer */ - "attempted to repeat an expression containing no syntax \ + ~"attempted to repeat an expression containing no syntax \ variables matched as repeating at this depth"); } lis_contradiction(msg) { /* FIXME #2887 blame macro invoker @@ -200,7 +200,7 @@ fn tt_next_token(&&r: tt_reader) -> {tok: token, sp: span} { if !zerok { r.sp_diag.span_fatal(sp, /* FIXME #2887 blame invoker */ - "this must repeat at least \ + ~"this must repeat at least \ once"); } /* we need to pop before we proceed, so recur */ diff --git a/src/libsyntax/parse.rs b/src/libsyntax/parse.rs index 7ccc9c5a438..9d56754e5d4 100644 --- a/src/libsyntax/parse.rs +++ b/src/libsyntax/parse.rs @@ -25,7 +25,7 @@ type parse_sess = @{ cm: codemap::codemap, mut next_id: node_id, span_diagnostic: span_handler, - interner: @interner::interner<@str/~>, + interner: @interner::interner<@~str>, // these two must be kept up to date mut chpos: uint, mut byte_pos: uint @@ -36,7 +36,7 @@ fn new_parse_sess(demitter: option<emitter>) -> parse_sess { ret @{cm: cm, mut next_id: 1, span_diagnostic: mk_span_handler(mk_handler(demitter), cm), - interner: @interner::mk::<@str/~>(|x| str::hash(*x), + interner: @interner::mk::<@~str>(|x| str::hash(*x), |x,y| str::eq(*x, *y)), mut chpos: 0u, mut byte_pos: 0u}; } @@ -46,24 +46,24 @@ fn new_parse_sess_special_handler(sh: span_handler, cm: codemap::codemap) ret @{cm: cm, mut next_id: 1, span_diagnostic: sh, - interner: @interner::mk::<@str/~>(|x| str::hash(*x), + interner: @interner::mk::<@~str>(|x| str::hash(*x), |x,y| str::eq(*x, *y)), mut chpos: 0u, mut byte_pos: 0u}; } -fn parse_crate_from_file(input: str, cfg: ast::crate_cfg, sess: parse_sess) -> - @ast::crate { - if str::ends_with(input, ".rc") { +fn parse_crate_from_file(input: ~str, cfg: ast::crate_cfg, + sess: parse_sess) -> @ast::crate { + if str::ends_with(input, ~".rc") { parse_crate_from_crate_file(input, cfg, sess) - } else if str::ends_with(input, ".rs") { + } else if str::ends_with(input, ~".rs") { parse_crate_from_source_file(input, cfg, sess) } else { - sess.span_diagnostic.handler().fatal("unknown input file type: " + + sess.span_diagnostic.handler().fatal(~"unknown input file type: " + input) } } -fn parse_crate_from_crate_file(input: str, cfg: ast::crate_cfg, +fn parse_crate_from_crate_file(input: ~str, cfg: ast::crate_cfg, sess: parse_sess) -> @ast::crate { let (p, rdr) = new_parser_etc_from_file(sess, cfg, input, parser::CRATE_FILE); @@ -87,7 +87,7 @@ fn parse_crate_from_crate_file(input: str, cfg: ast::crate_cfg, config: /* FIXME (#2543) */ copy p.cfg}); } -fn parse_crate_from_source_file(input: str, cfg: ast::crate_cfg, +fn parse_crate_from_source_file(input: ~str, cfg: ast::crate_cfg, sess: parse_sess) -> @ast::crate { let (p, rdr) = new_parser_etc_from_file(sess, cfg, input, parser::SOURCE_FILE); @@ -97,7 +97,7 @@ fn parse_crate_from_source_file(input: str, cfg: ast::crate_cfg, ret r; } -fn parse_crate_from_source_str(name: str, source: @str/~, cfg: ast::crate_cfg, +fn parse_crate_from_source_str(name: ~str, source: @~str, cfg: ast::crate_cfg, sess: parse_sess) -> @ast::crate { let (p, rdr) = new_parser_etc_from_source_str(sess, cfg, name, codemap::fss_none, source); @@ -107,7 +107,7 @@ fn parse_crate_from_source_str(name: str, source: @str/~, cfg: ast::crate_cfg, ret r; } -fn parse_expr_from_source_str(name: str, source: @str/~, cfg: ast::crate_cfg, +fn parse_expr_from_source_str(name: ~str, source: @~str, cfg: ast::crate_cfg, sess: parse_sess) -> @ast::expr { let (p, rdr) = new_parser_etc_from_source_str(sess, cfg, name, codemap::fss_none, source); @@ -117,7 +117,7 @@ fn parse_expr_from_source_str(name: str, source: @str/~, cfg: ast::crate_cfg, ret r; } -fn parse_item_from_source_str(name: str, source: @str/~, cfg: ast::crate_cfg, +fn parse_item_from_source_str(name: ~str, source: @~str, cfg: ast::crate_cfg, +attrs: ~[ast::attribute], vis: ast::visibility, sess: parse_sess) -> option<@ast::item> { @@ -130,8 +130,8 @@ fn parse_item_from_source_str(name: str, source: @str/~, cfg: ast::crate_cfg, } fn parse_from_source_str<T>(f: fn (p: parser) -> T, - name: str, ss: codemap::file_substr, - source: @str/~, cfg: ast::crate_cfg, + name: ~str, ss: codemap::file_substr, + source: @~str, cfg: ast::crate_cfg, sess: parse_sess) -> T { @@ -139,7 +139,7 @@ fn parse_from_source_str<T>(f: fn (p: parser) -> T, source); let r = f(p); if !p.reader.is_eof() { - p.reader.fatal("expected end-of-string"); + p.reader.fatal(~"expected end-of-string"); } sess.chpos = rdr.chpos; sess.byte_pos = sess.byte_pos + rdr.pos; @@ -155,8 +155,8 @@ fn next_node_id(sess: parse_sess) -> node_id { } fn new_parser_etc_from_source_str(sess: parse_sess, cfg: ast::crate_cfg, - +name: str, +ss: codemap::file_substr, - source: @str/~) -> (parser, string_reader) { + +name: ~str, +ss: codemap::file_substr, + source: @~str) -> (parser, string_reader) { let ftype = parser::SOURCE_FILE; let filemap = codemap::new_filemap_w_substr (name, ss, source, sess.chpos, sess.byte_pos); @@ -167,15 +167,15 @@ fn new_parser_etc_from_source_str(sess: parse_sess, cfg: ast::crate_cfg, } fn new_parser_from_source_str(sess: parse_sess, cfg: ast::crate_cfg, - +name: str, +ss: codemap::file_substr, - source: @str/~) -> parser { + +name: ~str, +ss: codemap::file_substr, + source: @~str) -> parser { let (p, _) = new_parser_etc_from_source_str(sess, cfg, name, ss, source); ret p; } -fn new_parser_etc_from_file(sess: parse_sess, cfg: ast::crate_cfg, +path: str, - ftype: parser::file_type) -> +fn new_parser_etc_from_file(sess: parse_sess, cfg: ast::crate_cfg, + +path: ~str, ftype: parser::file_type) -> (parser, string_reader) { let res = io::read_whole_file_str(path); alt res { @@ -190,7 +190,7 @@ fn new_parser_etc_from_file(sess: parse_sess, cfg: ast::crate_cfg, +path: str, ret (parser(sess, cfg, srdr as reader, ftype), srdr); } -fn new_parser_from_file(sess: parse_sess, cfg: ast::crate_cfg, +path: str, +fn new_parser_from_file(sess: parse_sess, cfg: ast::crate_cfg, +path: ~str, ftype: parser::file_type) -> parser { let (p, _) = new_parser_etc_from_file(sess, cfg, path, ftype); ret p; diff --git a/src/libsyntax/parse/attr.rs b/src/libsyntax/parse/attr.rs index b10a05d8ca4..995feff0b70 100644 --- a/src/libsyntax/parse/attr.rs +++ b/src/libsyntax/parse/attr.rs @@ -56,7 +56,7 @@ impl parser_attr for parser { let attr = ::attr::mk_sugared_doc_attr( *self.get_str(s), self.span.lo, self.span.hi); if attr.node.style != ast::attr_outer { - self.fatal("expected outer comment"); + self.fatal(~"expected outer comment"); } attrs += ~[attr]; self.bump(); diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs index aa3e808f63e..737307bb648 100644 --- a/src/libsyntax/parse/comments.rs +++ b/src/libsyntax/parse/comments.rs @@ -18,28 +18,28 @@ enum cmnt_style { blank_line, // Just a manual blank line "\n\n", for layout } -type cmnt = {style: cmnt_style, lines: ~[str], pos: uint}; +type cmnt = {style: cmnt_style, lines: ~[~str], pos: uint}; -fn is_doc_comment(s: str) -> bool { - s.starts_with("///") || - s.starts_with("//!") || - s.starts_with("/**") || - s.starts_with("/*!") +fn is_doc_comment(s: ~str) -> bool { + s.starts_with(~"///") || + s.starts_with(~"//!") || + s.starts_with(~"/**") || + s.starts_with(~"/*!") } -fn doc_comment_style(comment: str) -> ast::attr_style { +fn doc_comment_style(comment: ~str) -> ast::attr_style { assert is_doc_comment(comment); - if comment.starts_with("//!") || comment.starts_with("/*!") { + if comment.starts_with(~"//!") || comment.starts_with(~"/*!") { ast::attr_inner } else { ast::attr_outer } } -fn strip_doc_comment_decoration(comment: str) -> str { +fn strip_doc_comment_decoration(comment: ~str) -> ~str { /// remove whitespace-only lines from the start/end of lines - fn vertical_trim(lines: ~[str]) -> ~[str] { + fn vertical_trim(lines: ~[~str]) -> ~[~str] { let mut i = 0u, j = lines.len(); while i < j && lines[i].trim().is_empty() { i += 1u; @@ -51,7 +51,7 @@ fn strip_doc_comment_decoration(comment: str) -> str { } // drop leftmost columns that contain only values in chars - fn block_trim(lines: ~[str], chars: str, max: option<uint>) -> ~[str] { + fn block_trim(lines: ~[~str], chars: ~str, max: option<uint>) -> ~[~str] { let mut i = max.get_default(uint::max_value); for lines.each |line| { @@ -72,31 +72,31 @@ fn strip_doc_comment_decoration(comment: str) -> str { ret do lines.map |line| { let chars = str::chars(line); if i > chars.len() { - "" + ~"" } else { str::from_chars(chars.slice(i, chars.len())) } }; } - if comment.starts_with("//") { + if comment.starts_with(~"//") { ret comment.slice(3u, comment.len()).trim(); } - if comment.starts_with("/*") { + if comment.starts_with(~"/*") { let lines = str::lines_any(comment.slice(3u, comment.len() - 2u)); let lines = vertical_trim(lines); - let lines = block_trim(lines, "\t ", none); - let lines = block_trim(lines, "*", some(1u)); - let lines = block_trim(lines, "\t ", none); - ret str::connect(lines, "\n"); + let lines = block_trim(lines, ~"\t ", none); + let lines = block_trim(lines, ~"*", some(1u)); + let lines = block_trim(lines, ~"\t ", none); + ret str::connect(lines, ~"\n"); } - fail "not a doc-comment: " + comment; + fail ~"not a doc-comment: " + comment; } -fn read_to_eol(rdr: string_reader) -> str { - let mut val = ""; +fn read_to_eol(rdr: string_reader) -> ~str { + let mut val = ~""; while rdr.curr != '\n' && !is_eof(rdr) { str::push_char(val, rdr.curr); bump(rdr); @@ -105,7 +105,7 @@ fn read_to_eol(rdr: string_reader) -> str { ret val; } -fn read_one_line_comment(rdr: string_reader) -> str { +fn read_one_line_comment(rdr: string_reader) -> ~str { let val = read_to_eol(rdr); assert ((val[0] == '/' as u8 && val[1] == '/' as u8) || (val[0] == '#' as u8 && val[1] == '!' as u8)); @@ -120,7 +120,7 @@ fn consume_non_eol_whitespace(rdr: string_reader) { fn push_blank_line_comment(rdr: string_reader, &comments: ~[cmnt]) { #debug(">>> blank-line comment"); - let v: ~[str] = ~[]; + let v: ~[~str] = ~[]; vec::push(comments, {style: blank_line, lines: v, pos: rdr.chpos}); } @@ -151,7 +151,7 @@ fn read_line_comments(rdr: string_reader, code_to_the_left: bool, &comments: ~[cmnt]) { #debug(">>> line comments"); let p = rdr.chpos; - let mut lines: ~[str] = ~[]; + let mut lines: ~[~str] = ~[]; while rdr.curr == '/' && nextch(rdr) == '/' { let line = read_one_line_comment(rdr); log(debug, line); @@ -171,22 +171,22 @@ fn read_line_comments(rdr: string_reader, code_to_the_left: bool, } } -fn all_whitespace(s: str, begin: uint, end: uint) -> bool { +fn all_whitespace(s: ~str, begin: uint, end: uint) -> bool { let mut i: uint = begin; while i != end { if !is_whitespace(s[i] as char) { ret false; } i += 1u; } ret true; } -fn trim_whitespace_prefix_and_push_line(&lines: ~[str], - s: str, col: uint) unsafe { +fn trim_whitespace_prefix_and_push_line(&lines: ~[~str], + s: ~str, col: uint) unsafe { let mut s1; let len = str::len(s); if all_whitespace(s, 0u, uint::min(len, col)) { if col < len { s1 = str::slice(s, col, len); - } else { s1 = ""; } + } else { s1 = ~""; } } else { s1 = s; } - log(debug, "pushing line: " + s1); + log(debug, ~"pushing line: " + s1); vec::push(lines, s1); } @@ -194,7 +194,7 @@ fn read_block_comment(rdr: string_reader, code_to_the_left: bool, &comments: ~[cmnt]) { #debug(">>> block comment"); let p = rdr.chpos; - let mut lines: ~[str] = ~[]; + let mut lines: ~[~str] = ~[]; let mut col: uint = rdr.col; bump(rdr); bump(rdr); @@ -211,27 +211,27 @@ fn read_block_comment(rdr: string_reader, code_to_the_left: bool, ret; } - let mut curr_line = "/*"; + let mut curr_line = ~"/*"; let mut level: int = 1; while level > 0 { #debug("=== block comment level %d", level); - if is_eof(rdr) {(rdr as reader).fatal("unterminated block comment");} + if is_eof(rdr) {(rdr as reader).fatal(~"unterminated block comment");} if rdr.curr == '\n' { trim_whitespace_prefix_and_push_line(lines, curr_line, col); - curr_line = ""; + curr_line = ~""; bump(rdr); } else { str::push_char(curr_line, rdr.curr); if rdr.curr == '/' && nextch(rdr) == '*' { bump(rdr); bump(rdr); - curr_line += "*"; + curr_line += ~"*"; level += 1; } else { if rdr.curr == '*' && nextch(rdr) == '/' { bump(rdr); bump(rdr); - curr_line += "/"; + curr_line += ~"/"; level -= 1; } else { bump(rdr); } } @@ -268,14 +268,14 @@ fn consume_comment(rdr: string_reader, code_to_the_left: bool, #debug("<<< consume comment"); } -type lit = {lit: str, pos: uint}; +type lit = {lit: ~str, pos: uint}; fn gather_comments_and_literals(span_diagnostic: diagnostic::span_handler, - path: str, + path: ~str, srdr: io::reader) -> {cmnts: ~[cmnt], lits: ~[lit]} { let src = @str::from_bytes(srdr.read_whole_stream()); - let itr = @interner::mk::<@str/~>( + let itr = @interner::mk::<@~str>( |x| str::hash(*x), |x,y| str::eq(*x, *y) ); @@ -308,9 +308,9 @@ fn gather_comments_and_literals(span_diagnostic: diagnostic::span_handler, if token::is_lit(tok) { let s = get_str_from(rdr, bstart); vec::push(literals, {lit: s, pos: sp.lo}); - log(debug, "tok lit: " + s); + log(debug, ~"tok lit: " + s); } else { - log(debug, "tok: " + token::to_str(*rdr.interner, tok)); + log(debug, ~"tok: " + token::to_str(*rdr.interner, tok)); } first_read = false; } diff --git a/src/libsyntax/parse/common.rs b/src/libsyntax/parse/common.rs index 9e5f2ac2c9b..79ac3aeaf8b 100644 --- a/src/libsyntax/parse/common.rs +++ b/src/libsyntax/parse/common.rs @@ -18,7 +18,7 @@ fn seq_sep_none() -> seq_sep { ret {sep: option::none, trailing_sep_allowed: false}; } -fn token_to_str(reader: reader, ++token: token::token) -> str { +fn token_to_str(reader: reader, ++token: token::token) -> ~str { token::to_str(*reader.interner(), token) } @@ -28,23 +28,23 @@ impl parser_common for parser { fn unexpected_last(t: token::token) -> ! { self.span_fatal( copy self.last_span, - "unexpected token: `" + token_to_str(self.reader, t) + "`"); + ~"unexpected token: `" + token_to_str(self.reader, t) + ~"`"); } fn unexpected() -> ! { - self.fatal("unexpected token: `" - + token_to_str(self.reader, self.token) + "`"); + self.fatal(~"unexpected token: `" + + token_to_str(self.reader, self.token) + ~"`"); } fn expect(t: token::token) { if self.token == t { self.bump(); } else { - let mut s: str = "expected `"; + let mut s: ~str = ~"expected `"; s += token_to_str(self.reader, t); - s += "` but found `"; + s += ~"` but found `"; s += token_to_str(self.reader, self.token); - self.fatal(s + "`"); + self.fatal(s + ~"`"); } } @@ -52,10 +52,10 @@ impl parser_common for parser { alt copy self.token { token::IDENT(i, _) { self.bump(); ret self.get_str(i); } token::ACTUALLY(token::w_ident(*)) { self.bug( - "ident interpolation not converted to real token"); } - _ { self.fatal("expected ident, found `" + ~"ident interpolation not converted to real token"); } + _ { self.fatal(~"expected ident, found `" + token_to_str(self.reader, self.token) - + "`"); } + + ~"`"); } } } @@ -76,13 +76,13 @@ impl parser_common for parser { } // A sanity check that the word we are asking for is a known keyword - fn require_keyword(word: str) { + fn require_keyword(word: ~str) { if !self.keywords.contains_key(word) { self.bug(#fmt("unknown keyword: %s", word)); } } - fn token_is_keyword(word: str, ++tok: token::token) -> bool { + fn token_is_keyword(word: ~str, ++tok: token::token) -> bool { self.require_keyword(word); alt tok { token::IDENT(sid, false) { str::eq(word, *self.get_str(sid)) } @@ -90,7 +90,7 @@ impl parser_common for parser { } } - fn is_keyword(word: str) -> bool { + fn is_keyword(word: ~str) -> bool { self.token_is_keyword(word, self.token) } @@ -103,7 +103,7 @@ impl parser_common for parser { } } - fn eat_keyword(word: str) -> bool { + fn eat_keyword(word: ~str) -> bool { self.require_keyword(word); // FIXME (#13042): this gratuitous use of @ is to @@ -119,16 +119,16 @@ impl parser_common for parser { } } - fn expect_keyword(word: str) { + fn expect_keyword(word: ~str) { self.require_keyword(word); if !self.eat_keyword(word) { - self.fatal("expected `" + word + "`, found `" + + self.fatal(~"expected `" + word + ~"`, found `" + token_to_str(self.reader, self.token) + - "`"); + ~"`"); } } - fn is_restricted_keyword(word: str) -> bool { + fn is_restricted_keyword(word: ~str) -> bool { self.restricted_keywords.contains_key(word) } @@ -142,9 +142,9 @@ impl parser_common for parser { } } - fn check_restricted_keywords_(w: str) { + fn check_restricted_keywords_(w: ~str) { if self.is_restricted_keyword(w) { - self.fatal("found `" + w + "` in restricted position"); + self.fatal(~"found `" + w + ~"` in restricted position"); } } @@ -154,11 +154,11 @@ impl parser_common for parser { } else if self.token == token::BINOP(token::SHR) { self.swap(token::GT, self.span.lo + 1u, self.span.hi); } else { - let mut s: str = "expected `"; + let mut s: ~str = ~"expected `"; s += token_to_str(self.reader, token::GT); - s += "`, found `"; + s += ~"`, found `"; s += token_to_str(self.reader, self.token); - s += "`"; + s += ~"`"; self.fatal(s); } } diff --git a/src/libsyntax/parse/eval.rs b/src/libsyntax/parse/eval.rs index 54a2abf20c9..125dc809079 100644 --- a/src/libsyntax/parse/eval.rs +++ b/src/libsyntax/parse/eval.rs @@ -9,7 +9,7 @@ type ctx = fn eval_crate_directives(cx: ctx, cdirs: ~[@ast::crate_directive], - prefix: str, + prefix: ~str, &view_items: ~[@ast::view_item], &items: ~[@ast::item]) { for cdirs.each |sub_cdir| { @@ -18,11 +18,11 @@ fn eval_crate_directives(cx: ctx, } fn eval_crate_directives_to_mod(cx: ctx, cdirs: ~[@ast::crate_directive], - prefix: str, suffix: option<str>) + prefix: ~str, suffix: option<~str>) -> (ast::_mod, ~[ast::attribute]) { #debug("eval crate prefix: %s", prefix); #debug("eval crate suffix: %s", - option::get_default(suffix, "none")); + option::get_default(suffix, ~"none")); let (cview_items, citems, cattrs) = parse_companion_mod(cx, prefix, suffix); let mut view_items: ~[@ast::view_item] = ~[]; @@ -43,17 +43,17 @@ companion mod is a .rs file with the same name as the directory. We build the path to the companion mod by combining the prefix and the optional suffix then adding the .rs extension. */ -fn parse_companion_mod(cx: ctx, prefix: str, suffix: option<str>) +fn parse_companion_mod(cx: ctx, prefix: ~str, suffix: option<~str>) -> (~[@ast::view_item], ~[@ast::item], ~[ast::attribute]) { - fn companion_file(+prefix: str, suffix: option<str>) -> str { + fn companion_file(+prefix: ~str, suffix: option<~str>) -> ~str { ret alt suffix { option::some(s) { path::connect(prefix, s) } option::none { prefix } - } + ".rs"; + } + ~".rs"; } - fn file_exists(path: str) -> bool { + fn file_exists(path: ~str) -> bool { // Crude, but there's no lib function for this and I'm not // up to writing it just now alt io::file_reader(path) { @@ -78,8 +78,8 @@ fn parse_companion_mod(cx: ctx, prefix: str, suffix: option<str>) } } -fn cdir_path_opt(id: ast::ident, attrs: ~[ast::attribute]) -> @str/~ { - alt ::attr::first_attr_value_str_by_name(attrs, "path") { +fn cdir_path_opt(id: ast::ident, attrs: ~[ast::attribute]) -> @~str { + alt ::attr::first_attr_value_str_by_name(attrs, ~"path") { some(d) { ret d; } @@ -87,12 +87,12 @@ fn cdir_path_opt(id: ast::ident, attrs: ~[ast::attribute]) -> @str/~ { } } -fn eval_crate_directive(cx: ctx, cdir: @ast::crate_directive, prefix: str, +fn eval_crate_directive(cx: ctx, cdir: @ast::crate_directive, prefix: ~str, &view_items: ~[@ast::view_item], &items: ~[@ast::item]) { alt cdir.node { ast::cdir_src_mod(id, attrs) { - let file_path = cdir_path_opt(@(*id + ".rs"), attrs); + let file_path = cdir_path_opt(@(*id + ~".rs"), attrs); let full_path = if path::path_is_absolute(*file_path) { *file_path diff --git a/src/libsyntax/parse/lexer.rs b/src/libsyntax/parse/lexer.rs index d7f9fc12840..7afdc301b02 100644 --- a/src/libsyntax/parse/lexer.rs +++ b/src/libsyntax/parse/lexer.rs @@ -12,22 +12,22 @@ export string_reader_as_reader, tt_reader_as_reader; iface reader { fn is_eof() -> bool; fn next_token() -> {tok: token::token, sp: span}; - fn fatal(str) -> !; + fn fatal(~str) -> !; fn span_diag() -> span_handler; - fn interner() -> @interner<@str/~>; + fn interner() -> @interner<@~str>; fn peek() -> {tok: token::token, sp: span}; fn dup() -> reader; } type string_reader = @{ span_diagnostic: span_handler, - src: @str/~, + src: @~str, mut col: uint, mut pos: uint, mut curr: char, mut chpos: uint, filemap: codemap::filemap, - interner: @interner<@str/~>, + interner: @interner<@~str>, /* cached: */ mut peek_tok: token::token, mut peek_span: span @@ -35,7 +35,7 @@ type string_reader = @{ fn new_string_reader(span_diagnostic: span_handler, filemap: codemap::filemap, - itr: @interner<@str/~>) -> string_reader { + itr: @interner<@~str>) -> string_reader { let r = new_low_level_string_reader(span_diagnostic, filemap, itr); string_advance_token(r); /* fill in peek_* */ ret r; @@ -44,7 +44,7 @@ fn new_string_reader(span_diagnostic: span_handler, /* For comments.rs, which hackily pokes into 'pos' and 'curr' */ fn new_low_level_string_reader(span_diagnostic: span_handler, filemap: codemap::filemap, - itr: @interner<@str/~>) + itr: @interner<@~str>) -> string_reader { let r = @{span_diagnostic: span_diagnostic, src: filemap.src, mut col: 0u, mut pos: 0u, mut curr: -1 as char, @@ -75,11 +75,11 @@ impl string_reader_as_reader of reader for string_reader { string_advance_token(self); ret ret_val; } - fn fatal(m: str) -> ! { + fn fatal(m: ~str) -> ! { self.span_diagnostic.span_fatal(copy self.peek_span, m) } fn span_diag() -> span_handler { self.span_diagnostic } - fn interner() -> @interner<@str/~> { self.interner } + fn interner() -> @interner<@~str> { self.interner } fn peek() -> {tok: token::token, sp: span} { {tok: self.peek_tok, sp: self.peek_span} } @@ -97,11 +97,11 @@ impl tt_reader_as_reader of reader for tt_reader { } tt_next_token(self) } - fn fatal(m: str) -> ! { + fn fatal(m: ~str) -> ! { self.sp_diag.span_fatal(copy self.cur_span, m); } fn span_diag() -> span_handler { self.sp_diag } - fn interner() -> @interner<@str/~> { self.interner } + fn interner() -> @interner<@~str> { self.interner } fn peek() -> {tok: token::token, sp: span} { { tok: self.cur_tok, sp: self.cur_span } } @@ -125,7 +125,7 @@ fn string_advance_token(&&r: string_reader) { } -fn get_str_from(rdr: string_reader, start: uint) -> str unsafe { +fn get_str_from(rdr: string_reader, start: uint) -> ~str unsafe { // I'm pretty skeptical about this subtraction. What if there's a // multi-byte character before the mark? ret str::slice(*rdr.src, start - 1u, rdr.pos - 1u); @@ -211,7 +211,7 @@ fn consume_any_line_comment(rdr: string_reader) // line comments starting with "///" or "//!" are doc-comments if rdr.curr == '/' || rdr.curr == '!' { let start_chpos = rdr.chpos - 2u; - let mut acc = "//"; + let mut acc = ~"//"; while rdr.curr != '\n' && !is_eof(rdr) { str::push_char(acc, rdr.curr); bump(rdr); @@ -250,15 +250,15 @@ fn consume_block_comment(rdr: string_reader) // block comments starting with "/**" or "/*!" are doc-comments if rdr.curr == '*' || rdr.curr == '!' { let start_chpos = rdr.chpos - 2u; - let mut acc = "/*"; + let mut acc = ~"/*"; while !(rdr.curr == '*' && nextch(rdr) == '/') && !is_eof(rdr) { str::push_char(acc, rdr.curr); bump(rdr); } if is_eof(rdr) { - rdr.fatal("unterminated block doc-comment"); + rdr.fatal(~"unterminated block doc-comment"); } else { - acc += "*/"; + acc += ~"*/"; bump(rdr); bump(rdr); ret some({ @@ -270,7 +270,7 @@ fn consume_block_comment(rdr: string_reader) let mut level: int = 1; while level > 0 { - if is_eof(rdr) { rdr.fatal("unterminated block comment"); } + if is_eof(rdr) { rdr.fatal(~"unterminated block comment"); } if rdr.curr == '/' && nextch(rdr) == '*' { bump(rdr); bump(rdr); @@ -288,9 +288,9 @@ fn consume_block_comment(rdr: string_reader) ret consume_whitespace_and_comments(rdr); } -fn scan_exponent(rdr: string_reader) -> option<str> { +fn scan_exponent(rdr: string_reader) -> option<~str> { let mut c = rdr.curr; - let mut rslt = ""; + let mut rslt = ~""; if c == 'e' || c == 'E' { str::push_char(rslt, c); bump(rdr); @@ -302,12 +302,12 @@ fn scan_exponent(rdr: string_reader) -> option<str> { let exponent = scan_digits(rdr, 10u); if str::len(exponent) > 0u { ret some(rslt + exponent); - } else { rdr.fatal("scan_exponent: bad fp literal"); } - } else { ret none::<str>; } + } else { rdr.fatal(~"scan_exponent: bad fp literal"); } + } else { ret none::<~str>; } } -fn scan_digits(rdr: string_reader, radix: uint) -> str { - let mut rslt = ""; +fn scan_digits(rdr: string_reader, radix: uint) -> ~str { + let mut rslt = ~""; loop { let c = rdr.curr; if c == '_' { bump(rdr); again; } @@ -366,7 +366,7 @@ fn scan_number(c: char, rdr: string_reader) -> token::token { else { either::right(ast::ty_u64) }; } if str::len(num_str) == 0u { - rdr.fatal("no valid digits found for number"); + rdr.fatal(~"no valid digits found for number"); } let parsed = option::get(u64::from_str_radix(num_str, base as u64)); alt tp { @@ -379,7 +379,7 @@ fn scan_number(c: char, rdr: string_reader) -> token::token { is_float = true; bump(rdr); let dec_part = scan_digits(rdr, 10u); - num_str += "." + dec_part; + num_str += ~"." + dec_part; } alt scan_exponent(rdr) { some(s) { @@ -414,7 +414,7 @@ fn scan_number(c: char, rdr: string_reader) -> token::token { ast::ty_f); } else { if str::len(num_str) == 0u { - rdr.fatal("no valid digits found for number"); + rdr.fatal(~"no valid digits found for number"); } let parsed = option::get(u64::from_str_radix(num_str, base as u64)); @@ -440,7 +440,7 @@ fn scan_numeric_escape(rdr: string_reader, n_hex_digits: uint) -> char { } fn next_token_inner(rdr: string_reader) -> token::token { - let mut accum_str = ""; + let mut accum_str = ~""; let mut c = rdr.curr; if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') @@ -455,7 +455,7 @@ fn next_token_inner(rdr: string_reader) -> token::token { bump(rdr); c = rdr.curr; } - if str::eq(accum_str, "_") { ret token::UNDERSCORE; } + if str::eq(accum_str, ~"_") { ret token::UNDERSCORE; } let is_mod_name = c == ':' && nextch(rdr) == ':'; // FIXME: perform NFKC normalization here. (Issue #2253) @@ -578,7 +578,7 @@ fn next_token_inner(rdr: string_reader) -> token::token { } } if rdr.curr != '\'' { - rdr.fatal("unterminated character constant"); + rdr.fatal(~"unterminated character constant"); } bump(rdr); // advance curr past token ret token::LIT_INT(c2 as i64, ast::ty_char); diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 784044a2df0..1c34894eb98 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -160,8 +160,8 @@ class parser { let mut restriction: restriction; let mut quote_depth: uint; // not (yet) related to the quasiquoter let reader: reader; - let keywords: hashmap<str, ()>; - let restricted_keywords: hashmap<str, ()>; + let keywords: hashmap<~str, ()>; + let restricted_keywords: hashmap<~str, ()>; new(sess: parse_sess, cfg: ast::crate_cfg, +rdr: reader, ftype: file_type) { @@ -220,29 +220,29 @@ class parser { } ret copy self.buffer[(self.buffer_start + dist - 1) & 3].tok; } - fn fatal(m: str) -> ! { + fn fatal(m: ~str) -> ! { self.sess.span_diagnostic.span_fatal(copy self.span, m) } - fn span_fatal(sp: span, m: str) -> ! { + fn span_fatal(sp: span, m: ~str) -> ! { self.sess.span_diagnostic.span_fatal(sp, m) } - fn bug(m: str) -> ! { + fn bug(m: ~str) -> ! { self.sess.span_diagnostic.span_bug(copy self.span, m) } - fn warn(m: str) { + fn warn(m: ~str) { self.sess.span_diagnostic.span_warn(copy self.span, m) } - fn get_str(i: token::str_num) -> @str/~ { + fn get_str(i: token::str_num) -> @~str { interner::get(*self.reader.interner(), i) } fn get_id() -> node_id { next_node_id(self.sess) } fn parse_ty_fn(purity: ast::purity) -> ty_ { - let proto = if self.eat_keyword("extern") { - self.expect_keyword("fn"); + let proto = if self.eat_keyword(~"extern") { + self.expect_keyword(~"fn"); ast::proto_bare } else { - self.expect_keyword("fn"); + self.expect_keyword(~"fn"); self.parse_fn_ty_proto() }; ty_fn(proto, self.parse_ty_fn_decl(purity)) @@ -259,7 +259,7 @@ class parser { let name = self.parse_value_ident(); p.bump(); name - } else { @""/~ }; + } else { @~"" }; {mode: mode, ty: p.parse_ty(false), ident: name, id: p.get_id()} @@ -317,8 +317,8 @@ class parser { vis: vis}) } - _ { p.fatal("expected `;` or `}` but found `" + - token_to_str(p.reader, p.token) + "`"); + _ { p.fatal(~"expected `;` or `}` but found `" + + token_to_str(p.reader, p.token) + ~"`"); } } } @@ -345,7 +345,7 @@ class parser { fn ident_index(args: ~[arg], i: ident) -> uint { let mut j = 0u; for args.each |a| { if a.ident == i { ret j; } j += 1u; } - self.fatal("unbound variable `" + *i + "` in constraint arg"); + self.fatal(~"unbound variable `" + *i + ~"` in constraint arg"); } fn parse_type_constr_arg() -> @ty_constr_arg { @@ -431,7 +431,7 @@ class parser { } } - fn region_from_name(s: option<@str/~>) -> @region { + fn region_from_name(s: option<@~str>) -> @region { let r = alt s { some (string) { re_named(string) } none { re_anon } @@ -538,19 +538,19 @@ class parser { let region = self.parse_region_with_sep(); let mt = self.parse_mt(); ty_rptr(region, mt) - } else if self.eat_keyword("pure") { + } else if self.eat_keyword(~"pure") { self.parse_ty_fn(ast::pure_fn) - } else if self.eat_keyword("unsafe") { + } else if self.eat_keyword(~"unsafe") { self.parse_ty_fn(ast::unsafe_fn) - } else if self.is_keyword("fn") { + } else if self.is_keyword(~"fn") { self.parse_ty_fn(ast::impure_fn) - } else if self.eat_keyword("extern") { - self.expect_keyword("fn"); + } else if self.eat_keyword(~"extern") { + self.expect_keyword(~"fn"); ty_fn(proto_bare, self.parse_ty_fn_decl(ast::impure_fn)) } else if self.token == token::MOD_SEP || is_ident(self.token) { let path = self.parse_path_with_tps(colons_before_params); ty_path(path, self.get_id()) - } else { self.fatal("expected type"); }; + } else { self.fatal(~"expected type"); }; let sp = mk_sp(lo, self.last_span.hi); ret @{id: self.get_id(), @@ -588,9 +588,9 @@ class parser { @{id: p.get_id(), is_move: is_move, name: ident, span: sp} } - if self.eat_keyword("move") { + if self.eat_keyword(~"move") { either::right(parse_capture_item(self, true)) - } else if self.eat_keyword("copy") { + } else if self.eat_keyword(~"copy") { either::right(parse_capture_item(self, false)) } else { parse_arg_fn(self) @@ -642,7 +642,7 @@ class parser { some(mac_aq(mk_sp(lo,hi), e)) } _ { - self.fatal("expected `(` or unsuffixed integer literal"); + self.fatal(~"expected `(` or unsuffixed integer literal"); } } } @@ -692,9 +692,9 @@ class parser { fn parse_lit() -> lit { let lo = self.span.lo; - let lit = if self.eat_keyword("true") { + let lit = if self.eat_keyword(~"true") { lit_bool(true) - } else if self.eat_keyword("false") { + } else if self.eat_keyword(~"false") { lit_bool(false) } else { let tok = self.token; @@ -753,7 +753,7 @@ class parser { // Hack: avoid parsing vstores like /@ and /~. This is painful // because the notation for region bounds and the notation for // vstores is... um... the same. I guess that's my fault. This - // is still not ideal as for str/& we end up parsing more than we + // is still not ideal as for &str we end up parsing more than we // ought to and have to sort it out later. if self.token == token::BINOP(token::SLASH) && self.look_ahead(1u) == token::BINOP(token::AND) { @@ -781,9 +781,9 @@ class parser { } fn parse_mutability() -> mutability { - if self.eat_keyword("mut") { + if self.eat_keyword(~"mut") { m_mutbl - } else if self.eat_keyword("const") { + } else if self.eat_keyword(~"const") { m_const } else { m_imm @@ -866,7 +866,7 @@ class parser { ret self.mk_pexpr(lo, hi, expr_tup(es)); } else if self.token == token::LBRACE { self.bump(); - if self.is_keyword("mut") || + if self.is_keyword(~"mut") || is_plain_ident(self.token) && self.look_ahead(1u) == token::COLON { let mut fields = ~[self.parse_field(token::COLON)]; @@ -874,11 +874,11 @@ class parser { while self.token != token::RBRACE { // optional comma before "with" if self.token == token::COMMA - && self.token_is_keyword("with", + && self.token_is_keyword(~"with", self.look_ahead(1u)) { self.bump(); } - if self.eat_keyword("with") { + if self.eat_keyword(~"with") { base = some(self.parse_expr()); break; } self.expect(token::COMMA); @@ -897,36 +897,38 @@ class parser { } } else if token::is_bar(self.token) { ret pexpr(self.parse_lambda_expr()); - } else if self.eat_keyword("new") { + } else if self.eat_keyword(~"new") { self.expect(token::LPAREN); let r = self.parse_expr(); self.expect(token::RPAREN); let v = self.parse_expr(); ret self.mk_pexpr(lo, self.span.hi, expr_new(r, self.get_id(), v)); - } else if self.eat_keyword("if") { + } else if self.eat_keyword(~"if") { ret pexpr(self.parse_if_expr()); - } else if self.eat_keyword("for") { - ret pexpr(self.parse_sugary_call_expr("for", expr_loop_body)); - } else if self.eat_keyword("do") { - ret pexpr(self.parse_sugary_call_expr("do", expr_do_body)); - } else if self.eat_keyword("while") { + } else if self.eat_keyword(~"for") { + ret pexpr(self.parse_sugary_call_expr(~"for", expr_loop_body)); + } else if self.eat_keyword(~"do") { + ret pexpr(self.parse_sugary_call_expr(~"do", expr_do_body)); + } else if self.eat_keyword(~"while") { ret pexpr(self.parse_while_expr()); - } else if self.eat_keyword("loop") { + } else if self.eat_keyword(~"loop") { ret pexpr(self.parse_loop_expr()); - } else if self.eat_keyword("alt") { + } else if self.eat_keyword(~"alt") { ret pexpr(self.parse_alt_expr()); - } else if self.eat_keyword("fn") { + } else if self.eat_keyword(~"fn") { let proto = self.parse_fn_ty_proto(); alt proto { - proto_bare { self.fatal("fn expr are deprecated, use fn@"); } - proto_any { self.fatal("fn* cannot be used in an expression"); } + proto_bare { self.fatal(~"fn expr are deprecated, use fn@"); } + proto_any { + self.fatal(~"fn* cannot be used in an expression"); + } _ { /* fallthrough */ } } ret pexpr(self.parse_fn_expr(proto)); - } else if self.eat_keyword("unchecked") { + } else if self.eat_keyword(~"unchecked") { ret pexpr(self.parse_block_expr(lo, unchecked_blk)); - } else if self.eat_keyword("unsafe") { + } else if self.eat_keyword(~"unsafe") { ret pexpr(self.parse_block_expr(lo, unsafe_blk)); } else if self.token == token::LBRACKET { self.bump(); @@ -958,13 +960,13 @@ class parser { let ex_ext = self.parse_syntax_ext(); hi = ex_ext.span.hi; ex = ex_ext.node; - } else if self.eat_keyword("fail") { + } else if self.eat_keyword(~"fail") { if can_begin_expr(self.token) { let e = self.parse_expr(); hi = e.span.hi; ex = expr_fail(some(e)); } else { ex = expr_fail(none); } - } else if self.eat_keyword("log") { + } else if self.eat_keyword(~"log") { self.expect(token::LPAREN); let lvl = self.parse_expr(); self.expect(token::COMMA); @@ -972,18 +974,18 @@ class parser { ex = expr_log(2, lvl, e); hi = self.span.hi; self.expect(token::RPAREN); - } else if self.eat_keyword("assert") { + } else if self.eat_keyword(~"assert") { let e = self.parse_expr(); ex = expr_assert(e); hi = e.span.hi; - } else if self.eat_keyword("check") { + } else if self.eat_keyword(~"check") { /* Should be a predicate (pure boolean function) applied to arguments that are all either slot variables or literals. but the typechecker enforces that. */ let e = self.parse_expr(); hi = e.span.hi; ex = expr_check(checked_expr, e); - } else if self.eat_keyword("claim") { + } else if self.eat_keyword(~"claim") { /* Same rules as check, except that if check-claims is enabled (a command-line flag), then the parser turns claims into check */ @@ -991,25 +993,25 @@ class parser { let e = self.parse_expr(); hi = e.span.hi; ex = expr_check(claimed_expr, e); - } else if self.eat_keyword("ret") { + } else if self.eat_keyword(~"ret") { if can_begin_expr(self.token) { let e = self.parse_expr(); hi = e.span.hi; ex = expr_ret(some(e)); } else { ex = expr_ret(none); } - } else if self.eat_keyword("break") { + } else if self.eat_keyword(~"break") { ex = expr_break; hi = self.span.hi; - } else if self.eat_keyword("again") { + } else if self.eat_keyword(~"again") { ex = expr_again; hi = self.span.hi; - } else if self.eat_keyword("copy") { + } else if self.eat_keyword(~"copy") { let e = self.parse_expr(); ex = expr_copy(e); hi = e.span.hi; } else if self.token == token::MOD_SEP || - is_ident(self.token) && !self.is_keyword("true") && - !self.is_keyword("false") { + is_ident(self.token) && !self.is_keyword(~"true") && + !self.is_keyword(~"false") { let pth = self.parse_path_with_tps(true); /* `!`, as an operator, is prefix, so we know this isn't that */ @@ -1065,7 +1067,7 @@ class parser { fn parse_syntax_ext_naked(lo: uint) -> @expr { alt self.token { token::IDENT(_, _) {} - _ { self.fatal("expected a syntax expander name"); } + _ { self.fatal(~"expected a syntax expander name"); } } let pth = self.parse_path_without_tps(); //temporary for a backwards-compatible cycle: @@ -1093,7 +1095,7 @@ class parser { alt (self.token) { token::LBRACE {depth += 1u;} token::RBRACE {depth -= 1u;} - token::EOF {self.fatal("unexpected EOF in macro body");} + token::EOF {self.fatal(~"unexpected EOF in macro body");} _ {} } self.bump(); @@ -1181,7 +1183,7 @@ class parser { self.bump(); ret (some(sep), zerok); } else { - self.fatal("expected `*` or `+`"); + self.fatal(~"expected `*` or `+`"); } } } @@ -1201,11 +1203,11 @@ class parser { alt p.token { token::RPAREN | token::RBRACE | token::RBRACKET if !delim_ok { - p.fatal("incorrect close delimiter: `" - + token_to_str(p.reader, p.token) + "`"); + p.fatal(~"incorrect close delimiter: `" + + token_to_str(p.reader, p.token) + ~"`"); } token::EOF { - p.fatal("file ended in the middle of a macro invocation"); + p.fatal(~"file ended in the middle of a macro invocation"); } /* we ought to allow different depths of unquotation */ token::DOLLAR if p.quote_depth > 0u { @@ -1280,7 +1282,7 @@ class parser { let ms = self.parse_matcher_subseq(name_idx, token::LPAREN, token::RPAREN); if ms.len() == 0u { - self.fatal("repetition body must be nonempty"); + self.fatal(~"repetition body must be nonempty"); } let (sep, zerok) = self.parse_sep_and_zerok(); mtc_rep(ms, sep, zerok) @@ -1411,7 +1413,7 @@ class parser { } _ {} } - if as_prec > min_prec && self.eat_keyword("as") { + if as_prec > min_prec && self.eat_keyword(~"as") { let rhs = self.parse_ty(true); let _as = self.mk_pexpr(lhs.span.lo, rhs.span.hi, expr_cast(lhs, rhs)); @@ -1474,7 +1476,7 @@ class parser { let thn = self.parse_block(); let mut els: option<@expr> = none; let mut hi = thn.span.hi; - if self.eat_keyword("else") { + if self.eat_keyword(~"else") { let elexpr = self.parse_else_expr(); els = some(elexpr); hi = elexpr.span.hi; @@ -1483,7 +1485,7 @@ class parser { } fn parse_if_expr() -> @expr { - if self.eat_keyword("check") { + if self.eat_keyword(~"check") { let q = self.parse_if_expr_1(); ret self.mk_expr(q.lo, q.hi, expr_if_check(q.cond, q.then, q.els)); @@ -1560,7 +1562,7 @@ class parser { } fn parse_else_expr() -> @expr { - if self.eat_keyword("if") { + if self.eat_keyword(~"if") { ret self.parse_if_expr(); } else { let blk = self.parse_block(); @@ -1568,7 +1570,7 @@ class parser { } } - fn parse_sugary_call_expr(keyword: str, + fn parse_sugary_call_expr(keyword: ~str, ctor: fn(+@expr) -> expr_) -> @expr { let lo = self.last_span; // Parse the callee `foo` in @@ -1625,7 +1627,7 @@ class parser { fn parse_alt_expr() -> @expr { let lo = self.last_span.lo; - let mode = if self.eat_keyword("check") { alt_check } + let mode = if self.eat_keyword(~"check") { alt_check } else { alt_exhaustive }; let discriminant = self.parse_expr(); self.expect(token::LBRACE); @@ -1633,7 +1635,7 @@ class parser { while self.token != token::RBRACE { let pats = self.parse_pats(); let mut guard = none; - if self.eat_keyword("if") { guard = some(self.parse_expr()); } + if self.eat_keyword(~"if") { guard = some(self.parse_expr()); } if self.token == token::FAT_ARROW { self.bump(); } let blk = self.parse_block(); vec::push(arms, {pats: pats, guard: guard, body: blk}); @@ -1736,9 +1738,9 @@ class parser { if self.token == token::UNDERSCORE { self.bump(); if self.token != token::RBRACE { - self.fatal("expected `}`, found `" + + self.fatal(~"expected `}`, found `" + token_to_str(self.reader, self.token) + - "`"); + ~"`"); } etc = true; break; @@ -1789,10 +1791,10 @@ class parser { } } tok { - if !is_ident(tok) || self.is_keyword("true") - || self.is_keyword("false") { + if !is_ident(tok) || self.is_keyword(~"true") + || self.is_keyword(~"false") { let val = self.parse_expr_res(RESTRICT_NO_BAR_OP); - if self.eat_keyword("to") { + if self.eat_keyword(~"to") { let end = self.parse_expr_res(RESTRICT_NO_BAR_OP); hi = end.span.hi; pat = pat_range(val, end); @@ -1866,7 +1868,7 @@ class parser { } fn parse_let() -> @decl { - let is_mutbl = self.eat_keyword("mut"); + let is_mutbl = self.eat_keyword(~"mut"); let lo = self.span.lo; let mut locals = ~[self.parse_local(is_mutbl, true)]; while self.eat(token::COMMA) { @@ -1879,11 +1881,11 @@ class parser { fn parse_instance_var(pr: visibility) -> @class_member { let mut is_mutbl = class_immutable; let lo = self.span.lo; - if self.eat_keyword("mut") { + if self.eat_keyword(~"mut") { is_mutbl = class_mutable; } if !is_plain_ident(self.token) { - self.fatal("expected ident"); + self.fatal(~"expected ident"); } let name = self.parse_ident(); self.expect(token::COLON); @@ -1896,14 +1898,14 @@ class parser { fn check_expected_item(p: parser, current_attrs: ~[attribute]) { // If we have attributes then we should have an item if vec::is_not_empty(current_attrs) { - p.fatal("expected item"); + p.fatal(~"expected item"); } } let lo = self.span.lo; - if self.is_keyword("let") { + if self.is_keyword(~"let") { check_expected_item(self, first_item_attrs); - self.expect_keyword("let"); + self.expect_keyword(~"let"); let decl = self.parse_let(); ret @spanned(lo, decl.span.hi, stmt_decl(decl, self.get_id())); } else { @@ -1936,7 +1938,7 @@ class parser { } fn expr_is_complete(e: pexpr) -> bool { - log(debug, ("expr_is_complete", self.restriction, + log(debug, (~"expr_is_complete", self.restriction, print::pprust::expr_to_str(*e), classify::expr_requires_semi_to_be_stmt(*e))); ret self.restriction == RESTRICT_STMT_EXPR && @@ -1962,12 +1964,12 @@ class parser { } let lo = self.span.lo; - if self.eat_keyword("unchecked") { + if self.eat_keyword(~"unchecked") { self.expect(token::LBRACE); let {inner, next} = maybe_parse_inner_attrs_and_next(self, parse_attrs); ret (inner, self.parse_block_tail_(lo, unchecked_blk, next)); - } else if self.eat_keyword("unsafe") { + } else if self.eat_keyword(~"unsafe") { self.expect(token::LBRACE); let {inner, next} = maybe_parse_inner_attrs_and_next(self, parse_attrs); @@ -2004,7 +2006,7 @@ class parser { let mut initial_attrs = attrs_remaining; if self.token == token::RBRACE && !vec::is_empty(initial_attrs) { - self.fatal("expected item"); + self.fatal(~"expected item"); } while self.token != token::RBRACE { @@ -2028,9 +2030,9 @@ class parser { } t { if classify::stmt_ends_with_semi(*stmt) { - self.fatal("expected `;` or `}` after expression \ - but found `" - + token_to_str(self.reader, t) + "`"); + self.fatal(~"expected `;` or `}` after \ + expression but found `" + + token_to_str(self.reader, t) + ~"`"); } vec::push(stmts, stmt); } @@ -2060,9 +2062,9 @@ class parser { let ident = self.parse_ident(); if self.eat(token::COLON) { while self.token != token::COMMA && self.token != token::GT { - if self.eat_keyword("send") { push(bounds, bound_send); } - else if self.eat_keyword("copy") { push(bounds, bound_copy) } - else if self.eat_keyword("const") { + if self.eat_keyword(~"send") { push(bounds, bound_send); } + else if self.eat_keyword(~"copy") { push(bounds, bound_copy) } + else if self.eat_keyword(~"const") { push(bounds, bound_const) } else { push(bounds, bound_trait(self.parse_ty(false))); } @@ -2156,16 +2158,16 @@ class parser { fn parse_method_name() -> ident { alt copy self.token { token::BINOP(op) { self.bump(); @token::binop_to_str(op) } - token::NOT { self.bump(); @"!"/~ } + token::NOT { self.bump(); @~"!" } token::LBRACKET { self.bump(); self.expect(token::RBRACKET); - @"[]"/~ + @~"[]" } _ { let id = self.parse_value_ident(); - if id == @"unary"/~ && self.eat(token::BINOP(token::MINUS)) { - @"unary-"/~ + if id == @~"unary" && self.eat(token::BINOP(token::MINUS)) { + @~"unary-" } else { id } } @@ -2208,7 +2210,7 @@ class parser { self.parse_region_param(); (none, self.parse_ty_params()) } - else if self.is_keyword("of") { + else if self.is_keyword(~"of") { (none, ~[]) } else { let id = self.parse_ident(); @@ -2216,7 +2218,7 @@ class parser { (some(id), self.parse_ty_params()) } }; - let ifce = if self.eat_keyword("of") { + let ifce = if self.eat_keyword(~"of") { let path = self.parse_path_with_tps(false); if option::is_none(ident) { ident = some(vec::last(path.idents)); @@ -2225,9 +2227,9 @@ class parser { } else { none }; let ident = alt ident { some(name) { name } - none { self.expect_keyword("of"); fail; } + none { self.expect_keyword(~"of"); fail; } }; - self.expect_keyword("for"); + self.expect_keyword(~"for"); let ty = self.parse_ty(false); let mut meths = ~[]; self.expect(token::LBRACE); @@ -2310,14 +2312,14 @@ class parser { Is it strange for the parser to check this? */ none { - self.fatal("class with no constructor"); + self.fatal(~"class with no constructor"); } } } fn parse_single_class_item(vis: visibility) -> @class_member { - if self.eat_keyword("let") { + if self.eat_keyword(~"let") { let a_var = self.parse_instance_var(vis); self.expect(token::SEMI); ret a_var; @@ -2348,15 +2350,15 @@ class parser { fn parse_class_item(class_name_with_tps: @path) -> class_contents { - if self.eat_keyword("new") { + if self.eat_keyword(~"new") { // result type is always the type of the class ret self.parse_ctor(ty_path(class_name_with_tps, self.get_id())); } - else if self.eat_keyword("drop") { + else if self.eat_keyword(~"drop") { ret self.parse_dtor(); } - else if self.eat_keyword("priv") { + else if self.eat_keyword(~"priv") { self.expect(token::LBRACE); let mut results = ~[]; while self.token != token::RBRACE { @@ -2372,8 +2374,8 @@ class parser { } fn parse_visibility(def: visibility) -> visibility { - if self.eat_keyword("pub") { public } - else if self.eat_keyword("priv") { private } + if self.eat_keyword(~"pub") { public } + else if self.eat_keyword(~"priv") { private } else { def } } @@ -2395,8 +2397,8 @@ class parser { alt self.parse_item(attrs, vis) { some(i) { vec::push(items, i); } _ { - self.fatal("expected item but found `" + - token_to_str(self.reader, self.token) + "`"); + self.fatal(~"expected item but found `" + + token_to_str(self.reader, self.token) + ~"`"); } } #debug["parse_mod_items: attrs=%?", attrs]; @@ -2404,7 +2406,7 @@ class parser { if first && attrs_remaining.len() > 0u { // We parsed attributes for the first item but didn't find it - self.fatal("expected item"); + self.fatal(~"expected item"); } ret {view_items: view_items, items: items}; @@ -2444,12 +2446,12 @@ class parser { } fn parse_fn_purity() -> purity { - if self.eat_keyword("fn") { impure_fn } - else if self.eat_keyword("pure") { - self.expect_keyword("fn"); + if self.eat_keyword(~"fn") { impure_fn } + else if self.eat_keyword(~"pure") { + self.expect_keyword(~"fn"); pure_fn - } else if self.eat_keyword("unsafe") { - self.expect_keyword("fn"); + } else if self.eat_keyword(~"unsafe") { + self.expect_keyword(~"fn"); unsafe_fn } else { self.unexpected(); } @@ -2478,7 +2480,7 @@ class parser { } fn parse_item_foreign_mod() -> item_info { - self.expect_keyword("mod"); + self.expect_keyword(~"mod"); let id = self.parse_ident(); self.expect(token::LBRACE); let more_attrs = self.parse_inner_attrs_and_next(); @@ -2563,7 +2565,7 @@ class parser { } self.expect(token::RBRACE); if (have_disr && !all_nullary) { - self.fatal("discriminator values can only be used with a c-like \ + self.fatal(~"discriminator values can only be used with a c-like \ enum"); } (id, item_enum(variants, ty_params), none) @@ -2603,39 +2605,39 @@ class parser { fn parse_item(+attrs: ~[attribute], vis: visibility) -> option<@item> { let lo = self.span.lo; - let (ident, item_, extra_attrs) = if self.eat_keyword("const") { + let (ident, item_, extra_attrs) = if self.eat_keyword(~"const") { self.parse_item_const() - } else if self.is_keyword("fn") && + } else if self.is_keyword(~"fn") && !self.fn_expr_lookahead(self.look_ahead(1u)) { self.bump(); self.parse_item_fn(impure_fn) - } else if self.eat_keyword("pure") { - self.expect_keyword("fn"); + } else if self.eat_keyword(~"pure") { + self.expect_keyword(~"fn"); self.parse_item_fn(pure_fn) - } else if self.is_keyword("unsafe") + } else if self.is_keyword(~"unsafe") && self.look_ahead(1u) != token::LBRACE { self.bump(); - self.expect_keyword("fn"); + self.expect_keyword(~"fn"); self.parse_item_fn(unsafe_fn) - } else if self.eat_keyword("extern") { - if self.eat_keyword("fn") { + } else if self.eat_keyword(~"extern") { + if self.eat_keyword(~"fn") { self.parse_item_fn(extern_fn) } else { self.parse_item_foreign_mod() } - } else if self.eat_keyword("mod") { + } else if self.eat_keyword(~"mod") { self.parse_item_mod() - } else if self.eat_keyword("type") { + } else if self.eat_keyword(~"type") { self.parse_item_type() - } else if self.eat_keyword("enum") { + } else if self.eat_keyword(~"enum") { self.parse_item_enum(vis) - } else if self.eat_keyword("iface") { + } else if self.eat_keyword(~"iface") { self.parse_item_trait() - } else if self.eat_keyword("trait") { + } else if self.eat_keyword(~"trait") { self.parse_item_trait() - } else if self.eat_keyword("impl") { + } else if self.eat_keyword(~"impl") { self.parse_item_impl() - } else if self.eat_keyword("class") { + } else if self.eat_keyword(~"class") { self.parse_item_class() } else if !self.is_any_keyword(copy self.token) && self.look_ahead(1) == token::NOT @@ -2747,21 +2749,21 @@ class parser { } fn is_view_item() -> bool { - let tok = if !self.is_keyword("pub") && !self.is_keyword("priv") { + let tok = if !self.is_keyword(~"pub") && !self.is_keyword(~"priv") { self.token } else { self.look_ahead(1u) }; - self.token_is_keyword("use", tok) - || self.token_is_keyword("import", tok) - || self.token_is_keyword("export", tok) + self.token_is_keyword(~"use", tok) + || self.token_is_keyword(~"import", tok) + || self.token_is_keyword(~"export", tok) } fn parse_view_item(+attrs: ~[attribute]) -> @view_item { let lo = self.span.lo, vis = self.parse_visibility(private); - let node = if self.eat_keyword("use") { + let node = if self.eat_keyword(~"use") { self.parse_use() - } else if self.eat_keyword("import") { + } else if self.eat_keyword(~"import") { view_item_import(self.parse_view_paths()) - } else if self.eat_keyword("export") { + } else if self.eat_keyword(~"export") { view_item_export(self.parse_view_paths()) } else { fail; }; self.expect(token::SEMI); @@ -2775,7 +2777,7 @@ class parser { let mut attrs = vec::append(first_item_attrs, self.parse_outer_attributes()); let mut items = ~[]; - while if only_imports { self.is_keyword("import") } + while if only_imports { self.is_keyword(~"import") } else { self.is_view_item() } { vec::push(items, self.parse_view_item(attrs)); attrs = self.parse_outer_attributes(); @@ -2796,11 +2798,11 @@ class parser { config: self.cfg}); } - fn parse_str() -> @str/~ { + fn parse_str() -> @~str { alt copy self.token { token::LIT_STR(s) { self.bump(); self.get_str(s) } _ { - self.fatal("expected string literal") + self.fatal(~"expected string literal") } } } @@ -2821,8 +2823,8 @@ class parser { let expect_mod = vec::len(outer_attrs) > 0u; let lo = self.span.lo; - if expect_mod || self.is_keyword("mod") { - self.expect_keyword("mod"); + if expect_mod || self.is_keyword(~"mod") { + self.expect_keyword(~"mod"); let id = self.parse_ident(); alt self.token { // mod x = "foo.rs"; @@ -2849,7 +2851,7 @@ class parser { } else if self.is_view_item() { let vi = self.parse_view_item(outer_attrs); ret spanned(lo, vi.span.hi, cdir_view_item(vi)); - } else { ret self.fatal("expected crate directive"); } + } else { ret self.fatal(~"expected crate directive"); } } fn parse_crate_directives(term: token::token, @@ -2860,7 +2862,7 @@ class parser { // accept seeing the terminator next, so if we do see it then fail the // same way parse_crate_directive would if vec::len(first_outer_attr) > 0u && self.token == term { - self.expect_keyword("mod"); + self.expect_keyword(~"mod"); } let mut cdirs: ~[@crate_directive] = ~[]; diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index 2c7b14cfe11..7db5af23266 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -100,61 +100,61 @@ enum whole_nt { w_mtcs(~[ast::matcher]) } -fn binop_to_str(o: binop) -> str { +fn binop_to_str(o: binop) -> ~str { alt o { - PLUS { "+" } - MINUS { "-" } - STAR { "*" } - SLASH { "/" } - PERCENT { "%" } - CARET { "^" } - AND { "&" } - OR { "|" } - SHL { "<<" } - SHR { ">>" } + PLUS { ~"+" } + MINUS { ~"-" } + STAR { ~"*" } + SLASH { ~"/" } + PERCENT { ~"%" } + CARET { ~"^" } + AND { ~"&" } + OR { ~"|" } + SHL { ~"<<" } + SHR { ~">>" } } } -fn to_str(in: interner<@str/~>, t: token) -> str { +fn to_str(in: interner<@~str>, t: token) -> ~str { alt t { - EQ { "=" } - LT { "<" } - LE { "<=" } - EQEQ { "==" } - NE { "!=" } - GE { ">=" } - GT { ">" } - NOT { "!" } - TILDE { "~" } - OROR { "||" } - ANDAND { "&&" } + EQ { ~"=" } + LT { ~"<" } + LE { ~"<=" } + EQEQ { ~"==" } + NE { ~"!=" } + GE { ~">=" } + GT { ~">" } + NOT { ~"!" } + TILDE { ~"~" } + OROR { ~"||" } + ANDAND { ~"&&" } BINOP(op) { binop_to_str(op) } - BINOPEQ(op) { binop_to_str(op) + "=" } + BINOPEQ(op) { binop_to_str(op) + ~"=" } /* Structural symbols */ - AT { "@" } - DOT { "." } - ELLIPSIS { "..." } - COMMA { "," } - SEMI { "" } - COLON { ":" } - MOD_SEP { "::" } - RARROW { "->" } - LARROW { "<-" } - DARROW { "<->" } - FAT_ARROW { "=>" } - LPAREN { "(" } - RPAREN { ")" } - LBRACKET { "[" } - RBRACKET { "]" } - LBRACE { "{" } - RBRACE { "}" } - POUND { "#" } - DOLLAR { "$" } + AT { ~"@" } + DOT { ~"." } + ELLIPSIS { ~"..." } + COMMA { ~"," } + SEMI { ~"" } + COLON { ~":" } + MOD_SEP { ~"::" } + RARROW { ~"->" } + LARROW { ~"<-" } + DARROW { ~"<->" } + FAT_ARROW { ~"=>" } + LPAREN { ~"(" } + RPAREN { ~")" } + LBRACKET { ~"[" } + RBRACKET { ~"]" } + LBRACE { ~"{" } + RBRACE { ~"}" } + POUND { ~"#" } + DOLLAR { ~"$" } /* Literals */ LIT_INT(c, ast::ty_char) { - "'" + char::escape_default(c as char) + "'" + ~"'" + char::escape_default(c as char) + ~"'" } LIT_INT(i, t) { int::to_str(i as int, 10u) + ast_util::int_ty_to_str(t) @@ -170,28 +170,28 @@ fn to_str(in: interner<@str/~>, t: token) -> str { ast_util::float_ty_to_str(t) } LIT_STR(s) { - "\"" + ~"\"" + str::escape_default(*interner::get(in, s)) - + "\"" + + ~"\"" } /* Name components */ IDENT(s, _) { *interner::get(in, s) } - UNDERSCORE { "_" } + UNDERSCORE { ~"_" } /* Other */ DOC_COMMENT(s) { *interner::get(in, s) } - EOF { "<eof>" } + EOF { ~"<eof>" } ACTUALLY(w_nt) { - "an interpolated " + + ~"an interpolated " + alt w_nt { - w_item(*) { "item" } w_block(*) { "block" } - w_stmt(*) { "statement" } w_pat(*) { "pattern" } - w_expr(*) { "expression" } w_ty(*) { "type" } - w_ident(*) { "identifier" } w_path(*) { "path" } - w_tt(*) { "tt" } w_mtcs(*) { "matcher sequence" } + w_item(*) { ~"item" } w_block(*) { ~"block" } + w_stmt(*) { ~"statement" } w_pat(*) { ~"pattern" } + w_expr(*) { ~"expression" } w_ty(*) { ~"type" } + w_ident(*) { ~"identifier" } w_path(*) { ~"path" } + w_tt(*) { ~"tt" } w_mtcs(*) { ~"matcher sequence" } } } } @@ -256,7 +256,7 @@ pure fn is_bar(t: token) -> bool { * the grammar is unambiguous. Restricted keywords may not appear * in positions that might otherwise contain _value identifiers_. */ -fn keyword_table() -> hashmap<str, ()> { +fn keyword_table() -> hashmap<~str, ()> { let keywords = str_hash(); for contextual_keyword_table().each_key |word| { keywords.insert(word, ()); @@ -268,18 +268,18 @@ fn keyword_table() -> hashmap<str, ()> { } /// Keywords that may be used as identifiers -fn contextual_keyword_table() -> hashmap<str, ()> { +fn contextual_keyword_table() -> hashmap<~str, ()> { let words = str_hash(); let keys = ~[ - "as", - "else", - "move", - "of", - "priv", "pub", - "self", "send", "static", - "to", - "use", - "with" + ~"as", + ~"else", + ~"move", + ~"of", + ~"priv", ~"pub", + ~"self", ~"send", ~"static", + ~"to", + ~"use", + ~"with" ]; for keys.each |word| { words.insert(word, ()); @@ -301,23 +301,23 @@ fn contextual_keyword_table() -> hashmap<str, ()> { * * `true` or `false` as identifiers would always be shadowed by * the boolean constants */ -fn restricted_keyword_table() -> hashmap<str, ()> { +fn restricted_keyword_table() -> hashmap<~str, ()> { let words = str_hash(); let keys = ~[ - "alt", "again", "assert", - "break", - "check", "claim", "class", "const", "copy", - "do", "drop", - "else", "enum", "export", "extern", - "fail", "false", "fn", "for", - "if", "iface", "impl", "import", - "let", "log", "loop", - "mod", "mut", - "new", - "pure", "ret", - "true", "trait", "type", - "unchecked", "unsafe", - "while" + ~"alt", ~"again", ~"assert", + ~"break", + ~"check", ~"claim", ~"class", ~"const", ~"copy", + ~"do", ~"drop", + ~"else", ~"enum", ~"export", ~"extern", + ~"fail", ~"false", ~"fn", ~"for", + ~"if", ~"iface", ~"impl", ~"import", + ~"let", ~"log", ~"loop", + ~"mod", ~"mut", + ~"new", + ~"pure", ~"ret", + ~"true", ~"trait", ~"type", + ~"unchecked", ~"unsafe", + ~"while" ]; for keys.each |word| { words.insert(word, ()); diff --git a/src/libsyntax/print/pp.rs b/src/libsyntax/print/pp.rs index 09754d27e67..1a318d53635 100644 --- a/src/libsyntax/print/pp.rs +++ b/src/libsyntax/print/pp.rs @@ -59,33 +59,33 @@ type break_t = {offset: int, blank_space: int}; type begin_t = {offset: int, breaks: breaks}; -enum token { STRING(@str/~, int), BREAK(break_t), BEGIN(begin_t), END, EOF, } +enum token { STRING(@~str, int), BREAK(break_t), BEGIN(begin_t), END, EOF, } -fn tok_str(++t: token) -> str { +fn tok_str(++t: token) -> ~str { alt t { STRING(s, len) { ret #fmt["STR(%s,%d)", *s, len]; } - BREAK(_) { ret "BREAK"; } - BEGIN(_) { ret "BEGIN"; } - END { ret "END"; } - EOF { ret "EOF"; } + BREAK(_) { ret ~"BREAK"; } + BEGIN(_) { ret ~"BEGIN"; } + END { ret ~"END"; } + EOF { ret ~"EOF"; } } } fn buf_str(toks: ~[mut token], szs: ~[mut int], left: uint, right: uint, - lim: uint) -> str { + lim: uint) -> ~str { let n = vec::len(toks); assert (n == vec::len(szs)); let mut i = left; let mut L = lim; - let mut s = "["; + let mut s = ~"["; while i != right && L != 0u { L -= 1u; - if i != left { s += ", "; } + if i != left { s += ~", "; } s += #fmt["%d=%s", szs[i], tok_str(toks[i])]; i += 1u; i %= n; } - s += "]"; + s += ~"]"; ret s; } @@ -389,7 +389,7 @@ impl printer for printer { } fn print_newline(amount: int) { #debug("NEWLINE %d", amount); - self.out.write_str("\n"); + self.out.write_str(~"\n"); self.pending_indentation = 0; self.indent(amount); } @@ -405,9 +405,9 @@ impl printer for printer { {offset: 0, pbreak: broken(inconsistent)} } } - fn write_str(s: str) { + fn write_str(s: ~str) { while self.pending_indentation > 0 { - self.out.write_str(" "); + self.out.write_str(~" "); self.pending_indentation -= 1; } self.out.write_str(s); @@ -492,15 +492,15 @@ fn end(p: printer) { p.pretty_print(END); } fn eof(p: printer) { p.pretty_print(EOF); } -fn word(p: printer, wrd: str) { +fn word(p: printer, wrd: ~str) { p.pretty_print(STRING(@wrd, str::len(wrd) as int)); } -fn huge_word(p: printer, wrd: str) { +fn huge_word(p: printer, wrd: ~str) { p.pretty_print(STRING(@wrd, size_infinity)); } -fn zero_word(p: printer, wrd: str) { p.pretty_print(STRING(@wrd, 0)); } +fn zero_word(p: printer, wrd: ~str) { p.pretty_print(STRING(@wrd, 0)); } fn spaces(p: printer, n: uint) { break_offset(p, n, 0); } diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index c0cbf78c5cf..29da51ec083 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -64,7 +64,7 @@ const default_columns: uint = 78u; // it can scan the input text for comments and literals to // copy forward. fn print_crate(cm: codemap, span_diagnostic: diagnostic::span_handler, - crate: @ast::crate, filename: str, in: io::reader, + crate: @ast::crate, filename: ~str, in: io::reader, out: io::writer, ann: pp_ann, is_expanded: bool) { let r = comments::gather_comments_and_literals(span_diagnostic, filename, in); @@ -89,28 +89,28 @@ fn print_crate_(s: ps, &&crate: @ast::crate) { eof(s.s); } -fn ty_to_str(ty: @ast::ty) -> str { ret to_str(ty, print_type); } +fn ty_to_str(ty: @ast::ty) -> ~str { ret to_str(ty, print_type); } -fn pat_to_str(pat: @ast::pat) -> str { ret to_str(pat, print_pat); } +fn pat_to_str(pat: @ast::pat) -> ~str { ret to_str(pat, print_pat); } -fn expr_to_str(e: @ast::expr) -> str { ret to_str(e, print_expr); } +fn expr_to_str(e: @ast::expr) -> ~str { ret to_str(e, print_expr); } -fn stmt_to_str(s: ast::stmt) -> str { ret to_str(s, print_stmt); } +fn stmt_to_str(s: ast::stmt) -> ~str { ret to_str(s, print_stmt); } -fn item_to_str(i: @ast::item) -> str { ret to_str(i, print_item); } +fn item_to_str(i: @ast::item) -> ~str { ret to_str(i, print_item); } -fn attr_to_str(i: ast::attribute) -> str { ret to_str(i, print_attribute); } +fn attr_to_str(i: ast::attribute) -> ~str { ret to_str(i, print_attribute); } -fn typarams_to_str(tps: ~[ast::ty_param]) -> str { +fn typarams_to_str(tps: ~[ast::ty_param]) -> ~str { ret to_str(tps, print_type_params) } -fn path_to_str(&&p: @ast::path) -> str { +fn path_to_str(&&p: @ast::path) -> ~str { ret to_str(p, |a,b| print_path(a, b, false)); } fn fun_to_str(decl: ast::fn_decl, name: ast::ident, - params: ~[ast::ty_param]) -> str { + params: ~[ast::ty_param]) -> ~str { let buffer = io::mem_buffer(); let s = rust_printer(io::mem_buffer_writer(buffer)); print_fn(s, decl, name, params); @@ -134,7 +134,7 @@ fn test_fun_to_str() { assert fun_to_str(decl, "a", ~[]) == "fn a()"; } -fn block_to_str(blk: ast::blk) -> str { +fn block_to_str(blk: ast::blk) -> ~str { let buffer = io::mem_buffer(); let s = rust_printer(io::mem_buffer_writer(buffer)); // containing cbox, will be closed by print-block at } @@ -146,15 +146,15 @@ fn block_to_str(blk: ast::blk) -> str { io::mem_buffer_str(buffer) } -fn meta_item_to_str(mi: ast::meta_item) -> str { +fn meta_item_to_str(mi: ast::meta_item) -> ~str { ret to_str(@mi, print_meta_item); } -fn attribute_to_str(attr: ast::attribute) -> str { +fn attribute_to_str(attr: ast::attribute) -> ~str { ret to_str(attr, print_attribute); } -fn variant_to_str(var: ast::variant) -> str { +fn variant_to_str(var: ast::variant) -> ~str { ret to_str(var, print_variant); } @@ -182,17 +182,17 @@ fn box(s: ps, u: uint, b: pp::breaks) { pp::box(s.s, u, b); } -fn nbsp(s: ps) { word(s.s, " "); } +fn nbsp(s: ps) { word(s.s, ~" "); } -fn word_nbsp(s: ps, w: str) { word(s.s, w); nbsp(s); } +fn word_nbsp(s: ps, w: ~str) { word(s.s, w); nbsp(s); } -fn word_space(s: ps, w: str) { word(s.s, w); space(s.s); } +fn word_space(s: ps, w: ~str) { word(s.s, w); space(s.s); } -fn popen(s: ps) { word(s.s, "("); } +fn popen(s: ps) { word(s.s, ~"("); } -fn pclose(s: ps) { word(s.s, ")"); } +fn pclose(s: ps) { word(s.s, ~")"); } -fn head(s: ps, w: str) { +fn head(s: ps, w: ~str) { // outer-box is consistent cbox(s, indent_unit); // head-box is inconsistent @@ -202,14 +202,14 @@ fn head(s: ps, w: str) { } fn bopen(s: ps) { - word(s.s, "{"); + word(s.s, ~"{"); end(s); // close the head-box } fn bclose_(s: ps, span: codemap::span, indented: uint) { maybe_print_comment(s, span.hi); break_offset_if_not_bol(s, 1u, -(indented as int)); - word(s.s, "}"); + word(s.s, ~"}"); end(s); // close the outer-box } fn bclose(s: ps, span: codemap::span) { bclose_(s, span, indent_unit); } @@ -250,19 +250,19 @@ fn break_offset_if_not_bol(s: ps, n: uint, off: int) { // Synthesizes a comment that was not textually present in the original source // file. -fn synth_comment(s: ps, text: str) { - word(s.s, "/*"); +fn synth_comment(s: ps, text: ~str) { + word(s.s, ~"/*"); space(s.s); word(s.s, text); space(s.s); - word(s.s, "*/"); + word(s.s, ~"*/"); } fn commasep<IN>(s: ps, b: breaks, elts: ~[IN], op: fn(ps, IN)) { box(s, 0u, b); let mut first = true; for elts.each |elt| { - if first { first = false; } else { word_space(s, ","); } + if first { first = false; } else { word_space(s, ~","); } op(s, elt); } end(s); @@ -279,7 +279,7 @@ fn commasep_cmnt<IN>(s: ps, b: breaks, elts: ~[IN], op: fn(ps, IN), op(s, elt); i += 1u; if i < len { - word(s.s, ","); + word(s.s, ~","); maybe_print_trailing_comment(s, get_span(elt), some(get_span(elts[i]).hi)); space_if_not_bol(s); @@ -312,9 +312,9 @@ fn print_foreign_mod(s: ps, nmod: ast::foreign_mod, fn print_region(s: ps, region: @ast::region) { alt region.node { - ast::re_anon { word_space(s, "&"); } + ast::re_anon { word_space(s, ~"&"); } ast::re_named(name) { - word(s.s, "&"); + word(s.s, ~"&"); word(s.s, *name); } } @@ -328,41 +328,41 @@ fn print_type_ex(s: ps, &&ty: @ast::ty, print_colons: bool) { maybe_print_comment(s, ty.span.lo); ibox(s, 0u); alt ty.node { - ast::ty_nil { word(s.s, "()"); } - ast::ty_bot { word(s.s, "!"); } - ast::ty_box(mt) { word(s.s, "@"); print_mt(s, mt); } - ast::ty_uniq(mt) { word(s.s, "~"); print_mt(s, mt); } + ast::ty_nil { word(s.s, ~"()"); } + ast::ty_bot { word(s.s, ~"!"); } + ast::ty_box(mt) { word(s.s, ~"@"); print_mt(s, mt); } + ast::ty_uniq(mt) { word(s.s, ~"~"); print_mt(s, mt); } ast::ty_vec(mt) { - word(s.s, "["); + word(s.s, ~"["); alt mt.mutbl { - ast::m_mutbl { word_space(s, "mut"); } - ast::m_const { word_space(s, "const"); } + ast::m_mutbl { word_space(s, ~"mut"); } + ast::m_const { word_space(s, ~"const"); } ast::m_imm { } } print_type(s, mt.ty); - word(s.s, "]"); + word(s.s, ~"]"); } - ast::ty_ptr(mt) { word(s.s, "*"); print_mt(s, mt); } + ast::ty_ptr(mt) { word(s.s, ~"*"); print_mt(s, mt); } ast::ty_rptr(region, mt) { alt region.node { - ast::re_anon { word(s.s, "&"); } - _ { print_region(s, region); word(s.s, "."); } + ast::re_anon { word(s.s, ~"&"); } + _ { print_region(s, region); word(s.s, ~"."); } } print_mt(s, mt); } ast::ty_rec(fields) { - word(s.s, "{"); + word(s.s, ~"{"); fn print_field(s: ps, f: ast::ty_field) { cbox(s, indent_unit); print_mutability(s, f.node.mt.mutbl); word(s.s, *f.node.ident); - word_space(s, ":"); + word_space(s, ~":"); print_type(s, f.node.mt.ty); end(s); } fn get_span(f: ast::ty_field) -> codemap::span { ret f.span; } commasep_cmnt(s, consistent, fields, print_field, get_span); - word(s.s, ",}"); + word(s.s, ~",}"); } ast::ty_tup(elts) { popen(s); @@ -382,7 +382,7 @@ fn print_type_ex(s: ps, &&ty: @ast::ty, print_colons: bool) { alt v { ast::vstore_fixed(_) { print_type(s, t); - word(s.s, "/"); + word(s.s, ~"/"); print_vstore(s, v); } _ { @@ -392,10 +392,10 @@ fn print_type_ex(s: ps, &&ty: @ast::ty, print_colons: bool) { } } ast::ty_mac(_) { - fail "print_type doesn't know how to print a ty_mac"; + fail ~"print_type doesn't know how to print a ty_mac"; } ast::ty_infer { - fail "print_type shouldn't see a ty_infer"; + fail ~"print_type shouldn't see a ty_infer"; } } @@ -410,7 +410,7 @@ fn print_foreign_item(s: ps, item: @ast::foreign_item) { ast::foreign_item_fn(decl, typarams) { print_fn(s, decl, item.ident, typarams); end(s); // end head-ibox - word(s.s, ";"); + word(s.s, ~";"); end(s); // end the outer fn box } } @@ -424,33 +424,33 @@ fn print_item(s: ps, &&item: @ast::item) { s.ann.pre(ann_node); alt item.node { ast::item_const(ty, expr) { - head(s, "const"); - word_space(s, *item.ident + ":"); + head(s, ~"const"); + word_space(s, *item.ident + ~":"); print_type(s, ty); space(s.s); end(s); // end the head-ibox - word_space(s, "="); + word_space(s, ~"="); print_expr(s, expr); - word(s.s, ";"); + word(s.s, ~";"); end(s); // end the outer cbox } ast::item_fn(decl, typarams, body) { print_fn(s, decl, item.ident, typarams); - word(s.s, " "); + word(s.s, ~" "); print_block_with_attrs(s, body, item.attrs); } ast::item_mod(_mod) { - head(s, "mod"); + head(s, ~"mod"); word_nbsp(s, *item.ident); bopen(s); print_mod(s, _mod, item.attrs); bclose(s, item.span); } ast::item_foreign_mod(nmod) { - head(s, "extern"); - word_nbsp(s, "mod"); + head(s, ~"extern"); + word_nbsp(s, ~"mod"); word_nbsp(s, *item.ident); bopen(s); print_foreign_mod(s, nmod, item.attrs); @@ -459,15 +459,15 @@ fn print_item(s: ps, &&item: @ast::item) { ast::item_ty(ty, params) { ibox(s, indent_unit); ibox(s, 0u); - word_nbsp(s, "type"); + word_nbsp(s, ~"type"); word(s.s, *item.ident); print_type_params(s, params); end(s); // end the inner ibox space(s.s); - word_space(s, "="); + word_space(s, ~"="); print_type(s, ty); - word(s.s, ";"); + word(s.s, ~";"); end(s); // end the outer ibox } ast::item_enum(variants, params) { @@ -477,15 +477,15 @@ fn print_item(s: ps, &&item: @ast::item) { vec::len(variants[0].node.args) == 1u; if newtype { ibox(s, indent_unit); - word_space(s, "enum"); - } else { head(s, "enum"); } + word_space(s, ~"enum"); + } else { head(s, ~"enum"); } word(s.s, *item.ident); print_type_params(s, params); space(s.s); if newtype { - word_space(s, "="); + word_space(s, ~"="); print_type(s, variants[0].node.args[0].ty); - word(s.s, ";"); + word(s.s, ~";"); end(s); } else { bopen(s); @@ -495,7 +495,7 @@ fn print_item(s: ps, &&item: @ast::item) { print_outer_attributes(s, v.node.attrs); ibox(s, indent_unit); print_variant(s, v); - word(s.s, ","); + word(s.s, ~","); end(s); maybe_print_trailing_comment(s, v.span, none::<uint>); } @@ -503,25 +503,25 @@ fn print_item(s: ps, &&item: @ast::item) { } } ast::item_class(tps, traits, items, ctor, m_dtor) { - head(s, "class"); + head(s, ~"class"); word_nbsp(s, *item.ident); print_type_params(s, tps); if vec::len(traits) != 0u { - word_space(s, ":"); + word_space(s, ~":"); commasep(s, inconsistent, traits, |s, p| print_path(s, p.path, false)); } bopen(s); hardbreak_if_not_bol(s); maybe_print_comment(s, ctor.span.lo); - head(s, "new"); + head(s, ~"new"); print_fn_args_and_ret(s, ctor.node.dec, ~[]); space(s.s); print_block(s, ctor.node.body); do option::iter(m_dtor) |dtor| { hardbreak_if_not_bol(s); maybe_print_comment(s, dtor.span.lo); - head(s, "drop"); + head(s, ~"drop"); print_block(s, dtor.node.body); } for items.each |ci| { @@ -537,7 +537,7 @@ fn print_item(s: ps, &&item: @ast::item) { let pr = ast_util::class_member_visibility(ci); alt pr { ast::private { - head(s, "priv"); + head(s, ~"priv"); bopen(s); hardbreak_if_not_bol(s); } @@ -545,15 +545,15 @@ fn print_item(s: ps, &&item: @ast::item) { } alt ci.node { ast::instance_var(nm, t, mt, _,_) { - word_nbsp(s, "let"); + word_nbsp(s, ~"let"); alt mt { - ast::class_mutable { word_nbsp(s, "mut"); } + ast::class_mutable { word_nbsp(s, ~"mut"); } _ {} } word(s.s, *nm); - word_nbsp(s, ":"); + word_nbsp(s, ~":"); print_type(s, t); - word(s.s, ";"); + word(s.s, ~";"); } ast::class_method(m) { print_method(s, m); @@ -567,16 +567,16 @@ fn print_item(s: ps, &&item: @ast::item) { bclose(s, item.span); } ast::item_impl(tps, ifce, ty, methods) { - head(s, "impl"); + head(s, ~"impl"); word(s.s, *item.ident); print_type_params(s, tps); space(s.s); option::iter(ifce, |p| { - word_nbsp(s, "of"); + word_nbsp(s, ~"of"); print_path(s, p.path, false); space(s.s); }); - word_nbsp(s, "for"); + word_nbsp(s, ~"for"); print_type(s, ty); space(s.s); bopen(s); @@ -586,10 +586,10 @@ fn print_item(s: ps, &&item: @ast::item) { bclose(s, item.span); } ast::item_trait(tps, methods) { - head(s, "iface"); + head(s, ~"iface"); word(s.s, *item.ident); print_type_params(s, tps); - word(s.s, " "); + word(s.s, ~" "); bopen(s); for methods.each |meth| { print_trait_method(s, meth); } bclose(s, item.span); @@ -602,7 +602,7 @@ fn print_item(s: ps, &&item: @ast::item) { bclose(s, item.span); } ast::item_mac(_) { - fail "invalid item-position syntax bit" + fail ~"invalid item-position syntax bit" } } s.ann.post(ann_node); @@ -614,7 +614,7 @@ fn print_item(s: ps, &&item: @ast::item) { /// A prettier option would involve scraping the macro grammar for formatting /// advice. But that would be hard. fn print_tt(_s: ps, _tt: ast::token_tree) { - fail "token trees cannot be pretty-printed" + fail ~"token trees cannot be pretty-printed" } fn print_variant(s: ps, v: ast::variant) { @@ -630,7 +630,7 @@ fn print_variant(s: ps, v: ast::variant) { alt v.node.disr_expr { some(d) { space(s.s); - word_space(s, "="); + word_space(s, ~"="); print_expr(s, d); } _ {} @@ -642,7 +642,7 @@ fn print_ty_method(s: ps, m: ast::ty_method) { maybe_print_comment(s, m.span.lo); print_outer_attributes(s, m.attrs); print_ty_fn(s, none, m.decl, some(m.ident), some(m.tps)); - word(s.s, ";"); + word(s.s, ~";"); } fn print_trait_method(s: ps, m: ast::trait_method) { @@ -657,7 +657,7 @@ fn print_method(s: ps, meth: @ast::method) { maybe_print_comment(s, meth.span.lo); print_outer_attributes(s, meth.attrs); print_fn(s, meth.decl, meth.ident, meth.tps); - word(s.s, " "); + word(s.s, ~" "); print_block_with_attrs(s, meth.body, meth.attrs); } @@ -679,7 +679,7 @@ fn print_inner_attributes(s: ps, attrs: ~[ast::attribute]) { ast::attr_inner { print_attribute(s, attr); if !attr.node.is_sugared_doc { - word(s.s, ";"); + word(s.s, ~";"); } count += 1; } @@ -697,9 +697,9 @@ fn print_attribute(s: ps, attr: ast::attribute) { let comment = attr::get_meta_item_value_str(meta).get(); word(s.s, *comment); } else { - word(s.s, "#["); + word(s.s, ~"#["); print_meta_item(s, @attr.node.value); - word(s.s, "]"); + word(s.s, ~"]"); } } @@ -717,10 +717,10 @@ fn print_stmt(s: ps, st: ast::stmt) { ast::stmt_semi(expr, _) { space_if_not_bol(s); print_expr(s, expr); - word(s.s, ";"); + word(s.s, ~";"); } } - if parse::classify::stmt_ends_with_semi(st) { word(s.s, ";"); } + if parse::classify::stmt_ends_with_semi(st) { word(s.s, ~";"); } maybe_print_trailing_comment(s, st.span, none::<uint>); } @@ -743,15 +743,15 @@ fn print_possibly_embedded_block(s: ps, blk: ast::blk, embedded: embed_type, fn print_possibly_embedded_block_(s: ps, blk: ast::blk, embedded: embed_type, indented: uint, attrs: ~[ast::attribute]) { alt blk.node.rules { - ast::unchecked_blk { word(s.s, "unchecked"); } - ast::unsafe_blk { word(s.s, "unsafe"); } + ast::unchecked_blk { word(s.s, ~"unchecked"); } + ast::unsafe_blk { word(s.s, ~"unsafe"); } ast::default_blk { } } maybe_print_comment(s, blk.span.lo); let ann_node = node_block(s, blk); s.ann.pre(ann_node); alt embedded { - block_macro { word(s.s, "#{"); end(s); } + block_macro { word(s.s, ~"#{"); end(s); } block_block_fn { end(s); } block_normal { bopen(s); } } @@ -788,8 +788,8 @@ fn print_maybe_parens_discrim(s: ps, e: @ast::expr) { fn print_if(s: ps, test: @ast::expr, blk: ast::blk, elseopt: option<@ast::expr>, chk: bool) { - head(s, "if"); - if chk { word_nbsp(s, "check"); } + head(s, ~"if"); + if chk { word_nbsp(s, ~"check"); } print_maybe_parens_discrim(s, test); space(s.s); print_block(s, blk); @@ -801,7 +801,7 @@ fn print_if(s: ps, test: @ast::expr, blk: ast::blk, ast::expr_if(i, t, e) { cbox(s, indent_unit - 1u); ibox(s, 0u); - word(s.s, " else if "); + word(s.s, ~" else if "); print_maybe_parens_discrim(s, i); space(s.s); print_block(s, t); @@ -811,12 +811,12 @@ fn print_if(s: ps, test: @ast::expr, blk: ast::blk, ast::expr_block(b) { cbox(s, indent_unit - 1u); ibox(s, 0u); - word(s.s, " else "); + word(s.s, ~" else "); print_block(s, b); } // BLEAH, constraints would be great here _ { - fail "print_if saw if with weird alternative"; + fail ~"print_if saw if with weird alternative"; } } } @@ -829,31 +829,31 @@ fn print_if(s: ps, test: @ast::expr, blk: ast::blk, fn print_mac(s: ps, m: ast::mac) { alt m.node { ast::mac_invoc(path, arg, body) { - word(s.s, "#"); + word(s.s, ~"#"); print_path(s, path, false); alt arg { some(@{node: ast::expr_vec(_, _), _}) { } - _ { word(s.s, " "); } + _ { word(s.s, ~" "); } } option::iter(arg, |a| print_expr(s, a)); // FIXME: extension 'body' (#2339) } ast::mac_invoc_tt(path, tts) { print_path(s, path, false); - word(s.s, "!"); + word(s.s, ~"!"); bopen(s); for tts.each() |tt| { print_tt(s, tt); } bclose(s, m.span); } ast::mac_embed_type(ty) { - word(s.s, "#<"); + word(s.s, ~"#<"); print_type(s, ty); - word(s.s, ">"); + word(s.s, ~">"); } ast::mac_embed_block(blk) { print_possibly_embedded_block(s, blk, block_normal, indent_unit); } - ast::mac_ellipsis { word(s.s, "..."); } + ast::mac_ellipsis { word(s.s, ~"..."); } ast::mac_var(v) { word(s.s, #fmt("$%u", v)); } _ { /* fixme */ } } @@ -862,16 +862,16 @@ fn print_mac(s: ps, m: ast::mac) { fn print_vstore(s: ps, t: ast::vstore) { alt t { ast::vstore_fixed(some(i)) { word(s.s, #fmt("%u", i)); } - ast::vstore_fixed(none) { word(s.s, "_"); } - ast::vstore_uniq { word(s.s, "~"); } - ast::vstore_box { word(s.s, "@"); } + ast::vstore_fixed(none) { word(s.s, ~"_"); } + ast::vstore_uniq { word(s.s, ~"~"); } + ast::vstore_box { word(s.s, ~"@"); } ast::vstore_slice(r) { alt r.node { - ast::re_anon { word(s.s, "&"); } + ast::re_anon { word(s.s, ~"&"); } ast::re_named(name) { - word(s.s, "&"); + word(s.s, ~"&"); word(s.s, *name); - word(s.s, "."); + word(s.s, ~"."); } } } @@ -888,7 +888,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) { alt v { ast::vstore_fixed(_) { print_expr(s, e); - word(s.s, "/"); + word(s.s, ~"/"); print_vstore(s, v); } _ { @@ -899,38 +899,38 @@ fn print_expr(s: ps, &&expr: @ast::expr) { } ast::expr_vec(exprs, mutbl) { ibox(s, indent_unit); - word(s.s, "["); + word(s.s, ~"["); if mutbl == ast::m_mutbl { - word(s.s, "mut"); + word(s.s, ~"mut"); if vec::len(exprs) > 0u { nbsp(s); } } commasep_exprs(s, inconsistent, exprs); - word(s.s, "]"); + word(s.s, ~"]"); end(s); } ast::expr_rec(fields, wth) { fn print_field(s: ps, field: ast::field) { ibox(s, indent_unit); - if field.node.mutbl == ast::m_mutbl { word_nbsp(s, "mut"); } + if field.node.mutbl == ast::m_mutbl { word_nbsp(s, ~"mut"); } word(s.s, *field.node.ident); - word_space(s, ":"); + word_space(s, ~":"); print_expr(s, field.node.expr); end(s); } fn get_span(field: ast::field) -> codemap::span { ret field.span; } - word(s.s, "{"); + word(s.s, ~"{"); commasep_cmnt(s, consistent, fields, print_field, get_span); alt wth { some(expr) { if vec::len(fields) > 0u { space(s.s); } ibox(s, indent_unit); - word_space(s, "with"); + word_space(s, ~"with"); print_expr(s, expr); end(s); } - _ { word(s.s, ","); } + _ { word(s.s, ~","); } } - word(s.s, "}"); + word(s.s, ~"}"); } ast::expr_tup(exprs) { popen(s); @@ -942,8 +942,8 @@ fn print_expr(s: ps, &&expr: @ast::expr) { let blk = if has_block { let blk_arg = vec::pop(base_args); alt blk_arg.node { - ast::expr_loop_body(_) { word_nbsp(s, "for"); } - ast::expr_do_body(_) { word_nbsp(s, "do"); } + ast::expr_loop_body(_) { word_nbsp(s, ~"for"); } + ast::expr_do_body(_) { word_nbsp(s, ~"do"); } _ {} } some(blk_arg) @@ -971,7 +971,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) { print_op_maybe_parens(s, expr, parse::prec::unop_prec); } ast::expr_addr_of(m, expr) { - word(s.s, "&"); + word(s.s, ~"&"); print_mutability(s, m); print_expr(s, expr); } @@ -979,7 +979,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) { ast::expr_cast(expr, ty) { print_op_maybe_parens(s, expr, parse::prec::as_prec); space(s.s); - word_space(s, "as"); + word_space(s, ~"as"); print_type_ex(s, ty, true); } ast::expr_if(test, blk, elseopt) { @@ -989,21 +989,21 @@ fn print_expr(s: ps, &&expr: @ast::expr) { print_if(s, test, blk, elseopt, true); } ast::expr_while(test, blk) { - head(s, "while"); + head(s, ~"while"); print_maybe_parens_discrim(s, test); space(s.s); print_block(s, blk); } ast::expr_loop(blk) { - head(s, "loop"); + head(s, ~"loop"); space(s.s); print_block(s, blk); } ast::expr_alt(expr, arms, mode) { cbox(s, alt_indent_unit); ibox(s, 4u); - word_nbsp(s, "alt"); - if mode == ast::alt_check { word_nbsp(s, "check"); } + word_nbsp(s, ~"alt"); + if mode == ast::alt_check { word_nbsp(s, ~"check"); } print_maybe_parens_discrim(s, expr); space(s.s); bopen(s); @@ -1015,12 +1015,12 @@ fn print_expr(s: ps, &&expr: @ast::expr) { for arm.pats.each |p| { if first { first = false; - } else { space(s.s); word_space(s, "|"); } + } else { space(s.s); word_space(s, ~"|"); } print_pat(s, p); } space(s.s); alt arm.guard { - some(e) { word_space(s, "if"); print_expr(s, e); space(s.s); } + some(e) { word_space(s, ~"if"); print_expr(s, e); space(s.s); } none { } } print_possibly_embedded_block(s, arm.body, block_normal, @@ -1060,30 +1060,30 @@ fn print_expr(s: ps, &&expr: @ast::expr) { ibox(s, 0u); print_block(s, blk); } - ast::expr_copy(e) { word_space(s, "copy"); print_expr(s, e); } + ast::expr_copy(e) { word_space(s, ~"copy"); print_expr(s, e); } ast::expr_move(lhs, rhs) { print_expr(s, lhs); space(s.s); - word_space(s, "<-"); + word_space(s, ~"<-"); print_expr(s, rhs); } ast::expr_assign(lhs, rhs) { print_expr(s, lhs); space(s.s); - word_space(s, "="); + word_space(s, ~"="); print_expr(s, rhs); } ast::expr_swap(lhs, rhs) { print_expr(s, lhs); space(s.s); - word_space(s, "<->"); + word_space(s, ~"<->"); print_expr(s, rhs); } ast::expr_assign_op(op, lhs, rhs) { print_expr(s, lhs); space(s.s); word(s.s, ast_util::binop_to_str(op)); - word_space(s, "="); + word_space(s, ~"="); print_expr(s, rhs); } ast::expr_field(expr, id, tys) { @@ -1093,46 +1093,46 @@ fn print_expr(s: ps, &&expr: @ast::expr) { } else { print_expr_parens_if_not_bot(s, expr); } - word(s.s, "."); + word(s.s, ~"."); word(s.s, *id); if vec::len(tys) > 0u { - word(s.s, "::<"); + word(s.s, ~"::<"); commasep(s, inconsistent, tys, print_type); - word(s.s, ">"); + word(s.s, ~">"); } } ast::expr_index(expr, index) { print_expr_parens_if_not_bot(s, expr); - word(s.s, "["); + word(s.s, ~"["); print_expr(s, index); - word(s.s, "]"); + word(s.s, ~"]"); } ast::expr_path(path) { print_path(s, path, true); } ast::expr_fail(maybe_fail_val) { - word(s.s, "fail"); + word(s.s, ~"fail"); alt maybe_fail_val { - some(expr) { word(s.s, " "); print_expr(s, expr); } + some(expr) { word(s.s, ~" "); print_expr(s, expr); } _ { } } } - ast::expr_break { word(s.s, "break"); } - ast::expr_again { word(s.s, "again"); } + ast::expr_break { word(s.s, ~"break"); } + ast::expr_again { word(s.s, ~"again"); } ast::expr_ret(result) { - word(s.s, "ret"); + word(s.s, ~"ret"); alt result { - some(expr) { word(s.s, " "); print_expr(s, expr); } + some(expr) { word(s.s, ~" "); print_expr(s, expr); } _ { } } } ast::expr_log(lvl, lexp, expr) { alt check lvl { - 1 { word_nbsp(s, "log"); print_expr(s, expr); } - 0 { word_nbsp(s, "log_err"); print_expr(s, expr); } + 1 { word_nbsp(s, ~"log"); print_expr(s, expr); } + 0 { word_nbsp(s, ~"log_err"); print_expr(s, expr); } 2 { - word_nbsp(s, "log"); + word_nbsp(s, ~"log"); popen(s); print_expr(s, lexp); - word(s.s, ","); + word(s.s, ~","); space_if_not_bol(s); print_expr(s, expr); pclose(s); @@ -1141,19 +1141,19 @@ fn print_expr(s: ps, &&expr: @ast::expr) { } ast::expr_check(m, expr) { alt m { - ast::claimed_expr { word_nbsp(s, "claim"); } - ast::checked_expr { word_nbsp(s, "check"); } + ast::claimed_expr { word_nbsp(s, ~"claim"); } + ast::checked_expr { word_nbsp(s, ~"check"); } } popen(s); print_expr(s, expr); pclose(s); } ast::expr_assert(expr) { - word_nbsp(s, "assert"); + word_nbsp(s, ~"assert"); print_expr(s, expr); } ast::expr_new(p, _, v) { - word_nbsp(s, "new"); + word_nbsp(s, ~"new"); popen(s); print_expr(s, p); pclose(s); @@ -1186,7 +1186,7 @@ fn print_local_decl(s: ps, loc: @ast::local) { print_pat(s, loc.node.pat); alt loc.node.ty.node { ast::ty_infer { } - _ { word_space(s, ":"); print_type(s, loc.node.ty); } + _ { word_space(s, ~":"); print_type(s, loc.node.ty); } } } @@ -1196,12 +1196,12 @@ fn print_decl(s: ps, decl: @ast::decl) { ast::decl_local(locs) { space_if_not_bol(s); ibox(s, indent_unit); - word_nbsp(s, "let"); + word_nbsp(s, ~"let"); // if any are mut, all are mut if vec::any(locs, |l| l.node.is_mutbl) { assert vec::all(locs, |l| l.node.is_mutbl); - word_nbsp(s, "mut"); + word_nbsp(s, ~"mut"); } fn print_local(s: ps, &&loc: @ast::local) { @@ -1212,8 +1212,8 @@ fn print_decl(s: ps, decl: @ast::decl) { some(init) { nbsp(s); alt init.op { - ast::init_assign { word_space(s, "="); } - ast::init_move { word_space(s, "<-"); } + ast::init_assign { word_space(s, ~"="); } + ast::init_move { word_space(s, ~"<-"); } } print_expr(s, init.expr); } @@ -1232,33 +1232,33 @@ fn print_ident(s: ps, ident: ast::ident) { word(s.s, *ident); } fn print_for_decl(s: ps, loc: @ast::local, coll: @ast::expr) { print_local_decl(s, loc); space(s.s); - word_space(s, "in"); + word_space(s, ~"in"); print_expr(s, coll); } fn print_path(s: ps, &&path: @ast::path, colons_before_params: bool) { maybe_print_comment(s, path.span.lo); - if path.global { word(s.s, "::"); } + if path.global { word(s.s, ~"::"); } let mut first = true; for path.idents.each |id| { - if first { first = false; } else { word(s.s, "::"); } + if first { first = false; } else { word(s.s, ~"::"); } word(s.s, *id); } if path.rp.is_some() || !path.types.is_empty() { - if colons_before_params { word(s.s, "::"); } + if colons_before_params { word(s.s, ~"::"); } alt path.rp { none { /* ok */ } some(r) { - word(s.s, "/"); + word(s.s, ~"/"); print_region(s, r); } } if !path.types.is_empty() { - word(s.s, "<"); + word(s.s, ~"<"); commasep(s, inconsistent, path.types, print_type); - word(s.s, ">"); + word(s.s, ~">"); } } } @@ -1270,18 +1270,18 @@ fn print_pat(s: ps, &&pat: @ast::pat) { /* Pat isn't normalized, but the beauty of it is that it doesn't matter */ alt pat.node { - ast::pat_wild { word(s.s, "_"); } + ast::pat_wild { word(s.s, ~"_"); } ast::pat_ident(path, sub) { print_path(s, path, true); alt sub { - some(p) { word(s.s, "@"); print_pat(s, p); } + some(p) { word(s.s, ~"@"); print_pat(s, p); } none {} } } ast::pat_enum(path, args_) { print_path(s, path, true); alt args_ { - none { word(s.s, "(*)"); } + none { word(s.s, ~"(*)"); } some(args) { if vec::len(args) > 0u { popen(s); @@ -1292,34 +1292,34 @@ fn print_pat(s: ps, &&pat: @ast::pat) { } } ast::pat_rec(fields, etc) { - word(s.s, "{"); + word(s.s, ~"{"); fn print_field(s: ps, f: ast::field_pat) { cbox(s, indent_unit); word(s.s, *f.ident); - word_space(s, ":"); + word_space(s, ~":"); print_pat(s, f.pat); end(s); } fn get_span(f: ast::field_pat) -> codemap::span { ret f.pat.span; } commasep_cmnt(s, consistent, fields, print_field, get_span); if etc { - if vec::len(fields) != 0u { word_space(s, ","); } - word(s.s, "_"); + if vec::len(fields) != 0u { word_space(s, ~","); } + word(s.s, ~"_"); } - word(s.s, "}"); + word(s.s, ~"}"); } ast::pat_tup(elts) { popen(s); commasep(s, inconsistent, elts, print_pat); pclose(s); } - ast::pat_box(inner) { word(s.s, "@"); print_pat(s, inner); } - ast::pat_uniq(inner) { word(s.s, "~"); print_pat(s, inner); } + ast::pat_box(inner) { word(s.s, ~"@"); print_pat(s, inner); } + ast::pat_uniq(inner) { word(s.s, ~"~"); print_pat(s, inner); } ast::pat_lit(e) { print_expr(s, e); } ast::pat_range(begin, end) { print_expr(s, begin); space(s.s); - word_space(s, "to"); + word_space(s, ~"to"); print_expr(s, end); } } @@ -1329,8 +1329,8 @@ fn print_pat(s: ps, &&pat: @ast::pat) { fn print_fn(s: ps, decl: ast::fn_decl, name: ast::ident, typarams: ~[ast::ty_param]) { alt decl.purity { - ast::impure_fn { head(s, "fn") } - _ { head(s, purity_to_str(decl.purity) + " fn") } + ast::impure_fn { head(s, ~"fn") } + _ { head(s, purity_to_str(decl.purity) + ~" fn") } } word(s.s, *name); print_type_params(s, typarams); @@ -1343,9 +1343,9 @@ fn print_fn_args(s: ps, decl: ast::fn_decl, if cap_items.is_not_empty() { let mut first = decl.inputs.is_empty(); for cap_items.each |cap_item| { - if first { first = false; } else { word_space(s, ","); } - if cap_item.is_move { word_nbsp(s, "move") } - else { word_nbsp(s, "copy") } + if first { first = false; } else { word_space(s, ~","); } + if cap_item.is_move { word_nbsp(s, ~"move") } + else { word_nbsp(s, ~"copy") } word(s.s, *cap_item.name); } } @@ -1363,49 +1363,49 @@ fn print_fn_args_and_ret(s: ps, decl: ast::fn_decl, maybe_print_comment(s, decl.output.span.lo); if decl.output.node != ast::ty_nil { space_if_not_bol(s); - word_space(s, "->"); + word_space(s, ~"->"); print_type(s, decl.output); } } fn print_fn_block_args(s: ps, decl: ast::fn_decl, cap_items: ~[ast::capture_item]) { - word(s.s, "|"); + word(s.s, ~"|"); print_fn_args(s, decl, cap_items); - word(s.s, "|"); + word(s.s, ~"|"); if decl.output.node != ast::ty_infer { space_if_not_bol(s); - word_space(s, "->"); + word_space(s, ~"->"); print_type(s, decl.output); } maybe_print_comment(s, decl.output.span.lo); } -fn mode_to_str(m: ast::mode) -> str { +fn mode_to_str(m: ast::mode) -> ~str { alt m { - ast::expl(ast::by_mutbl_ref) { "&" } - ast::expl(ast::by_move) { "-" } - ast::expl(ast::by_ref) { "&&" } - ast::expl(ast::by_val) { "++" } - ast::expl(ast::by_copy) { "+" } - ast::infer(_) { "" } + ast::expl(ast::by_mutbl_ref) { ~"&" } + ast::expl(ast::by_move) { ~"-" } + ast::expl(ast::by_ref) { ~"&&" } + ast::expl(ast::by_val) { ~"++" } + ast::expl(ast::by_copy) { ~"+" } + ast::infer(_) { ~"" } } } fn print_arg_mode(s: ps, m: ast::mode) { let ms = mode_to_str(m); - if ms != "" { word(s.s, ms); } + if ms != ~"" { word(s.s, ms); } } fn print_bounds(s: ps, bounds: @~[ast::ty_param_bound]) { if vec::len(*bounds) > 0u { - word(s.s, ":"); + word(s.s, ~":"); for vec::each(*bounds) |bound| { nbsp(s); alt bound { - ast::bound_copy { word(s.s, "copy"); } - ast::bound_send { word(s.s, "send"); } - ast::bound_const { word(s.s, "const"); } + ast::bound_copy { word(s.s, ~"copy"); } + ast::bound_send { word(s.s, ~"send"); } + ast::bound_const { word(s.s, ~"const"); } ast::bound_trait(t) { print_type(s, t); } } } @@ -1414,13 +1414,13 @@ fn print_bounds(s: ps, bounds: @~[ast::ty_param_bound]) { fn print_type_params(s: ps, &¶ms: ~[ast::ty_param]) { if vec::len(params) > 0u { - word(s.s, "<"); + word(s.s, ~"<"); fn printParam(s: ps, param: ast::ty_param) { word(s.s, *param.ident); print_bounds(s, param.bounds); } commasep(s, inconsistent, params, printParam); - word(s.s, ">"); + word(s.s, ~">"); } } @@ -1430,7 +1430,7 @@ fn print_meta_item(s: ps, &&item: @ast::meta_item) { ast::meta_word(name) { word(s.s, *name); } ast::meta_name_value(name, value) { word_space(s, *name); - word_space(s, "="); + word_space(s, ~"="); print_literal(s, @value); } ast::meta_list(name, items) { @@ -1448,23 +1448,23 @@ fn print_view_path(s: ps, &&vp: @ast::view_path) { ast::view_path_simple(ident, path, _) { if path.idents[vec::len(path.idents)-1u] != ident { word_space(s, *ident); - word_space(s, "="); + word_space(s, ~"="); } print_path(s, path, false); } ast::view_path_glob(path, _) { print_path(s, path, false); - word(s.s, "::*"); + word(s.s, ~"::*"); } ast::view_path_list(path, idents, _) { print_path(s, path, false); - word(s.s, "::{"); + word(s.s, ~"::{"); do commasep(s, inconsistent, idents) |s, w| { word(s.s, *w.node.name) } - word(s.s, "}"); + word(s.s, ~"}"); } } } @@ -1479,7 +1479,7 @@ fn print_view_item(s: ps, item: @ast::view_item) { print_outer_attributes(s, item.attrs); alt item.node { ast::view_item_use(id, mta, _) { - head(s, "use"); + head(s, ~"use"); word(s.s, *id); if vec::len(mta) > 0u { popen(s); @@ -1489,16 +1489,16 @@ fn print_view_item(s: ps, item: @ast::view_item) { } ast::view_item_import(vps) { - head(s, "import"); + head(s, ~"import"); print_view_paths(s, vps); } ast::view_item_export(vps) { - head(s, "export"); + head(s, ~"export"); print_view_paths(s, vps); } } - word(s.s, ";"); + word(s.s, ~";"); end(s); // end inner head-block end(s); // end outer head-block } @@ -1512,8 +1512,8 @@ fn print_op_maybe_parens(s: ps, expr: @ast::expr, outer_prec: uint) { fn print_mutability(s: ps, mutbl: ast::mutability) { alt mutbl { - ast::m_mutbl { word_nbsp(s, "mut"); } - ast::m_const { word_nbsp(s, "const"); } + ast::m_mutbl { word_nbsp(s, ~"mut"); } + ast::m_const { word_nbsp(s, ~"const"); } ast::m_imm {/* nothing */ } } } @@ -1532,7 +1532,7 @@ fn print_arg(s: ps, input: ast::arg) { } _ { if str::len(*input.ident) > 0u { - word_space(s, *input.ident + ":"); + word_space(s, *input.ident + ~":"); } print_type(s, input.ty); } @@ -1545,7 +1545,7 @@ fn print_ty_fn(s: ps, opt_proto: option<ast::proto>, tps: option<~[ast::ty_param]>) { ibox(s, indent_unit); word(s.s, opt_proto_to_str(opt_proto)); - alt id { some(id) { word(s.s, " "); word(s.s, *id); } _ { } } + alt id { some(id) { word(s.s, ~" "); word(s.s, *id); } _ { } } alt tps { some(tps) { print_type_params(s, tps); } _ { } } zerobreak(s.s); popen(s); @@ -1555,8 +1555,8 @@ fn print_ty_fn(s: ps, opt_proto: option<ast::proto>, if decl.output.node != ast::ty_nil { space_if_not_bol(s); ibox(s, indent_unit); - word_space(s, "->"); - if decl.cf == ast::noreturn { word_nbsp(s, "!"); } + word_space(s, ~"->"); + if decl.cf == ast::noreturn { word_nbsp(s, ~"!"); } else { print_type(s, decl.output); } end(s); } @@ -1609,12 +1609,12 @@ fn print_literal(s: ps, &&lit: @ast::lit) { alt lit.node { ast::lit_str(st) { print_string(s, *st); } ast::lit_int(ch, ast::ty_char) { - word(s.s, "'" + char::escape_default(ch as char) + "'"); + word(s.s, ~"'" + char::escape_default(ch as char) + ~"'"); } ast::lit_int(i, t) { if i < 0_i64 { word(s.s, - "-" + u64::to_str(-i as u64, 10u) + ~"-" + u64::to_str(-i as u64, 10u) + ast_util::int_ty_to_str(t)); } else { word(s.s, @@ -1629,7 +1629,7 @@ fn print_literal(s: ps, &&lit: @ast::lit) { } ast::lit_int_unsuffixed(i) { if i < 0_i64 { - word(s.s, "-" + u64::to_str(-i as u64, 10u)); + word(s.s, ~"-" + u64::to_str(-i as u64, 10u)); } else { word(s.s, u64::to_str(i as u64, 10u)); } @@ -1637,14 +1637,14 @@ fn print_literal(s: ps, &&lit: @ast::lit) { ast::lit_float(f, t) { word(s.s, *f + ast_util::float_ty_to_str(t)); } - ast::lit_nil { word(s.s, "()"); } + ast::lit_nil { word(s.s, ~"()"); } ast::lit_bool(val) { - if val { word(s.s, "true"); } else { word(s.s, "false"); } + if val { word(s.s, ~"true"); } else { word(s.s, ~"false"); } } } } -fn lit_to_str(l: @ast::lit) -> str { ret to_str(l, print_literal); } +fn lit_to_str(l: @ast::lit) -> ~str { ret to_str(l, print_literal); } fn next_lit(s: ps, pos: uint) -> option<comments::lit> { alt s.literals { @@ -1693,7 +1693,7 @@ fn print_comment(s: ps, cmnt: comments::cmnt) { } } comments::trailing { - word(s.s, " "); + word(s.s, ~" "); if vec::len(cmnt.lines) == 1u { word(s.s, cmnt.lines[0]); hardbreak(s.s); @@ -1710,7 +1710,7 @@ fn print_comment(s: ps, cmnt: comments::cmnt) { // We need to do at least one, possibly two hardbreaks. let is_semi = alt s.s.last_token() { - pp::STRING(s, _) { *s == ";" } + pp::STRING(s, _) { *s == ~";" } _ { false } }; if is_semi || is_begin(s) || is_end(s) { hardbreak(s.s); } @@ -1719,13 +1719,13 @@ fn print_comment(s: ps, cmnt: comments::cmnt) { } } -fn print_string(s: ps, st: str) { - word(s.s, "\""); +fn print_string(s: ps, st: ~str) { + word(s.s, ~"\""); word(s.s, str::escape_default(st)); - word(s.s, "\""); + word(s.s, ~"\""); } -fn to_str<T>(t: T, f: fn@(ps, T)) -> str { +fn to_str<T>(t: T, f: fn@(ps, T)) -> ~str { let buffer = io::mem_buffer(); let s = rust_printer(io::mem_buffer_writer(buffer)); f(s, t); @@ -1744,23 +1744,23 @@ fn next_comment(s: ps) -> option<comments::cmnt> { } } -fn constr_args_to_str<T>(f: fn@(T) -> str, +fn constr_args_to_str<T>(f: fn@(T) -> ~str, args: ~[@ast::sp_constr_arg<T>]) -> - str { + ~str { let mut comma = false; - let mut s = "("; + let mut s = ~"("; for args.each |a| { - if comma { s += ", "; } else { comma = true; } + if comma { s += ~", "; } else { comma = true; } s += constr_arg_to_str::<T>(f, a.node); } - s += ")"; + s += ~")"; ret s; } -fn constr_arg_to_str<T>(f: fn@(T) -> str, c: ast::constr_arg_general_<T>) -> - str { +fn constr_arg_to_str<T>(f: fn@(T) -> ~str, c: ast::constr_arg_general_<T>) -> + ~str { alt c { - ast::carg_base { ret "*"; } + ast::carg_base { ret ~"*"; } ast::carg_ident(i) { ret f(i); } ast::carg_lit(l) { ret lit_to_str(l); } } @@ -1769,53 +1769,55 @@ fn constr_arg_to_str<T>(f: fn@(T) -> str, c: ast::constr_arg_general_<T>) -> // needed b/c constr_args_to_str needs // something that takes an alias // (argh) -fn uint_to_str(&&i: uint) -> str { ret uint::str(i); } +fn uint_to_str(&&i: uint) -> ~str { ret uint::str(i); } -fn ast_ty_fn_constr_to_str(&&c: @ast::constr) -> str { +fn ast_ty_fn_constr_to_str(&&c: @ast::constr) -> ~str { ret path_to_str(c.node.path) + constr_args_to_str(uint_to_str, c.node.args); } -fn ast_fn_constr_to_str(decl: ast::fn_decl, &&c: @ast::constr) -> str { +fn ast_fn_constr_to_str(decl: ast::fn_decl, &&c: @ast::constr) -> ~str { let arg_to_str = |a| fn_arg_idx_to_str(decl, a); ret path_to_str(c.node.path) + constr_args_to_str(arg_to_str, c.node.args); } -fn ty_constr_to_str(&&c: @ast::ty_constr) -> str { - fn ty_constr_path_to_str(&&p: @ast::path) -> str { "*." + path_to_str(p) } +fn ty_constr_to_str(&&c: @ast::ty_constr) -> ~str { + fn ty_constr_path_to_str(&&p: @ast::path) -> ~str { + ~"*." + path_to_str(p) + } ret path_to_str(c.node.path) + constr_args_to_str::<@ast::path>(ty_constr_path_to_str, c.node.args); } -fn constrs_str<T>(constrs: ~[T], elt: fn(T) -> str) -> str { - let mut s = "", colon = true; +fn constrs_str<T>(constrs: ~[T], elt: fn(T) -> ~str) -> ~str { + let mut s = ~"", colon = true; for constrs.each |c| { - if colon { s += " : "; colon = false; } else { s += ", "; } + if colon { s += ~" : "; colon = false; } else { s += ~", "; } s += elt(c); } ret s; } -fn fn_arg_idx_to_str(decl: ast::fn_decl, &&idx: uint) -> str { +fn fn_arg_idx_to_str(decl: ast::fn_decl, &&idx: uint) -> ~str { *decl.inputs[idx].ident } -fn opt_proto_to_str(opt_p: option<ast::proto>) -> str { +fn opt_proto_to_str(opt_p: option<ast::proto>) -> ~str { alt opt_p { - none { "fn" } + none { ~"fn" } some(p) { proto_to_str(p) } } } -fn purity_to_str(p: ast::purity) -> str { +fn purity_to_str(p: ast::purity) -> ~str { alt p { - ast::impure_fn {"impure"} - ast::unsafe_fn {"unsafe"} - ast::pure_fn {"pure"} - ast::extern_fn {"extern"} + ast::impure_fn {~"impure"} + ast::unsafe_fn {~"unsafe"} + ast::pure_fn {~"pure"} + ast::extern_fn {~"extern"} } } @@ -1826,13 +1828,13 @@ fn print_purity(s: ps, p: ast::purity) { } } -fn proto_to_str(p: ast::proto) -> str { +fn proto_to_str(p: ast::proto) -> ~str { ret alt p { - ast::proto_bare { "extern fn" } - ast::proto_any { "fn" } - ast::proto_block { "fn&" } - ast::proto_uniq { "fn~" } - ast::proto_box { "fn@" } + ast::proto_bare { ~"extern fn" } + ast::proto_any { ~"fn" } + ast::proto_block { ~"fn&" } + ast::proto_uniq { ~"fn~" } + ast::proto_box { ~"fn@" } }; } diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs index 3387b716ec6..6d3c2ba74bc 100644 --- a/src/libsyntax/visit.rs +++ b/src/libsyntax/visit.rs @@ -28,8 +28,8 @@ fn name_of_fn(fk: fn_kind) -> ident { alt fk { fk_item_fn(name, _) | fk_method(name, _, _) | fk_ctor(name, _, _, _) { /* FIXME (#2543) */ copy name } - fk_anon(*) | fk_fn_block(*) { @"anon"/~ } - fk_dtor(*) { @"drop"/~ } + fk_anon(*) | fk_fn_block(*) { @~"anon" } + fk_dtor(*) { @~"drop" } } } diff --git a/src/rustc/back/abi.rs b/src/rustc/back/abi.rs index d6c0c5fa2dd..8213ff1576e 100644 --- a/src/rustc/back/abi.rs +++ b/src/rustc/back/abi.rs @@ -66,13 +66,13 @@ const worst_case_glue_call_args: uint = 7u; const abi_version: uint = 1u; -fn memcpy_glue_name() -> str { ret "rust_memcpy_glue"; } +fn memcpy_glue_name() -> ~str { ret ~"rust_memcpy_glue"; } -fn bzero_glue_name() -> str { ret "rust_bzero_glue"; } +fn bzero_glue_name() -> ~str { ret ~"rust_bzero_glue"; } -fn yield_glue_name() -> str { ret "rust_yield_glue"; } +fn yield_glue_name() -> ~str { ret ~"rust_yield_glue"; } -fn no_op_type_glue_name() -> str { ret "rust_no_op_type_glue"; } +fn no_op_type_glue_name() -> ~str { ret ~"rust_no_op_type_glue"; } // // Local Variables: // mode: rust diff --git a/src/rustc/back/link.rs b/src/rustc/back/link.rs index 089bde35734..22a9150df56 100644 --- a/src/rustc/back/link.rs +++ b/src/rustc/back/link.rs @@ -25,11 +25,11 @@ enum output_type { output_type_exe, } -fn llvm_err(sess: session, msg: str) -> ! unsafe { +fn llvm_err(sess: session, msg: ~str) -> ! unsafe { let cstr = llvm::LLVMRustGetLastError(); if cstr == ptr::null() { sess.fatal(msg); - } else { sess.fatal(msg + ": " + str::unsafe::from_c_str(cstr)); } + } else { sess.fatal(msg + ~": " + str::unsafe::from_c_str(cstr)); } } mod write { @@ -43,15 +43,16 @@ mod write { // Decides what to call an intermediate file, given the name of the output // and the extension to use. - fn mk_intermediate_name(output_path: str, extension: str) -> str unsafe { + fn mk_intermediate_name(output_path: ~str, extension: ~str) -> + ~str unsafe { let stem = alt str::find_char(output_path, '.') { some(dot_pos) { str::slice(output_path, 0u, dot_pos) } none { output_path } }; - ret stem + "." + extension; + ret stem + ~"." + extension; } - fn run_passes(sess: session, llmod: ModuleRef, output: str) { + fn run_passes(sess: session, llmod: ModuleRef, output: ~str) { let opts = sess.opts; if sess.time_llvm_passes() { llvm::LLVMRustEnableTimePasses(); } let mut pm = mk_pass_manager(); @@ -68,14 +69,14 @@ mod write { alt opts.output_type { output_type_bitcode { if opts.optimize != 0u { - let filename = mk_intermediate_name(output, "no-opt.bc"); + let filename = mk_intermediate_name(output, ~"no-opt.bc"); str::as_c_str(filename, |buf| { llvm::LLVMWriteBitcodeToFile(llmod, buf) }); } } _ { - let filename = mk_intermediate_name(output, "bc"); + let filename = mk_intermediate_name(output, ~"bc"); str::as_c_str(filename, |buf| { llvm::LLVMWriteBitcodeToFile(llmod, buf) }); @@ -147,7 +148,7 @@ mod write { if opts.save_temps { // Always output the bitcode file with --save-temps - let filename = mk_intermediate_name(output, "opt.bc"); + let filename = mk_intermediate_name(output, ~"opt.bc"); llvm::LLVMRunPassManager(pm.llpm, llmod); str::as_c_str(filename, |buf| { llvm::LLVMWriteBitcodeToFile(llmod, buf) @@ -287,28 +288,28 @@ mod write { * */ -fn build_link_meta(sess: session, c: ast::crate, output: str, +fn build_link_meta(sess: session, c: ast::crate, output: ~str, sha: sha1) -> link_meta { type provided_metas = - {name: option<@str/~>, - vers: option<@str/~>, + {name: option<@~str>, + vers: option<@~str>, 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 name: option<@~str> = none; + let mut vers: option<@~str> = none; 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" { + if *attr::get_meta_item_name(meta) == ~"name" { alt attr::get_meta_item_value_str(meta) { some(v) { name = some(v); } none { vec::push(cmh_items, meta); } } - } else if *attr::get_meta_item_name(meta) == "vers" { + } else if *attr::get_meta_item_name(meta) == ~"vers" { alt attr::get_meta_item_value_str(meta) { some(v) { vers = some(v); } none { vec::push(cmh_items, meta); } @@ -321,12 +322,12 @@ 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 { - fn len_and_str(s: str) -> str { + dep_hashes: ~[@~str]) -> ~str { + fn len_and_str(s: ~str) -> ~str { ret #fmt["%u_%s", str::len(s), s]; } - fn len_and_str_lit(l: ast::lit) -> str { + fn len_and_str_lit(l: ast::lit) -> ~str { ret len_and_str(pprust::lit_to_str(@l)); } @@ -343,7 +344,7 @@ fn build_link_meta(sess: session, c: ast::crate, output: str, ast::meta_word(name) { sha.input_str(len_and_str(*name)); } ast::meta_list(_, _) { // FIXME (#607): Implement this - fail "unimplemented meta_item variant"; + fail ~"unimplemented meta_item variant"; } } } @@ -355,14 +356,14 @@ fn build_link_meta(sess: session, c: ast::crate, output: str, ret truncated_sha1_result(sha); } - fn warn_missing(sess: session, name: str, default: str) { + fn warn_missing(sess: session, name: ~str, default: ~str) { if !sess.building_library { ret; } sess.warn(#fmt["missing crate link meta `%s`, using `%s` as default", name, default]); } fn crate_meta_name(sess: session, _crate: ast::crate, - output: str, metas: provided_metas) -> @str/~ { + output: ~str, metas: provided_metas) -> @~str { ret alt metas.name { some(v) { v } none { @@ -375,21 +376,21 @@ fn build_link_meta(sess: session, c: ast::crate, output: str, appear to have an extension", output)); } vec::pop(os); - str::connect(os, ".") + str::connect(os, ~".") }; - warn_missing(sess, "name", name); + warn_missing(sess, ~"name", name); @name } }; } fn crate_meta_vers(sess: session, _crate: ast::crate, - metas: provided_metas) -> @str/~ { + metas: provided_metas) -> @~str { ret alt metas.vers { some(v) { v } none { - let vers = "0.0"; - warn_missing(sess, "vers", vers); + let vers = ~"0.0"; + warn_missing(sess, ~"vers", vers); @vers } }; @@ -405,30 +406,30 @@ fn build_link_meta(sess: session, c: ast::crate, output: str, ret {name: name, vers: vers, extras_hash: extras_hash}; } -fn truncated_sha1_result(sha: sha1) -> str unsafe { +fn truncated_sha1_result(sha: sha1) -> ~str unsafe { ret str::slice(sha.result_str(), 0u, 16u); } // This calculates STH for a symbol, as defined above fn symbol_hash(tcx: ty::ctxt, sha: sha1, t: ty::t, - link_meta: link_meta) -> str { + link_meta: link_meta) -> ~str { // NB: do *not* use abbrevs here as we want the symbol names // to be independent of one another in the crate. sha.reset(); sha.input_str(*link_meta.name); - sha.input_str("-"); + sha.input_str(~"-"); sha.input_str(link_meta.extras_hash); - sha.input_str("-"); + sha.input_str(~"-"); sha.input_str(encoder::encoded_ty(tcx, t)); let hash = truncated_sha1_result(sha); // Prefix with _ so that it never blends into adjacent digits - ret "_" + hash; + ret ~"_" + hash; } -fn get_symbol_hash(ccx: @crate_ctxt, t: ty::t) -> str { +fn get_symbol_hash(ccx: @crate_ctxt, t: ty::t) -> ~str { alt ccx.type_sha1s.find(t) { some(h) { ret h; } none { @@ -442,17 +443,17 @@ fn get_symbol_hash(ccx: @crate_ctxt, t: ty::t) -> str { // Name sanitation. LLVM will happily accept identifiers with weird names, but // gas doesn't! -fn sanitize(s: str) -> str { - let mut result = ""; +fn sanitize(s: ~str) -> ~str { + let mut result = ~""; do str::chars_iter(s) |c| { alt c { - '@' { result += "_sbox_"; } - '~' { result += "_ubox_"; } - '*' { result += "_ptr_"; } - '&' { result += "_ref_"; } - ',' { result += "_"; } + '@' { result += ~"_sbox_"; } + '~' { result += ~"_ubox_"; } + '*' { result += ~"_ptr_"; } + '&' { result += ~"_ref_"; } + ',' { result += ~"_"; } - '{' | '(' { result += "_of_"; } + '{' | '(' { result += ~"_of_"; } 'a' to 'z' | 'A' to 'Z' | '0' to '9' @@ -469,16 +470,16 @@ fn sanitize(s: str) -> str { if result.len() > 0u && result[0] != '_' as u8 && ! char::is_XID_start(result[0] as char) { - ret "_" + result; + ret ~"_" + result; } ret result; } -fn mangle(ss: path) -> str { +fn mangle(ss: path) -> ~str { // Follow C++ namespace-mangling style - let mut n = "_ZN"; // Begin name-sequence. + let mut n = ~"_ZN"; // Begin name-sequence. for ss.each |s| { alt s { path_name(s) | path_mod(s) { @@ -486,52 +487,52 @@ fn mangle(ss: path) -> str { n += #fmt["%u%s", str::len(sani), sani]; } } } - n += "E"; // End name-sequence. + n += ~"E"; // End name-sequence. n } -fn exported_name(path: path, hash: @str/~, vers: @str/~) -> str { +fn exported_name(path: path, hash: @~str, vers: @~str) -> ~str { ret mangle( vec::append_one(vec::append_one(path, path_name(hash)), path_name(vers))); } -fn mangle_exported_name(ccx: @crate_ctxt, path: path, t: ty::t) -> str { +fn mangle_exported_name(ccx: @crate_ctxt, path: path, t: ty::t) -> ~str { let hash = get_symbol_hash(ccx, t); ret exported_name(path, @hash, ccx.link_meta.vers); } fn mangle_internal_name_by_type_only(ccx: @crate_ctxt, - t: ty::t, name: @str/~) -> - str { + t: ty::t, name: @~str) -> + ~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)]); } fn mangle_internal_name_by_path_and_seq(ccx: @crate_ctxt, path: path, - flav: @str/~) -> str { + flav: @~str) -> ~str { ret mangle(vec::append_one(path, path_name(@ccx.names(*flav)))); } -fn mangle_internal_name_by_path(_ccx: @crate_ctxt, path: path) -> str { +fn mangle_internal_name_by_path(_ccx: @crate_ctxt, path: path) -> ~str { ret mangle(path); } -fn mangle_internal_name_by_seq(ccx: @crate_ctxt, flav: @str/~) -> str { +fn mangle_internal_name_by_seq(ccx: @crate_ctxt, flav: @~str) -> ~str { ret ccx.names(*flav); } // If the user wants an exe generated we need to invoke // cc to link the object file with some libs fn link_binary(sess: session, - obj_filename: str, - out_filename: str, + obj_filename: ~str, + out_filename: ~str, lm: link_meta) { // Converts a library file name into a cc -l argument - fn unlib(config: @session::config, filename: str) -> str unsafe { - let rmlib = fn@(filename: str) -> str { - let found = str::find_str(filename, "lib"); + fn unlib(config: @session::config, filename: ~str) -> ~str unsafe { + let rmlib = fn@(filename: ~str) -> ~str { + let found = str::find_str(filename, ~"lib"); if config.os == session::os_macos || (config.os == session::os_linux || config.os == session::os_freebsd) && @@ -539,10 +540,10 @@ fn link_binary(sess: session, ret str::slice(filename, 3u, str::len(filename)); } else { ret filename; } }; - fn rmext(filename: str) -> str { + fn rmext(filename: ~str) -> ~str { let mut parts = str::split_char(filename, '.'); vec::pop(parts); - ret str::connect(parts, "."); + ret str::connect(parts, ~"."); } ret alt config.os { session::os_macos { rmext(rmlib(filename)) } @@ -564,46 +565,46 @@ fn link_binary(sess: session, path::connect(path::dirname(out_filename), long_libname) } else { out_filename }; - log(debug, "output: " + output); + log(debug, ~"output: " + output); // The default library location, we need this to find the runtime. // The location of crates will be determined as needed. - let stage: str = "-L" + sess.filesearch.get_target_lib_path(); + let stage: ~str = ~"-L" + sess.filesearch.get_target_lib_path(); // In the future, FreeBSD will use clang as default compiler. // It would be flexible to use cc (system's default C compiler) // instead of hard-coded gcc. // For win32, there is no cc command, // so we add a condition to make it use gcc. - let cc_prog: str = - if sess.targ_cfg.os == session::os_win32 { "gcc" } else { "cc" }; + let cc_prog: ~str = + if sess.targ_cfg.os == session::os_win32 { ~"gcc" } else { ~"cc" }; // The invocations of cc share some flags across platforms let mut cc_args = vec::append(~[stage], sess.targ_cfg.target_strs.cc_args); - vec::push(cc_args, "-o"); + vec::push(cc_args, ~"-o"); vec::push(cc_args, output); vec::push(cc_args, obj_filename); let mut lib_cmd; let os = sess.targ_cfg.os; if os == session::os_macos { - lib_cmd = "-dynamiclib"; - } else { lib_cmd = "-shared"; } + lib_cmd = ~"-dynamiclib"; + } else { lib_cmd = ~"-shared"; } // # Crate linking let cstore = sess.cstore; for cstore::get_used_crate_files(cstore).each |cratepath| { - if str::ends_with(cratepath, ".rlib") { + if str::ends_with(cratepath, ~".rlib") { vec::push(cc_args, cratepath); again; } let cratepath = cratepath; let dir = path::dirname(cratepath); - if dir != "" { vec::push(cc_args, "-L" + dir); } + if dir != ~"" { vec::push(cc_args, ~"-L" + dir); } let libarg = unlib(sess.targ_cfg, path::basename(cratepath)); - vec::push(cc_args, "-l" + libarg); + vec::push(cc_args, ~"-l" + libarg); } let ula = cstore::get_used_link_args(cstore); @@ -618,11 +619,11 @@ 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| { vec::push(cc_args, "-L" + path); } + for addl_paths.each |path| { vec::push(cc_args, ~"-L" + path); } // The names of the extern libraries let used_libs = cstore::get_used_libraries(cstore); - for used_libs.each |l| { vec::push(cc_args, "-l" + l); } + for used_libs.each |l| { vec::push(cc_args, ~"-l" + l); } if sess.building_library { vec::push(cc_args, lib_cmd); @@ -630,35 +631,35 @@ fn link_binary(sess: session, // On mac we need to tell the linker to let this library // be rpathed if sess.targ_cfg.os == session::os_macos { - vec::push(cc_args, "-Wl,-install_name,@rpath/" + vec::push(cc_args, ~"-Wl,-install_name,@rpath/" + path::basename(output)); } } if !sess.debugging_opt(session::no_rt) { // Always want the runtime linked in - vec::push(cc_args, "-lrustrt"); + vec::push(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 { - vec::push_all(cc_args, ~["-lrt", "-ldl"]); + vec::push_all(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 - vec::push(cc_args, "-lm"); + vec::push(cc_args, ~"-lm"); } if sess.targ_cfg.os == session::os_freebsd { - vec::push_all(cc_args, ~["-pthread", "-lrt", - "-L/usr/local/lib", "-lexecinfo", - "-L/usr/local/lib/gcc46", - "-L/usr/local/lib/gcc44", "-lstdc++", - "-Wl,-z,origin", - "-Wl,-rpath,/usr/local/lib/gcc46", - "-Wl,-rpath,/usr/local/lib/gcc44"]); + vec::push_all(cc_args, ~[~"-pthread", ~"-lrt", + ~"-L/usr/local/lib", ~"-lexecinfo", + ~"-L/usr/local/lib/gcc46", + ~"-L/usr/local/lib/gcc44", ~"-lstdc++", + ~"-Wl,-z,origin", + ~"-Wl,-rpath,/usr/local/lib/gcc46", + ~"-Wl,-rpath,/usr/local/lib/gcc44"]); } // OS X 10.6 introduced 'compact unwind info', which is produced by the @@ -666,31 +667,31 @@ 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 { - vec::push(cc_args, "-Wl,-no_compact_unwind"); + vec::push(cc_args, ~"-Wl,-no_compact_unwind"); } // Stack growth requires statically linking a __morestack function - vec::push(cc_args, "-lmorestack"); + vec::push(cc_args, ~"-lmorestack"); // FIXME (#2397): At some point we want to rpath our guesses as to where // extern libraries might live, based on the addl_lib_search_paths vec::push_all(cc_args, rpath::get_rpath_flags(sess, output)); - #debug("%s link args: %s", cc_prog, str::connect(cc_args, " ")); + #debug("%s link args: %s", cc_prog, str::connect(cc_args, ~" ")); // We run 'cc' here let prog = run::program_output(cc_prog, cc_args); if 0 != prog.status { sess.err(#fmt["linking with `%s` failed with code %d", cc_prog, prog.status]); sess.note(#fmt["%s arguments: %s", - cc_prog, str::connect(cc_args, " ")]); + cc_prog, str::connect(cc_args, ~" ")]); sess.note(prog.err + prog.out); sess.abort_if_errors(); } // 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 diff --git a/src/rustc/back/rpath.rs b/src/rustc/back/rpath.rs index f29dc26ed39..2e16d92cec8 100644 --- a/src/rustc/back/rpath.rs +++ b/src/rustc/back/rpath.rs @@ -13,7 +13,7 @@ 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 @@ -40,17 +40,17 @@ fn get_sysroot_absolute_rt_lib(sess: session::session) -> path::path { let mut path = vec::append(~[sess.filesearch.sysroot()], filesearch::relative_target_lib_path( sess.opts.target_triple)); - vec::push(path, os::dll_filename("rustrt")); + vec::push(path, 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] { + target_triple: ~str) -> ~[~str] { #debug("cwd: %s", cwd); #debug("sysroot: %s", sysroot); #debug("output: %s", output); @@ -72,16 +72,16 @@ fn get_rpaths(os: session::os, cwd: path::path, sysroot: path::path, // And a final backup rpath to the global library location. 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); } } - log_rpaths("relative", rel_rpaths); - log_rpaths("absolute", abs_rpaths); - log_rpaths("fallback", fallback_rpaths); + log_rpaths(~"relative", rel_rpaths); + log_rpaths(~"absolute", abs_rpaths); + log_rpaths(~"fallback", fallback_rpaths); let mut rpaths = rel_rpaths; vec::push_all(rpaths, abs_rpaths); @@ -95,7 +95,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) @@ -105,12 +105,12 @@ fn get_rpaths_relative_to_output(os: session::os, fn get_rpath_relative_to_output(os: session::os, cwd: path::path, output: path::path, - &&lib: path::path) : not_win32(os) -> str { + &&lib: path::path) : not_win32(os) -> ~str { // Mac doesn't appear to support $ORIGIN let prefix = alt os { - session::os_linux { "$ORIGIN" + path::path_sep() } - session::os_freebsd { "$ORIGIN" + path::path_sep() } - session::os_macos { "@executable_path" + path::path_sep() } + session::os_linux { ~"$ORIGIN" + path::path_sep() } + session::os_freebsd { ~"$ORIGIN" + path::path_sep() } + session::os_macos { ~"@executable_path" + path::path_sep() } session::os_win32 { core::unreachable(); } }; @@ -142,7 +142,7 @@ fn get_relative_to(abs1: path::path, abs2: path::path) -> path::path { } let mut path = ~[]; - for uint::range(start_idx, len1 - 1u) |_i| { vec::push(path, ".."); }; + for uint::range(start_idx, len1 - 1u) |_i| { vec::push(path, ~".."); }; // FIXME (#2880): use view here. vec::push_all(path, vec::slice(split2, start_idx, len2 - 1u)); @@ -150,15 +150,15 @@ fn get_relative_to(abs1: path::path, abs2: path::path) -> path::path { if check vec::is_not_empty(path) { ret path::connect_many(path); } else { - ret "."; + ret ~"."; } } -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) ) } -fn get_absolute_rpath(cwd: path::path, &&lib: path::path) -> str { +fn get_absolute_rpath(cwd: path::path, &&lib: path::path) -> ~str { path::dirname(get_absolute(cwd, lib)) } @@ -170,11 +170,11 @@ fn get_absolute(cwd: path::path, lib: path::path) -> path::path { } } -fn get_install_prefix_rpath(cwd: path::path, target_triple: str) -> str { +fn get_install_prefix_rpath(cwd: path::path, target_triple: ~str) -> ~str { let install_prefix = #env("CFG_PREFIX"); - if install_prefix == "" { - fail "rustc compiled without CFG_PREFIX environment variable"; + if install_prefix == ~"" { + fail ~"rustc compiled without CFG_PREFIX environment variable"; } let path = vec::append( @@ -183,7 +183,7 @@ fn get_install_prefix_rpath(cwd: path::path, target_triple: str) -> str { 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 = ~[]; for rpaths.each |rpath| { @@ -199,116 +199,116 @@ 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] fn test_get_absolute1() { - let cwd = "/dir"; - let lib = "some/path/lib"; + let cwd = ~"/dir"; + let lib = ~"some/path/lib"; let res = get_absolute(cwd, lib); - assert res == "/dir/some/path/lib"; + assert res == ~"/dir/some/path/lib"; } #[test] fn test_get_absolute2() { - let cwd = "/dir"; - let lib = "/some/path/lib"; + let cwd = ~"/dir"; + let lib = ~"/some/path/lib"; let res = get_absolute(cwd, lib); - assert res == "/some/path/lib"; + assert res == ~"/some/path/lib"; } #[test] fn test_prefix_rpath() { - let res = get_install_prefix_rpath("/usr/lib", "triple"); - let d = path::connect(#env("CFG_PREFIX"), "/lib/rustc/triple/lib"); + let res = get_install_prefix_rpath(~"/usr/lib", ~"triple"); + let d = path::connect(#env("CFG_PREFIX"), ~"/lib/rustc/triple/lib"); assert str::ends_with(res, d); } #[test] fn test_prefix_rpath_abs() { - let res = get_install_prefix_rpath("/usr/lib", "triple"); + let res = get_install_prefix_rpath(~"/usr/lib", ~"triple"); assert path::path_is_absolute(res); } #[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"]; + let res = minimize_rpaths(~[~"1a", ~"2", ~"2", ~"1a", ~"4a", + ~"1a", ~"2", ~"3", ~"4a", ~"3"]); + assert res == ~[~"1a", ~"2", ~"4a", ~"3"]; } #[test] fn test_relative_to1() { - let p1 = "/usr/bin/rustc"; - let p2 = "/usr/lib/mylib"; + let p1 = ~"/usr/bin/rustc"; + let p2 = ~"/usr/lib/mylib"; let res = get_relative_to(p1, p2); - assert res == "../lib"; + assert res == ~"../lib"; } #[test] fn test_relative_to2() { - let p1 = "/usr/bin/rustc"; - let p2 = "/usr/bin/../lib/mylib"; + let p1 = ~"/usr/bin/rustc"; + let p2 = ~"/usr/bin/../lib/mylib"; let res = get_relative_to(p1, p2); - assert res == "../lib"; + assert res == ~"../lib"; } #[test] fn test_relative_to3() { - let p1 = "/usr/bin/whatever/rustc"; - let p2 = "/usr/lib/whatever/mylib"; + let p1 = ~"/usr/bin/whatever/rustc"; + let p2 = ~"/usr/lib/whatever/mylib"; let res = get_relative_to(p1, p2); - assert res == "../../lib/whatever"; + assert res == ~"../../lib/whatever"; } #[test] fn test_relative_to4() { - let p1 = "/usr/bin/whatever/../rustc"; - let p2 = "/usr/lib/whatever/mylib"; + let p1 = ~"/usr/bin/whatever/../rustc"; + let p2 = ~"/usr/lib/whatever/mylib"; let res = get_relative_to(p1, p2); - assert res == "../lib/whatever"; + assert res == ~"../lib/whatever"; } #[test] fn test_relative_to5() { - let p1 = "/usr/bin/whatever/../rustc"; - let p2 = "/usr/lib/whatever/../mylib"; + let p1 = ~"/usr/bin/whatever/../rustc"; + let p2 = ~"/usr/lib/whatever/../mylib"; let res = get_relative_to(p1, p2); - assert res == "../lib"; + assert res == ~"../lib"; } #[test] fn test_relative_to6() { - let p1 = "/1"; - let p2 = "/2/3"; + let p1 = ~"/1"; + let p2 = ~"/2/3"; let res = get_relative_to(p1, p2); - assert res == "2"; + assert res == ~"2"; } #[test] fn test_relative_to7() { - let p1 = "/1/2"; - let p2 = "/3"; + let p1 = ~"/1/2"; + let p2 = ~"/3"; let res = get_relative_to(p1, p2); - assert res == ".."; + assert res == ~".."; } #[test] fn test_relative_to8() { - let p1 = "/home/brian/Dev/rust/build/" - + "stage2/lib/rustc/i686-unknown-linux-gnu/lib/librustc.so"; - let p2 = "/home/brian/Dev/rust/build/stage2/bin/.." - + "/lib/rustc/i686-unknown-linux-gnu/lib/libstd.so"; + let p1 = ~"/home/brian/Dev/rust/build/" + + ~"stage2/lib/rustc/i686-unknown-linux-gnu/lib/librustc.so"; + let p2 = ~"/home/brian/Dev/rust/build/stage2/bin/.." + + ~"/lib/rustc/i686-unknown-linux-gnu/lib/libstd.so"; let res = get_relative_to(p1, p2); - assert res == "."; + assert res == ~"."; } #[test] @@ -317,8 +317,8 @@ mod test { let o = session::os_linux; check not_win32(o); let res = get_rpath_relative_to_output(o, - "/usr", "bin/rustc", "lib/libstd.so"); - assert res == "$ORIGIN/../lib"; + ~"/usr", ~"bin/rustc", ~"lib/libstd.so"); + assert res == ~"$ORIGIN/../lib"; } #[test] @@ -344,7 +344,7 @@ mod test { #[test] fn test_get_absolute_rpath() { - let res = get_absolute_rpath("/usr", "lib/libstd.so"); - assert res == "/usr/lib"; + let res = get_absolute_rpath(~"/usr", ~"lib/libstd.so"); + assert res == ~"/usr/lib"; } } diff --git a/src/rustc/back/target_strs.rs b/src/rustc/back/target_strs.rs index ca11e4c6d69..798c4868a7c 100644 --- a/src/rustc/back/target_strs.rs +++ b/src/rustc/back/target_strs.rs @@ -1,7 +1,7 @@ type t = { - module_asm: str, - meta_sect_name: str, - data_layout: str, - target_triple: str, - cc_args: ~[str] + module_asm: ~str, + meta_sect_name: ~str, + data_layout: ~str, + target_triple: ~str, + cc_args: ~[~str] }; diff --git a/src/rustc/back/upcall.rs b/src/rustc/back/upcall.rs index e95f7e39af4..94c69976c8c 100644 --- a/src/rustc/back/upcall.rs +++ b/src/rustc/back/upcall.rs @@ -30,7 +30,7 @@ fn declare_upcalls(targ_cfg: @session::config, _tn: type_names, tydesc_type: TypeRef, llmod: ModuleRef) -> @upcalls { - fn decl(llmod: ModuleRef, prefix: str, name: str, + fn decl(llmod: ModuleRef, prefix: ~str, name: ~str, tys: ~[TypeRef], rv: TypeRef) -> ValueRef { let mut arg_tys: ~[TypeRef] = ~[]; @@ -41,63 +41,63 @@ fn declare_upcalls(targ_cfg: @session::config, fn nothrow(f: ValueRef) -> ValueRef { base::set_no_unwind(f); f } - let d = |a,b,c| decl(llmod, "upcall_", a, b, c); - let dv = |a,b| decl(llmod, "upcall_", a, b, T_void()); + let d = |a,b,c| decl(llmod, ~"upcall_", a, b, c); + let dv = |a,b| decl(llmod, ~"upcall_", a, b, T_void()); let int_t = T_int(targ_cfg); let size_t = T_size_t(targ_cfg); - ret @{_fail: dv("fail", ~[T_ptr(T_i8()), + ret @{_fail: dv(~"fail", ~[T_ptr(T_i8()), T_ptr(T_i8()), size_t]), - trace: dv("trace", ~[T_ptr(T_i8()), + trace: dv(~"trace", ~[T_ptr(T_i8()), T_ptr(T_i8()), int_t]), malloc: - nothrow(d("malloc", + nothrow(d(~"malloc", ~[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", + nothrow(d(~"exchange_malloc", ~[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), 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()))), cmp_type: - dv("cmp_type", + dv(~"cmp_type", ~[T_ptr(T_i1()), T_ptr(tydesc_type), T_ptr(T_i8()), T_ptr(T_i8()), T_i8()]), log_type: - dv("log_type", ~[T_ptr(tydesc_type), + dv(~"log_type", ~[T_ptr(tydesc_type), 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", + d(~"call_shim_on_c_stack", // arguments: void *args, void *fn_ptr ~[T_ptr(T_i8()), T_ptr(T_i8())], int_t), call_shim_on_rust_stack: - d("call_shim_on_rust_stack", + d(~"call_shim_on_rust_stack", ~[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", ~[])) }; } // diff --git a/src/rustc/back/x86.rs b/src/rustc/back/x86.rs index 63ca5b60e65..a7cd20e875b 100644 --- a/src/rustc/back/x86.rs +++ b/src/rustc/back/x86.rs @@ -4,38 +4,39 @@ import metadata::loader::meta_section_name; fn get_target_strs(target_os: session::os) -> target_strs::t { ret { - module_asm: "", + module_asm: ~"", meta_sect_name: meta_section_name(sess_os_to_meta_os(target_os)), data_layout: alt target_os { session::os_macos { - "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16" + "-i32:32:32-i64:32:64" + - "-f32:32:32-f64:32:64-v64:64:64" + - "-v128:128:128-a0:0:64-f80:128:128" + "-n8:16:32" + ~"e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16" + + ~"-i32:32:32-i64:32:64" + + ~"-f32:32:32-f64:32:64-v64:64:64" + + ~"-v128:128:128-a0:0:64-f80:128:128" + ~"-n8:16:32" } session::os_win32 { - "e-p:32:32-f64:64:64-i64:64:64-f80:32:32-n8:16:32" + ~"e-p:32:32-f64:64:64-i64:64:64-f80:32:32-n8:16:32" } session::os_linux { - "e-p:32:32-f64:32:64-i64:32:64-f80:32:32-n8:16:32" + ~"e-p:32:32-f64:32:64-i64:32:64-f80:32:32-n8:16:32" } session::os_freebsd { - "e-p:32:32-f64:32:64-i64:32:64-f80:32:32-n8:16:32" + ~"e-p:32:32-f64:32:64-i64:32:64-f80:32:32-n8:16:32" } }, target_triple: alt target_os { - session::os_macos { "i686-apple-darwin" } - session::os_win32 { "i686-pc-mingw32" } - session::os_linux { "i686-unknown-linux-gnu" } - session::os_freebsd { "i686-unknown-freebsd" } + session::os_macos { ~"i686-apple-darwin" } + session::os_win32 { ~"i686-pc-mingw32" } + session::os_linux { ~"i686-unknown-linux-gnu" } + session::os_freebsd { ~"i686-unknown-freebsd" } }, - cc_args: ~["-m32"] + cc_args: ~[~"-m32"] }; } diff --git a/src/rustc/back/x86_64.rs b/src/rustc/back/x86_64.rs index b3e6c518dd4..63399cd2b41 100644 --- a/src/rustc/back/x86_64.rs +++ b/src/rustc/back/x86_64.rs @@ -4,45 +4,45 @@ import metadata::loader::meta_section_name; fn get_target_strs(target_os: session::os) -> target_strs::t { ret { - module_asm: "", + module_asm: ~"", meta_sect_name: meta_section_name(sess_os_to_meta_os(target_os)), data_layout: alt target_os { session::os_macos { - "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"+ - "f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-"+ - "s0:64:64-f80:128:128-n8:16:32:64" + ~"e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"+ + ~"f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-"+ + ~"s0:64:64-f80:128:128-n8:16:32:64" } session::os_win32 { // FIXME: Test this. Copied from linux (#2398) - "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"+ - "f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-"+ - "s0:64:64-f80:128:128-n8:16:32:64-S128" + ~"e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"+ + ~"f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-"+ + ~"s0:64:64-f80:128:128-n8:16:32:64-S128" } session::os_linux { - "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"+ - "f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-"+ - "s0:64:64-f80:128:128-n8:16:32:64-S128" + ~"e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"+ + ~"f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-"+ + ~"s0:64:64-f80:128:128-n8:16:32:64-S128" } session::os_freebsd { - "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"+ - "f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-"+ - "s0:64:64-f80:128:128-n8:16:32:64-S128" + ~"e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"+ + ~"f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-"+ + ~"s0:64:64-f80:128:128-n8:16:32:64-S128" } }, target_triple: alt target_os { - session::os_macos { "x86_64-apple-darwin" } - session::os_win32 { "x86_64-pc-mingw32" } - session::os_linux { "x86_64-unknown-linux-gnu" } - session::os_freebsd { "x86_64-unknown-freebsd" } + session::os_macos { ~"x86_64-apple-darwin" } + session::os_win32 { ~"x86_64-pc-mingw32" } + session::os_linux { ~"x86_64-unknown-linux-gnu" } + session::os_freebsd { ~"x86_64-unknown-freebsd" } }, - cc_args: ~["-m64"] + cc_args: ~[~"-m64"] }; } diff --git a/src/rustc/driver/driver.rs b/src/rustc/driver/driver.rs index eda52e0dcf4..47b126df332 100644 --- a/src/rustc/driver/driver.rs +++ b/src/rustc/driver/driver.rs @@ -22,45 +22,45 @@ enum pp_mode {ppm_normal, ppm_expanded, ppm_typed, ppm_identified, * The name used for source code that doesn't originate in a file * (e.g. source from stdin or a string) */ -fn anon_src() -> str { "<anon>" } +fn anon_src() -> ~str { ~"<anon>" } -fn source_name(input: input) -> str { +fn source_name(input: input) -> ~str { alt input { file_input(ifile) { ifile } str_input(_) { anon_src() } } } -fn default_configuration(sess: session, argv0: str, input: input) -> +fn default_configuration(sess: session, argv0: ~str, input: input) -> ast::crate_cfg { let libc = alt sess.targ_cfg.os { - session::os_win32 { "msvcrt.dll" } - session::os_macos { "libc.dylib" } - session::os_linux { "libc.so.6" } - session::os_freebsd { "libc.so.7" } + session::os_win32 { ~"msvcrt.dll" } + session::os_macos { ~"libc.dylib" } + session::os_linux { ~"libc.so.6" } + session::os_freebsd { ~"libc.so.7" } // _ { "libc.so" } }; let mk = attr::mk_name_value_item_str; let arch = alt sess.targ_cfg.arch { - session::arch_x86 { "x86" } - session::arch_x86_64 { "x86_64" } - session::arch_arm { "arm" } + session::arch_x86 { ~"x86" } + session::arch_x86_64 { ~"x86_64" } + session::arch_arm { ~"arm" } }; ret ~[ // Target bindings. attr::mk_word_item(@os::family()), - mk(@"target_os"/~, os::sysname()), - mk(@"target_family"/~, os::family()), - mk(@"target_arch"/~, arch), - mk(@"target_libc"/~, libc), + mk(@~"target_os", os::sysname()), + mk(@~"target_family", os::family()), + mk(@~"target_arch", arch), + mk(@~"target_libc", libc), // Build bindings. - mk(@"build_compiler"/~, argv0), - mk(@"build_input"/~, source_name(input))]; + mk(@~"build_compiler", argv0), + mk(@~"build_input", source_name(input))]; } -fn build_configuration(sess: session, argv0: str, input: input) -> +fn build_configuration(sess: session, argv0: ~str, input: input) -> ast::crate_cfg { // Combine the configuration requested by the session (command line) with // some default and generated configuration items @@ -69,16 +69,16 @@ fn build_configuration(sess: session, argv0: str, input: input) -> // If the user wants a test runner, then add the test cfg let gen_cfg = { - if sess.opts.test && !attr::contains_name(user_cfg, "test") + if sess.opts.test && !attr::contains_name(user_cfg, ~"test") { - ~[attr::mk_word_item(@"test"/~)] + ~[attr::mk_word_item(@~"test")] } else { ~[] } }; ret vec::append(vec::append(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. @@ -89,9 +89,9 @@ fn parse_cfgspecs(cfgspecs: ~[str]) -> ast::crate_cfg { enum input { /// Load source from file - file_input(str), + file_input(~str), /// The string is the source - str_input(str) + str_input(~str) } fn parse_input(sess: session, cfg: ast::crate_cfg, input: input) @@ -108,7 +108,7 @@ fn parse_input(sess: session, cfg: ast::crate_cfg, input: input) } } -fn time<T>(do_it: bool, what: str, thunk: fn() -> T) -> T { +fn time<T>(do_it: bool, what: ~str, thunk: fn() -> T) -> T { if !do_it { ret thunk(); } let start = std::time::precise_time_s(); let rv = thunk(); @@ -131,93 +131,93 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg, outputs: option<output_filenames>) -> {crate: @ast::crate, tcx: option<ty::ctxt>} { let time_passes = sess.time_passes(); - let mut crate = time(time_passes, "parsing", + let mut crate = time(time_passes, ~"parsing", ||parse_input(sess, cfg, input) ); if upto == cu_parse { ret {crate: crate, tcx: none}; } sess.building_library = session::building_library( sess.opts.crate_type, crate, sess.opts.test); - crate = time(time_passes, "configuration", || + crate = time(time_passes, ~"configuration", || front::config::strip_unconfigured_items(crate)); - crate = time(time_passes, "maybe building test harness", || + crate = time(time_passes, ~"maybe building test harness", || front::test::modify_for_testing(sess, crate)); - crate = time(time_passes, "expansion", || + crate = time(time_passes, ~"expansion", || syntax::ext::expand::expand_crate(sess.parse_sess, sess.opts.cfg, crate)); if upto == cu_expand { ret {crate: crate, tcx: none}; } - crate = time(time_passes, "intrinsic injection", || + crate = time(time_passes, ~"intrinsic injection", || front::intrinsic_inject::inject_intrinsic(sess, crate)); - crate = time(time_passes, "core injection", || + crate = time(time_passes, ~"core injection", || front::core_inject::maybe_inject_libcore_ref(sess, crate)); - time(time_passes, "building warning settings table", || + time(time_passes, ~"building warning settings table", || lint::build_settings_crate(sess, crate)); - let ast_map = time(time_passes, "ast indexing", || + let ast_map = time(time_passes, ~"ast indexing", || syntax::ast_map::map_crate(sess.diagnostic(), *crate)); - time(time_passes, "external crate/lib resolution", || + time(time_passes, ~"external crate/lib resolution", || creader::read_crates(sess.diagnostic(), *crate, sess.cstore, sess.filesearch, session::sess_os_to_meta_os(sess.targ_cfg.os), sess.opts.static)); let { def_map: def_map, exp_map: exp_map, impl_map: impl_map } = - time(time_passes, "resolution", || + time(time_passes, ~"resolution", || middle::resolve3::resolve_crate(sess, ast_map, crate)); - let freevars = time(time_passes, "freevar finding", || + let freevars = time(time_passes, ~"freevar finding", || freevars::annotate_freevars(def_map, crate)); - let region_map = time(time_passes, "region resolution", || + let region_map = time(time_passes, ~"region resolution", || middle::region::resolve_crate(sess, def_map, crate)); - let rp_set = time(time_passes, "region paramerization inference", || + let rp_set = time(time_passes, ~"region paramerization inference", || middle::region::determine_rp_in_crate(sess, ast_map, def_map, crate)); let ty_cx = ty::mk_ctxt(sess, def_map, ast_map, freevars, region_map, rp_set); - let (method_map, vtable_map) = time(time_passes, "typechecking", || + let (method_map, vtable_map) = time(time_passes, ~"typechecking", || typeck::check_crate(ty_cx, impl_map, crate)); - time(time_passes, "const checking", || + time(time_passes, ~"const checking", || middle::check_const::check_crate(sess, crate, ast_map, def_map, method_map, ty_cx)); if upto == cu_typeck { ret {crate: crate, tcx: some(ty_cx)}; } - time(time_passes, "block-use checking", || + time(time_passes, ~"block-use checking", || middle::block_use::check_crate(ty_cx, crate)); - time(time_passes, "loop checking", || + time(time_passes, ~"loop checking", || middle::check_loop::check_crate(ty_cx, crate)); - time(time_passes, "alt checking", || + time(time_passes, ~"alt checking", || middle::check_alt::check_crate(ty_cx, crate)); - let last_use_map = time(time_passes, "liveness checking", || + let last_use_map = time(time_passes, ~"liveness checking", || middle::liveness::check_crate(ty_cx, method_map, crate)); - time(time_passes, "typestate checking", || + time(time_passes, ~"typestate checking", || middle::tstate::ck::check_crate(ty_cx, crate)); - let (root_map, mutbl_map) = time(time_passes, "borrow checking", || + let (root_map, mutbl_map) = time(time_passes, ~"borrow checking", || middle::borrowck::check_crate(ty_cx, method_map, last_use_map, crate)); - time(time_passes, "kind checking", || + time(time_passes, ~"kind checking", || kind::check_crate(ty_cx, method_map, last_use_map, crate)); - time(time_passes, "lint checking", || lint::check_crate(ty_cx, crate)); + time(time_passes, ~"lint checking", || lint::check_crate(ty_cx, crate)); if upto == cu_no_trans { ret {crate: crate, tcx: some(ty_cx)}; } let outputs = option::get(outputs); @@ -227,11 +227,11 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg, impl_map: impl_map, method_map: method_map, vtable_map: vtable_map}; - let (llmod, link_meta) = time(time_passes, "translation", || + let (llmod, link_meta) = time(time_passes, ~"translation", || trans::base::trans_crate(sess, crate, ty_cx, outputs.obj_filename, exp_map, maps)); - time(time_passes, "LLVM passes", || + time(time_passes, ~"LLVM passes", || link::write::run_passes(sess, llmod, outputs.obj_filename)); let stop_after_codegen = @@ -240,7 +240,7 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg, if stop_after_codegen { ret {crate: crate, tcx: some(ty_cx)}; } - time(time_passes, "linking", || + time(time_passes, ~"linking", || link::link_binary(sess, outputs.obj_filename, outputs.out_filename, link_meta)); @@ -248,7 +248,7 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg, } fn compile_input(sess: session, cfg: ast::crate_cfg, input: input, - outdir: option<str>, output: option<str>) { + outdir: option<~str>, output: option<~str>) { let upto = if sess.opts.parse_only { cu_parse } else if sess.opts.no_trans { cu_no_trans } @@ -266,7 +266,7 @@ fn pretty_print_input(sess: session, cfg: ast::crate_cfg, input: input, alt node { pprust::node_expr(s, expr) { pp::space(s.s); - pp::word(s.s, "as"); + pp::word(s.s, ~"as"); pp::space(s.s); pp::word(s.s, ppaux::ty_to_str(tcx, ty::expr_ty(tcx, expr))); pprust::pclose(s); @@ -283,7 +283,7 @@ fn pretty_print_input(sess: session, cfg: ast::crate_cfg, input: input, pprust::node_block(s, blk) { pp::space(s.s); pprust::synth_comment(s, - "block " + int::to_str(blk.node.id, 10u)); + ~"block " + int::to_str(blk.node.id, 10u)); } pprust::node_expr(s, expr) { pp::space(s.s); @@ -292,7 +292,7 @@ fn pretty_print_input(sess: session, cfg: ast::crate_cfg, input: input, } pprust::node_pat(s, pat) { pp::space(s.s); - pprust::synth_comment(s, "pat " + int::to_str(pat.id, 10u)); + pprust::synth_comment(s, ~"pat " + int::to_str(pat.id, 10u)); } } } @@ -327,29 +327,29 @@ fn pretty_print_input(sess: session, cfg: ast::crate_cfg, input: input, } } -fn get_os(triple: str) -> option<session::os> { - ret if str::contains(triple, "win32") || - str::contains(triple, "mingw32") { +fn get_os(triple: ~str) -> option<session::os> { + ret if str::contains(triple, ~"win32") || + str::contains(triple, ~"mingw32") { some(session::os_win32) - } else if str::contains(triple, "darwin") { + } else if str::contains(triple, ~"darwin") { some(session::os_macos) - } else if str::contains(triple, "linux") { + } else if str::contains(triple, ~"linux") { some(session::os_linux) - } else if str::contains(triple, "freebsd") { + } else if str::contains(triple, ~"freebsd") { some(session::os_freebsd) } else { none }; } -fn get_arch(triple: str) -> option<session::arch> { - ret if str::contains(triple, "i386") || str::contains(triple, "i486") || - str::contains(triple, "i586") || - str::contains(triple, "i686") || - str::contains(triple, "i786") { +fn get_arch(triple: ~str) -> option<session::arch> { + ret if str::contains(triple, ~"i386") || str::contains(triple, ~"i486") || + str::contains(triple, ~"i586") || + str::contains(triple, ~"i686") || + str::contains(triple, ~"i786") { some(session::arch_x86) - } else if str::contains(triple, "x86_64") { + } else if str::contains(triple, ~"x86_64") { some(session::arch_x86_64) - } else if str::contains(triple, "arm") || - str::contains(triple, "xscale") { + } else if str::contains(triple, ~"arm") || + str::contains(triple, ~"xscale") { some(session::arch_arm) } else { none }; } @@ -358,12 +358,12 @@ fn build_target_config(sopts: @session::options, demitter: diagnostic::emitter) -> @session::config { let os = alt get_os(sopts.target_triple) { some(os) { os } - none { early_error(demitter, "unknown operating system") } + none { early_error(demitter, ~"unknown operating system") } }; let arch = alt get_arch(sopts.target_triple) { some(arch) { arch } none { early_error(demitter, - "unknown architecture: " + sopts.target_triple) } + ~"unknown architecture: " + sopts.target_triple) } }; let (int_type, uint_type, float_type) = alt arch { session::arch_x86 {(ast::ty_i32, ast::ty_u32, ast::ty_f64)} @@ -381,7 +381,7 @@ fn build_target_config(sopts: @session::options, ret target_cfg; } -fn host_triple() -> str { +fn host_triple() -> ~str { // Get the host triple out of the build environment. This ensures that our // idea of the host triple is the same as for the set of libraries we've // actually built. We can't just take LLVM's host triple because they @@ -391,29 +391,29 @@ fn host_triple() -> str { // be grabbing (at compile time) the target triple that this rustc is // built with and calling that (at runtime) the host triple. let ht = #env("CFG_HOST_TRIPLE"); - ret if ht != "" { + ret if ht != ~"" { ht } else { - fail "rustc built without CFG_HOST_TRIPLE" + fail ~"rustc built without CFG_HOST_TRIPLE" }; } fn build_session_options(match: getopts::match, demitter: diagnostic::emitter) -> @session::options { - let crate_type = if opt_present(match, "lib") { + let crate_type = if opt_present(match, ~"lib") { session::lib_crate - } else if opt_present(match, "bin") { + } else if opt_present(match, ~"bin") { session::bin_crate } else { session::unknown_crate }; - let static = opt_present(match, "static"); + let static = opt_present(match, ~"static"); - let parse_only = opt_present(match, "parse-only"); - let no_trans = opt_present(match, "no-trans"); + let parse_only = opt_present(match, ~"parse-only"); + let no_trans = opt_present(match, ~"no-trans"); - let lint_flags = vec::append(getopts::opt_strs(match, "W"), - getopts::opt_strs(match, "warn")); + let lint_flags = vec::append(getopts::opt_strs(match, ~"W"), + getopts::opt_strs(match, ~"warn")); let lint_dict = lint::get_lint_dict(); let lint_opts = do vec::map(lint_flags) |flag| { alt lint::lookup_lint(lint_dict, flag) { @@ -425,7 +425,7 @@ fn build_session_options(match: getopts::match, }; let mut debugging_opts = 0u; - let debug_flags = getopts::opt_strs(match, "Z"); + let debug_flags = getopts::opt_strs(match, ~"Z"); let debug_map = session::debugging_opts_map(); for debug_flags.each |debug_flag| { let mut this_bit = 0u; @@ -442,40 +442,41 @@ fn build_session_options(match: getopts::match, let output_type = if parse_only || no_trans { link::output_type_none - } else if opt_present(match, "S") && opt_present(match, "emit-llvm") { + } else if opt_present(match, ~"S") && + opt_present(match, ~"emit-llvm") { link::output_type_llvm_assembly - } else if opt_present(match, "S") { + } else if opt_present(match, ~"S") { link::output_type_assembly - } else if opt_present(match, "c") { + } else if opt_present(match, ~"c") { link::output_type_object - } else if opt_present(match, "emit-llvm") { + } else if opt_present(match, ~"emit-llvm") { link::output_type_bitcode } else { link::output_type_exe }; - let extra_debuginfo = opt_present(match, "xg"); - let debuginfo = opt_present(match, "g") || extra_debuginfo; - let sysroot_opt = getopts::opt_maybe_str(match, "sysroot"); - let target_opt = getopts::opt_maybe_str(match, "target"); - let save_temps = getopts::opt_present(match, "save-temps"); + let extra_debuginfo = opt_present(match, ~"xg"); + let debuginfo = opt_present(match, ~"g") || extra_debuginfo; + let sysroot_opt = getopts::opt_maybe_str(match, ~"sysroot"); + let target_opt = getopts::opt_maybe_str(match, ~"target"); + let save_temps = getopts::opt_present(match, ~"save-temps"); alt output_type { // unless we're emitting huamn-readable assembly, omit comments. link::output_type_llvm_assembly | link::output_type_assembly {} _ { debugging_opts |= session::no_asm_comments; } } let opt_level: uint = - if opt_present(match, "O") { - if opt_present(match, "opt-level") { - early_error(demitter, "-O and --opt-level both provided"); + if opt_present(match, ~"O") { + if opt_present(match, ~"opt-level") { + early_error(demitter, ~"-O and --opt-level both provided"); } 2u - } else if opt_present(match, "opt-level") { - alt getopts::opt_str(match, "opt-level") { - "0" { 0u } - "1" { 1u } - "2" { 2u } - "3" { 3u } + } else if opt_present(match, ~"opt-level") { + alt getopts::opt_str(match, ~"opt-level") { + ~"0" { 0u } + ~"1" { 1u } + ~"2" { 2u } + ~"3" { 3u } _ { - early_error(demitter, "optimization level needs " + - "to be between 0-3") + early_error(demitter, ~"optimization level needs " + + ~"to be between 0-3") } } } else { 0u }; @@ -485,9 +486,9 @@ fn build_session_options(match: getopts::match, some(s) { s } }; - let addl_lib_search_paths = getopts::opt_strs(match, "L"); - let cfg = parse_cfgspecs(getopts::opt_strs(match, "cfg")); - let test = opt_present(match, "test"); + let addl_lib_search_paths = getopts::opt_strs(match, ~"L"); + let cfg = parse_cfgspecs(getopts::opt_strs(match, ~"cfg")); + let test = opt_present(match, ~"test"); let sopts: @session::options = @{crate_type: crate_type, static: static, @@ -545,44 +546,45 @@ fn build_session_( warning_settings: warning_settings} } -fn parse_pretty(sess: session, &&name: str) -> pp_mode { - if str::eq(name, "normal") { +fn parse_pretty(sess: session, &&name: ~str) -> pp_mode { + if str::eq(name, ~"normal") { ret ppm_normal; - } else if str::eq(name, "expanded") { + } else if str::eq(name, ~"expanded") { ret ppm_expanded; - } else if str::eq(name, "typed") { + } else if str::eq(name, ~"typed") { ret ppm_typed; - } else if str::eq(name, "expanded,identified") { + } else if str::eq(name, ~"expanded,identified") { ret ppm_expanded_identified; - } else if str::eq(name, "identified") { + } else if str::eq(name, ~"identified") { ret ppm_identified; } - sess.fatal("argument to `pretty` must be one of `normal`, `typed`, or " + - "`identified`"); + sess.fatal(~"argument to `pretty` must be one of `normal`, `typed`, or " + + ~"`identified`"); } 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"), - optflag("O"), optopt("opt-level"), optmulti("L"), optflag("S"), - optopt("o"), optopt("out-dir"), optflag("xg"), - optflag("c"), optflag("g"), optflag("save-temps"), - optopt("sysroot"), optopt("target"), + ret ~[optflag(~"h"), optflag(~"help"), optflag(~"v"), optflag(~"version"), + optflag(~"emit-llvm"), optflagopt(~"pretty"), + optflag(~"ls"), optflag(~"parse-only"), optflag(~"no-trans"), + optflag(~"O"), optopt(~"opt-level"), optmulti(~"L"), optflag(~"S"), + optopt(~"o"), optopt(~"out-dir"), optflag(~"xg"), + optflag(~"c"), optflag(~"g"), optflag(~"save-temps"), + optopt(~"sysroot"), optopt(~"target"), - optmulti("W"), optmulti("warn"), + optmulti(~"W"), optmulti(~"warn"), - optmulti("Z"), + optmulti(~"Z"), - optmulti("cfg"), optflag("test"), - optflag("lib"), optflag("bin"), optflag("static"), optflag("gc")]; + optmulti(~"cfg"), optflag(~"test"), + optflag(~"lib"), optflag(~"bin"), + optflag(~"static"), optflag(~"gc")]; } -type output_filenames = @{out_filename: str, obj_filename:str}; +type output_filenames = @{out_filename: ~str, obj_filename:~str}; fn build_output_filenames(input: input, - odir: option<str>, - ofile: option<str>, + odir: option<~str>, + ofile: option<~str>, sess: session) -> output_filenames { let obj_path; @@ -595,13 +597,13 @@ fn build_output_filenames(input: input, let obj_suffix = alt sopts.output_type { - link::output_type_none { "none" } - link::output_type_bitcode { "bc" } - link::output_type_assembly { "s" } - link::output_type_llvm_assembly { "ll" } + link::output_type_none { ~"none" } + link::output_type_bitcode { ~"bc" } + link::output_type_assembly { ~"s" } + link::output_type_llvm_assembly { ~"ll" } // Object and exe output both use the '.o' extension here link::output_type_object | link::output_type_exe { - "o" + ~"o" } }; @@ -630,7 +632,7 @@ fn build_output_filenames(input: input, path::basename(path) } str_input(_) { - "rust_out" + ~"rust_out" } }; let base_path = path::connect(dirname, base_filename); @@ -640,10 +642,10 @@ fn build_output_filenames(input: input, let basename = path::basename(base_path); let dylibname = os::dll_filename(basename); out_path = path::connect(dirname, dylibname); - obj_path = path::connect(dirname, basename + "." + obj_suffix); + obj_path = path::connect(dirname, basename + ~"." + obj_suffix); } else { out_path = base_path; - obj_path = base_path + "." + obj_suffix; + obj_path = base_path + ~"." + obj_suffix; } } @@ -653,7 +655,7 @@ fn build_output_filenames(input: input, out_file } else { let (base, _) = path::splitext(out_file); - let modified = base + "." + obj_suffix; + let modified = base + ~"." + obj_suffix; modified }; @@ -665,7 +667,7 @@ fn build_output_filenames(input: input, } if odir != none { - sess.warn("ignoring --out-dir flag due to -o flag."); + sess.warn(~"ignoring --out-dir flag due to -o flag."); } } } @@ -673,12 +675,12 @@ fn build_output_filenames(input: input, obj_filename: obj_path}; } -fn early_error(emitter: diagnostic::emitter, msg: str) -> ! { +fn early_error(emitter: diagnostic::emitter, msg: ~str) -> ! { emitter(none, msg, diagnostic::fatal); fail; } -fn list_metadata(sess: session, path: str, out: io::writer) { +fn list_metadata(sess: session, path: ~str, out: io::writer) { metadata::loader::list_file_metadata( session::sess_os_to_meta_os(sess.targ_cfg.os), path, out); } @@ -690,15 +692,15 @@ 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: " + + err(f) { fail ~"test_switch_implies_cfg_test: " + getopts::fail_str(f); } }; let sessopts = build_session_options(match, diagnostic::emit); let sess = build_session(sessopts, diagnostic::emit); - let cfg = build_configuration(sess, "whatever", str_input("")); - assert (attr::contains_name(cfg, "test")); + let cfg = build_configuration(sess, ~"whatever", str_input(~"")); + assert (attr::contains_name(cfg, ~"test")); } // When the user supplies --test and --cfg test, don't implicitly add @@ -706,15 +708,17 @@ 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); } + err(f) { + fail ~"test_switch_implies_cfg_test_unless_cfg_test: " + + getopts::fail_str(f); + } }; let sessopts = build_session_options(match, diagnostic::emit); let sess = build_session(sessopts, diagnostic::emit); - let cfg = build_configuration(sess, "whatever", str_input("")); - let test_items = attr::find_meta_items_by_name(cfg, "test"); + let cfg = build_configuration(sess, ~"whatever", str_input(~"")); + let test_items = attr::find_meta_items_by_name(cfg, ~"test"); assert (vec::len(test_items) == 1u); } } diff --git a/src/rustc/driver/rustc.rs b/src/rustc/driver/rustc.rs index 5a9c6774db5..e54ca83ebdc 100644 --- a/src/rustc/driver/rustc.rs +++ b/src/rustc/driver/rustc.rs @@ -20,17 +20,17 @@ import rustc::driver::session; import rustc::middle::lint; import io::reader_util; -fn version(argv0: str) { - let mut vers = "unknown version"; +fn version(argv0: ~str) { + let mut vers = ~"unknown version"; let env_vers = #env["CFG_VERSION"]; if str::len(env_vers) != 0u { vers = env_vers; } io::println(#fmt("%s %s", argv0, vers)); io::println(#fmt("host: %s", host_triple())); } -fn usage(argv0: str) { +fn usage(argv0: ~str) { io::println(#fmt("Usage: %s [options] <input>\n", argv0) + - " + ~" Options: --bin Compile an executable crate (default) @@ -81,24 +81,24 @@ fn describe_warnings() { let lint_dict = lint::get_lint_dict(); let mut max_key = 0u; for lint_dict.each_key |k| { max_key = uint::max(k.len(), max_key); } - fn padded(max: uint, s: str) -> str { + fn padded(max: uint, s: ~str) -> ~str { str::from_bytes(vec::from_elem(max - s.len(), ' ' as u8)) + s } io::println(#fmt("\nAvailable warnings:\n")); io::println(#fmt(" %s %7.7s %s", - padded(max_key, "name"), "default", "meaning")); + padded(max_key, ~"name"), ~"default", ~"meaning")); io::println(#fmt(" %s %7.7s %s\n", - padded(max_key, "----"), "-------", "-------")); + padded(max_key, ~"----"), ~"-------", ~"-------")); for lint_dict.each |k, v| { - let k = str::replace(k, "_", "-"); + let k = str::replace(k, ~"_", ~"-"); io::println(#fmt(" %s %7.7s %s", padded(max_key, k), - alt v.default { lint::warn { "warn" } - lint::error { "error" } - lint::ignore { "ignore" } }, + alt v.default { lint::warn { ~"warn" } + lint::error { ~"error" } + lint::ignore { ~"ignore" } }, v.desc)); } - io::println(""); + io::println(~""); } fn describe_debug_flags() { @@ -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(); @@ -126,62 +126,62 @@ fn run_compiler(args: ~[str], demitter: diagnostic::emitter) { } }; - if opt_present(match, "h") || opt_present(match, "help") { + if opt_present(match, ~"h") || opt_present(match, ~"help") { usage(binary); ret; } - let lint_flags = vec::append(getopts::opt_strs(match, "W"), - getopts::opt_strs(match, "warn")); - if lint_flags.contains("help") { + let lint_flags = vec::append(getopts::opt_strs(match, ~"W"), + getopts::opt_strs(match, ~"warn")); + if lint_flags.contains(~"help") { describe_warnings(); ret; } - if getopts::opt_strs(match, "Z").contains("help") { + if getopts::opt_strs(match, ~"Z").contains(~"help") { describe_debug_flags(); ret; } - if opt_present(match, "v") || opt_present(match, "version") { + if opt_present(match, ~"v") || opt_present(match, ~"version") { version(binary); ret; } let input = alt vec::len(match.free) { - 0u { early_error(demitter, "no input filename given") } + 0u { early_error(demitter, ~"no input filename given") } 1u { let ifile = match.free[0]; - if ifile == "-" { + if ifile == ~"-" { let src = str::from_bytes(io::stdin().read_whole_stream()); str_input(src) } else { file_input(ifile) } } - _ { early_error(demitter, "multiple input filenames provided") } + _ { early_error(demitter, ~"multiple input filenames provided") } }; let sopts = build_session_options(match, demitter); let sess = build_session(sopts, demitter); - let odir = getopts::opt_maybe_str(match, "out-dir"); - let ofile = getopts::opt_maybe_str(match, "o"); + let odir = getopts::opt_maybe_str(match, ~"out-dir"); + let ofile = getopts::opt_maybe_str(match, ~"o"); let cfg = build_configuration(sess, binary, input); let pretty = - option::map(getopts::opt_default(match, "pretty", - "normal"), + option::map(getopts::opt_default(match, ~"pretty", + ~"normal"), |a| parse_pretty(sess, a) ); alt pretty { some::<pp_mode>(ppm) { pretty_print_input(sess, cfg, input, ppm); ret; } none::<pp_mode> {/* continue */ } } - let ls = opt_present(match, "ls"); + let ls = opt_present(match, ~"ls"); if ls { alt input { file_input(ifile) { list_metadata(sess, ifile, io::stdout()); } str_input(_) { - early_error(demitter, "can not list metadata for stdin"); + early_error(demitter, ~"can not list metadata for stdin"); } } ret; @@ -216,7 +216,7 @@ fn monitor(+f: fn~(diagnostic::emitter)) { // The 'diagnostics emitter'. Every error, warning, etc. should // go through this function. let demitter = fn@(cmsp: option<(codemap::codemap, codemap::span)>, - msg: str, lvl: diagnostic::level) { + msg: ~str, lvl: diagnostic::level) { if lvl == diagnostic::fatal { comm::send(ch, fatal); } @@ -239,13 +239,13 @@ fn monitor(+f: fn~(diagnostic::emitter)) { if comm::recv(p) == done { diagnostic::emit( none, - diagnostic::ice_msg("unexpected failure"), + diagnostic::ice_msg(~"unexpected failure"), diagnostic::error); for [ - "the compiler hit an unexpected failure path. \ + ~"the compiler hit an unexpected failure path. \ this is a bug", - "try running with RUST_LOG=rustc=0,::rt::backtrace \ + ~"try running with RUST_LOG=rustc=0,::rt::backtrace \ to get further details and report the results \ to github.com/mozilla/rust/issues" ]/_.each |note| { @@ -258,7 +258,7 @@ fn monitor(+f: fn~(diagnostic::emitter)) { } } -fn main(args: ~[str]) { +fn main(args: ~[~str]) { do monitor |demitter| { run_compiler(args, demitter); } diff --git a/src/rustc/driver/session.rs b/src/rustc/driver/session.rs index 8daa4ec8e8a..3697934dbc0 100644 --- a/src/rustc/driver/session.rs +++ b/src/rustc/driver/session.rs @@ -40,23 +40,24 @@ const borrowck_stats: uint = 1024u; const borrowck_note_pure: uint = 2048; const borrowck_note_loan: uint = 4096; -fn debugging_opts_map() -> ~[(str, str, uint)] { - ~[("ppregions", "prettyprint regions with \ +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), - ("count-llvm-insns", "count where LLVM \ + (~"time-passes", ~"measure time of each rustc pass", time_passes), + (~"count-llvm-insns", ~"count where LLVM \ instrs originate", count_llvm_insns), - ("time-llvm-passes", "measure time of each LLVM pass", time_llvm_passes), - ("trans-stats", "gather trans statistics", trans_stats), - ("no-asm-comments", "omit comments when using -S", no_asm_comments), - ("no-verify", "skip LLVM verification", no_verify), - ("trace", "emit trace logs", trace), - ("no-rt", "do not link to the runtime", no_rt), - ("coherence", "perform coherence checking", coherence), - ("borrowck-stats", "gather borrowck statistics", borrowck_stats), - ("borrowck-note-pure", "note where purity is req'd", + (~"time-llvm-passes", ~"measure time of each LLVM pass", + time_llvm_passes), + (~"trans-stats", ~"gather trans statistics", trans_stats), + (~"no-asm-comments", ~"omit comments when using -S", no_asm_comments), + (~"no-verify", ~"skip LLVM verification", no_verify), + (~"trace", ~"emit trace logs", trace), + (~"no-rt", ~"do not link to the runtime", no_rt), + (~"coherence", ~"perform coherence checking", coherence), + (~"borrowck-stats", ~"gather borrowck statistics", borrowck_stats), + (~"borrowck-note-pure", ~"note where purity is req'd", borrowck_note_pure), - ("borrowck-note-loan", "note where loans are req'd", + (~"borrowck-note-loan", ~"note where loans are req'd", borrowck_note_loan) ] } @@ -72,9 +73,9 @@ type options = lint_opts: ~[(lint::lint, lint::level)], save_temps: bool, output_type: back::link::output_type, - addl_lib_search_paths: ~[str], - maybe_sysroot: option<str>, - target_triple: str, + addl_lib_search_paths: ~[~str], + maybe_sysroot: option<~str>, + target_triple: ~str, cfg: ast::crate_cfg, test: bool, parse_only: bool, @@ -82,7 +83,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, @@ -94,20 +95,20 @@ type session = @{targ_cfg: @config, span_diagnostic: diagnostic::span_handler, filesearch: filesearch::filesearch, mut building_library: bool, - working_dir: str, + working_dir: ~str, warning_settings: lint::warning_settings}; impl session for session { - fn span_fatal(sp: span, msg: str) -> ! { + fn span_fatal(sp: span, msg: ~str) -> ! { self.span_diagnostic.span_fatal(sp, msg) } - fn fatal(msg: str) -> ! { + fn fatal(msg: ~str) -> ! { self.span_diagnostic.handler().fatal(msg) } - fn span_err(sp: span, msg: str) { + fn span_err(sp: span, msg: ~str) { self.span_diagnostic.span_err(sp, msg) } - fn err(msg: str) { + fn err(msg: ~str) { self.span_diagnostic.handler().err(msg) } fn has_errors() -> bool { @@ -116,32 +117,32 @@ impl session for session { fn abort_if_errors() { self.span_diagnostic.handler().abort_if_errors() } - fn span_warn(sp: span, msg: str) { + fn span_warn(sp: span, msg: ~str) { self.span_diagnostic.span_warn(sp, msg) } - fn warn(msg: str) { + fn warn(msg: ~str) { self.span_diagnostic.handler().warn(msg) } - fn span_note(sp: span, msg: str) { + fn span_note(sp: span, msg: ~str) { self.span_diagnostic.span_note(sp, msg) } - fn note(msg: str) { + fn note(msg: ~str) { self.span_diagnostic.handler().note(msg) } - fn span_bug(sp: span, msg: str) -> ! { + fn span_bug(sp: span, msg: ~str) -> ! { self.span_diagnostic.span_bug(sp, msg) } - fn bug(msg: str) -> ! { + fn bug(msg: ~str) -> ! { self.span_diagnostic.handler().bug(msg) } - fn span_unimpl(sp: span, msg: str) -> ! { + fn span_unimpl(sp: span, msg: ~str) -> ! { self.span_diagnostic.span_unimpl(sp, msg) } - fn unimpl(msg: str) -> ! { + fn unimpl(msg: ~str) -> ! { self.span_diagnostic.handler().unimpl(msg) } fn span_lint_level(level: lint::level, - sp: span, msg: str) { + sp: span, msg: ~str) { alt level { lint::ignore { } lint::warn { self.span_warn(sp, msg); } @@ -150,7 +151,7 @@ impl session for session { } fn span_lint(lint_mode: lint::lint, expr_id: ast::node_id, item_id: ast::node_id, - span: span, msg: str) { + span: span, msg: ~str) { let level = lint::get_warning_settings_level( self.warning_settings, lint_mode, expr_id, item_id); self.span_lint_level(level, span, msg); @@ -201,7 +202,7 @@ fn basic_options() -> @options { } // Seems out of place, but it uses session, so I'm putting it here -fn expect<T: copy>(sess: session, opt: option<T>, msg: fn() -> str) -> T { +fn expect<T: copy>(sess: session, opt: option<T>, msg: fn() -> ~str) -> T { diagnostic::expect(sess.diagnostic(), opt, msg) } @@ -216,8 +217,8 @@ fn building_library(req_crate_type: crate_type, crate: @ast::crate, } else { alt syntax::attr::first_attr_value_str_by_name( crate.node.attrs, - "crate_type") { - option::some(@"lib"/~) { true } + ~"crate_type") { + option::some(@~"lib") { true } _ { false } } } @@ -240,12 +241,12 @@ fn sess_os_to_meta_os(os: os) -> metadata::loader::os { mod test { import syntax::ast_util; - fn make_crate_type_attr(t: str) -> ast::attribute { + fn make_crate_type_attr(t: ~str) -> ast::attribute { ast_util::respan(ast_util::dummy_sp(), { style: ast::attr_outer, value: ast_util::respan(ast_util::dummy_sp(), ast::meta_name_value( - @"crate_type"/~, + @~"crate_type", ast_util::respan(ast_util::dummy_sp(), ast::lit_str(@t)))), is_sugared_doc: false @@ -254,8 +255,8 @@ 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")]; } + 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: ~[]}, diff --git a/src/rustc/front/config.rs b/src/rustc/front/config.rs index a044b45b3ae..c633cf5d2af 100644 --- a/src/rustc/front/config.rs +++ b/src/rustc/front/config.rs @@ -125,7 +125,7 @@ fn in_cfg(cfg: ast::crate_cfg, attrs: ~[ast::attribute]) -> 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"); + let cfg_metas = attr::find_meta_items_by_name(metas, ~"cfg"); // Pull the inner meta_items from the #[cfg(meta_item, ...)] attributes, // so we can match against them. This is the list of configurations for diff --git a/src/rustc/front/core_inject.rs b/src/rustc/front/core_inject.rs index c16fbabdcce..24b1a8094e3 100644 --- a/src/rustc/front/core_inject.rs +++ b/src/rustc/front/core_inject.rs @@ -16,7 +16,7 @@ fn maybe_inject_libcore_ref(sess: session, } fn use_core(crate: @ast::crate) -> bool { - !attr::attrs_contains_name(crate.node.attrs, "no_core") + !attr::attrs_contains_name(crate.node.attrs, ~"no_core") } fn inject_libcore_ref(sess: session, @@ -30,11 +30,11 @@ 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), + 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"/~), + let vp = spanned(ast::view_path_glob(ident_to_path(dummy_sp(), @~"core"), n2)); let vi2 = @{node: ast::view_item_import(~[vp]), attrs: ~[], diff --git a/src/rustc/front/intrinsic.rs b/src/rustc/front/intrinsic.rs index 21d8777e22d..7f2e11ecccd 100644 --- a/src/rustc/front/intrinsic.rs +++ b/src/rustc/front/intrinsic.rs @@ -64,14 +64,14 @@ mod intrinsic { fn visit_enter_rec(n_fields: uint, sz: uint, align: uint) -> bool; - fn visit_rec_field(i: uint, name: str/&, + fn visit_rec_field(i: uint, name: &str, mtbl: uint, inner: *tydesc) -> bool; fn visit_leave_rec(n_fields: uint, sz: uint, align: uint) -> bool; fn visit_enter_class(n_fields: uint, sz: uint, align: uint) -> bool; - fn visit_class_field(i: uint, name: str/&, + fn visit_class_field(i: uint, name: &str, mtbl: uint, inner: *tydesc) -> bool; fn visit_leave_class(n_fields: uint, sz: uint, align: uint) -> bool; @@ -87,12 +87,12 @@ mod intrinsic { fn visit_enter_enum_variant(variant: uint, disr_val: int, n_fields: uint, - name: str/&) -> bool; + name: &str) -> bool; fn visit_enum_variant_field(i: uint, inner: *tydesc) -> bool; fn visit_leave_enum_variant(variant: uint, disr_val: int, n_fields: uint, - name: str/&) -> bool; + name: &str) -> bool; fn visit_leave_enum(n_variants: uint, sz: uint, align: uint) -> bool; diff --git a/src/rustc/front/intrinsic_inject.rs b/src/rustc/front/intrinsic_inject.rs index 9f2741804bf..ea841c0700c 100644 --- a/src/rustc/front/intrinsic_inject.rs +++ b/src/rustc/front/intrinsic_inject.rs @@ -9,7 +9,7 @@ fn inject_intrinsic(sess: session, let intrinsic_module = @#include_str("intrinsic.rs"); - let item = parse::parse_item_from_source_str("<intrinsic>", + let item = parse::parse_item_from_source_str(~"<intrinsic>", intrinsic_module, sess.opts.cfg, ~[], ast::public, @@ -18,7 +18,7 @@ fn inject_intrinsic(sess: session, alt item { some(i) { i } none { - sess.fatal("no item found in intrinsic module"); + sess.fatal(~"no item found in intrinsic module"); } }; diff --git a/src/rustc/front/test.rs b/src/rustc/front/test.rs index f533c922531..17b92f6925e 100644 --- a/src/rustc/front/test.rs +++ b/src/rustc/front/test.rs @@ -58,7 +58,7 @@ fn strip_test_functions(crate: @ast::crate) -> @ast::crate { // When not compiling with --test we should not compile the // #[test] functions do config::strip_items(crate) |attrs| { - !attr::contains_name(attr::attr_metas(attrs), "test") + !attr::contains_name(attr::attr_metas(attrs), ~"test") } } @@ -72,7 +72,7 @@ fn fold_mod(_cx: test_ctxt, m: ast::_mod, fld: fold::ast_fold) -> ast::_mod { fn nomain(&&item: @ast::item) -> option<@ast::item> { alt item.node { ast::item_fn(_, _, _) { - if *item.ident == "main" { + if *item.ident == ~"main" { option::none } else { option::some(item) } } @@ -106,7 +106,7 @@ fn fold_item(cx: test_ctxt, &&i: @ast::item, fld: fold::ast_fold) -> ast::item_fn(decl, _, _) if decl.purity == ast::unsafe_fn { cx.sess.span_fatal( i.span, - "unsafe functions cannot be used for tests"); + ~"unsafe functions cannot be used for tests"); } _ { #debug("this is a test function"); @@ -126,7 +126,7 @@ fn fold_item(cx: test_ctxt, &&i: @ast::item, fld: fold::ast_fold) -> fn is_test_fn(i: @ast::item) -> bool { let has_test_attr = - vec::len(attr::find_attrs_by_name(i.attrs, "test")) > 0u; + vec::len(attr::find_attrs_by_name(i.attrs, ~"test")) > 0u; fn has_test_signature(i: @ast::item) -> bool { alt i.node { @@ -144,7 +144,7 @@ fn is_test_fn(i: @ast::item) -> bool { } fn is_ignored(cx: test_ctxt, i: @ast::item) -> bool { - let ignoreattrs = attr::find_attrs_by_name(i.attrs, "ignore"); + let ignoreattrs = attr::find_attrs_by_name(i.attrs, ~"ignore"); let ignoreitems = attr::attr_metas(ignoreattrs); let cfg_metas = vec::concat(vec::filter_map(ignoreitems, |&&i| attr::get_meta_item_list(i) )); @@ -156,7 +156,7 @@ fn is_ignored(cx: test_ctxt, i: @ast::item) -> bool { } fn should_fail(i: @ast::item) -> bool { - vec::len(attr::find_attrs_by_name(i.attrs, "should_fail")) > 0u + vec::len(attr::find_attrs_by_name(i.attrs, ~"should_fail")) > 0u } fn add_test_module(cx: test_ctxt, m: ast::_mod) -> ast::_mod { @@ -192,9 +192,9 @@ fn mk_test_module(cx: test_ctxt) -> @ast::item { 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"/~)); + attr::mk_attr(attr::mk_word_item(@~"!resolve_unexported")); let item: ast::item = - {ident: @"__test"/~, + {ident: @~"__test", attrs: ~[resolve_unexported_attr], id: cx.sess.next_node_id(), node: item_, @@ -233,7 +233,7 @@ fn mk_tests(cx: test_ctxt) -> @ast::item { let item_ = ast::item_fn(decl, ~[], body); let item: ast::item = - {ident: @"tests"/~, + {ident: @~"tests", attrs: ~[], id: cx.sess.next_node_id(), node: item_, @@ -247,19 +247,19 @@ fn mk_path(cx: test_ctxt, path: ~[ast::ident]) -> ~[ast::ident] { // the paths with std:: let is_std = { let items = attr::find_linkage_metas(cx.crate.node.attrs); - alt attr::last_meta_item_value_str_by_name(items, "name") { - some(@"std"/~) { true } + alt attr::last_meta_item_value_str_by_name(items, ~"name") { + some(@~"std") { true } _ { false } } }; if is_std { path } - else { vec::append(~[@"std"/~], path) } + else { vec::append(~[@~"std"], path) } } // 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"/~])); + path_node(mk_path(cx, ~[@~"test", @~"test_desc"])); let test_desc_ty: ast::ty = {id: cx.sess.next_node_id(), @@ -314,7 +314,7 @@ fn mk_test_desc_rec(cx: test_ctxt, test: test) -> @ast::expr { let name_field: ast::field = - nospan({mutbl: ast::m_imm, ident: @"name"/~, expr: @name_expr}); + nospan({mutbl: ast::m_imm, ident: @~"name", expr: @name_expr}); let fn_path = path_node(path); @@ -327,7 +327,7 @@ fn mk_test_desc_rec(cx: test_ctxt, test: test) -> @ast::expr { let fn_wrapper_expr = mk_test_wrapper(cx, fn_expr, span); let fn_field: ast::field = - nospan({mutbl: ast::m_imm, ident: @"fn"/~, expr: fn_wrapper_expr}); + nospan({mutbl: ast::m_imm, ident: @~"fn", expr: fn_wrapper_expr}); let ignore_lit: ast::lit = nospan(ast::lit_bool(test.ignore)); @@ -338,7 +338,7 @@ fn mk_test_desc_rec(cx: test_ctxt, test: test) -> @ast::expr { span: span}; let ignore_field: ast::field = - nospan({mutbl: ast::m_imm, ident: @"ignore"/~, expr: @ignore_expr}); + nospan({mutbl: ast::m_imm, ident: @~"ignore", expr: @ignore_expr}); let fail_lit: ast::lit = nospan(ast::lit_bool(test.should_fail)); @@ -350,7 +350,7 @@ fn mk_test_desc_rec(cx: test_ctxt, test: test) -> @ast::expr { let fail_field: ast::field = nospan({mutbl: ast::m_imm, - ident: @"should_fail"/~, + ident: @~"should_fail", expr: @fail_expr}); let desc_rec_: ast::expr_ = @@ -406,7 +406,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_inner = @{id: cx.sess.next_node_id(), node: ast::ty_path(str_pt, cx.sess.next_node_id()), span: dummy_sp()}; @@ -425,7 +425,7 @@ fn mk_main(cx: test_ctxt) -> @ast::item { let args_arg: ast::arg = {mode: ast::expl(ast::by_val), ty: @args_ty, - ident: @"args"/~, + ident: @~"args", id: cx.sess.next_node_id()}; let ret_ty = {id: cx.sess.next_node_id(), @@ -448,7 +448,7 @@ fn mk_main(cx: test_ctxt) -> @ast::item { let item_ = ast::item_fn(decl, ~[], body); let item: ast::item = - {ident: @"main"/~, + {ident: @~"main", attrs: ~[], id: cx.sess.next_node_id(), node: item_, @@ -460,7 +460,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); @@ -469,7 +469,7 @@ fn mk_test_main_call(cx: test_ctxt) -> @ast::expr { 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); @@ -484,7 +484,7 @@ fn mk_test_main_call(cx: test_ctxt) -> @ast::expr { 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); diff --git a/src/rustc/lib/llvm.rs b/src/rustc/lib/llvm.rs index 1df423cdbb2..0c00a8674a5 100644 --- a/src/rustc/lib/llvm.rs +++ b/src/rustc/lib/llvm.rs @@ -987,19 +987,19 @@ fn SetLinkage(Global: ValueRef, Link: Linkage) { /* Memory-managed object interface to type handles. */ -type type_names = @{type_names: std::map::hashmap<TypeRef, str>, - named_types: std::map::hashmap<str, TypeRef>}; +type type_names = @{type_names: std::map::hashmap<TypeRef, ~str>, + named_types: std::map::hashmap<~str, TypeRef>}; -fn associate_type(tn: type_names, s: str, t: TypeRef) { +fn associate_type(tn: type_names, s: ~str, t: TypeRef) { assert tn.type_names.insert(t, s); assert tn.named_types.insert(s, t); } -fn type_has_name(tn: type_names, t: TypeRef) -> option<str> { +fn type_has_name(tn: type_names, t: TypeRef) -> option<~str> { ret tn.type_names.find(t); } -fn name_has_type(tn: type_names, s: str) -> option<TypeRef> { +fn name_has_type(tn: type_names, s: ~str) -> option<TypeRef> { ret tn.named_types.find(s); } @@ -1010,12 +1010,12 @@ fn mk_type_names() -> type_names { named_types: std::map::str_hash()} } -fn type_to_str(names: type_names, ty: TypeRef) -> str { +fn type_to_str(names: type_names, ty: TypeRef) -> ~str { ret type_to_str_inner(names, ~[], ty); } fn type_to_str_inner(names: type_names, outer0: ~[TypeRef], ty: TypeRef) -> - str { + ~str { alt type_has_name(names, ty) { option::some(n) { ret n; } _ {} @@ -1026,30 +1026,30 @@ fn type_to_str_inner(names: type_names, outer0: ~[TypeRef], ty: TypeRef) -> let kind = llvm::LLVMGetTypeKind(ty); fn tys_str(names: type_names, outer: ~[TypeRef], - tys: ~[TypeRef]) -> str { - let mut s: str = ""; + tys: ~[TypeRef]) -> ~str { + let mut s: ~str = ~""; let mut first: bool = true; for tys.each |t| { - if first { first = false; } else { s += ", "; } + if first { first = false; } else { s += ~", "; } s += type_to_str_inner(names, outer, t); } ret s; } alt kind { - Void { ret "Void"; } - Half { ret "Half"; } - Float { ret "Float"; } - Double { ret "Double"; } - X86_FP80 { ret "X86_FP80"; } - FP128 { ret "FP128"; } - PPC_FP128 { ret "PPC_FP128"; } - Label { ret "Label"; } + Void { ret ~"Void"; } + Half { ret ~"Half"; } + Float { ret ~"Float"; } + Double { ret ~"Double"; } + X86_FP80 { ret ~"X86_FP80"; } + FP128 { ret ~"FP128"; } + PPC_FP128 { ret ~"PPC_FP128"; } + Label { ret ~"Label"; } Integer { - ret "i" + int::str(llvm::LLVMGetIntTypeWidth(ty) as int); + ret ~"i" + int::str(llvm::LLVMGetIntTypeWidth(ty) as int); } Function { - let mut s = "fn("; + let mut s = ~"fn("; let out_ty: TypeRef = llvm::LLVMGetReturnType(ty); let n_args = llvm::LLVMCountParamTypes(ty) as uint; let args = vec::from_elem(n_args, 0 as TypeRef); @@ -1057,25 +1057,25 @@ fn type_to_str_inner(names: type_names, outer0: ~[TypeRef], ty: TypeRef) -> llvm::LLVMGetParamTypes(ty, vec::unsafe::to_ptr(args)); } s += tys_str(names, outer, args); - s += ") -> "; + s += ~") -> "; s += type_to_str_inner(names, outer, out_ty); ret s; } Struct { - let mut s: str = "{"; + let mut s: ~str = ~"{"; let n_elts = llvm::LLVMCountStructElementTypes(ty) as uint; let elts = vec::from_elem(n_elts, 0 as TypeRef); unsafe { llvm::LLVMGetStructElementTypes(ty, vec::unsafe::to_ptr(elts)); } s += tys_str(names, outer, elts); - s += "}"; + s += ~"}"; ret s; } Array { let el_ty = llvm::LLVMGetElementType(ty); - ret "[" + type_to_str_inner(names, outer, el_ty) + " x " + - uint::str(llvm::LLVMGetArrayLength(ty) as uint) + "]"; + ret ~"[" + type_to_str_inner(names, outer, el_ty) + ~" x " + + uint::str(llvm::LLVMGetArrayLength(ty) as uint) + ~"]"; } Pointer { let mut i: uint = 0u; @@ -1083,23 +1083,23 @@ fn type_to_str_inner(names: type_names, outer0: ~[TypeRef], ty: TypeRef) -> i += 1u; if tout as int == ty as int { let n: uint = vec::len::<TypeRef>(outer0) - i; - ret "*\\" + int::str(n as int); + ret ~"*\\" + int::str(n as int); } } let addrstr = { let addrspace = llvm::LLVMGetPointerAddressSpace(ty) as uint; if addrspace == 0u { - "" + ~"" } else { #fmt("addrspace(%u)", addrspace) } }; - ret addrstr + "*" + + ret addrstr + ~"*" + type_to_str_inner(names, outer, llvm::LLVMGetElementType(ty)); } - Vector { ret "Vector"; } - Metadata { ret "Metadata"; } - X86_MMX { ret "X86_MMAX"; } + Vector { ret ~"Vector"; } + Metadata { ret ~"Metadata"; } + X86_MMX { ret ~"X86_MMAX"; } } } @@ -1109,7 +1109,7 @@ fn float_width(llt: TypeRef) -> uint { 2 { 64u } 3 { 80u } 4 | 5 { 128u } - _ { fail "llvm_float_width called on a non-float type" } + _ { fail ~"llvm_float_width called on a non-float type" } }; } @@ -1131,7 +1131,7 @@ class target_data_res { type target_data = {lltd: TargetDataRef, dtor: @target_data_res}; -fn mk_target_data(string_rep: str) -> target_data { +fn mk_target_data(string_rep: ~str) -> target_data { let lltd = str::as_c_str(string_rep, |buf| llvm::LLVMCreateTargetData(buf) ); ret {lltd: lltd, dtor: @target_data_res(lltd)}; diff --git a/src/rustc/metadata/common.rs b/src/rustc/metadata/common.rs index b6883097a5b..e7ef25a04d5 100644 --- a/src/rustc/metadata/common.rs +++ b/src/rustc/metadata/common.rs @@ -127,11 +127,11 @@ enum astencode_tag { // Reserves 0x50 -- 0x6f // djb's cdb hashes. fn hash_node_id(&&node_id: int) -> uint { ret 177573u ^ (node_id as uint); } -fn hash_path(&&s: str) -> uint { +fn hash_path(&&s: ~str) -> uint { let mut h = 5381u; for str::each(s) |ch| { h = (h << 5u) + h ^ (ch as uint); } ret h; } -type link_meta = {name: @str/~, vers: @str/~, extras_hash: str}; +type link_meta = {name: @~str, vers: @~str, extras_hash: ~str}; diff --git a/src/rustc/metadata/creader.rs b/src/rustc/metadata/creader.rs index 09713da9c74..28022a37320 100644 --- a/src/rustc/metadata/creader.rs +++ b/src/rustc/metadata/creader.rs @@ -38,7 +38,7 @@ fn read_crates(diag: span_handler, crate: ast::crate, type cache_entry = { cnum: int, span: span, - hash: @str/~, + hash: @~str, metas: @~[@ast::meta_item] }; @@ -49,7 +49,7 @@ fn dump_crates(crate_cache: dvec<cache_entry>) { #debug("span: %?", entry.span); #debug("hash: %?", entry.hash); let attrs = ~[ - attr::mk_attr(attr::mk_list_item(@"link"/~, *entry.metas)) + 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)); @@ -79,9 +79,9 @@ fn warn_if_multiple_versions(diag: span_handler, diag.handler().warn( #fmt("using multiple versions of crate `%s`", *name)); for matches.each |match| { - diag.span_note(match.span, "used here"); + diag.span_note(match.span, ~"used here"); let attrs = ~[ - attr::mk_attr(attr::mk_list_item(@"link"/~, *match.metas)) + attr::mk_attr(attr::mk_list_item(@~"link", *match.metas)) ]; loader::note_linkage_attrs(diag, attrs); } @@ -103,7 +103,7 @@ fn visit_view_item(e: env, i: @ast::view_item) { alt i.node { ast::view_item_use(ident, meta_items, id) { #debug("resolving use stmt. ident: %?, meta: %?", ident, meta_items); - let cnum = resolve_crate(e, ident, meta_items, "", i.span); + let cnum = resolve_crate(e, ident, meta_items, ~"", i.span); cstore::add_use_stmt_cnum(e.cstore, id, cnum); } _ { } @@ -123,25 +123,25 @@ fn visit_item(e: env, i: @ast::item) { let cstore = e.cstore; let foreign_name = - alt attr::first_attr_value_str_by_name(i.attrs, "link_name") { + alt attr::first_attr_value_str_by_name(i.attrs, ~"link_name") { some(nn) { - if *nn == "" { + if *nn == ~"" { e.diag.span_fatal( i.span, - "empty #[link_name] not allowed; use #[nolink]."); + ~"empty #[link_name] not allowed; use #[nolink]."); } nn } none { i.ident } }; let mut already_added = false; - if vec::len(attr::find_attrs_by_name(i.attrs, "nolink")) == 0u { + if vec::len(attr::find_attrs_by_name(i.attrs, ~"nolink")) == 0u { already_added = !cstore::add_used_library(cstore, *foreign_name); } - let link_args = attr::find_attrs_by_name(i.attrs, "link_args"); + let link_args = attr::find_attrs_by_name(i.attrs, ~"link_args"); if vec::len(link_args) > 0u && already_added { - e.diag.span_fatal(i.span, "library '" + *foreign_name + - "' already added: can't specify link_args."); + e.diag.span_fatal(i.span, ~"library '" + *foreign_name + + ~"' already added: can't specify link_args."); } for link_args.each |a| { alt attr::get_meta_item_value_str(attr::attr_meta(a)) { @@ -168,10 +168,10 @@ fn metas_with(ident: ast::ident, key: ast::ident, fn metas_with_ident(ident: ast::ident, metas: ~[@ast::meta_item]) -> ~[@ast::meta_item] { - metas_with(ident, @"name"/~, metas) + 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| { @@ -184,7 +184,7 @@ fn existing_match(e: env, metas: ~[@ast::meta_item], hash: str) -> } fn resolve_crate(e: env, ident: ast::ident, metas: ~[@ast::meta_item], - hash: str, span: span) -> ast::crate_num { + hash: ~str, span: span) -> ast::crate_num { let metas = metas_with_ident(ident, metas); alt existing_match(e, metas, hash) { @@ -218,7 +218,7 @@ fn resolve_crate(e: env, ident: ast::ident, metas: ~[@ast::meta_item], let cnum_map = resolve_crate_deps(e, cdata); let cname = - alt attr::last_meta_item_value_str_by_name(metas, "name") { + alt attr::last_meta_item_value_str_by_name(metas, ~"name") { option::some(v) { v } option::none { ident } }; @@ -245,7 +245,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) { diff --git a/src/rustc/metadata/csearch.rs b/src/rustc/metadata/csearch.rs index 16b2481edd9..22d70f86eb8 100644 --- a/src/rustc/metadata/csearch.rs +++ b/src/rustc/metadata/csearch.rs @@ -30,7 +30,7 @@ export get_impl_method; export get_item_path; export maybe_get_item_ast, found_ast, found, found_parent, not_found; -fn get_symbol(cstore: cstore::cstore, def: ast::def_id) -> str { +fn get_symbol(cstore: cstore::cstore, def: ast::def_id) -> ~str { let cdata = cstore::get_crate_data(cstore, def.crate).data; ret decoder::get_symbol(cdata, def.node); } diff --git a/src/rustc/metadata/cstore.rs b/src/rustc/metadata/cstore.rs index f805d8d16cd..af9b6d57e57 100644 --- a/src/rustc/metadata/cstore.rs +++ b/src/rustc/metadata/cstore.rs @@ -37,9 +37,9 @@ type cnum_map = map::hashmap<ast::crate_num, ast::crate_num>; // Multiple items may have the same def_id in crate metadata. They may be // renamed imports or reexports. This map keeps the "real" module path // and def_id. -type mod_path_map = map::hashmap<ast::def_id, @str/~>; +type mod_path_map = map::hashmap<ast::def_id, @~str>; -type crate_metadata = @{name: str, +type crate_metadata = @{name: ~str, 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>; @@ -83,12 +83,12 @@ fn get_crate_data(cstore: cstore, cnum: ast::crate_num) -> crate_metadata { ret p(cstore).metas.get(cnum); } -fn get_crate_hash(cstore: cstore, cnum: ast::crate_num) -> @str/~ { +fn get_crate_hash(cstore: cstore, cnum: ast::crate_num) -> @~str { let cdata = get_crate_data(cstore, cnum); ret decoder::get_crate_hash(cdata.data); } -fn get_crate_vers(cstore: cstore, cnum: ast::crate_num) -> @str/~ { +fn get_crate_vers(cstore: cstore, cnum: ast::crate_num) -> @~str { let cdata = get_crate_data(cstore, cnum); ret decoder::get_crate_vers(cdata.data); } @@ -111,33 +111,33 @@ fn iter_crate_data(cstore: cstore, i: fn(ast::crate_num, crate_metadata)) { for p(cstore).metas.each |k,v| { i(k, v);}; } -fn add_used_crate_file(cstore: cstore, lib: str) { +fn add_used_crate_file(cstore: cstore, lib: ~str) { if !vec::contains(p(cstore).used_crate_files, lib) { vec::push(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; } -fn add_used_library(cstore: cstore, lib: str) -> bool { - assert lib != ""; +fn add_used_library(cstore: cstore, lib: ~str) -> bool { + assert lib != ~""; if vec::contains(p(cstore).used_libraries, lib) { ret false; } vec::push(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; } -fn add_used_link_args(cstore: cstore, args: str) { +fn add_used_link_args(cstore: cstore, args: ~str) { vec::push_all(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,8 +153,8 @@ 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/~] { - type crate_hash = {name: @str/~, hash: @str/~}; +fn get_dep_hashes(cstore: cstore) -> ~[@~str] { + type crate_hash = {name: @~str, hash: @~str}; let mut result = ~[]; for p(cstore).use_crate_map.each_value |cnum| { @@ -171,14 +171,14 @@ fn get_dep_hashes(cstore: cstore) -> ~[@str/~] { for sorted.each |x| { #debug(" hash[%s]: %s", *x.name, *x.hash); } - fn mapper(ch: crate_hash) -> @str/~ { ret ch.hash; } + fn mapper(ch: crate_hash) -> @~str { ret ch.hash; } ret vec::map(sorted, mapper); } 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), ~[], - |ds| str::split_str(*ds, "::").map(|x| @x ) ) + |ds| str::split_str(*ds, ~"::").map(|x| @x ) ) } // Local Variables: // mode: rust diff --git a/src/rustc/metadata/decoder.rs b/src/rustc/metadata/decoder.rs index bd3697a23b2..45bdee06070 100644 --- a/src/rustc/metadata/decoder.rs +++ b/src/rustc/metadata/decoder.rs @@ -112,7 +112,7 @@ fn item_family(item: ebml::doc) -> char { ebml::doc_as_u8(fam) as char } -fn item_symbol(item: ebml::doc) -> str { +fn item_symbol(item: ebml::doc) -> ~str { let sym = ebml::get_doc(item, tag_items_data_item_symbol); ret str::from_bytes(ebml::doc_data(sym)); } @@ -214,7 +214,7 @@ fn enum_variant_ids(item: ebml::doc, cdata: cmd) -> ~[ast::def_id] { // 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 eq_item(data: &[u8], s: ~str) -> bool { // XXX: Use string equality. let data_len = data.len(); let s_len = s.len(); @@ -385,7 +385,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)); } @@ -399,19 +399,19 @@ enum def_like { fn def_like_to_def(def_like: def_like) -> ast::def { alt def_like { dl_def(def) { ret def; } - dl_impl(*) { fail "found impl in def_like_to_def"; } - dl_field { fail "found field in def_like_to_def"; } + dl_impl(*) { fail ~"found impl in def_like_to_def"; } + dl_field { fail ~"found field in def_like_to_def"; } } } // A path. class path_entry { // The full path, separated by '::'. - let path_string: str; + let path_string: ~str; // The definition, implementation, or field that this path corresponds to. let def_like: def_like; - new(path_string: str, def_like: def_like) { + new(path_string: ~str, def_like: def_like) { self.path_string = path_string; self.def_like = def_like; } @@ -429,8 +429,8 @@ fn each_path(cdata: cmd, f: fn(path_entry) -> bool) { do ebml::tagged_docs(items_data, tag_items_data_item) |item_doc| { if !broken { let name = ast_map::path_to_str_with_sep(item_path(item_doc), - "::"); - if name != "" { + ~"::"); + if name != ~"" { // Extract the def ID. let def_id = class_member_id(item_doc, cdata); @@ -628,7 +628,7 @@ fn get_trait_methods(cdata: cmd, id: ast::node_id, tcx: ty::ctxt) let fty = alt ty::get(ty).struct { ty::ty_fn(f) { f } _ { tcx.diag.handler().bug( - "get_trait_methods: id has non-function type"); + ~"get_trait_methods: id has non-function type"); } }; vec::push(result, {ident: name, tps: bounds, fty: fty, purity: alt check item_family(mth) { @@ -684,7 +684,7 @@ fn family_names_type(fam_ch: char) -> bool { alt fam_ch { 'y' | 't' | 'I' { true } _ { false } } } -fn read_path(d: ebml::doc) -> {path: str, pos: uint} { +fn read_path(d: ebml::doc) -> {path: ~str, pos: uint} { let desc = ebml::doc_data(d); let pos = io::u64_from_be_bytes(desc, 0u, 4u) as uint; let pathbytes = vec::slice::<u8>(desc, 4u, vec::len::<u8>(desc)); @@ -692,8 +692,8 @@ fn read_path(d: ebml::doc) -> {path: str, pos: uint} { ret {path: path, pos: pos}; } -fn describe_def(items: ebml::doc, id: ast::def_id) -> str { - if id.crate != ast::local_crate { ret "external"; } +fn describe_def(items: ebml::doc, id: ast::def_id) -> ~str { + if id.crate != ast::local_crate { ret ~"external"; } let it = alt maybe_find_item(id.node, items) { some(it) { it } none { fail (#fmt("describe_def: item not found %?", id)); } @@ -701,26 +701,26 @@ fn describe_def(items: ebml::doc, id: ast::def_id) -> str { ret item_family_to_str(item_family(it)); } -fn item_family_to_str(fam: char) -> str { +fn item_family_to_str(fam: char) -> ~str { alt check fam { - 'c' { ret "const"; } - 'f' { ret "fn"; } - 'u' { ret "unsafe fn"; } - 'p' { ret "pure fn"; } - 'F' { ret "foreign fn"; } - 'U' { ret "unsafe foreign fn"; } - 'P' { ret "pure foreign fn"; } - 'y' { ret "type"; } - 'T' { ret "foreign type"; } - 't' { ret "type"; } - 'm' { ret "mod"; } - 'n' { ret "foreign mod"; } - 'v' { ret "enum"; } - 'i' { ret "impl"; } - 'I' { ret "trait"; } - 'C' { ret "class"; } - 'g' { ret "public field"; } - 'j' { ret "private field"; } + 'c' { ret ~"const"; } + 'f' { ret ~"fn"; } + 'u' { ret ~"unsafe fn"; } + 'p' { ret ~"pure fn"; } + 'F' { ret ~"foreign fn"; } + 'U' { ret ~"unsafe foreign fn"; } + 'P' { ret ~"pure foreign fn"; } + 'y' { ret ~"type"; } + 'T' { ret ~"foreign type"; } + 't' { ret ~"type"; } + 'm' { ret ~"mod"; } + 'n' { ret ~"foreign mod"; } + 'v' { ret ~"enum"; } + 'i' { ret ~"impl"; } + 'I' { ret ~"trait"; } + 'C' { ret ~"class"; } + 'g' { ret ~"public field"; } + 'j' { ret ~"private field"; } } } @@ -776,14 +776,14 @@ fn list_meta_items(meta_items: ebml::doc, out: io::writer) { } } -fn list_crate_attributes(md: ebml::doc, hash: @str/~, out: io::writer) { +fn list_crate_attributes(md: ebml::doc, hash: @~str, out: io::writer) { out.write_str(#fmt("=Crate Attributes (%s)=\n", *hash)); for get_attributes(md).each |attr| { out.write_str(#fmt["%s\n", pprust::attribute_to_str(attr)]); } - out.write_str("\n\n"); + out.write_str(~"\n\n"); } fn get_crate_attributes(data: @~[u8]) -> ~[ast::attribute] { @@ -791,14 +791,14 @@ fn get_crate_attributes(data: @~[u8]) -> ~[ast::attribute] { } type crate_dep = {cnum: ast::crate_num, name: ast::ident, - vers: @str/~, hash: @str/~}; + vers: @~str, hash: @~str}; 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; - fn docstr(doc: ebml::doc, tag_: uint) -> str { + fn docstr(doc: ebml::doc, tag_: uint) -> ~str { str::from_bytes(ebml::doc_data(ebml::get_doc(doc, tag_))) } do ebml::tagged_docs(depsdoc, tag_crate_dep) |depdoc| { @@ -812,33 +812,33 @@ fn get_crate_deps(data: @~[u8]) -> ~[crate_dep] { } fn list_crate_deps(data: @~[u8], out: io::writer) { - out.write_str("=External Dependencies=\n"); + out.write_str(~"=External Dependencies=\n"); for get_crate_deps(data).each |dep| { out.write_str(#fmt["%d %s-%s-%s\n", dep.cnum, *dep.name, *dep.hash, *dep.vers]); } - out.write_str("\n"); + 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") { + attr::find_linkage_metas(attrs), ~"vers") { some(ver) { ver } - none { @"0.0"/~ } + none { @~"0.0" } }; } fn list_crate_items(bytes: @~[u8], md: ebml::doc, out: io::writer) { - out.write_str("=Items=\n"); + out.write_str(~"=Items=\n"); let items = ebml::get_doc(md, tag_items); do iter_crate_items(bytes) |tag, path, did| { // Don't print out any metadata info about intrinsics @@ -847,10 +847,10 @@ fn list_crate_items(bytes: @~[u8], md: ebml::doc, out: io::writer) { describe_def(items, did)]); } } - out.write_str("\n"); + out.write_str(~"\n"); } -fn iter_crate_items(bytes: @~[u8], proc: fn(uint, str, ast::def_id)) { +fn iter_crate_items(bytes: @~[u8], proc: fn(uint, ~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); @@ -867,9 +867,9 @@ fn iter_crate_items(bytes: @~[u8], proc: fn(uint, str, ast::def_id)) { }; } -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, "::")), "::") +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 @@ -913,7 +913,7 @@ fn translate_def_id(cdata: cmd, did: ast::def_id) -> ast::def_id { alt cdata.cnum_map.find(did.crate) { option::some(n) { ret {crate: n, node: did.node}; } - option::none { fail "didn't find a crate in the cnum_map"; } + option::none { fail ~"didn't find a crate in the cnum_map"; } } } diff --git a/src/rustc/metadata/encoder.rs b/src/rustc/metadata/encoder.rs index 8b8df41ab43..d1ecf88b3fe 100644 --- a/src/rustc/metadata/encoder.rs +++ b/src/rustc/metadata/encoder.rs @@ -43,10 +43,10 @@ type encode_parms = { diag: span_handler, tcx: ty::ctxt, reachable: hashmap<ast::node_id, ()>, - reexports: ~[(str, 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>, + item_symbols: hashmap<ast::node_id, ~str>, + discrim_symbols: hashmap<ast::node_id, ~str>, link_meta: link_meta, cstore: cstore::cstore, encode_inlined_item: encode_inlined_item @@ -56,10 +56,10 @@ enum encode_ctxt = { diag: span_handler, tcx: ty::ctxt, reachable: hashmap<ast::node_id, ()>, - reexports: ~[(str, 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>, + item_symbols: hashmap<ast::node_id, ~str>, + discrim_symbols: hashmap<ast::node_id, ~str>, link_meta: link_meta, cstore: cstore::cstore, encode_inlined_item: encode_inlined_item, @@ -109,7 +109,7 @@ 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>]) { + path: ~[ident], &index: ~[entry<~str>]) { for variants.each |variant| { add_to_index(ebml_w, path, index, variant.node.name); do ebml_w.wr_tag(tag_paths_data_item) { @@ -119,7 +119,7 @@ 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 mut full_path = ~[]; vec::push_all(full_path, path); @@ -129,7 +129,7 @@ fn add_to_index(ebml_w: ebml::writer, path: &[ident], &index: ~[entry<str>], } fn encode_foreign_module_item_paths(ebml_w: ebml::writer, nmod: foreign_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); do ebml_w.wr_tag(tag_paths_foreign_path) { @@ -140,7 +140,7 @@ fn encode_foreign_module_item_paths(ebml_w: ebml::writer, nmod: foreign_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 { again; } @@ -158,7 +158,7 @@ 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>]) { + &index: ~[entry<~str>]) { for module.items.each |it| { if !reachable(ecx, it.id) || !ast_util::is_exported(it.ident, module) { again; } @@ -220,7 +220,7 @@ fn encode_module_item_paths(ebml_w: ebml::writer, ecx: @encode_ctxt, } } item_impl(*) {} - item_mac(*) { fail "item macros unimplemented" } + item_mac(*) { fail ~"item macros unimplemented" } } } } @@ -232,8 +232,8 @@ fn encode_trait_ref(ebml_w: ebml::writer, ecx: @encode_ctxt, t: @trait_ref) { } fn encode_item_paths(ebml_w: ebml::writer, ecx: @encode_ctxt, crate: @crate) - -> ~[entry<str>] { - let mut index: ~[entry<str>] = ~[]; + -> ~[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); @@ -243,7 +243,7 @@ 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; vec::push(index, {val: path, pos: ebml_w.writer.tell()}); @@ -264,7 +264,7 @@ fn encode_family(ebml_w: ebml::writer, c: char) { ebml_w.end_tag(); } -fn def_to_str(did: def_id) -> str { ret #fmt["%d:%d", did.crate, did.node]; } +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]) { @@ -641,7 +641,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item, do option::iter(m_dtor) |dtor| { vec::push(*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 { + + ~"_dtor"), path, if tps.len() > 0u { some(ii_dtor(dtor, item.ident, tps, local_def(item.id))) } else { none }, tps, ast_util::dtor_dec()); @@ -766,7 +766,7 @@ 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(); } - item_mac(*) { fail "item macros unimplemented" } + item_mac(*) { fail ~"item macros unimplemented" } } } @@ -802,7 +802,7 @@ fn encode_info_for_items(ecx: @encode_ctxt, ebml_w: ebml::writer, ebml_w.start_tag(tag_items_data); vec::push(*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| { @@ -886,7 +886,7 @@ fn encode_index<T>(ebml_w: ebml::writer, buckets: ~[@~[entry<T>]], ebml_w.end_tag(); } -fn write_str(writer: io::writer, &&s: str) { writer.write_str(s); } +fn write_str(writer: io::writer, &&s: ~str) { writer.write_str(s); } fn write_int(writer: io::writer, &&n: int) { writer.write_be_uint(n as uint, 4u); @@ -948,22 +948,22 @@ fn synthesize_crate_attrs(ecx: @encode_ctxt, crate: @crate) -> ~[attribute] { fn synthesize_link_attr(ecx: @encode_ctxt, items: ~[@meta_item]) -> attribute { - assert (*ecx.link_meta.name != ""); - assert (*ecx.link_meta.vers != ""); + assert (*ecx.link_meta.name != ~""); + assert (*ecx.link_meta.vers != ~""); let name_item = - attr::mk_name_value_item_str(@"name"/~, *ecx.link_meta.name); + attr::mk_name_value_item_str(@~"name", *ecx.link_meta.name); let vers_item = - attr::mk_name_value_item_str(@"vers"/~, *ecx.link_meta.vers); + attr::mk_name_value_item_str(@~"vers", *ecx.link_meta.vers); let other_items = { - let tmp = attr::remove_meta_items_by_name(items, @"name"/~); - attr::remove_meta_items_by_name(tmp, @"vers"/~) + let tmp = attr::remove_meta_items_by_name(items, @~"name"); + attr::remove_meta_items_by_name(tmp, @~"vers") }; let meta_items = vec::append(~[name_item, vers_item], other_items); - let link_item = attr::mk_list_item(@"link"/~, meta_items); + let link_item = attr::mk_list_item(@~"link", meta_items); ret attr::mk_attr(link_item); } @@ -973,7 +973,7 @@ fn synthesize_crate_attrs(ecx: @encode_ctxt, crate: @crate) -> ~[attribute] { for crate.node.attrs.each |attr| { vec::push( attrs, - if *attr::get_attr_name(attr) != "link" { + if *attr::get_attr_name(attr) != ~"link" { attr } else { alt attr.node.value.node { @@ -1046,7 +1046,7 @@ fn encode_crate_dep(ebml_w: ebml::writer, dep: decoder::crate_dep) { ebml_w.end_tag(); } -fn encode_hash(ebml_w: ebml::writer, hash: str) { +fn encode_hash(ebml_w: ebml::writer, hash: ~str) { ebml_w.start_tag(tag_crate_hash); ebml_w.writer.write(str::bytes(hash)); ebml_w.end_tag(); @@ -1099,7 +1099,7 @@ fn encode_metadata(parms: encode_parms, crate: @crate) -> ~[u8] { } // Get the encoded string for a type -fn encoded_ty(tcx: ty::ctxt, t: ty::t) -> str { +fn encoded_ty(tcx: ty::ctxt, t: ty::t) -> ~str { let cx = @{diag: tcx.diag, ds: def_to_str, tcx: tcx, diff --git a/src/rustc/metadata/filesearch.rs b/src/rustc/metadata/filesearch.rs index ab42afb1edd..cb773589dcc 100644 --- a/src/rustc/metadata/filesearch.rs +++ b/src/rustc/metadata/filesearch.rs @@ -31,11 +31,11 @@ iface filesearch { } fn mk_filesearch(maybe_sysroot: option<path>, - target_triple: str, + target_triple: ~str, addl_lib_search_paths: ~[path]) -> filesearch { type filesearch_impl = {sysroot: path, addl_lib_search_paths: ~[path], - target_triple: str}; + target_triple: ~str}; impl of filesearch for filesearch_impl { fn sysroot() -> path { self.sysroot } fn lib_search_paths() -> ~[path] { @@ -88,12 +88,12 @@ 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 { + target_triple: ~str) -> path { let path = vec::append(~[sysroot], relative_target_lib_path(target_triple)); let path = path::connect_many(path); @@ -102,9 +102,9 @@ fn make_target_lib_path(sysroot: path, fn get_default_sysroot() -> path { alt os::self_exe_path() { - option::some(p) { path::normalize(path::connect(p, "..")) } + option::some(p) { path::normalize(path::connect(p, ~"..")) } option::none { - fail "can't determine value for sysroot"; + fail ~"can't determine value for sysroot"; } } } @@ -116,30 +116,30 @@ fn get_sysroot(maybe_sysroot: option<path>) -> path { } } -fn get_cargo_sysroot() -> result<path, str> { - let path = ~[get_default_sysroot(), libdir(), "cargo"]; +fn get_cargo_sysroot() -> result<path, ~str> { + let path = ~[get_default_sysroot(), libdir(), ~"cargo"]; result::ok(path::connect_many(path)) } -fn get_cargo_root() -> result<path, str> { - alt os::getenv("CARGO_ROOT") { +fn get_cargo_root() -> result<path, ~str> { + alt os::getenv(~"CARGO_ROOT") { some(_p) { result::ok(_p) } none { alt os::homedir() { - some(_q) { result::ok(path::connect(_q, ".cargo")) } - none { result::err("no CARGO_ROOT or home directory") } + some(_q) { result::ok(path::connect(_q, ~".cargo")) } + none { result::err(~"no CARGO_ROOT or home directory") } } } } } -fn get_cargo_root_nearest() -> result<path, str> { +fn get_cargo_root_nearest() -> result<path, ~str> { do result::chain(get_cargo_root()) |p| { let cwd = os::getcwd(); let mut dirname = path::dirname(cwd); let mut dirpath = path::split(dirname); - let cwd_cargo = path::connect(cwd, ".cargo"); - let mut par_cargo = path::connect(dirname, ".cargo"); + let cwd_cargo = path::connect(cwd, ~".cargo"); + let mut par_cargo = path::connect(dirname, ~".cargo"); let mut rslt = result::ok(cwd_cargo); if !os::path_is_dir(cwd_cargo) && cwd_cargo != p { @@ -150,20 +150,20 @@ fn get_cargo_root_nearest() -> result<path, str> { } vec::pop(dirpath); dirname = path::dirname(dirname); - par_cargo = path::connect(dirname, ".cargo"); + par_cargo = path::connect(dirname, ~".cargo"); } } rslt } } -fn get_cargo_lib_path() -> result<path, str> { +fn get_cargo_lib_path() -> result<path, ~str> { do result::chain(get_cargo_root()) |p| { result::ok(path::connect(p, libdir())) } } -fn get_cargo_lib_path_nearest() -> result<path, str> { +fn get_cargo_lib_path_nearest() -> result<path, ~str> { do result::chain(get_cargo_root_nearest()) |p| { result::ok(path::connect(p, libdir())) } @@ -171,10 +171,10 @@ fn get_cargo_lib_path_nearest() -> result<path, str> { // The name of the directory rustc expects libraries to be located. // On Unix should be "lib", on windows "bin" -fn libdir() -> str { +fn libdir() -> ~str { let libdir = #env("CFG_LIBDIR"); if str::is_empty(libdir) { - fail "rustc compiled without CFG_LIBDIR environment variable"; + fail ~"rustc compiled without CFG_LIBDIR environment variable"; } libdir } diff --git a/src/rustc/metadata/loader.rs b/src/rustc/metadata/loader.rs index 32ed2c527bb..862e6b90e7d 100644 --- a/src/rustc/metadata/loader.rs +++ b/src/rustc/metadata/loader.rs @@ -31,12 +31,12 @@ type ctxt = { span: span, ident: ast::ident, metas: ~[@ast::meta_item], - hash: str, + 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 { @@ -46,33 +46,33 @@ 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) } -fn libname(cx: ctxt) -> {prefix: str, suffix: str} { - if cx.static { ret {prefix: "lib", suffix: ".rlib"}; } +fn libname(cx: ctxt) -> {prefix: ~str, suffix: ~str} { + if cx.static { ret {prefix: ~"lib", suffix: ~".rlib"}; } alt cx.os { - os_win32 { ret {prefix: "", suffix: ".dll"}; } - os_macos { ret {prefix: "lib", suffix: ".dylib"}; } - os_linux { ret {prefix: "lib", suffix: ".so"}; } - os_freebsd { ret {prefix: "lib", suffix: ".so"}; } + os_win32 { ret {prefix: ~"", suffix: ~".dll"}; } + os_macos { ret {prefix: ~"lib", suffix: ~".dylib"}; } + os_linux { ret {prefix: ~"lib", suffix: ~".so"}; } + os_freebsd { ret {prefix: ~"lib", suffix: ~".so"}; } } } fn find_library_crate_aux(cx: ctxt, - nn: {prefix: str, suffix: str}, + 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 prefix: ~str = nn.prefix + *crate_name + ~"-"; + let suffix: ~str = nn.suffix; let mut matches = ~[]; filesearch::search(filesearch, |path| { #debug("inspecting file %s", path); - let f: str = path::basename(path); + let f: ~str = path::basename(path); if !(str::starts_with(f, prefix) && str::ends_with(f, suffix)) { #debug("skipping %s, doesn't look like %s*%s", path, prefix, suffix); @@ -105,7 +105,7 @@ fn find_library_crate_aux(cx: ctxt, } else { cx.diag.span_err( cx.span, #fmt("multiple matching crates for `%s`", *crate_name)); - cx.diag.handler().note("candidates:"); + cx.diag.handler().note(~"candidates:"); for matches.each |match| { cx.diag.handler().note(#fmt("path: %s", match.ident)); let attrs = decoder::get_crate_attributes(match.data); @@ -116,8 +116,8 @@ fn find_library_crate_aux(cx: ctxt, } } -fn crate_name_from_metas(metas: ~[@ast::meta_item]) -> @str/~ { - let name_items = attr::find_meta_items_by_name(metas, "name"); +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) { alt attr::get_meta_item_value_str(i) { @@ -127,7 +127,7 @@ fn crate_name_from_metas(metas: ~[@ast::meta_item]) -> @str/~ { _ { fail } } } - none { fail "expected to find the crate name" } + none { fail ~"expected to find the crate name" } } } @@ -138,7 +138,7 @@ fn note_linkage_attrs(diag: span_handler, attrs: ~[ast::attribute]) { } fn crate_matches(crate_data: @~[u8], metas: ~[@ast::meta_item], - hash: str) -> bool { + hash: ~str) -> bool { let attrs = decoder::get_crate_attributes(crate_data); let linkage_metas = attr::find_linkage_metas(attrs); if hash.is_not_empty() { @@ -170,7 +170,7 @@ 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) }); @@ -196,21 +196,21 @@ fn get_metadata_section(os: os, ret option::none::<@~[u8]>; } -fn meta_section_name(os: os) -> str { +fn meta_section_name(os: os) -> ~str { alt os { - os_macos { "__DATA,__note.rustc" } - os_win32 { ".note.rustc" } - os_linux { ".note.rustc" } - os_freebsd { ".note.rustc" } + os_macos { ~"__DATA,__note.rustc" } + os_win32 { ~".note.rustc" } + os_linux { ~".note.rustc" } + os_freebsd { ~".note.rustc" } } } // A diagnostic function for dumping crate metadata to an output stream -fn list_file_metadata(os: os, path: str, out: io::writer) { +fn list_file_metadata(os: os, path: ~str, out: io::writer) { alt get_metadata_section(os, path) { option::some(bytes) { decoder::list_crate_metadata(bytes, out); } option::none { - out.write_str("could not find metadata in " + path + ".\n"); + out.write_str(~"could not find metadata in " + path + ~".\n"); } } } diff --git a/src/rustc/metadata/tydecode.rs b/src/rustc/metadata/tydecode.rs index 31a92b72f97..c0420f49a09 100644 --- a/src/rustc/metadata/tydecode.rs +++ b/src/rustc/metadata/tydecode.rs @@ -42,7 +42,7 @@ fn parse_ident(st: @pstate, last: char) -> ast::ident { fn parse_ident_(st: @pstate, is_last: fn@(char) -> bool) -> ast::ident { - let mut rslt = ""; + let mut rslt = ~""; while !is_last(peek(st)) { rslt += str::from_byte(next_byte(st)); } @@ -170,7 +170,7 @@ fn parse_proto(c: char) -> ast::proto { '*' { ast::proto_any } '&' { ast::proto_block } 'n' { ast::proto_bare } - _ { fail "illegal fn type kind " + str::from_char(c); } + _ { fail ~"illegal fn type kind " + str::from_char(c); } } } @@ -197,7 +197,7 @@ 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]/~ = []/~; + let mut params: ~[ty::t] = ~[]; while peek(st) != ']' { vec::push(params, parse_ty(st, conv)); } st.pos = st.pos + 1u; @@ -245,8 +245,8 @@ fn parse_opt<T>(st: @pstate, f: fn() -> T) -> option<T> { } } -fn parse_str(st: @pstate, term: char) -> str { - let mut result = ""; +fn parse_str(st: @pstate, term: char) -> ~str { + let mut result = ~""; while peek(st) != term { result += str::from_byte(next_byte(st)); } @@ -320,7 +320,7 @@ 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, '='); vec::push(fields, {ident: name, mt: parse_mt(st, conv)}); @@ -330,7 +330,7 @@ fn parse_ty(st: @pstate, conv: conv_did) -> ty::t { } 'T' { assert (next(st) == '['); - let mut params = []/~; + let mut params = ~[]; while peek(st) != ']' { vec::push(params, parse_ty(st, conv)); } st.pos = st.pos + 1u; ret ty::mk_tup(st.tcx, params); @@ -403,7 +403,7 @@ fn parse_mt(st: @pstate, conv: conv_did) -> ty::mt { } fn parse_def(st: @pstate, conv: conv_did) -> ast::def_id { - let mut def = []/~; + let mut def = ~[]; while peek(st) != '|' { vec::push(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 } diff --git a/src/rustc/metadata/tyencode.rs b/src/rustc/metadata/tyencode.rs index 026f06bc8b0..6cb430c519f 100644 --- a/src/rustc/metadata/tyencode.rs +++ b/src/rustc/metadata/tyencode.rs @@ -19,7 +19,7 @@ export enc_mode; type ctxt = { diag: span_handler, // Def -> str Callback: - ds: fn@(def_id) -> str, + ds: fn@(def_id) -> ~str, // The type context. tcx: ty::ctxt, reachable: fn@(node_id) -> bool, @@ -29,7 +29,7 @@ type ctxt = { // Compact string representation for ty.t values. API ty_str & parse_from_str. // Extra parameters are for converting to/from def_ids in the string rep. // Whatever format you choose should not contain pipe characters. -type ty_abbrev = {pos: uint, len: uint, s: @str/~}; +type ty_abbrev = {pos: uint, len: uint, s: @~str}; enum abbrev_ctxt { ac_no_abbrevs, ac_use_abbrevs(hashmap<ty::t, ty_abbrev>), } @@ -84,8 +84,8 @@ fn enc_ty(w: io::writer, cx: @ctxt, t: ty::t) { let abbrev_len = 3u + estimate_sz(pos) + estimate_sz(len); if abbrev_len < len { // I.e. it's actually an abbreviation. - let s = "#" + uint::to_str(pos, 16u) + ":" + - uint::to_str(len, 16u) + "#"; + let s = ~"#" + uint::to_str(pos, 16u) + ~":" + + uint::to_str(len, 16u) + ~"#"; let a = {pos: pos, len: len, s: @s}; abbrevs.insert(t, a); } @@ -146,7 +146,7 @@ fn enc_region(w: io::writer, cx: @ctxt, r: ty::region) { } ty::re_var(_) { // these should not crop up after typeck - cx.diag.handler().bug("Cannot encode region variables"); + cx.diag.handler().bug(~"Cannot encode region variables"); } } } @@ -192,45 +192,45 @@ fn enc_sty(w: io::writer, cx: @ctxt, st: ty::sty) { alt t { ty_i { w.write_char('i'); } ty_char { w.write_char('c'); } - ty_i8 { w.write_str("MB"/&); } - ty_i16 { w.write_str("MW"/&); } - ty_i32 { w.write_str("ML"/&); } - ty_i64 { w.write_str("MD"/&); } + ty_i8 { w.write_str(&"MB"); } + ty_i16 { w.write_str(&"MW"); } + ty_i32 { w.write_str(&"ML"); } + ty_i64 { w.write_str(&"MD"); } } } ty::ty_uint(t) { alt t { ty_u { w.write_char('u'); } - ty_u8 { w.write_str("Mb"/&); } - ty_u16 { w.write_str("Mw"/&); } - ty_u32 { w.write_str("Ml"/&); } - ty_u64 { w.write_str("Md"/&); } + ty_u8 { w.write_str(&"Mb"); } + ty_u16 { w.write_str(&"Mw"); } + ty_u32 { w.write_str(&"Ml"); } + ty_u64 { w.write_str(&"Md"); } } } ty::ty_float(t) { alt t { ty_f { w.write_char('l'); } - ty_f32 { w.write_str("Mf"/&); } - ty_f64 { w.write_str("MF"/&); } + ty_f32 { w.write_str(&"Mf"); } + ty_f64 { w.write_str(&"MF"); } } } ty::ty_str { w.write_char('S'); } ty::ty_enum(def, substs) { - w.write_str("t["/&); + w.write_str(&"t["); w.write_str(cx.ds(def)); w.write_char('|'); enc_substs(w, cx, substs); w.write_char(']'); } ty::ty_trait(def, substs) { - w.write_str("x["/&); + w.write_str(&"x["); w.write_str(cx.ds(def)); w.write_char('|'); enc_substs(w, cx, substs); w.write_char(']'); } ty::ty_tup(ts) { - w.write_str("T["/&); + w.write_str(&"T["); for ts.each |t| { enc_ty(w, cx, t); } w.write_char(']'); } @@ -254,7 +254,7 @@ fn enc_sty(w: io::writer, cx: @ctxt, st: ty::sty) { ty::ty_vec(mt) { w.write_char('I'); enc_mt(w, cx, mt); } ty::ty_unboxed_vec(mt) { w.write_char('U'); enc_mt(w, cx, mt); } ty::ty_rec(fields) { - w.write_str("R["/&); + w.write_str(&"R["); for fields.each |field| { w.write_str(*field.ident); w.write_char('='); @@ -284,37 +284,37 @@ fn enc_sty(w: io::writer, cx: @ctxt, st: ty::sty) { w.write_char('s'); } ty::ty_type { w.write_char('Y'); } - ty::ty_opaque_closure_ptr(ty::ck_block) { w.write_str("C&"/&); } - ty::ty_opaque_closure_ptr(ty::ck_box) { w.write_str("C@"/&); } - ty::ty_opaque_closure_ptr(ty::ck_uniq) { w.write_str("C~"/&); } + ty::ty_opaque_closure_ptr(ty::ck_block) { w.write_str(&"C&"); } + ty::ty_opaque_closure_ptr(ty::ck_box) { w.write_str(&"C@"); } + ty::ty_opaque_closure_ptr(ty::ck_uniq) { w.write_str(&"C~"); } ty::ty_constr(ty, cs) { - w.write_str("A["/&); + w.write_str(&"A["); enc_ty(w, cx, ty); for cs.each |tc| { enc_ty_constr(w, cx, tc); } w.write_char(']'); } ty::ty_opaque_box { w.write_char('B'); } ty::ty_class(def, substs) { - #debug("~~~~ %s", "a["); - w.write_str("a["/&); + #debug("~~~~ %s", ~"a["); + w.write_str(&"a["); let s = cx.ds(def); #debug("~~~~ %s", s); w.write_str(s); - #debug("~~~~ %s", "|"); + #debug("~~~~ %s", ~"|"); w.write_char('|'); enc_substs(w, cx, substs); - #debug("~~~~ %s", "]"); + #debug("~~~~ %s", ~"]"); w.write_char(']'); } } } fn enc_proto(w: io::writer, proto: proto) { alt proto { - proto_uniq { w.write_str("f~"/&); } - proto_box { w.write_str("f@"/&); } - proto_block { w.write_str("f&"); } - proto_any { w.write_str("f*"/&); } - proto_bare { w.write_str("fn"/&); } + proto_uniq { w.write_str(&"f~"); } + proto_box { w.write_str(&"f@"); } + proto_block { w.write_str(~"f&"); } + proto_any { w.write_str(&"f*"); } + proto_bare { w.write_str(&"fn"); } } } diff --git a/src/rustc/middle/astencode.rs b/src/rustc/middle/astencode.rs index a4810e77b56..2211f62f235 100644 --- a/src/rustc/middle/astencode.rs +++ b/src/rustc/middle/astencode.rs @@ -433,10 +433,10 @@ fn encode_vtable_res(ecx: @e::encode_ctxt, fn encode_vtable_origin(ecx: @e::encode_ctxt, ebml_w: ebml::writer, vtable_origin: typeck::vtable_origin) { - do ebml_w.emit_enum("vtable_origin") { + do ebml_w.emit_enum(~"vtable_origin") { alt vtable_origin { typeck::vtable_static(def_id, tys, vtable_res) { - do ebml_w.emit_enum_variant("vtable_static", 0u, 3u) { + do ebml_w.emit_enum_variant(~"vtable_static", 0u, 3u) { do ebml_w.emit_enum_variant_arg(0u) { ebml_w.emit_def_id(def_id) } @@ -449,7 +449,7 @@ fn encode_vtable_origin(ecx: @e::encode_ctxt, } } typeck::vtable_param(pn, bn) { - do ebml_w.emit_enum_variant("vtable_param", 1u, 2u) { + do ebml_w.emit_enum_variant(~"vtable_param", 1u, 2u) { do ebml_w.emit_enum_variant_arg(0u) { ebml_w.emit_uint(pn); } @@ -459,7 +459,7 @@ fn encode_vtable_origin(ecx: @e::encode_ctxt, } } typeck::vtable_trait(def_id, tys) { - do ebml_w.emit_enum_variant("vtable_trait", 1u, 3u) { + do ebml_w.emit_enum_variant(~"vtable_trait", 1u, 3u) { do ebml_w.emit_enum_variant_arg(0u) { ebml_w.emit_def_id(def_id) } @@ -480,7 +480,7 @@ impl helpers for ebml::ebml_deserializer { fn read_vtable_origin(xcx: extended_decode_ctxt) -> typeck::vtable_origin { - do self.read_enum("vtable_origin") { + do self.read_enum(~"vtable_origin") { do self.read_enum_variant |i| { alt check i { 0u { @@ -552,15 +552,15 @@ impl helpers for ebml::writer { fn emit_tpbt(ecx: @e::encode_ctxt, tpbt: ty::ty_param_bounds_and_ty) { do self.emit_rec { - do self.emit_rec_field("bounds", 0u) { + do self.emit_rec_field(~"bounds", 0u) { do self.emit_from_vec(*tpbt.bounds) |bs| { self.emit_bounds(ecx, bs); } } - do self.emit_rec_field("rp", 1u) { + do self.emit_rec_field(~"rp", 1u) { self.emit_bool(tpbt.rp); } - do self.emit_rec_field("ty", 2u) { + do self.emit_rec_field(~"ty", 2u) { self.emit_ty(ecx, tpbt.ty); } } @@ -755,13 +755,13 @@ impl decoder for ebml::ebml_deserializer { -> ty::ty_param_bounds_and_ty { do self.read_rec { { - bounds: self.read_rec_field("bounds", 0u, || { + bounds: self.read_rec_field(~"bounds", 0u, || { @self.read_to_vec(|| self.read_bounds(xcx) ) }), - rp: self.read_rec_field("rp", 1u, || { + rp: self.read_rec_field(~"rp", 1u, || { self.read_bool() }), - ty: self.read_rec_field("ty", 2u, || { + ty: self.read_rec_field(~"ty", 2u, || { self.read_ty(xcx) }) } diff --git a/src/rustc/middle/block_use.rs b/src/rustc/middle/block_use.rs index e6bafb4c48a..6c103915aaf 100644 --- a/src/rustc/middle/block_use.rs +++ b/src/rustc/middle/block_use.rs @@ -16,7 +16,7 @@ fn visit_expr(ex: @expr, cx: ctx, v: visit::vt<ctx>) { alt ty::get(ty::expr_ty(cx.tcx, ex)).struct { ty::ty_fn({proto: p, _}) if is_blockish(p) { cx.tcx.sess.span_err(ex.span, - "expressions with stack closure type \ + ~"expressions with stack closure type \ can only appear in callee or (by-ref) argument position"); } _ {} diff --git a/src/rustc/middle/borrowck.rs b/src/rustc/middle/borrowck.rs index 01d04fa167a..4db8ae6705d 100644 --- a/src/rustc/middle/borrowck.rs +++ b/src/rustc/middle/borrowck.rs @@ -185,7 +185,7 @@ fn check_crate(tcx: ty::ctxt, check_loans::check_loans(bccx, req_maps, crate); if tcx.sess.borrowck_stats() { - io::println("--- borrowck stats ---"); + io::println(~"--- borrowck stats ---"); io::println(#fmt["paths requiring guarantees: %u", bccx.guaranteed_paths]); io::println(#fmt["paths requiring loans : %s", @@ -200,7 +200,7 @@ fn check_crate(tcx: ty::ctxt, ret (bccx.root_map, bccx.mutbl_map); - fn make_stat(bccx: borrowck_ctxt, stat: uint) -> str { + fn make_stat(bccx: borrowck_ctxt, stat: uint) -> ~str { let stat_f = stat as float; let total = bccx.guaranteed_paths as float; #fmt["%u (%.0f%%)", stat , stat_f * 100f / total] @@ -386,11 +386,11 @@ impl error_methods for borrowck_ctxt { self.bckerr_code_to_str(err.code)]); } - fn span_err(s: span, m: str) { + fn span_err(s: span, m: ~str) { self.tcx.sess.span_err(s, m); } - fn span_note(s: span, m: str) { + fn span_note(s: span, m: ~str) { self.tcx.sess.span_note(s, m); } @@ -408,14 +408,14 @@ impl error_methods for borrowck_ctxt { } impl to_str_methods for borrowck_ctxt { - fn cat_to_repr(cat: categorization) -> str { + fn cat_to_repr(cat: categorization) -> ~str { alt cat { - cat_special(sk_method) { "method" } - cat_special(sk_static_item) { "static_item" } - cat_special(sk_self) { "self" } - cat_special(sk_heap_upvar) { "heap-upvar" } - cat_stack_upvar(_) { "stack-upvar" } - cat_rvalue { "rvalue" } + cat_special(sk_method) { ~"method" } + cat_special(sk_static_item) { ~"static_item" } + cat_special(sk_self) { ~"self" } + cat_special(sk_heap_upvar) { ~"heap-upvar" } + cat_stack_upvar(_) { ~"stack-upvar" } + cat_rvalue { ~"rvalue" } cat_local(node_id) { #fmt["local(%d)", node_id] } cat_binding(node_id) { #fmt["binding(%d)", node_id] } cat_arg(node_id) { #fmt["arg(%d)", node_id] } @@ -430,33 +430,33 @@ impl to_str_methods for borrowck_ctxt { } } - fn mut_to_str(mutbl: ast::mutability) -> str { + fn mut_to_str(mutbl: ast::mutability) -> ~str { alt mutbl { - m_mutbl { "mutable" } - m_const { "const" } - m_imm { "immutable" } + m_mutbl { ~"mutable" } + m_const { ~"const" } + m_imm { ~"immutable" } } } - fn ptr_sigil(ptr: ptr_kind) -> str { + fn ptr_sigil(ptr: ptr_kind) -> ~str { alt ptr { - uniq_ptr { "~" } - gc_ptr { "@" } - region_ptr { "&" } - unsafe_ptr { "*" } + uniq_ptr { ~"~" } + gc_ptr { ~"@" } + region_ptr { ~"&" } + unsafe_ptr { ~"*" } } } - fn comp_to_repr(comp: comp_kind) -> str { + fn comp_to_repr(comp: comp_kind) -> ~str { alt comp { comp_field(fld, _) { *fld } - comp_index(*) { "[]" } - comp_tuple { "()" } - comp_variant(_) { "<enum>" } + comp_index(*) { ~"[]" } + comp_tuple { ~"()" } + comp_variant(_) { ~"<enum>" } } } - fn lp_to_str(lp: @loan_path) -> str { + fn lp_to_str(lp: @loan_path) -> ~str { alt *lp { lp_local(node_id) { #fmt["local(%d)", node_id] @@ -475,56 +475,56 @@ impl to_str_methods for borrowck_ctxt { } } - fn cmt_to_repr(cmt: cmt) -> str { + fn cmt_to_repr(cmt: cmt) -> ~str { #fmt["{%s id:%d m:%s lp:%s ty:%s}", self.cat_to_repr(cmt.cat), cmt.id, self.mut_to_str(cmt.mutbl), - cmt.lp.map_default("none", |p| self.lp_to_str(p) ), + cmt.lp.map_default(~"none", |p| self.lp_to_str(p) ), ty_to_str(self.tcx, cmt.ty)] } - fn pk_to_sigil(pk: ptr_kind) -> str { + fn pk_to_sigil(pk: ptr_kind) -> ~str { alt pk { - uniq_ptr {"~"} - gc_ptr {"@"} - region_ptr {"&"} - unsafe_ptr {"*"} + uniq_ptr {~"~"} + gc_ptr {~"@"} + region_ptr {~"&"} + unsafe_ptr {~"*"} } } - fn cmt_to_str(cmt: cmt) -> str { + fn cmt_to_str(cmt: cmt) -> ~str { let mut_str = self.mut_to_str(cmt.mutbl); alt cmt.cat { - cat_special(sk_method) { "method" } - cat_special(sk_static_item) { "static item" } - cat_special(sk_self) { "self reference" } + cat_special(sk_method) { ~"method" } + cat_special(sk_static_item) { ~"static item" } + cat_special(sk_self) { ~"self reference" } cat_special(sk_heap_upvar) { - "captured outer variable in a heap closure" + ~"captured outer variable in a heap closure" } - cat_rvalue { "non-lvalue" } - cat_local(_) { mut_str + " local variable" } - cat_binding(_) { "pattern binding" } - cat_arg(_) { "argument" } + cat_rvalue { ~"non-lvalue" } + cat_local(_) { mut_str + ~" local variable" } + cat_binding(_) { ~"pattern binding" } + cat_arg(_) { ~"argument" } cat_deref(_, _, pk) { #fmt["dereference of %s %s pointer", mut_str, self.pk_to_sigil(pk)] } cat_stack_upvar(_) { - "captured outer " + mut_str + " variable in a stack closure" + ~"captured outer " + mut_str + ~" variable in a stack closure" } - cat_comp(_, comp_field(*)) { mut_str + " field" } - cat_comp(_, comp_tuple) { "tuple content" } - cat_comp(_, comp_variant(_)) { "enum content" } + cat_comp(_, comp_field(*)) { mut_str + ~" field" } + cat_comp(_, comp_tuple) { ~"tuple content" } + cat_comp(_, comp_variant(_)) { ~"enum content" } cat_comp(_, comp_index(t, _)) { alt ty::get(t).struct { ty::ty_vec(*) | ty::ty_evec(*) { - mut_str + " vec content" + mut_str + ~" vec content" } ty::ty_str | ty::ty_estr(*) { - mut_str + " str content" + mut_str + ~" str content" } - _ { mut_str + " indexed content" } + _ { mut_str + ~" indexed content" } } } cat_discr(cmt, _) { @@ -533,20 +533,20 @@ impl to_str_methods for borrowck_ctxt { } } - fn bckerr_code_to_str(code: bckerr_code) -> str { + fn bckerr_code_to_str(code: bckerr_code) -> ~str { alt code { err_mutbl(req, act) { #fmt["creating %s alias to aliasable, %s memory", self.mut_to_str(req), self.mut_to_str(act)] } err_mut_uniq { - "unique value in aliasable, mutable location" + ~"unique value in aliasable, mutable location" } err_mut_variant { - "enum variant in aliasable, mutable location" + ~"enum variant in aliasable, mutable location" } err_preserve_gc { - "GC'd value would have to be preserved for longer \ + ~"GC'd value would have to be preserved for longer \ than the scope of the function" } } diff --git a/src/rustc/middle/borrowck/check_loans.rs b/src/rustc/middle/borrowck/check_loans.rs index 4977af45b7e..d32d5dfd4a9 100644 --- a/src/rustc/middle/borrowck/check_loans.rs +++ b/src/rustc/middle/borrowck/check_loans.rs @@ -70,11 +70,11 @@ impl methods for assignment_type { at_mutbl_ref {false} } } - fn ing_form(desc: str) -> str { + fn ing_form(desc: ~str) -> ~str { alt self { - at_straight_up { "assigning to " + desc } - at_swap { "swapping to and from " + desc } - at_mutbl_ref { "taking mut reference to " + desc } + at_straight_up { ~"assigning to " + desc } + at_swap { ~"swapping to and from " + desc } + at_mutbl_ref { ~"taking mut reference to " + desc } } } } @@ -381,7 +381,7 @@ impl methods for check_loan_ctxt { } } - fn report_purity_error(pc: purity_cause, sp: span, msg: str) { + fn report_purity_error(pc: purity_cause, sp: span, msg: ~str) { alt pc { pc_pure_fn { self.tcx().sess.span_err( diff --git a/src/rustc/middle/borrowck/gather_loans.rs b/src/rustc/middle/borrowck/gather_loans.rs index ddbd78b631c..3c21c6d0c0f 100644 --- a/src/rustc/middle/borrowck/gather_loans.rs +++ b/src/rustc/middle/borrowck/gather_loans.rs @@ -426,7 +426,7 @@ impl methods for gather_loan_ctxt { self.gather_pat(subcmt, subpat, arm_id, alt_id); } none { - tcx.sess.span_bug(pat.span, "Non derefable type"); + tcx.sess.span_bug(pat.span, ~"Non derefable type"); } } } diff --git a/src/rustc/middle/borrowck/loan.rs b/src/rustc/middle/borrowck/loan.rs index 84f7f5a9d15..5549ca53eb2 100644 --- a/src/rustc/middle/borrowck/loan.rs +++ b/src/rustc/middle/borrowck/loan.rs @@ -39,7 +39,7 @@ impl loan_methods for loan_ctxt { if cmt.lp.is_none() { self.bccx.tcx.sess.span_bug( cmt.span, - "loan() called with non-lendable value"); + ~"loan() called with non-lendable value"); } alt cmt.cat { @@ -47,7 +47,7 @@ impl loan_methods for loan_ctxt { // should never be loanable self.bccx.tcx.sess.span_bug( cmt.span, - "rvalue with a non-none lp"); + ~"rvalue with a non-none lp"); } cat_local(_) | cat_arg(_) | cat_stack_upvar(_) { self.ok_with_loan_of(cmt, req_mutbl) @@ -88,7 +88,7 @@ impl loan_methods for loan_ctxt { // Aliased data is simply not lendable. self.bccx.tcx.sess.span_bug( cmt.span, - "aliased ptr with a non-none lp"); + ~"aliased ptr with a non-none lp"); } } } diff --git a/src/rustc/middle/borrowck/preserve.rs b/src/rustc/middle/borrowck/preserve.rs index 7ec2520cd59..08d7227557b 100644 --- a/src/rustc/middle/borrowck/preserve.rs +++ b/src/rustc/middle/borrowck/preserve.rs @@ -25,7 +25,8 @@ impl public_methods for borrowck_ctxt { if opt_scope_id.is_some() { self.tcx.sess.span_bug( cmt.span, - "preserve() called with local and non-none opt_scope_id"); + ~"preserve() called with local and \ + non-none opt_scope_id"); } ok(()) } diff --git a/src/rustc/middle/check_alt.rs b/src/rustc/middle/check_alt.rs index ed7c76d39ad..9b2bcc31572 100644 --- a/src/rustc/middle/check_alt.rs +++ b/src/rustc/middle/check_alt.rs @@ -43,7 +43,7 @@ fn check_arms(tcx: ty::ctxt, arms: ~[arm]) { let v = ~[pat]; alt is_useful(tcx, seen, v) { not_useful { - tcx.sess.span_err(pat.span, "unreachable pattern"); + tcx.sess.span_err(pat.span, ~"unreachable pattern"); } _ {} } @@ -67,8 +67,8 @@ fn check_exhaustive(tcx: ty::ctxt, sp: span, pats: ~[@pat]) { alt ty::get(ty).struct { ty::ty_bool { alt check ctor { - val(const_int(1i64)) { some(@"true"/~) } - val(const_int(0i64)) { some(@"false"/~) } + val(const_int(1i64)) { some(@~"true") } + val(const_int(0i64)) { some(@~"false") } } } ty::ty_enum(id, _) { @@ -82,9 +82,9 @@ fn check_exhaustive(tcx: ty::ctxt, sp: span, pats: ~[@pat]) { } } }; - let msg = "non-exhaustive patterns" + alt ext { - some(s) { ": " + *s + " not covered" } - none { "" } + let msg = ~"non-exhaustive patterns" + alt ext { + some(s) { ~": " + *s + ~" not covered" } + none { ~"" } }; tcx.sess.span_err(sp, msg); } @@ -344,7 +344,7 @@ fn check_local(tcx: ty::ctxt, loc: @local, &&s: (), v: visit::vt<()>) { visit::visit_local(loc, s, v); if is_refutable(tcx, loc.node.pat) { tcx.sess.span_err(loc.node.pat.span, - "refutable pattern in local binding"); + ~"refutable pattern in local binding"); } } diff --git a/src/rustc/middle/check_const.rs b/src/rustc/middle/check_const.rs index 5ac7834c348..287c701d7d0 100644 --- a/src/rustc/middle/check_const.rs +++ b/src/rustc/middle/check_const.rs @@ -63,16 +63,16 @@ fn check_expr(sess: session, def_map: resolve::def_map, expr_unary(box(_), _) | expr_unary(uniq(_), _) | expr_unary(deref, _){ sess.span_err(e.span, - "disallowed operator in constant expression"); + ~"disallowed operator in constant expression"); ret; } expr_lit(@{node: lit_str(_), _}) { sess.span_err(e.span, - "string constants are not supported"); + ~"string constants are not supported"); } expr_binary(_, _, _) | expr_unary(_, _) { if method_map.contains_key(e.id) { - sess.span_err(e.span, "user-defined operators are not \ + sess.span_err(e.span, ~"user-defined operators are not \ allowed in constant expressions"); } } @@ -80,9 +80,9 @@ fn check_expr(sess: session, def_map: resolve::def_map, expr_cast(_, _) { let ety = ty::expr_ty(tcx, e); if !ty::type_is_numeric(ety) { - sess.span_err(e.span, "can not cast to `" + + sess.span_err(e.span, ~"can not cast to `" + util::ppaux::ty_to_str(tcx, ety) + - "` in a constant expression"); + ~"` in a constant expression"); } } expr_path(_) { @@ -90,19 +90,20 @@ fn check_expr(sess: session, def_map: resolve::def_map, some(def_const(def_id)) { if !ast_util::is_local(def_id) { sess.span_err( - e.span, "paths in constants may only refer to \ + e.span, ~"paths in constants may only refer to \ crate-local constants"); } } _ { sess.span_err( - e.span, "paths in constants may only refer to constants"); + e.span, + ~"paths in constants may only refer to constants"); } } } _ { sess.span_err(e.span, - "constant contains unimplemented expression type"); + ~"constant contains unimplemented expression type"); ret; } } @@ -112,14 +113,14 @@ fn check_expr(sess: session, def_map: resolve::def_map, if t != ty_char { if (v as u64) > ast_util::int_ty_max( if t == ty_i { sess.targ_cfg.int_type } else { t }) { - sess.span_err(e.span, "literal out of range for its type"); + sess.span_err(e.span, ~"literal out of range for its type"); } } } expr_lit(@{node: lit_uint(v, t), _}) { if v > ast_util::uint_ty_max( if t == ty_u { sess.targ_cfg.uint_type } else { t }) { - sess.span_err(e.span, "literal out of range for its type"); + sess.span_err(e.span, ~"literal out of range for its type"); } } _ {} @@ -157,7 +158,7 @@ fn check_item_recursion(sess: session, ast_map: ast_map::map, fn visit_item(it: @item, &&env: env, v: visit::vt<env>) { if (*env.idstack).contains(it.id) { - env.sess.span_fatal(env.root_it.span, "recursive constant"); + env.sess.span_fatal(env.root_it.span, ~"recursive constant"); } (*env.idstack).push(it.id); visit::visit_item(it, env, v); diff --git a/src/rustc/middle/check_loop.rs b/src/rustc/middle/check_loop.rs index 524e88fc49e..69bb7220a4c 100644 --- a/src/rustc/middle/check_loop.rs +++ b/src/rustc/middle/check_loop.rs @@ -30,17 +30,17 @@ fn check_crate(tcx: ty::ctxt, crate: @crate) { } expr_break { if !cx.in_loop { - tcx.sess.span_err(e.span, "`break` outside of loop"); + tcx.sess.span_err(e.span, ~"`break` outside of loop"); } } expr_again { if !cx.in_loop { - tcx.sess.span_err(e.span, "`again` outside of loop"); + tcx.sess.span_err(e.span, ~"`again` outside of loop"); } } expr_ret(oe) { if !cx.can_ret { - tcx.sess.span_err(e.span, "`ret` in block function"); + tcx.sess.span_err(e.span, ~"`ret` in block function"); } visit::visit_expr_opt(oe, cx, v); } diff --git a/src/rustc/middle/const_eval.rs b/src/rustc/middle/const_eval.rs index cc36455da06..cdb1a3b10d0 100644 --- a/src/rustc/middle/const_eval.rs +++ b/src/rustc/middle/const_eval.rs @@ -6,7 +6,7 @@ enum const_val { const_float(f64), const_int(i64), const_uint(u64), - const_str(str), + const_str(~str), } // FIXME: issue #1417 @@ -159,7 +159,7 @@ fn compare_const_vals(a: const_val, b: const_val) -> int { } } _ { - fail "compare_const_vals: ill-typed comparison"; + fail ~"compare_const_vals: ill-typed comparison"; } } } diff --git a/src/rustc/middle/freevars.rs b/src/rustc/middle/freevars.rs index ae581290ab4..7bbc2db0665 100644 --- a/src/rustc/middle/freevars.rs +++ b/src/rustc/middle/freevars.rs @@ -51,7 +51,7 @@ fn collect_freevars(def_map: resolve::def_map, blk: ast::blk) ast::expr_path(path) { let mut i = 0; alt def_map.find(expr.id) { - none { fail ("Not found: " + path_to_str(path)) } + none { fail (~"Not found: " + path_to_str(path)) } some(df) { let mut def = df; while i < depth { @@ -106,7 +106,7 @@ fn annotate_freevars(def_map: resolve::def_map, crate: @ast::crate) -> fn get_freevars(tcx: ty::ctxt, fid: ast::node_id) -> freevar_info { alt tcx.freevars.find(fid) { - none { fail "get_freevars: " + int::str(fid) + " has no freevars"; } + none { fail ~"get_freevars: " + int::str(fid) + ~" has no freevars"; } some(d) { ret d; } } } diff --git a/src/rustc/middle/kind.rs b/src/rustc/middle/kind.rs index b4709820276..7d89b4c701a 100644 --- a/src/rustc/middle/kind.rs +++ b/src/rustc/middle/kind.rs @@ -39,18 +39,18 @@ import lint::{non_implicitly_copyable_typarams,implicit_copies}; // primitives in the stdlib are explicitly annotated to only take sendable // types. -fn kind_to_str(k: kind) -> str { +fn kind_to_str(k: kind) -> ~str { let mut kinds = ~[]; if ty::kind_lteq(kind_const(), k) { - vec::push(kinds, "const"); + vec::push(kinds, ~"const"); } if ty::kind_can_be_copied(k) { - vec::push(kinds, "copy"); + vec::push(kinds, ~"copy"); } if ty::kind_can_be_sent(k) { - vec::push(kinds, "send"); + vec::push(kinds, ~"send"); } - str::connect(kinds, " ") + str::connect(kinds, ~" ") } type rval_map = std::map::hashmap<node_id, ()>; @@ -125,13 +125,13 @@ fn with_appropriate_checker(cx: ctx, id: node_id, b: fn(check_fn)) { if fv.is_none() { cx.tcx.sess.span_err( sp, - "cannot capture values explicitly with a block closure"); + ~"cannot capture values explicitly with a block closure"); } } fn check_for_bare(cx: ctx, _id: node_id, _fv: option<@freevar_entry>, _is_move: bool,_var_t: ty::t, sp: span) { - cx.tcx.sess.span_err(sp, "attempted dynamic environment capture"); + cx.tcx.sess.span_err(sp, ~"attempted dynamic environment capture"); } let fty = ty::node_id_to_type(cx.tcx, id); @@ -224,13 +224,13 @@ fn check_expr(e: @expr, cx: ctx, v: visit::vt<ctx>) { let t = ty::expr_ty(cx.tcx, ex); let ty_fields = alt ty::get(t).struct { ty::ty_rec(f) { f } - _ { cx.tcx.sess.span_bug(ex.span, "bad expr type in record"); } + _ { cx.tcx.sess.span_bug(ex.span, ~"bad expr type in record"); } }; for ty_fields.each |tf| { if !vec::any(fields, |f| f.node.ident == tf.ident ) && !ty::kind_can_be_copied(ty::type_kind(cx.tcx, tf.mt.ty)) { cx.tcx.sess.span_err(ex.span, - "copying a noncopyable value"); + ~"copying a noncopyable value"); } } } @@ -340,15 +340,15 @@ fn check_bounds(cx: ctx, id: node_id, sp: span, cx.tcx.sess.span_lint( non_implicitly_copyable_typarams, id, cx.current_item, sp, - "instantiating copy type parameter with a \ + ~"instantiating copy type parameter with a \ not implicitly copyable type"); } else { cx.tcx.sess.span_err( sp, - "instantiating a type parameter with an incompatible type " + - "(needs `" + kind_to_str(p_kind) + - "`, got `" + kind_to_str(kind) + - "`, missing `" + kind_to_str(p_kind - kind) + "`)"); + ~"instantiating a type parameter with an incompatible type " + + ~"(needs `" + kind_to_str(p_kind) + + ~"`, got `" + kind_to_str(kind) + + ~"`, missing `" + kind_to_str(p_kind - kind) + ~"`)"); } } } @@ -381,7 +381,7 @@ fn check_copy_ex(cx: ctx, ex: @expr, implicit_copy: bool) { } fn check_imm_free_var(cx: ctx, def: def, sp: span) { - let msg = "mutable variables cannot be implicitly captured; \ + let msg = ~"mutable variables cannot be implicitly captured; \ use a capture clause"; alt def { def_local(_, is_mutbl) { @@ -413,18 +413,18 @@ fn check_copy(cx: ctx, id: node_id, ty: ty::t, sp: span, implicit_copy: bool) { let k = ty::type_kind(cx.tcx, ty); if !ty::kind_can_be_copied(k) { - cx.tcx.sess.span_err(sp, "copying a noncopyable value"); + cx.tcx.sess.span_err(sp, ~"copying a noncopyable value"); } else if implicit_copy && !ty::kind_can_be_implicitly_copied(k) { cx.tcx.sess.span_lint( implicit_copies, id, cx.current_item, sp, - "implicitly copying a non-implicitly-copyable value"); + ~"implicitly copying a non-implicitly-copyable value"); } } fn check_send(cx: ctx, ty: ty::t, sp: span) { if !ty::kind_can_be_sent(ty::type_kind(cx.tcx, ty)) { - cx.tcx.sess.span_err(sp, "not a sendable value"); + cx.tcx.sess.span_err(sp, ~"not a sendable value"); } } diff --git a/src/rustc/middle/lint.rs b/src/rustc/middle/lint.rs index ce91f5ce27e..adb333def8d 100644 --- a/src/rustc/middle/lint.rs +++ b/src/rustc/middle/lint.rs @@ -73,10 +73,10 @@ enum level { } type lint_spec = @{lint: lint, - desc: str, + desc: ~str, default: level}; -type lint_dict = hashmap<str,lint_spec>; +type lint_dict = hashmap<~str,lint_spec>; /* Pass names should not contain a '-', as the compiler normalizes @@ -84,55 +84,55 @@ type lint_dict = hashmap<str,lint_spec>; */ fn get_lint_dict() -> lint_dict { let v = ~[ - ("ctypes", + (~"ctypes", @{lint: ctypes, - desc: "proper use of core::libc types in foreign modules", + desc: ~"proper use of core::libc types in foreign modules", default: warn}), - ("unused_imports", + (~"unused_imports", @{lint: unused_imports, - desc: "imports that are never used", + desc: ~"imports that are never used", default: ignore}), - ("while_true", + (~"while_true", @{lint: while_true, - desc: "suggest using loop { } instead of while(true) { }", + desc: ~"suggest using loop { } instead of while(true) { }", default: warn}), - ("path_statement", + (~"path_statement", @{lint: path_statement, - desc: "path statements with no effect", + desc: ~"path statements with no effect", default: warn}), - ("old_vecs", + (~"old_vecs", @{lint: old_vecs, - desc: "old (deprecated) vectors", + desc: ~"old (deprecated) vectors", default: error}), - ("old_strs", + (~"old_strs", @{lint: old_strs, - desc: "old (deprecated) strings", + desc: ~"old (deprecated) strings", default: warn}), - ("unrecognized_warning", + (~"unrecognized_warning", @{lint: unrecognized_warning, - desc: "unrecognized warning attribute", + desc: ~"unrecognized warning attribute", default: warn}), - ("non_implicitly_copyable_typarams", + (~"non_implicitly_copyable_typarams", @{lint: non_implicitly_copyable_typarams, - desc: "passing non implicitly copyable types as copy type params", + desc: ~"passing non implicitly copyable types as copy type params", default: warn}), - ("vecs_not_implicitly_copyable", + (~"vecs_not_implicitly_copyable", @{lint: vecs_not_implicitly_copyable, - desc: "make vecs and strs not implicitly copyable\ + desc: ~"make vecs and strs not implicitly copyable\ (`err` is ignored; only checked at top level", default: warn}), - ("implicit_copies", + (~"implicit_copies", @{lint: implicit_copies, - desc: "implicit copies of non implicitly copyable data", + desc: ~"implicit copies of non implicitly copyable data", default: warn}) ]; @@ -198,7 +198,7 @@ impl methods for ctxt { } } - fn span_lint(level: level, span: span, msg: str) { + fn span_lint(level: level, span: span, msg: ~str) { self.sess.span_lint_level(level, span, msg); } @@ -211,7 +211,8 @@ impl methods for ctxt { let mut new_ctxt = self; - let metas = attr::attr_metas(attr::find_attrs_by_name(attrs, "warn")); + let metas = attr::attr_metas( + attr::find_attrs_by_name(attrs, ~"warn")); for metas.each |meta| { alt meta.node { ast::meta_list(_, metas) { @@ -239,14 +240,14 @@ impl methods for ctxt { _ { self.sess.span_err( meta.span, - "malformed warning attribute"); + ~"malformed warning attribute"); } } } } _ { self.sess.span_err(meta.span, - "malformed warning attribute"); + ~"malformed warning attribute"); } } } @@ -256,12 +257,12 @@ impl methods for ctxt { } -fn lookup_lint(dict: lint_dict, s: str) - -> (str, option<(lint, level)>) { - let s = str::replace(s, "-", "_"); - let (name, level) = if s.starts_with("no_") { +fn lookup_lint(dict: lint_dict, s: ~str) + -> (~str, option<(lint, level)>) { + let s = str::replace(s, ~"-", ~"_"); + let (name, level) = if s.starts_with(~"no_") { (s.substr(3u, s.len() - 3u), ignore) - } else if s.starts_with("err_") { + } else if s.starts_with(~"err_") { (s.substr(4u, s.len() - 4u), error) } else { (s, warn) @@ -341,7 +342,7 @@ fn check_item_while_true(cx: ty::ctxt, it: @ast::item) { cx.sess.span_lint( while_true, e.id, it.id, e.span, - "denote infinite loops with loop { ... }"); + ~"denote infinite loops with loop { ... }"); } _ {} } @@ -367,14 +368,14 @@ fn check_item_ctypes(cx: ty::ctxt, it: @ast::item) { cx.sess.span_lint( ctypes, id, fn_id, ty.span, - "found rust type `int` in foreign module, while \ + ~"found rust type `int` in foreign module, while \ libc::c_int or libc::c_long should be used"); } ast::def_prim_ty(ast::ty_uint(ast::ty_u)) { cx.sess.span_lint( ctypes, id, fn_id, ty.span, - "found rust type `uint` in foreign module, while \ + ~"found rust type `uint` in foreign module, while \ libc::c_uint or libc::c_ulong should be used"); } _ { } @@ -411,7 +412,7 @@ fn check_item_path_statement(cx: ty::ctxt, it: @ast::item) { cx.sess.span_lint( path_statement, id, it.id, s.span, - "path statement with no effect"); + ~"path statement with no effect"); } _ {} } @@ -432,13 +433,13 @@ fn check_item_old_vecs(cx: ty::ctxt, it: @ast::item) { if ! uses_vstore.contains_key(e.id) { cx.sess.span_lint( old_vecs, e.id, it.id, - e.span, "deprecated vec expr"); + e.span, ~"deprecated vec expr"); } ast::expr_lit(@{node: ast::lit_str(_), span:_}) if ! uses_vstore.contains_key(e.id) { cx.sess.span_lint( old_strs, e.id, it.id, - e.span, "deprecated str expr"); + e.span, ~"deprecated str expr"); } ast::expr_vstore(@inner, _) { @@ -454,14 +455,14 @@ fn check_item_old_vecs(cx: ty::ctxt, it: @ast::item) { if ! uses_vstore.contains_key(t.id) { cx.sess.span_lint( old_vecs, t.id, it.id, - t.span, "deprecated vec type"); + t.span, ~"deprecated vec type"); } 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"); + t.span, ~"deprecated str type"); } ast::ty_vstore(inner, _) | ast::ty_box({ty: inner, _}) | diff --git a/src/rustc/middle/liveness.rs b/src/rustc/middle/liveness.rs index 1987dcc0f63..6bce1ab88d1 100644 --- a/src/rustc/middle/liveness.rs +++ b/src/rustc/middle/liveness.rs @@ -153,11 +153,11 @@ fn check_crate(tcx: ty::ctxt, } impl of to_str::to_str for live_node { - fn to_str() -> str { #fmt["ln(%u)", *self] } + fn to_str() -> ~str { #fmt["ln(%u)", *self] } } impl of to_str::to_str for variable { - fn to_str() -> str { #fmt["v(%u)", *self] } + fn to_str() -> ~str { #fmt["v(%u)", *self] } } // ______________________________________________________________________ @@ -289,9 +289,9 @@ class ir_maps { fn variable_name(var: variable) -> ident { alt self.var_kinds[*var] { vk_local(_, name) | vk_arg(_, name, _) {name} - vk_field(name) {@("self." + *name)} - vk_self {@"self"/~} - vk_implicit_ret {@"<implicit-ret>"/~} + vk_field(name) {@(~"self." + *name)} + vk_self {@~"self"} + vk_implicit_ret {@~"<implicit-ret>"} } } @@ -303,7 +303,7 @@ class ir_maps { alt self.capture_map.find(expr.id) { some(caps) {caps} none { - self.tcx.sess.span_bug(expr.span, "no registered caps"); + self.tcx.sess.span_bug(expr.span, ~"no registered caps"); } } } @@ -580,7 +580,7 @@ class liveness { } none { self.tcx.sess.span_bug( - span, "Not present in def map") + span, ~"Not present in def map") } } } @@ -654,26 +654,26 @@ class liveness { for uint::range(0u, self.ir.num_vars) |var_idx| { let idx = node_base_idx + var_idx; if test(idx).is_valid() { - wr.write_str(" "); + wr.write_str(~" "); wr.write_str(variable(var_idx).to_str()); } } } - fn ln_str(ln: live_node) -> str { + fn ln_str(ln: live_node) -> ~str { do io::with_str_writer |wr| { - wr.write_str("[ln("); + wr.write_str(~"[ln("); wr.write_uint(*ln); - wr.write_str(") of kind "); + wr.write_str(~") of kind "); wr.write_str(#fmt["%?", copy self.ir.lnks[*ln]]); - wr.write_str(" reads"); + wr.write_str(~" reads"); self.write_vars(wr, ln, |idx| self.users[idx].reader ); - wr.write_str(" writes"); + wr.write_str(~" writes"); self.write_vars(wr, ln, |idx| self.users[idx].writer ); - wr.write_str(" "); - wr.write_str(" precedes "); + wr.write_str(~" "); + wr.write_str(~" precedes "); wr.write_str((copy self.successors[*ln]).to_str()); - wr.write_str("]"); + wr.write_str(~"]"); } } @@ -1003,7 +1003,7 @@ class liveness { expr_break { if !self.break_ln.is_valid() { self.tcx.sess.span_bug( - expr.span, "break with invalid break_ln"); + expr.span, ~"break with invalid break_ln"); } self.break_ln @@ -1012,7 +1012,7 @@ class liveness { expr_again { if !self.cont_ln.is_valid() { self.tcx.sess.span_bug( - expr.span, "cont with invalid cont_ln"); + expr.span, ~"cont with invalid cont_ln"); } self.cont_ln @@ -1117,7 +1117,7 @@ class liveness { } expr_mac(*) { - self.tcx.sess.span_bug(expr.span, "unexpanded macro"); + self.tcx.sess.span_bug(expr.span, ~"unexpanded macro"); } } } @@ -1505,7 +1505,7 @@ impl check_methods for @liveness { } else if ty::type_is_bot(t_ret) { // for bot return types, not ok. Function should fail. self.tcx.sess.span_err( - sp, "some control paths may return"); + sp, ~"some control paths may return"); } else { alt fk { visit::fk_ctor(*) { @@ -1513,7 +1513,7 @@ impl check_methods for @liveness { } _ { self.tcx.sess.span_err( - sp, "not all control paths return a value"); + sp, ~"not all control paths return a value"); } } } @@ -1630,11 +1630,11 @@ impl check_methods for @liveness { some(lnk_expr(span)) { self.tcx.sess.span_err( span, - "re-assignment of immutable variable"); + ~"re-assignment of immutable variable"); self.tcx.sess.span_note( orig_span, - "prior assignment occurs here"); + ~"prior assignment occurs here"); } some(lnk) { self.tcx.sess.span_bug( @@ -1671,7 +1671,7 @@ impl check_methods for @liveness { vk_self { self.tcx.sess.span_err( move_span, - "illegal move from self (cannot move out of a field of \ + ~"illegal move from self (cannot move out of a field of \ self)"); ret; } @@ -1686,7 +1686,7 @@ impl check_methods for @liveness { self.report_illegal_read(move_span, lnk, var, moved_variable); self.tcx.sess.span_note( - move_span, "move of variable occurred here"); + move_span, ~"move of variable occurred here"); } @@ -1695,9 +1695,9 @@ impl check_methods for @liveness { var: variable, rk: read_kind) { let msg = alt rk { - possibly_uninitialized_variable {"possibly uninitialized variable"} - possibly_uninitialized_field {"possibly uninitialized field"} - moved_variable {"moved variable"} + possibly_uninitialized_variable {~"possibly uninitialized variable"} + possibly_uninitialized_field {~"possibly uninitialized field"} + moved_variable {~"moved variable"} }; let name = (*self.ir).variable_name(var); alt lnk { diff --git a/src/rustc/middle/region.rs b/src/rustc/middle/region.rs index 532d85645df..76851e4f778 100644 --- a/src/rustc/middle/region.rs +++ b/src/rustc/middle/region.rs @@ -150,7 +150,7 @@ type parent = option<ast::node_id>; /* Records the parameter ID of a region name. */ type binding = {node_id: ast::node_id, - name: str, + name: ~str, br: ty::bound_region}; // Mapping from a block/expr/binding to the innermost scope that @@ -265,7 +265,7 @@ fn nearest_common_ancestor(region_map: region_map, scope_a: ast::node_id, fn parent_id(cx: ctxt, span: span) -> ast::node_id { alt cx.parent { none { - cx.sess.span_bug(span, "crate should not be parent here"); + cx.sess.span_bug(span, ~"crate should not be parent here"); } some(parent_id) { parent_id @@ -505,7 +505,7 @@ impl methods for determine_rp_ctxt { fn region_is_relevant(r: @ast::region) -> bool { alt r.node { ast::re_anon {self.anon_implies_rp} - ast::re_named(@"self"/~) {true} + ast::re_named(@~"self") {true} ast::re_named(_) {false} } } diff --git a/src/rustc/middle/resolve.rs b/src/rustc/middle/resolve.rs index fb5c81caeb1..9d026b1cc20 100644 --- a/src/rustc/middle/resolve.rs +++ b/src/rustc/middle/resolve.rs @@ -104,7 +104,7 @@ type indexed_mod = { glob_imports: dvec<glob_imp_def>, mut globbed_exports: ~[ident], glob_imported_names: hashmap<ident, glob_import_state>, - path: str + path: ~str }; /* foreign modules can't contain enums, and we don't store their ASTs because @@ -254,11 +254,11 @@ fn map_crate(e: @env, c: @ast::crate) { } } - fn path_from_scope(sc: scopes, n: str) -> str { - let mut path = n + "::"; + fn path_from_scope(sc: scopes, n: ~str) -> ~str { + let mut path = n + ~"::"; do list::iter(sc) |s| { alt s { - scope_item(i) { path = *i.ident + "::" + path; } + scope_item(i) { path = *i.ident + ~"::" + path; } _ {} } } @@ -316,7 +316,7 @@ fn map_crate(e: @env, c: @ast::crate) { e.mod_map.get(ast::crate_node_id). glob_imports.push(glob); } - _ { e.sess.span_bug(vi.span, "unexpected scope in a \ + _ { e.sess.span_bug(vi.span, ~"unexpected scope in a \ glob import"); } } } @@ -343,7 +343,7 @@ fn map_crate(e: @env, c: @ast::crate) { glob_imports: dvec(), mut globbed_exports: ~[], glob_imported_names: box_str_hash(), - path: ""}); + path: ~""}); // Next, assemble the links for globbed imports and exports. let v_link_glob = @@ -379,10 +379,10 @@ fn check_unused_imports(e: @env, level: lint::level) { if !vec::contains(e.used_imports.data, k) { alt level { lint::warn { - e.sess.span_warn(sp, "unused import " + *name); + e.sess.span_warn(sp, ~"unused import " + *name); } lint::error { - e.sess.span_err(sp, "unused import " + *name); + e.sess.span_err(sp, ~"unused import " + *name); } lint::ignore { } @@ -511,7 +511,7 @@ fn resolve_names(e: @env, c: @ast::crate) { } _ { e.sess.span_err(p.span, - "not an enum variant: " + + ~"not an enum variant: " + ast_util::path_name(p)); } } @@ -525,8 +525,8 @@ fn resolve_names(e: @env, c: @ast::crate) { e.def_map.insert(pat.id, fnd); } some(fnd@ast::def_const(_)) { - e.sess.span_err(p.span, "pattern variable conflicts \ - with constant '" + *path_to_ident(p) + "'"); + e.sess.span_err(p.span, ~"pattern variable conflicts \ + with constant '" + *path_to_ident(p) + ~"'"); } // Binds a var -- nothing needs to be done _ {} @@ -552,7 +552,7 @@ fn visit_item_with_scope(e: @env, i: @ast::item, let old_resolve_unexported = e.resolve_unexported; e.resolve_unexported |= attr::contains_name(attr::attr_metas(i.attrs), - "!resolve_unexported"); + ~"!resolve_unexported"); let sc = @cons(scope_item(i), sc); alt i.node { @@ -759,8 +759,8 @@ fn follow_import(e: env, &&sc: scopes, path: ~[ident], sp: span) -> alt dcur { some(ast::def_mod(_)) | some(ast::def_foreign_mod(_)) { ret dcur; } _ { - e.sess.span_err(sp, str::connect(path.map(|x|*x), "::") + - " does not name a module."); + e.sess.span_err(sp, str::connect(path.map(|x|*x), ~"::") + + ~" does not name a module."); ret none; } } @@ -790,7 +790,7 @@ fn resolve_import(e: env, n_id: node_id, name: ast::ident, md = lookup(ns_module); if is_none(val) && is_none(typ) && is_none(md) && vec::len(impls) == 0u { - unresolved_err(e, cx, sp, name, "import"); + unresolved_err(e, cx, sp, name, ~"import"); } else { e.imports.insert(id, resolved(val, typ, md, @impls, name, sp)); } @@ -834,7 +834,7 @@ fn resolve_import(e: env, n_id: node_id, name: ast::ident, option::get(e.mod_map.get(ast::crate_node_id).m).view_items) } _ { - e.sess.bug("find_imports_after: nil or unexpected scope"); + e.sess.bug(~"find_imports_after: nil or unexpected scope"); } } } @@ -885,7 +885,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)); } _ { } } @@ -893,17 +893,17 @@ fn resolve_import(e: env, n_id: node_id, name: ast::ident, // Utilities -fn ns_name(ns: namespace) -> str { +fn ns_name(ns: namespace) -> ~str { alt ns { - ns_type { "typename" } - ns_val { "name" } - ns_module { "modulename" } + ns_type { ~"typename" } + ns_val { ~"name" } + ns_module { ~"modulename" } } } enum ctxt { in_mod(def), in_scope(scopes), } -fn unresolved_err(e: env, cx: ctxt, sp: span, name: ident, kind: str) { +fn unresolved_err(e: env, cx: ctxt, sp: span, name: ident, kind: ~str) { fn find_fn_or_mod_scope(sc: scopes) -> option<scope> { for list::each(sc) |cur| { alt cur { @@ -936,18 +936,18 @@ fn unresolved_err(e: env, cx: ctxt, sp: span, name: ident, kind: str) { } else if did.node != ast::crate_node_id { let paths = e.ext_map.get(did); path = @str::connect(vec::append_one(paths, path).map(|x|*x), - "::"); + ~"::"); } } } e.sess.span_err(sp, mk_unresolved_msg(path, kind)); } -fn unresolved_fatal(e: env, sp: span, id: ident, kind: str) -> ! { +fn unresolved_fatal(e: env, sp: span, id: ident, kind: ~str) -> ! { e.sess.span_fatal(sp, mk_unresolved_msg(id, kind)); } -fn mk_unresolved_msg(id: ident, kind: str) -> str { +fn mk_unresolved_msg(id: ident, kind: ~str) -> ~str { ret #fmt["unresolved %s: %s", kind, *id]; } @@ -1037,22 +1037,22 @@ fn lookup_in_scope(e: env, &&sc: scopes, sp: span, name: ident, ns: namespace, scope_toplevel { if ns == ns_type { ret some(ast::def_prim_ty(alt *name { - "bool" { ast::ty_bool } - "int" { ast::ty_int(ast::ty_i) } - "uint" { ast::ty_uint(ast::ty_u) } - "float" { ast::ty_float(ast::ty_f) } - "str" { ast::ty_str } - "char" { ast::ty_int(ast::ty_char) } - "i8" { ast::ty_int(ast::ty_i8) } - "i16" { ast::ty_int(ast::ty_i16) } - "i32" { ast::ty_int(ast::ty_i32) } - "i64" { ast::ty_int(ast::ty_i64) } - "u8" { ast::ty_uint(ast::ty_u8) } - "u16" { ast::ty_uint(ast::ty_u16) } - "u32" { ast::ty_uint(ast::ty_u32) } - "u64" { ast::ty_uint(ast::ty_u64) } - "f32" { ast::ty_float(ast::ty_f32) } - "f64" { ast::ty_float(ast::ty_f64) } + ~"bool" { ast::ty_bool } + ~"int" { ast::ty_int(ast::ty_i) } + ~"uint" { ast::ty_uint(ast::ty_u) } + ~"float" { ast::ty_float(ast::ty_f) } + ~"str" { ast::ty_str } + ~"char" { ast::ty_int(ast::ty_char) } + ~"i8" { ast::ty_int(ast::ty_i8) } + ~"i16" { ast::ty_int(ast::ty_i16) } + ~"i32" { ast::ty_int(ast::ty_i32) } + ~"i64" { ast::ty_int(ast::ty_i64) } + ~"u8" { ast::ty_uint(ast::ty_u8) } + ~"u16" { ast::ty_uint(ast::ty_u16) } + ~"u32" { ast::ty_uint(ast::ty_u32) } + ~"u64" { ast::ty_uint(ast::ty_u64) } + ~"f32" { ast::ty_float(ast::ty_f32) } + ~"f64" { ast::ty_float(ast::ty_f64) } _ { ret none; } })); } @@ -1071,7 +1071,7 @@ fn lookup_in_scope(e: env, &&sc: scopes, sp: span, name: ident, ns: namespace, } ast::item_trait(tps, _) { if ns == ns_type { - if *name == "self" { + if *name == ~"self" { ret some(def_self(it.id)); } ret lookup_in_ty_params(e, name, tps); @@ -1096,7 +1096,7 @@ fn lookup_in_scope(e: env, &&sc: scopes, sp: span, name: ident, ns: namespace, } } scope_method(id, tps) { - if (*name == "self" && ns == ns_val) { + if (*name == ~"self" && ns == ns_val) { ret some(ast::def_self(id)); } else if ns == ns_type { ret lookup_in_ty_params(e, name, tps); @@ -1152,9 +1152,9 @@ fn lookup_in_scope(e: env, &&sc: scopes, sp: span, name: ident, ns: namespace, (left_fn && local || left_fn_level2 && self_scope || scope_is_fn(hd) && left_fn && def_is_ty_arg(df)) { let msg = if ns == ns_type { - "attempt to use a type argument out of scope" + ~"attempt to use a type argument out of scope" } else { - "attempted dynamic environment-capture" + ~"attempted dynamic environment-capture" }; e.sess.span_fatal(sp, msg); } else if local || self_scope { @@ -1331,7 +1331,7 @@ fn lookup_in_block(e: env, name: ident, sp: span, b: ast::blk_, pos: uint, } } } - _ { e.sess.span_bug(vi.span, "unexpected view_item in block"); } + _ { e.sess.span_bug(vi.span, ~"unexpected view_item in block"); } } } ret none; @@ -1417,7 +1417,7 @@ fn lookup_in_mod(e: env, m: def, sp: span, name: ident, ns: namespace, } _ { // Precondition - e.sess.span_bug(sp, "lookup_in_mod was passed a non-mod def"); + e.sess.span_bug(sp, ~"lookup_in_mod was passed a non-mod def"); } } } @@ -1444,7 +1444,7 @@ fn lookup_import(e: env, n_id: node_id, ns: namespace) -> option<def> { ret lookup_import(e, n_id, ns); } resolving(sp) { - e.sess.span_err(sp, "cyclic import"); + e.sess.span_err(sp, ~"cyclic import"); ret none; } resolved(val, typ, md, _, _, _) { @@ -1454,7 +1454,7 @@ fn lookup_import(e: env, n_id: node_id, ns: namespace) -> option<def> { ret alt ns { ns_val { val } ns_type { typ } ns_module { md } }; } is_glob(_,_,_) { - e.sess.bug("lookup_import: can't handle is_glob"); + e.sess.bug(~"lookup_import: can't handle is_glob"); } } } @@ -1530,7 +1530,7 @@ fn lookup_in_globs(e: env, globs: ~[glob_imp_def], sp: span, id: ident, } _ { - e.sess.span_bug(sp, "lookup_in_globs: not a glob"); + e.sess.span_bug(sp, ~"lookup_in_globs: not a glob"); } } alt lookup_in_mod(e, def.def, sp, name, ns, dr) { @@ -1551,8 +1551,8 @@ fn lookup_in_globs(e: env, globs: ~[glob_imp_def], sp: span, id: ident, let sp = match.path.span; e.sess.span_note(sp, #fmt["'%s' is imported here", *id]); } - e.sess.span_fatal(sp, "'" + *id + "' is glob-imported from" + - " multiple different modules."); + e.sess.span_fatal(sp, ~"'" + *id + ~"' is glob-imported from" + + ~" multiple different modules."); } } @@ -1712,7 +1712,7 @@ fn ns_for_def(d: def) -> namespace { ast::def_ty(_) | ast::def_binding(_) | ast::def_use(_) | ast::def_ty_param(_, _) | ast::def_prim_ty(_) | ast::def_class(_) { ns_type } - ast::def_region(_) { fail "regions are not handled by this pass" } + ast::def_region(_) { fail ~"regions are not handled by this pass" } } } @@ -1750,25 +1750,25 @@ fn check_mod_name(e: env, name: ident, entries: @list<mod_index_entry>) { let mut saw_type = false; let mut saw_value = false; let mut entries = entries; - fn dup(e: env, sp: span, word: str, name: ident) { - e.sess.span_fatal(sp, "duplicate definition of " + word + *name); + fn dup(e: env, sp: span, word: ~str, name: ident) { + e.sess.span_fatal(sp, ~"duplicate definition of " + word + *name); } loop { alt *entries { cons(entry, rest) { if !is_none(lookup_in_mie(e, entry, ns_val)) { if saw_value { - dup(e, mie_span(entry), "", name); + dup(e, mie_span(entry), ~"", name); } else { saw_value = true; } } if !is_none(lookup_in_mie(e, entry, ns_type)) { if saw_type { - dup(e, mie_span(entry), "type ", name); + dup(e, mie_span(entry), ~"type ", name); } else { saw_type = true; } } if !is_none(lookup_in_mie(e, entry, ns_module)) { if saw_mod { - dup(e, mie_span(entry), "module ", name); + dup(e, mie_span(entry), ~"module ", name); } else { saw_mod = true; } } entries = rest; @@ -1799,11 +1799,11 @@ fn check_item(e: @env, i: @ast::item, &&x: (), v: vt<()>) { ast::item_fn(decl, ty_params, _) { check_fn(*e, i.span, decl); ensure_unique(*e, i.span, ty_params, |tp| tp.ident, - "type parameter"); + ~"type parameter"); } ast::item_enum(_, ty_params) { ensure_unique(*e, i.span, ty_params, |tp| tp.ident, - "type parameter"); + ~"type parameter"); } ast::item_trait(_, methods) { ensure_unique(*e, i.span, methods, |m| { @@ -1816,11 +1816,11 @@ fn check_item(e: @env, i: @ast::item, &&x: (), v: vt<()>) { } } }, - "method"); + ~"method"); } ast::item_impl(_, _, _, methods) { ensure_unique(*e, i.span, methods, |m| m.ident, - "method"); + ~"method"); } _ { } } @@ -1834,28 +1834,28 @@ fn check_pat(e: @env, ch: checker, p: @ast::pat) { fn check_arm(e: @env, a: ast::arm, &&x: (), v: vt<()>) { visit::visit_arm(a, x, v); - let ch0 = checker(*e, "binding"); + let ch0 = checker(*e, ~"binding"); check_pat(e, ch0, a.pats[0]); let seen0 = ch0.seen.get(); let mut i = vec::len(a.pats); while i > 1u { i -= 1u; - let ch = checker(*e, "binding"); + let ch = checker(*e, ~"binding"); check_pat(e, ch, a.pats[i]); // Ensure the bindings introduced in this pattern are the same as in // the first pattern. if ch.seen.len() != seen0.len() { e.sess.span_err(a.pats[i].span, - "inconsistent number of bindings"); + ~"inconsistent number of bindings"); } else { for ch.seen.each |name| { if is_none(vec::find(seen0, |x| str::eq(*name, *x))) { // Fight the alias checker let name_ = name; e.sess.span_err(a.pats[i].span, - "binding " + *name_ + - " does not occur in first pattern"); + ~"binding " + *name_ + + ~" does not occur in first pattern"); } } } @@ -1864,15 +1864,15 @@ fn check_arm(e: @env, a: ast::arm, &&x: (), v: vt<()>) { fn check_block(e: @env, b: ast::blk, &&x: (), v: vt<()>) { visit::visit_block(b, x, v); - let values = checker(*e, "value"); - let types = checker(*e, "type"); - let mods = checker(*e, "module"); + let values = checker(*e, ~"value"); + let types = checker(*e, ~"type"); + let mods = checker(*e, ~"module"); for b.node.stmts.each |st| { alt st.node { ast::stmt_decl(d, _) { alt d.node { ast::decl_local(locs) { - let local_values = checker(*e, "value"); + let local_values = checker(*e, ~"value"); for locs.each |loc| { do pat_util::pat_bindings(e.def_map, loc.node.pat) |_i, p_sp, n| { @@ -1911,14 +1911,14 @@ fn check_block(e: @env, b: ast::blk, &&x: (), v: vt<()>) { fn check_fn(e: env, sp: span, decl: ast::fn_decl) { fn arg_name(a: ast::arg) -> ident { ret a.ident; } - ensure_unique(e, sp, decl.inputs, arg_name, "argument"); + ensure_unique(e, sp, decl.inputs, arg_name, ~"argument"); } fn check_expr(e: @env, ex: @ast::expr, &&x: (), v: vt<()>) { alt ex.node { ast::expr_rec(fields, _) { fn field_name(f: ast::field) -> ident { ret f.node.ident; } - ensure_unique(*e, ex.span, fields, field_name, "field"); + ensure_unique(*e, ex.span, fields, field_name, ~"field"); } _ { } } @@ -1929,16 +1929,16 @@ fn check_ty(e: @env, ty: @ast::ty, &&x: (), v: vt<()>) { alt ty.node { ast::ty_rec(fields) { fn field_name(f: ast::ty_field) -> ident { ret f.node.ident; } - ensure_unique(*e, ty.span, fields, field_name, "field"); + ensure_unique(*e, ty.span, fields, field_name, ~"field"); } _ { } } visit::visit_ty(ty, x, v); } -type checker = @{seen: dvec<ident>, kind: str, sess: session}; +type checker = @{seen: dvec<ident>, kind: ~str, sess: session}; -fn checker(e: env, kind: str) -> checker { +fn checker(e: env, kind: ~str) -> checker { ret @{seen: dvec(), kind: kind, sess: e.sess}; } @@ -1946,7 +1946,7 @@ fn check_name(ch: checker, sp: span, name: ident) { for ch.seen.each |s| { if str::eq(*s, *name) { ch.sess.span_fatal( - sp, "duplicate " + ch.kind + " name: " + *name); + sp, ~"duplicate " + ch.kind + ~" name: " + *name); } } } @@ -1956,7 +1956,7 @@ fn add_name(ch: checker, sp: span, name: ident) { } fn ensure_unique<T>(e: env, sp: span, elts: ~[T], id: fn(T) -> ident, - kind: str) { + kind: ~str) { let ch = checker(e, kind); for elts.each |elt| { add_name(ch, sp, id(elt)); } } @@ -1969,7 +1969,7 @@ fn check_exports(e: @env) { if defid.crate != ast::local_crate { // FIXME: ought to support external export-globs eventually. #2527 - e.sess.span_unimpl(sp, "glob-export of items in external crate"); + e.sess.span_unimpl(sp, ~"glob-export of items in external crate"); } else { let mid = def_id_of_def(m); @@ -1994,7 +1994,7 @@ fn check_exports(e: @env) { } } _ { - let s = "glob-export from mod with non-items"; + let s = ~"glob-export from mod with non-items"; e.sess.span_unimpl(sp, s); } } @@ -2047,7 +2047,7 @@ fn check_exports(e: @env) { maybe_add_reexport(e, export_id, t); maybe_add_reexport(e, export_id, m); } - _ { e.sess.span_bug(vi.span, "unresolved export"); } + _ { e.sess.span_bug(vi.span, ~"unresolved export"); } } } mie_item(@{id, _}) | mie_foreign_item(@{id, _}) | @@ -2142,7 +2142,8 @@ fn check_exports(e: @env) { let id = if vec::len(path.idents) == 1u { path.idents[0] } else { - e.sess.span_fatal(vp.span, "bad export name-list") + e.sess.span_fatal(vp.span, + ~"bad export name-list") }; check_export_enum_list(e, node_id, _mod, vp.span, id, ids); diff --git a/src/rustc/middle/resolve3.rs b/src/rustc/middle/resolve3.rs index c2f97907319..07af1e5538a 100644 --- a/src/rustc/middle/resolve3.rs +++ b/src/rustc/middle/resolve3.rs @@ -203,18 +203,18 @@ fn Atom(n: uint) -> Atom { } class AtomTable { - let atoms: hashmap<@str/~,Atom>; - let strings: dvec<@str/~>; + let atoms: hashmap<@~str,Atom>; + let strings: dvec<@~str>; let mut atom_count: uint; new() { - self.atoms = hashmap::<@str/~,Atom>(|x| str::hash(*x), + self.atoms = hashmap::<@~str,Atom>(|x| str::hash(*x), |x, y| str::eq(*x, *y)); self.strings = dvec(); self.atom_count = 0u; } - fn intern(string: @str/~) -> Atom { + fn intern(string: @~str) -> Atom { alt self.atoms.find(string) { none { /* fall through */ } some(atom) { ret atom; } @@ -228,11 +228,11 @@ class AtomTable { ret atom; } - fn atom_to_str(atom: Atom) -> @str/~ { + fn atom_to_str(atom: Atom) -> @~str { ret self.strings.get_elt(atom); } - fn atoms_to_strs(atoms: ~[Atom], f: fn(@str/~) -> bool) { + fn atoms_to_strs(atoms: ~[Atom], f: fn(@~str) -> bool) { for atoms.each |atom| { if !f(self.atom_to_str(atom)) { ret; @@ -240,15 +240,15 @@ class AtomTable { } } - fn atoms_to_str(atoms: ~[Atom]) -> @str/~ { + fn atoms_to_str(atoms: ~[Atom]) -> @~str { // XXX: str::connect should do this. - let mut result = ""; + let mut result = ~""; let mut first = true; for self.atoms_to_strs(atoms) |string| { if first { first = false; } else { - result += "::"; + result += ~"::"; } result += *string; @@ -498,7 +498,8 @@ class NameBindings { fn get_module() -> @Module { alt self.module_def { NoModuleDef { - fail "get_module called on a node with no module definition!"; + fail + ~"get_module called on a node with no module definition!"; } ModuleDef(module) { ret module; @@ -560,25 +561,25 @@ class PrimitiveTypeTable { new(atom_table: @AtomTable) { self.primitive_types = atom_hashmap(); - self.intern(atom_table, @"bool"/~, ty_bool); - self.intern(atom_table, @"char"/~, ty_int(ty_char)); - self.intern(atom_table, @"float"/~, ty_float(ty_f)); - self.intern(atom_table, @"f32"/~, ty_float(ty_f32)); - self.intern(atom_table, @"f64"/~, ty_float(ty_f64)); - self.intern(atom_table, @"int"/~, ty_int(ty_i)); - self.intern(atom_table, @"i8"/~, ty_int(ty_i8)); - self.intern(atom_table, @"i16"/~, ty_int(ty_i16)); - self.intern(atom_table, @"i32"/~, ty_int(ty_i32)); - self.intern(atom_table, @"i64"/~, ty_int(ty_i64)); - self.intern(atom_table, @"str"/~, ty_str); - self.intern(atom_table, @"uint"/~, ty_uint(ty_u)); - self.intern(atom_table, @"u8"/~, ty_uint(ty_u8)); - self.intern(atom_table, @"u16"/~, ty_uint(ty_u16)); - self.intern(atom_table, @"u32"/~, ty_uint(ty_u32)); - self.intern(atom_table, @"u64"/~, ty_uint(ty_u64)); + self.intern(atom_table, @~"bool", ty_bool); + self.intern(atom_table, @~"char", ty_int(ty_char)); + self.intern(atom_table, @~"float", ty_float(ty_f)); + self.intern(atom_table, @~"f32", ty_float(ty_f32)); + self.intern(atom_table, @~"f64", ty_float(ty_f64)); + self.intern(atom_table, @~"int", ty_int(ty_i)); + self.intern(atom_table, @~"i8", ty_int(ty_i8)); + self.intern(atom_table, @~"i16", ty_int(ty_i16)); + self.intern(atom_table, @~"i32", ty_int(ty_i32)); + self.intern(atom_table, @~"i64", ty_int(ty_i64)); + self.intern(atom_table, @~"str", ty_str); + self.intern(atom_table, @~"uint", ty_uint(ty_u)); + self.intern(atom_table, @~"u8", ty_uint(ty_u8)); + self.intern(atom_table, @~"u16", ty_uint(ty_u16)); + self.intern(atom_table, @~"u32", ty_uint(ty_u32)); + self.intern(atom_table, @~"u64", ty_uint(ty_u64)); } - fn intern(atom_table: @AtomTable, string: @str/~, + fn intern(atom_table: @AtomTable, string: @~str, primitive_type: prim_ty) { let atom = (*atom_table).intern(string); self.primitive_types.insert(atom, primitive_type); @@ -651,7 +652,7 @@ class Resolver { self.type_ribs = @dvec(); self.xray_context = NoXray; - self.self_atom = (*self.atom_table).intern(@"self"/~); + self.self_atom = (*self.atom_table).intern(@~"self"); self.primitive_type_table = @PrimitiveTypeTable(self.atom_table); self.namespaces = ~[ ModuleNS, TypeNS, ValueNS, ImplNS ]; @@ -934,7 +935,7 @@ class Resolver { } item_mac(*) { - fail "item macros unimplemented" + fail ~"item macros unimplemented" } } } @@ -1038,14 +1039,15 @@ class Resolver { let last_ident = full_path.idents.last(); if last_ident != ident { self.session.span_err(view_item.span, - "cannot export under \ + ~"cannot export under \ a new name"); } if full_path.idents.len() != 1u { - self.session.span_err(view_item.span, - "cannot export an item \ - that is not in this \ - module"); + self.session.span_err( + view_item.span, + ~"cannot export an item \ + that is not in this \ + module"); } let atom = (*self.atom_table).intern(ident); @@ -1054,7 +1056,7 @@ class Resolver { view_path_glob(*) { self.session.span_err(view_item.span, - "export globs are \ + ~"export globs are \ unsupported"); } @@ -1063,7 +1065,7 @@ class Resolver { path_list_idents.len() == 0u { self.session.span_warn(view_item.span, - "this syntax for \ + ~"this syntax for \ exporting no \ variants is \ unsupported; export \ @@ -1072,7 +1074,7 @@ class Resolver { } else { if path.idents.len() != 0u { self.session.span_err(view_item.span, - "cannot export an \ + ~"cannot export an \ item that is not \ in this module"); } @@ -1180,7 +1182,7 @@ class Resolver { path_entry.path_string, path_entry.def_like); - let mut pieces = split_str(path_entry.path_string, "::"); + let mut pieces = split_str(path_entry.path_string, ~"::"); let final_ident = pop(pieces); // Find the module we need, creating modules along the way if we @@ -1251,7 +1253,7 @@ class Resolver { alt existing_module.parent_link { NoParentLink | BlockParentLink(*) { - fail "can't happen"; + fail ~"can't happen"; } ModuleParentLink (parent_module, @@ -1468,7 +1470,7 @@ class Resolver { } if self.unresolved_imports == prev_unresolved_imports { - self.session.err("failed to resolve imports"); + self.session.err(~"failed to resolve imports"); self.report_unresolved_imports(module_root); break; } @@ -1520,7 +1522,7 @@ class Resolver { Failed { // We presumably emitted an error. Continue. self.session.span_err(import_directive.span, - "failed to resolve import"); + ~"failed to resolve import"); } Indeterminate { // Bail out. We'll come around next time. @@ -1803,7 +1805,7 @@ class Resolver { binding"); } UnknownResult { - fail "module result should be known at this point"; + fail ~"module result should be known at this point"; } } alt value_result { @@ -1813,7 +1815,7 @@ class Resolver { } UnboundResult { /* Continue. */ } UnknownResult { - fail "value result should be known at this point"; + fail ~"value result should be known at this point"; } } alt type_result { @@ -1823,7 +1825,7 @@ class Resolver { } UnboundResult { /* Continue. */ } UnknownResult { - fail "type result should be known at this point"; + fail ~"type result should be known at this point"; } } alt impl_result { @@ -1834,7 +1836,7 @@ class Resolver { } UnboundImplResult { /* Continue. */ } UnknownImplResult { - fail "impl result should be known at this point"; + fail ~"impl result should be known at this point"; } } @@ -2025,7 +2027,7 @@ class Resolver { xray) { Failed { - self.session.span_err(span, "unresolved name"); + self.session.span_err(span, ~"unresolved name"); ret Failed; } Indeterminate { @@ -2082,7 +2084,7 @@ class Resolver { let mut search_module; alt self.resolve_module_in_lexical_scope(module, first_element) { Failed { - self.session.span_err(span, "unresolved name"); + self.session.span_err(span, ~"unresolved name"); ret Failed; } Indeterminate { @@ -2316,7 +2318,7 @@ class Resolver { source_name = source; } GlobImport { - fail "found `import *`, which is invalid"; + fail ~"found `import *`, which is invalid"; } } @@ -2443,14 +2445,15 @@ class Resolver { if is_none(module_result) && is_none(value_result) && is_none(type_result) && is_none(impl_result) { - self.session.span_err(import_directive.span, "unresolved import"); + self.session.span_err(import_directive.span, + ~"unresolved import"); ret Failed; } // Otherwise, proceed and write in the bindings. alt module.import_resolutions.find(target_name) { none { - fail "(resolving one-level renaming import) reduced graph \ + fail ~"(resolving one-level renaming import) reduced graph \ construction or glob importing should have created the \ import resolution name by now"; } @@ -2488,7 +2491,7 @@ class Resolver { let import_count = module.imports.len(); if index != import_count { self.session.span_err(module.imports.get_elt(index).span, - "unresolved import"); + ~"unresolved import"); } // Descend into children and anonymous children. @@ -2800,15 +2803,15 @@ class Resolver { // named function item. This is not allowed, so we // report an error. - self.session.span_err(span, - "attempted dynamic environment-\ - capture"); + self.session.span_err( + span, + ~"attempted dynamic environment-capture"); } else { // This was an attempt to use a type parameter outside // its scope. self.session.span_err(span, - "attempt to use a type \ + ~"attempt to use a type \ argument out of scope"); } @@ -2881,7 +2884,7 @@ class Resolver { // Items with the !resolve_unexported attribute are X-ray contexts. // This is used to allow the test runner to run unexported tests. let orig_xray_flag = self.xray_context; - if contains_name(attr_metas(item.attrs), "!resolve_unexported") { + if contains_name(attr_metas(item.attrs), ~"!resolve_unexported") { self.xray_context = Xray; } @@ -3014,7 +3017,7 @@ class Resolver { if !self.session.building_library && is_none(self.session.main_fn) && - str::eq(*item.ident, "main") { + str::eq(*item.ident, ~"main") { self.session.main_fn = some((item.id, item.span)); } @@ -3037,7 +3040,7 @@ class Resolver { } item_mac(*) { - fail "item macros unimplemented" + fail ~"item macros unimplemented" } } @@ -3102,7 +3105,7 @@ class Resolver { capture_item.span) { none { self.session.span_err(capture_item.span, - "unresolved name in \ + ~"unresolved name in \ capture clause"); } some(def) { @@ -3231,7 +3234,7 @@ class Resolver { alt self.resolve_path(interface.path, TypeNS, true, visitor) { none { self.session.span_err(interface.path.span, - "attempt to implement a \ + ~"attempt to implement a \ nonexistent interface"); } some(def) { @@ -3345,7 +3348,7 @@ class Resolver { true, visitor) { none { self.session.span_err(span, - "attempt to implement an \ + ~"attempt to implement an \ unknown interface"); } some(def) { @@ -3441,7 +3444,7 @@ class Resolver { for arm.pats.each() |p: @pat| { if self.num_bindings(p) != good { self.session.span_err(p.span, - "inconsistent number of bindings"); + ~"inconsistent number of bindings"); self.warn_var_patterns(arm); break; }; @@ -3544,7 +3547,7 @@ class Resolver { // Write the result into the def map. #debug("(resolving type) writing resolution for `%s` \ (id %d)", - connect(path.idents.map(|x| *x), "::"), + connect(path.idents.map(|x| *x), ~"::"), path_id); self.record_def(path_id, def); } @@ -3552,7 +3555,7 @@ class Resolver { self.session.span_err (ty.span, #fmt("use of undeclared type name `%s`", connect(path.idents.map(|x| *x), - "::"))); + ~"::"))); } } } @@ -3565,7 +3568,7 @@ class Resolver { false, visitor) { none { self.session.span_err(constraint.span, - "(resolving function) \ + ~"(resolving function) \ use of undeclared \ constraint"); } @@ -3623,7 +3626,7 @@ class Resolver { } FoundConst { self.session.span_err(pattern.span, - "pattern variable \ + ~"pattern variable \ conflicts with a constant \ in scope"); } @@ -3699,7 +3702,7 @@ class Resolver { } none { self.session.span_err(path.span, - "unresolved enum variant"); + ~"unresolved enum variant"); } } @@ -3735,7 +3738,7 @@ class Resolver { Success(target) { alt target.bindings.value_def { none { - fail "resolved name in the value namespace to a set \ + fail ~"resolved name in the value namespace to a set \ of name bindings with no def?!"; } some(def @ def_variant(*)) { @@ -3751,7 +3754,7 @@ class Resolver { } Indeterminate { - fail "unexpected indeterminate result"; + fail ~"unexpected indeterminate result"; } Failed { @@ -3858,7 +3861,7 @@ class Resolver { ret ImportNameDefinition(def); } none { - fail "target for namespace doesn't refer to \ + fail ~"target for namespace doesn't refer to \ bindings that contain a definition for \ that namespace!"; } @@ -3910,7 +3913,7 @@ class Resolver { } Indeterminate { - fail "indeterminate unexpected"; + fail ~"indeterminate unexpected"; } Success(resulting_module) { @@ -3964,7 +3967,7 @@ class Resolver { } Indeterminate { - fail "indeterminate unexpected"; + fail ~"indeterminate unexpected"; } Success(resulting_module) { @@ -4012,7 +4015,7 @@ class Resolver { AllowCapturingSelf); } ModuleNS | ImplNS { - fail "module or impl namespaces do not have local ribs"; + fail ~"module or impl namespaces do not have local ribs"; } } @@ -4044,7 +4047,7 @@ class Resolver { Success(target) { alt (*target.bindings).def_for_namespace(namespace) { none { - fail "resolved name in a namespace to a set of name \ + fail ~"resolved name in a namespace to a set of name \ bindings with no def for that namespace?!"; } some(def) { @@ -4056,7 +4059,7 @@ class Resolver { } } Indeterminate { - fail "unexpected indeterminate result"; + fail ~"unexpected indeterminate result"; } Failed { ret none; @@ -4083,14 +4086,14 @@ class Resolver { some(def) { // Write the result into the def map. #debug("(resolving expr) resolved `%s`", - connect(path.idents.map(|x| *x), "::")); + connect(path.idents.map(|x| *x), ~"::")); self.record_def(expr.id, def); } none { self.session.span_err(expr.span, #fmt("unresolved name: %s", connect(path.idents.map(|x| *x), - "::"))); + ~"::"))); } } @@ -4197,15 +4200,15 @@ class Resolver { alt self.unused_import_lint_level { warn { self.session.span_warn(import_resolution.span, - "unused import"); + ~"unused import"); } error { self.session.span_err(import_resolution.span, - "unused import"); + ~"unused import"); } ignore { self.session.span_bug(import_resolution.span, - "shouldn't be here if lint \ + ~"shouldn't be here if lint \ pass is ignored"); } } @@ -4221,7 +4224,7 @@ class Resolver { // /// A somewhat inefficient routine to print out the name of a module. - fn module_to_str(module: @Module) -> str { + fn module_to_str(module: @Module) -> ~str { let atoms = dvec(); let mut current_module = module; loop { @@ -4234,21 +4237,21 @@ class Resolver { current_module = module; } BlockParentLink(module, node_id) { - atoms.push((*self.atom_table).intern(@"<opaque>"/~)); + atoms.push((*self.atom_table).intern(@~"<opaque>")); current_module = module; } } } if atoms.len() == 0u { - ret "???"; + ret ~"???"; } - let mut string = ""; + let mut string = ~""; let mut i = atoms.len() - 1u; loop { if i < atoms.len() - 1u { - string += "::"; + string += ~"::"; } string += *(*self.atom_table).atom_to_str(atoms.get_elt(i)); @@ -4273,36 +4276,36 @@ class Resolver { for module.import_resolutions.each |name, import_resolution| { let mut module_repr; alt (*import_resolution).target_for_namespace(ModuleNS) { - none { module_repr = ""; } + none { module_repr = ~""; } some(target) { - module_repr = " module:?"; + module_repr = ~" module:?"; // XXX } } let mut value_repr; alt (*import_resolution).target_for_namespace(ValueNS) { - none { value_repr = ""; } + none { value_repr = ~""; } some(target) { - value_repr = " value:?"; + value_repr = ~" value:?"; // XXX } } let mut type_repr; alt (*import_resolution).target_for_namespace(TypeNS) { - none { type_repr = ""; } + none { type_repr = ~""; } some(target) { - type_repr = " type:?"; + type_repr = ~" type:?"; // XXX } } let mut impl_repr; alt (*import_resolution).target_for_namespace(ImplNS) { - none { impl_repr = ""; } + none { impl_repr = ~""; } some(target) { - impl_repr = " impl:?"; + impl_repr = ~" impl:?"; // XXX } } diff --git a/src/rustc/middle/trans/alt.rs b/src/rustc/middle/trans/alt.rs index 2fdf8c3ff7f..0b7053a2c2b 100644 --- a/src/rustc/middle/trans/alt.rs +++ b/src/rustc/middle/trans/alt.rs @@ -41,7 +41,7 @@ enum opt_result { range_result(result, result), } fn trans_opt(bcx: block, o: opt) -> opt_result { - let _icx = bcx.insn_ctxt("alt::trans_opt"); + let _icx = bcx.insn_ctxt(~"alt::trans_opt"); let ccx = bcx.ccx(); let mut bcx = bcx; alt o { @@ -275,7 +275,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} { - let _icx = bcx.insn_ctxt("alt::extract_variant_args"); + 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 { ty::ty_enum(id, substs) { assert id == vdefs.enm; substs.tps } @@ -389,7 +389,7 @@ fn pick_col(m: match) -> uint { 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 _icx = bcx.insn_ctxt(~"alt::compile_submatch"); let mut bcx = bcx; let tcx = bcx.tcx(), dm = tcx.def_map; if m.len() == 0u { Br(bcx, option::get(chk)()); ret; } @@ -404,7 +404,7 @@ fn compile_submatch(bcx: block, m: match, vals: ~[ValueRef], bcx.fcx.lllocals.insert(val, loc); }; let {bcx: guard_cx, val} = { - do with_scope_result(bcx, e.info(), "guard") |bcx| { + do with_scope_result(bcx, e.info(), ~"guard") |bcx| { trans_temp_expr(bcx, e) } }; @@ -460,7 +460,7 @@ fn compile_submatch(bcx: block, m: match, vals: ~[ValueRef], let tup_ty = node_id_type(bcx, pat_id); let n_tup_elts = alt ty::get(tup_ty).struct { ty::ty_tup(elts) { elts.len() } - _ { ccx.sess.bug("non-tuple type in tuple pattern"); } + _ { ccx.sess.bug(~"non-tuple type in tuple pattern"); } }; let mut tup_vals = ~[], i = 0u; while i < n_tup_elts { @@ -531,7 +531,7 @@ fn compile_submatch(bcx: block, m: match, vals: ~[ValueRef], } let else_cx = alt kind { no_branch | single { bcx } - _ { sub_block(bcx, "match_else") } + _ { sub_block(bcx, ~"match_else") } }; let sw = if kind == switch { Switch(bcx, test_val, else_cx.llbb, opts.len()) @@ -546,7 +546,7 @@ fn compile_submatch(bcx: block, m: match, vals: ~[ValueRef], i += 1u; let mut opt_cx = else_cx; if !exhaustive || i < len { - opt_cx = sub_block(bcx, "match_case"); + opt_cx = sub_block(bcx, ~"match_case"); alt kind { single { Br(bcx, opt_cx.llbb); } switch { @@ -560,7 +560,7 @@ fn compile_submatch(bcx: block, m: match, vals: ~[ValueRef], compare { let t = node_id_type(bcx, pat_id); let {bcx: after_cx, val: matches} = { - do with_scope_result(bcx, none, "compare_scope") |bcx| { + do with_scope_result(bcx, none, ~"compare_scope") |bcx| { alt trans_opt(bcx, opt) { single_result({bcx, val}) { trans_compare(bcx, ast::eq, test_val, t, val, t) @@ -575,7 +575,7 @@ fn compile_submatch(bcx: block, m: match, vals: ~[ValueRef], } } }; - bcx = sub_block(after_cx, "compare_next"); + bcx = sub_block(after_cx, ~"compare_next"); CondBr(after_cx, matches, opt_cx.llbb, bcx.llbb); } _ { } @@ -608,7 +608,7 @@ fn compile_submatch(bcx: block, m: match, vals: ~[ValueRef], // Returns false for unreachable blocks 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 _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| { @@ -642,15 +642,15 @@ fn trans_alt(bcx: block, arms: ~[ast::arm], mode: ast::alt_mode, dest: dest) -> block { - let _icx = bcx.insn_ctxt("alt::trans_alt"); - do with_scope(bcx, alt_expr.info(), "alt") |bcx| { + let _icx = bcx.insn_ctxt(~"alt::trans_alt"); + do with_scope(bcx, alt_expr.info(), ~"alt") |bcx| { trans_alt_inner(bcx, expr, arms, mode, dest) } } 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 _icx = scope_cx.insn_ctxt(~"alt::trans_alt_inner"); let bcx = scope_cx, tcx = bcx.tcx(); let mut bodies = ~[], match = ~[]; @@ -658,7 +658,7 @@ fn trans_alt_inner(scope_cx: block, expr: @ast::expr, arms: ~[ast::arm], if bcx.unreachable { ret bcx; } for vec::each(arms) |a| { - let body = scope_block(bcx, a.body.info(), "case_body"); + let body = scope_block(bcx, a.body.info(), ~"case_body"); let id_map = pat_util::pat_id_map(tcx.def_map, a.pats[0]); vec::push(bodies, body); for vec::each(a.pats) |p| { @@ -676,8 +676,8 @@ fn trans_alt_inner(scope_cx: block, expr: @ast::expr, arms: ~[ast::arm], fn mk_fail(bcx: block, sp: span, done: @mut option<BasicBlockRef>) -> BasicBlockRef { alt *done { some(bb) { ret bb; } _ { } } - let fail_cx = sub_block(bcx, "case_fallthrough"); - trans_fail(fail_cx, some(sp), "non-exhaustive match failure");; + let fail_cx = sub_block(bcx, ~"case_fallthrough"); + trans_fail(fail_cx, some(sp), ~"non-exhaustive match failure");; *done = some(fail_cx.llbb); ret fail_cx.llbb; } @@ -709,7 +709,7 @@ fn trans_alt_inner(scope_cx: block, expr: @ast::expr, arms: ~[ast::arm], // Not alt-related, but similar to the pattern-munging code above fn bind_irrefutable_pat(bcx: block, pat: @ast::pat, val: ValueRef, make_copy: bool) -> block { - let _icx = bcx.insn_ctxt("alt::bind_irrefutable_pat"); + let _icx = bcx.insn_ctxt(~"alt::bind_irrefutable_pat"); let ccx = bcx.fcx.ccx; let mut bcx = bcx; diff --git a/src/rustc/middle/trans/base.rs b/src/rustc/middle/trans/base.rs index 17d00eb2ed9..9273170c65c 100644 --- a/src/rustc/middle/trans/base.rs +++ b/src/rustc/middle/trans/base.rs @@ -65,11 +65,11 @@ enum dest { ignore, } -fn dest_str(ccx: @crate_ctxt, d: dest) -> str { +fn dest_str(ccx: @crate_ctxt, d: dest) -> ~str { alt d { by_val(v) { #fmt["by_val(%s)", val_str(ccx.tn, *v)] } save_in(v) { #fmt["save_in(%s)", val_str(ccx.tn, v)] } - ignore { "ignore" } + ignore { ~"ignore" } } } @@ -95,7 +95,7 @@ class icx_popper { } impl ccx_icx for @crate_ctxt { - fn insn_ctxt(s: str) -> icx_popper { + fn insn_ctxt(s: ~str) -> icx_popper { #debug("new insn_ctxt: %s", s); if self.sess.count_llvm_insns() { vec::push(*self.stats.llvm_insn_ctxt, s); @@ -105,20 +105,20 @@ impl ccx_icx for @crate_ctxt { } impl bcx_icx for block { - fn insn_ctxt(s: str) -> icx_popper { + fn insn_ctxt(s: ~str) -> icx_popper { self.ccx().insn_ctxt(s) } } impl fcx_icx for fn_ctxt { - fn insn_ctxt(s: str) -> icx_popper { + fn insn_ctxt(s: ~str) -> icx_popper { self.ccx.insn_ctxt(s) } } fn join_returns(parent_cx: block, in_cxs: ~[block], in_ds: ~[dest], out_dest: dest) -> block { - let out = sub_block(parent_cx, "join"); + let out = sub_block(parent_cx, ~"join"); let mut reachable = false, i = 0u, phi = none; for vec::each(in_cxs) |cx| { if !cx.unreachable { @@ -160,11 +160,11 @@ fn store_in_dest(bcx: block, val: ValueRef, dest: dest) -> block { fn get_dest_addr(dest: dest) -> ValueRef { alt dest { save_in(a) { a } - _ { fail "get_dest_addr: not a save_in"; } + _ { fail ~"get_dest_addr: not a save_in"; } } } -fn log_fn_time(ccx: @crate_ctxt, name: str, start: time::timespec, +fn log_fn_time(ccx: @crate_ctxt, name: ~str, start: time::timespec, end: time::timespec) { let elapsed = 1000 * ((end.sec - start.sec) as int) + ((end.nsec as int) - (start.nsec as int)) / 1000000; @@ -172,7 +172,7 @@ fn log_fn_time(ccx: @crate_ctxt, name: str, start: time::timespec, } -fn decl_fn(llmod: ModuleRef, name: str, cc: lib::llvm::CallConv, +fn decl_fn(llmod: ModuleRef, name: ~str, cc: lib::llvm::CallConv, llty: TypeRef) -> ValueRef { let llfn: ValueRef = str::as_c_str(name, |buf| { llvm::LLVMGetOrInsertFunction(llmod, buf, llty) @@ -181,21 +181,22 @@ fn decl_fn(llmod: ModuleRef, name: str, cc: lib::llvm::CallConv, ret llfn; } -fn decl_cdecl_fn(llmod: ModuleRef, name: str, llty: TypeRef) -> ValueRef { +fn decl_cdecl_fn(llmod: ModuleRef, name: ~str, llty: TypeRef) -> ValueRef { ret decl_fn(llmod, name, lib::llvm::CCallConv, llty); } // Only use this if you are going to actually define the function. It's // not valid to simply declare a function as internal. -fn decl_internal_cdecl_fn(llmod: ModuleRef, name: str, llty: TypeRef) -> +fn decl_internal_cdecl_fn(llmod: ModuleRef, name: ~str, llty: TypeRef) -> ValueRef { let llfn = decl_cdecl_fn(llmod, name, llty); lib::llvm::SetLinkage(llfn, lib::llvm::InternalLinkage); ret llfn; } -fn get_extern_fn(externs: hashmap<str, ValueRef>, llmod: ModuleRef, name: str, +fn get_extern_fn(externs: hashmap<~str, ValueRef>, + llmod: ModuleRef, name: ~str, cc: lib::llvm::CallConv, ty: TypeRef) -> ValueRef { if externs.contains_key(name) { ret externs.get(name); } let f = decl_fn(llmod, name, cc, ty); @@ -203,8 +204,8 @@ fn get_extern_fn(externs: hashmap<str, ValueRef>, llmod: ModuleRef, name: str, ret f; } -fn get_extern_const(externs: hashmap<str, ValueRef>, llmod: ModuleRef, - name: str, ty: TypeRef) -> ValueRef { +fn get_extern_const(externs: hashmap<~str, ValueRef>, llmod: ModuleRef, + name: ~str, ty: TypeRef) -> ValueRef { if externs.contains_key(name) { ret externs.get(name); } let c = str::as_c_str(name, |buf| llvm::LLVMAddGlobal(llmod, ty, buf)); externs.insert(name, c); @@ -212,10 +213,10 @@ fn get_extern_const(externs: hashmap<str, ValueRef>, llmod: ModuleRef, } fn get_simple_extern_fn(cx: block, - externs: hashmap<str, ValueRef>, + externs: hashmap<~str, ValueRef>, llmod: ModuleRef, - name: str, n_args: int) -> ValueRef { - let _icx = cx.insn_ctxt("get_simple_extern_fn"); + name: ~str, n_args: int) -> ValueRef { + let _icx = cx.insn_ctxt(~"get_simple_extern_fn"); let ccx = cx.fcx.ccx; let inputs = vec::from_elem(n_args as uint, ccx.int_type); let output = ccx.int_type; @@ -223,10 +224,10 @@ fn get_simple_extern_fn(cx: block, ret get_extern_fn(externs, llmod, name, lib::llvm::CCallConv, t); } -fn trans_foreign_call(cx: block, externs: hashmap<str, ValueRef>, - llmod: ModuleRef, name: str, args: ~[ValueRef]) -> +fn trans_foreign_call(cx: block, externs: hashmap<~str, ValueRef>, + llmod: ModuleRef, name: ~str, args: ~[ValueRef]) -> ValueRef { - let _icx = cx.insn_ctxt("trans_foreign_call"); + let _icx = cx.insn_ctxt(~"trans_foreign_call"); let n = args.len() as int; let llforeign: ValueRef = get_simple_extern_fn(cx, externs, llmod, name, n); @@ -238,26 +239,26 @@ fn trans_foreign_call(cx: block, externs: hashmap<str, ValueRef>, } fn trans_free(cx: block, v: ValueRef) -> block { - let _icx = cx.insn_ctxt("trans_free"); + let _icx = cx.insn_ctxt(~"trans_free"); Call(cx, cx.ccx().upcalls.free, ~[PointerCast(cx, v, T_ptr(T_i8()))]); cx } fn trans_unique_free(cx: block, v: ValueRef) -> block { - let _icx = cx.insn_ctxt("trans_unique_free"); + let _icx = cx.insn_ctxt(~"trans_unique_free"); Call(cx, cx.ccx().upcalls.exchange_free, ~[PointerCast(cx, v, T_ptr(T_i8()))]); ret cx; } fn umax(cx: block, a: ValueRef, b: ValueRef) -> ValueRef { - let _icx = cx.insn_ctxt("umax"); + let _icx = cx.insn_ctxt(~"umax"); let cond = ICmp(cx, lib::llvm::IntULT, a, b); ret Select(cx, cond, b, a); } fn umin(cx: block, a: ValueRef, b: ValueRef) -> ValueRef { - let _icx = cx.insn_ctxt("umin"); + let _icx = cx.insn_ctxt(~"umin"); let cond = ICmp(cx, lib::llvm::IntULT, a, b); ret Select(cx, cond, a, b); } @@ -271,7 +272,7 @@ fn alloca_zeroed(cx: block, t: TypeRef) -> ValueRef { } fn alloca_maybe_zeroed(cx: block, t: TypeRef, zero: bool) -> ValueRef { - let _icx = cx.insn_ctxt("alloca"); + let _icx = cx.insn_ctxt(~"alloca"); if cx.unreachable { ret llvm::LLVMGetUndef(t); } let initcx = raw_block(cx.fcx, cx.fcx.llstaticallocas); let p = Alloca(initcx, t); @@ -280,7 +281,7 @@ fn alloca_maybe_zeroed(cx: block, t: TypeRef, zero: bool) -> ValueRef { } fn zero_mem(cx: block, llptr: ValueRef, t: ty::t) -> block { - let _icx = cx.insn_ctxt("zero_mem"); + let _icx = cx.insn_ctxt(~"zero_mem"); let bcx = cx; let ccx = cx.ccx(); let llty = type_of(ccx, t); @@ -289,7 +290,7 @@ fn zero_mem(cx: block, llptr: ValueRef, t: ty::t) -> block { } fn arrayalloca(cx: block, t: TypeRef, v: ValueRef) -> ValueRef { - let _icx = cx.insn_ctxt("arrayalloca"); + let _icx = cx.insn_ctxt(~"arrayalloca"); if cx.unreachable { ret llvm::LLVMGetUndef(t); } ret ArrayAlloca(raw_block(cx.fcx, cx.fcx.llstaticallocas), t, v); } @@ -298,7 +299,7 @@ fn arrayalloca(cx: block, t: TypeRef, v: ValueRef) -> ValueRef { // The type of the returned pointer is always i8*. If you care about the // return type, use bump_ptr(). fn ptr_offs(bcx: block, base: ValueRef, sz: ValueRef) -> ValueRef { - let _icx = bcx.insn_ctxt("ptr_offs"); + let _icx = bcx.insn_ctxt(~"ptr_offs"); let raw = PointerCast(bcx, base, T_ptr(T_i8())); InBoundsGEP(bcx, raw, ~[sz]) } @@ -307,7 +308,7 @@ fn ptr_offs(bcx: block, base: ValueRef, sz: ValueRef) -> ValueRef { // to a given type. fn bump_ptr(bcx: block, t: ty::t, base: ValueRef, sz: ValueRef) -> ValueRef { - let _icx = bcx.insn_ctxt("bump_ptr"); + let _icx = bcx.insn_ctxt(~"bump_ptr"); let ccx = bcx.ccx(); let bumped = ptr_offs(bcx, base, sz); let typ = T_ptr(type_of(ccx, t)); @@ -320,7 +321,7 @@ fn bump_ptr(bcx: block, t: ty::t, base: ValueRef, sz: ValueRef) -> fn GEP_enum(bcx: block, llblobptr: ValueRef, enum_id: ast::def_id, variant_id: ast::def_id, ty_substs: ~[ty::t], ix: uint) -> ValueRef { - let _icx = bcx.insn_ctxt("GEP_enum"); + let _icx = bcx.insn_ctxt(~"GEP_enum"); let ccx = bcx.ccx(); let variant = ty::enum_variant_with_id(ccx.tcx, enum_id, variant_id); assert ix < variant.args.len(); @@ -341,7 +342,7 @@ fn GEP_enum(bcx: block, llblobptr: ValueRef, enum_id: ast::def_id, fn opaque_box_body(bcx: block, body_t: ty::t, boxptr: ValueRef) -> ValueRef { - let _icx = bcx.insn_ctxt("opaque_box_body"); + let _icx = bcx.insn_ctxt(~"opaque_box_body"); let ccx = bcx.ccx(); let boxptr = PointerCast(bcx, boxptr, T_ptr(T_box_header(ccx))); let bodyptr = GEPi(bcx, boxptr, ~[1u]); @@ -352,7 +353,7 @@ fn opaque_box_body(bcx: block, // potentially dynamic size. fn malloc_raw_dyn(bcx: block, t: ty::t, heap: heap, size: ValueRef) -> ValueRef { - let _icx = bcx.insn_ctxt("malloc_raw"); + let _icx = bcx.insn_ctxt(~"malloc_raw"); let ccx = bcx.ccx(); let (mk_fn, upcall) = alt heap { @@ -386,7 +387,7 @@ fn malloc_raw(bcx: block, t: ty::t, heap: heap) -> ValueRef { // and pulls out the body fn malloc_general_dyn(bcx: block, t: ty::t, heap: heap, size: ValueRef) -> {box: ValueRef, body: ValueRef} { - let _icx = bcx.insn_ctxt("malloc_general"); + let _icx = bcx.insn_ctxt(~"malloc_general"); let llbox = malloc_raw_dyn(bcx, t, heap, size); let non_gc_box = non_gc_box_cast(bcx, llbox); let body = GEPi(bcx, non_gc_box, ~[0u, abi::box_field_body]); @@ -471,23 +472,23 @@ fn set_glue_inlining(f: ValueRef, t: ty::t) { // Double-check that we never ask LLVM to declare the same symbol twice. It // silently mangles such symbols, breaking our linkage model. -fn note_unique_llvm_symbol(ccx: @crate_ctxt, sym: str) { +fn note_unique_llvm_symbol(ccx: @crate_ctxt, sym: ~str) { if ccx.all_llvm_symbols.contains_key(sym) { - ccx.sess.bug("duplicate LLVM symbol: " + sym); + ccx.sess.bug(~"duplicate LLVM symbol: " + sym); } ccx.all_llvm_symbols.insert(sym, ()); } // Generates the declaration for (but doesn't emit) a type descriptor. fn declare_tydesc(ccx: @crate_ctxt, t: ty::t) -> @tydesc_info { - let _icx = ccx.insn_ctxt("declare_tydesc"); + let _icx = ccx.insn_ctxt(~"declare_tydesc"); let llty = type_of(ccx, t); let llsize = llsize_of(ccx, llty); let llalign = llalign_of(ccx, llty); //XXX this triggers duplicate LLVM symbols let name = if false /*ccx.sess.opts.debuginfo*/ { - mangle_internal_name_by_type_only(ccx, t, @"tydesc"/~) - } else { mangle_internal_name_by_seq(ccx, @"tydesc"/~) }; + mangle_internal_name_by_type_only(ccx, t, @~"tydesc") + } else { mangle_internal_name_by_seq(ccx, @~"tydesc") }; note_unique_llvm_symbol(ccx, name); log(debug, #fmt("+++ declare_tydesc %s %s", ty_to_str(ccx.tcx, t), name)); let gvar = str::as_c_str(name, |buf| { @@ -502,22 +503,22 @@ fn declare_tydesc(ccx: @crate_ctxt, t: ty::t) -> @tydesc_info { mut drop_glue: none, mut free_glue: none, mut visit_glue: none}; - log(debug, "--- declare_tydesc " + ppaux::ty_to_str(ccx.tcx, t)); + log(debug, ~"--- declare_tydesc " + ppaux::ty_to_str(ccx.tcx, t)); ret inf; } type glue_helper = fn@(block, ValueRef, ty::t); fn declare_generic_glue(ccx: @crate_ctxt, t: ty::t, llfnty: TypeRef, - name: str) -> ValueRef { - let _icx = ccx.insn_ctxt("declare_generic_glue"); + name: ~str) -> ValueRef { + let _icx = ccx.insn_ctxt(~"declare_generic_glue"); let name = name; let mut fn_nm; //XXX this triggers duplicate LLVM symbols if false /*ccx.sess.opts.debuginfo*/ { - fn_nm = mangle_internal_name_by_type_only(ccx, t, @("glue_" + name)); + fn_nm = mangle_internal_name_by_type_only(ccx, t, @(~"glue_" + name)); } else { - fn_nm = mangle_internal_name_by_seq(ccx, @("glue_" + name)); + fn_nm = mangle_internal_name_by_seq(ccx, @(~"glue_" + name)); } note_unique_llvm_symbol(ccx, fn_nm); let llfn = decl_cdecl_fn(ccx.llmod, fn_nm, llfnty); @@ -527,7 +528,7 @@ fn declare_generic_glue(ccx: @crate_ctxt, t: ty::t, llfnty: TypeRef, fn make_generic_glue_inner(ccx: @crate_ctxt, t: ty::t, llfn: ValueRef, helper: glue_helper) -> ValueRef { - let _icx = ccx.insn_ctxt("make_generic_glue_inner"); + let _icx = ccx.insn_ctxt(~"make_generic_glue_inner"); let fcx = new_fn_ctxt(ccx, ~[], llfn, none); lib::llvm::SetLinkage(llfn, lib::llvm::InternalLinkage); ccx.stats.n_glues_created += 1u; @@ -548,9 +549,9 @@ fn make_generic_glue_inner(ccx: @crate_ctxt, t: ty::t, } fn make_generic_glue(ccx: @crate_ctxt, t: ty::t, llfn: ValueRef, - helper: glue_helper, name: str) + helper: glue_helper, name: ~str) -> ValueRef { - let _icx = ccx.insn_ctxt("make_generic_glue"); + let _icx = ccx.insn_ctxt(~"make_generic_glue"); if !ccx.sess.trans_stats() { ret make_generic_glue_inner(ccx, t, llfn, helper); } @@ -558,13 +559,13 @@ fn make_generic_glue(ccx: @crate_ctxt, t: ty::t, llfn: ValueRef, let start = time::get_time(); let llval = make_generic_glue_inner(ccx, t, llfn, helper); let end = time::get_time(); - log_fn_time(ccx, "glue " + name + " " + ty_to_short_str(ccx.tcx, t), + log_fn_time(ccx, ~"glue " + name + ~" " + ty_to_short_str(ccx.tcx, t), start, end); ret llval; } fn emit_tydescs(ccx: @crate_ctxt) { - let _icx = ccx.insn_ctxt("emit_tydescs"); + let _icx = ccx.insn_ctxt(~"emit_tydescs"); for ccx.tydescs.each |key, val| { let glue_fn_ty = T_ptr(T_glue_fn(ccx)); let ti = val; @@ -613,7 +614,7 @@ fn emit_tydescs(ccx: @crate_ctxt) { } fn make_take_glue(bcx: block, v: ValueRef, t: ty::t) { - let _icx = bcx.insn_ctxt("make_take_glue"); + let _icx = bcx.insn_ctxt(~"make_take_glue"); // NB: v is a *pointer* to type t here, not a direct value. let bcx = alt ty::get(t).struct { ty::ty_box(_) | ty::ty_opaque_box | @@ -655,7 +656,7 @@ fn make_take_glue(bcx: block, v: ValueRef, t: ty::t) { } fn incr_refcnt_of_boxed(cx: block, box_ptr: ValueRef) { - let _icx = cx.insn_ctxt("incr_refcnt_of_boxed"); + let _icx = cx.insn_ctxt(~"incr_refcnt_of_boxed"); let ccx = cx.ccx(); maybe_validate_box(cx, box_ptr); let rc_ptr = GEPi(cx, box_ptr, ~[0u, abi::box_field_refcnt]); @@ -665,10 +666,10 @@ fn incr_refcnt_of_boxed(cx: block, box_ptr: ValueRef) { } fn make_visit_glue(bcx: block, v: ValueRef, t: ty::t) { - let _icx = bcx.insn_ctxt("make_visit_glue"); + let _icx = bcx.insn_ctxt(~"make_visit_glue"); let mut bcx = bcx; - assert bcx.ccx().tcx.intrinsic_defs.contains_key(@"ty_visitor"/~); - let (iid, ty) = bcx.ccx().tcx.intrinsic_defs.get(@"ty_visitor"/~); + assert bcx.ccx().tcx.intrinsic_defs.contains_key(@~"ty_visitor"); + let (iid, ty) = bcx.ccx().tcx.intrinsic_defs.get(@~"ty_visitor"); let v = PointerCast(bcx, v, T_ptr(type_of::type_of(bcx.ccx(), ty))); bcx = reflect::emit_calls_to_trait_visit_ty(bcx, t, v, iid); build_return(bcx); @@ -679,7 +680,7 @@ fn make_free_glue(bcx: block, v: ValueRef, t: ty::t) { // v is a pointer to the actual box component of the type here. The // ValueRef will have the wrong type here (make_generic_glue is casting // everything to a pointer to the type that the glue acts on). - let _icx = bcx.insn_ctxt("make_free_glue"); + let _icx = bcx.insn_ctxt(~"make_free_glue"); let ccx = bcx.ccx(); let bcx = alt ty::get(t).struct { ty::ty_box(body_mt) { @@ -761,7 +762,7 @@ fn trans_class_drop(bcx: block, v0: ValueRef, dtor_did: ast::def_id, fn make_drop_glue(bcx: block, v0: ValueRef, t: ty::t) { // NB: v0 is an *alias* of type t here, not a direct value. - let _icx = bcx.insn_ctxt("make_drop_glue"); + let _icx = bcx.insn_ctxt(~"make_drop_glue"); let ccx = bcx.ccx(); let bcx = alt ty::get(t).struct { ty::ty_box(_) | ty::ty_opaque_box | @@ -810,7 +811,7 @@ fn make_drop_glue(bcx: block, v0: ValueRef, t: ty::t) { fn get_res_dtor(ccx: @crate_ctxt, did: ast::def_id, parent_id: ast::def_id, substs: ~[ty::t]) -> ValueRef { - let _icx = ccx.insn_ctxt("trans_res_dtor"); + let _icx = ccx.insn_ctxt(~"trans_res_dtor"); if (substs.len() > 0u) { let did = if did.crate != ast::local_crate { maybe_instantiate_inline(ccx, did) @@ -842,7 +843,7 @@ fn maybe_validate_box(_cx: block, _box_ptr: ValueRef) { } fn decr_refcnt_maybe_free(bcx: block, box_ptr: ValueRef, t: ty::t) -> block { - let _icx = bcx.insn_ctxt("decr_refcnt_maybe_free"); + let _icx = bcx.insn_ctxt(~"decr_refcnt_maybe_free"); let ccx = bcx.ccx(); maybe_validate_box(bcx, box_ptr); @@ -858,7 +859,7 @@ fn decr_refcnt_maybe_free(bcx: block, box_ptr: ValueRef, t: ty::t) -> block { } // Structural comparison: a rather involved form of glue. -fn maybe_name_value(cx: @crate_ctxt, v: ValueRef, s: str) { +fn maybe_name_value(cx: @crate_ctxt, v: ValueRef, s: ~str) { if cx.sess.opts.save_temps { let _: () = str::as_c_str(s, |buf| llvm::LLVMSetValueName(v, buf)); } @@ -881,12 +882,12 @@ fn compare_scalar_types(cx: block, lhs: ValueRef, rhs: ValueRef, ty::ty_float(_) { ret rslt(cx, f(floating_point)); } ty::ty_type { ret rslt(trans_fail(cx, none, - "attempt to compare values of type type"), + ~"attempt to compare values of type type"), C_nil()); } _ { // Should never get here, because t is scalar. - cx.sess().bug("non-scalar type passed to \ + cx.sess().bug(~"non-scalar type passed to \ compare_scalar_types"); } } @@ -896,9 +897,9 @@ fn compare_scalar_types(cx: block, lhs: ValueRef, rhs: ValueRef, // A helper function to do the actual comparison of scalar values. fn compare_scalar_values(cx: block, lhs: ValueRef, rhs: ValueRef, nt: scalar_type, op: ast::binop) -> ValueRef { - let _icx = cx.insn_ctxt("compare_scalar_values"); + let _icx = cx.insn_ctxt(~"compare_scalar_values"); fn die_(cx: block) -> ! { - cx.tcx().sess.bug("compare_scalar_values: must be a\ + cx.tcx().sess.bug(~"compare_scalar_values: must be a\ comparison operator"); } let die = fn@() -> ! { die_(cx) }; @@ -967,13 +968,13 @@ fn store_inbounds(cx: block, v: ValueRef, p: ValueRef, // Iterates through the elements of a structural type. fn iter_structural_ty(cx: block, av: ValueRef, t: ty::t, f: val_and_ty_fn) -> block { - let _icx = cx.insn_ctxt("iter_structural_ty"); + let _icx = cx.insn_ctxt(~"iter_structural_ty"); fn iter_variant(cx: block, a_tup: ValueRef, variant: ty::variant_info, tps: ~[ty::t], tid: ast::def_id, f: val_and_ty_fn) -> block { - let _icx = cx.insn_ctxt("iter_variant"); + let _icx = cx.insn_ctxt(~"iter_variant"); if variant.args.len() == 0u { ret cx; } let fn_ty = variant.ctor_ty; let ccx = cx.ccx(); @@ -989,7 +990,7 @@ fn iter_structural_ty(cx: block, av: ValueRef, t: ty::t, j += 1u; } } - _ { cx.tcx().sess.bug("iter_variant: not a function type"); } + _ { cx.tcx().sess.bug(~"iter_variant: not a function type"); } } ret cx; } @@ -1036,14 +1037,14 @@ fn iter_structural_ty(cx: block, av: ValueRef, t: ty::t, // NB: we must hit the discriminant first so that structural // comparison know not to proceed when the discriminants differ. cx = f(cx, lldiscrim_a_ptr, ty::mk_int(cx.tcx())); - let unr_cx = sub_block(cx, "enum-iter-unr"); + let unr_cx = sub_block(cx, ~"enum-iter-unr"); Unreachable(unr_cx); let llswitch = Switch(cx, lldiscrim_a, unr_cx.llbb, n_variants); - let next_cx = sub_block(cx, "enum-iter-next"); + let next_cx = sub_block(cx, ~"enum-iter-next"); for vec::each(*variants) |variant| { let variant_cx = sub_block(cx, - "enum-iter-variant-" + + ~"enum-iter-variant-" + int::to_str(variant.disr_val, 10u)); AddCase(llswitch, C_int(ccx, variant.disr_val), variant_cx.llbb); let variant_cx = @@ -1066,7 +1067,7 @@ fn iter_structural_ty(cx: block, av: ValueRef, t: ty::t, cx = f(cx, llfld_a, fld.mt.ty); } } - _ { cx.sess().unimpl("type in iter_structural_ty"); } + _ { cx.sess().unimpl(~"type in iter_structural_ty"); } } ret cx; } @@ -1081,7 +1082,7 @@ fn lazily_emit_all_tydesc_glue(ccx: @crate_ctxt, fn lazily_emit_tydesc_glue(ccx: @crate_ctxt, field: uint, ti: @tydesc_info) { - let _icx = ccx.insn_ctxt("lazily_emit_tydesc_glue"); + let _icx = ccx.insn_ctxt(~"lazily_emit_tydesc_glue"); if field == abi::tydesc_field_take_glue { alt ti.take_glue { some(_) { } @@ -1089,10 +1090,10 @@ fn lazily_emit_tydesc_glue(ccx: @crate_ctxt, field: uint, #debug("+++ lazily_emit_tydesc_glue TAKE %s", ppaux::ty_to_str(ccx.tcx, ti.ty)); let glue_fn = declare_generic_glue - (ccx, ti.ty, T_glue_fn(ccx), "take"); + (ccx, ti.ty, T_glue_fn(ccx), ~"take"); ti.take_glue = some(glue_fn); make_generic_glue(ccx, ti.ty, glue_fn, - make_take_glue, "take"); + make_take_glue, ~"take"); #debug("--- lazily_emit_tydesc_glue TAKE %s", ppaux::ty_to_str(ccx.tcx, ti.ty)); } @@ -1104,10 +1105,10 @@ fn lazily_emit_tydesc_glue(ccx: @crate_ctxt, field: uint, #debug("+++ lazily_emit_tydesc_glue DROP %s", ppaux::ty_to_str(ccx.tcx, ti.ty)); let glue_fn = - declare_generic_glue(ccx, ti.ty, T_glue_fn(ccx), "drop"); + declare_generic_glue(ccx, ti.ty, T_glue_fn(ccx), ~"drop"); ti.drop_glue = some(glue_fn); make_generic_glue(ccx, ti.ty, glue_fn, - make_drop_glue, "drop"); + make_drop_glue, ~"drop"); #debug("--- lazily_emit_tydesc_glue DROP %s", ppaux::ty_to_str(ccx.tcx, ti.ty)); } @@ -1119,10 +1120,10 @@ fn lazily_emit_tydesc_glue(ccx: @crate_ctxt, field: uint, #debug("+++ lazily_emit_tydesc_glue FREE %s", ppaux::ty_to_str(ccx.tcx, ti.ty)); let glue_fn = - declare_generic_glue(ccx, ti.ty, T_glue_fn(ccx), "free"); + declare_generic_glue(ccx, ti.ty, T_glue_fn(ccx), ~"free"); ti.free_glue = some(glue_fn); make_generic_glue(ccx, ti.ty, glue_fn, - make_free_glue, "free"); + make_free_glue, ~"free"); #debug("--- lazily_emit_tydesc_glue FREE %s", ppaux::ty_to_str(ccx.tcx, ti.ty)); } @@ -1134,10 +1135,10 @@ fn lazily_emit_tydesc_glue(ccx: @crate_ctxt, field: uint, #debug("+++ lazily_emit_tydesc_glue VISIT %s", ppaux::ty_to_str(ccx.tcx, ti.ty)); let glue_fn = - declare_generic_glue(ccx, ti.ty, T_glue_fn(ccx), "visit"); + declare_generic_glue(ccx, ti.ty, T_glue_fn(ccx), ~"visit"); ti.visit_glue = some(glue_fn); make_generic_glue(ccx, ti.ty, glue_fn, - make_visit_glue, "visit"); + make_visit_glue, ~"visit"); #debug("--- lazily_emit_tydesc_glue VISIT %s", ppaux::ty_to_str(ccx.tcx, ti.ty)); } @@ -1148,7 +1149,7 @@ fn lazily_emit_tydesc_glue(ccx: @crate_ctxt, field: uint, // See [Note-arg-mode] fn call_tydesc_glue_full(++cx: block, v: ValueRef, tydesc: ValueRef, field: uint, static_ti: option<@tydesc_info>) { - let _icx = cx.insn_ctxt("call_tydesc_glue_full"); + let _icx = cx.insn_ctxt(~"call_tydesc_glue_full"); if cx.unreachable { ret; } let mut static_glue_fn = none; @@ -1188,7 +1189,7 @@ fn call_tydesc_glue_full(++cx: block, v: ValueRef, tydesc: ValueRef, // See [Note-arg-mode] fn call_tydesc_glue(++cx: block, v: ValueRef, t: ty::t, field: uint) -> block { - let _icx = cx.insn_ctxt("call_tydesc_glue"); + let _icx = cx.insn_ctxt(~"call_tydesc_glue"); let ti = get_tydesc(cx.ccx(), t); call_tydesc_glue_full(cx, v, ti.tydesc, field, some(ti)); ret cx; @@ -1198,7 +1199,7 @@ fn call_cmp_glue(bcx: block, lhs: ValueRef, rhs: ValueRef, t: ty::t, llop: ValueRef) -> ValueRef { // We can't use call_tydesc_glue_full() and friends here because compare // glue has a special signature. - let _icx = bcx.insn_ctxt("call_cmp_glue"); + let _icx = bcx.insn_ctxt(~"call_cmp_glue"); let lllhs = spill_if_immediate(bcx, lhs, t); let llrhs = spill_if_immediate(bcx, rhs, t); @@ -1216,7 +1217,7 @@ fn call_cmp_glue(bcx: block, lhs: ValueRef, rhs: ValueRef, t: ty::t, } fn take_ty(cx: block, v: ValueRef, t: ty::t) -> block { - let _icx = cx.insn_ctxt("take_ty"); + let _icx = cx.insn_ctxt(~"take_ty"); if ty::type_needs_drop(cx.tcx(), t) { ret call_tydesc_glue(cx, v, t, abi::tydesc_field_take_glue); } @@ -1224,7 +1225,7 @@ fn take_ty(cx: block, v: ValueRef, t: ty::t) -> block { } fn drop_ty(cx: block, v: ValueRef, t: ty::t) -> block { - let _icx = cx.insn_ctxt("drop_ty"); + let _icx = cx.insn_ctxt(~"drop_ty"); if ty::type_needs_drop(cx.tcx(), t) { ret call_tydesc_glue(cx, v, t, abi::tydesc_field_drop_glue); } @@ -1232,7 +1233,7 @@ fn drop_ty(cx: block, v: ValueRef, t: ty::t) -> block { } fn drop_ty_immediate(bcx: block, v: ValueRef, t: ty::t) -> block { - let _icx = bcx.insn_ctxt("drop_ty_immediate"); + let _icx = bcx.insn_ctxt(~"drop_ty_immediate"); alt ty::get(t).struct { ty::ty_uniq(_) | ty::ty_vec(_) | ty::ty_str | ty::ty_evec(_, ty::vstore_uniq) | @@ -1244,12 +1245,12 @@ fn drop_ty_immediate(bcx: block, v: ValueRef, t: ty::t) -> block { ty::ty_estr(ty::vstore_box) { decr_refcnt_maybe_free(bcx, v, t) } - _ { bcx.tcx().sess.bug("drop_ty_immediate: non-box ty"); } + _ { bcx.tcx().sess.bug(~"drop_ty_immediate: non-box ty"); } } } fn take_ty_immediate(bcx: block, v: ValueRef, t: ty::t) -> result { - let _icx = bcx.insn_ctxt("take_ty_immediate"); + let _icx = bcx.insn_ctxt(~"take_ty_immediate"); alt ty::get(t).struct { ty::ty_box(_) | ty::ty_opaque_box | ty::ty_evec(_, ty::vstore_box) | @@ -1270,7 +1271,7 @@ fn take_ty_immediate(bcx: block, v: ValueRef, t: ty::t) -> result { } fn free_ty(cx: block, v: ValueRef, t: ty::t) -> block { - let _icx = cx.insn_ctxt("free_ty"); + let _icx = cx.insn_ctxt(~"free_ty"); if ty::type_needs_drop(cx.tcx(), t) { ret call_tydesc_glue(cx, v, t, abi::tydesc_field_free_glue); } @@ -1283,11 +1284,11 @@ fn call_memmove(cx: block, dst: ValueRef, src: ValueRef, // alignment information when the alignment is statically known (it must // be nothing more than a constant int, or LLVM complains -- not even a // constant element of a tydesc works). - let _icx = cx.insn_ctxt("call_memmove"); + let _icx = cx.insn_ctxt(~"call_memmove"); let ccx = cx.ccx(); let key = alt ccx.sess.targ_cfg.arch { - session::arch_x86 | session::arch_arm { "llvm.memmove.p0i8.p0i8.i32" } - session::arch_x86_64 { "llvm.memmove.p0i8.p0i8.i64" } + session::arch_x86 | session::arch_arm { ~"llvm.memmove.p0i8.p0i8.i32" } + session::arch_x86_64 { ~"llvm.memmove.p0i8.p0i8.i64" } }; let memmove = ccx.intrinsics.get(key); let src_ptr = PointerCast(cx, src, T_ptr(T_i8())); @@ -1299,7 +1300,7 @@ fn call_memmove(cx: block, dst: ValueRef, src: ValueRef, } fn memmove_ty(bcx: block, dst: ValueRef, src: ValueRef, t: ty::t) { - let _icx = bcx.insn_ctxt("memmove_ty"); + let _icx = bcx.insn_ctxt(~"memmove_ty"); let ccx = bcx.ccx(); if ty::type_is_structural(t) { let llsz = llsize_of(ccx, type_of(ccx, t)); @@ -1322,7 +1323,7 @@ fn type_is_structural_or_param(t: ty::t) -> bool { fn copy_val(cx: block, action: copy_action, dst: ValueRef, src: ValueRef, t: ty::t) -> block { - let _icx = cx.insn_ctxt("copy_val"); + let _icx = cx.insn_ctxt(~"copy_val"); if action == DROP_EXISTING && (type_is_structural_or_param(t) || ty::type_is_unique(t)) { @@ -1339,7 +1340,7 @@ fn copy_val(cx: block, action: copy_action, dst: ValueRef, fn copy_val_no_check(bcx: block, action: copy_action, dst: ValueRef, src: ValueRef, t: ty::t) -> block { - let _icx = bcx.insn_ctxt("copy_val_no_check"); + let _icx = bcx.insn_ctxt(~"copy_val_no_check"); let ccx = bcx.ccx(); let mut bcx = bcx; if ty::type_is_scalar(t) { @@ -1357,7 +1358,7 @@ fn copy_val_no_check(bcx: block, action: copy_action, dst: ValueRef, memmove_ty(bcx, dst, src, t); ret take_ty(bcx, dst, t); } - ccx.sess.bug("unexpected type in trans::copy_val_no_check: " + + ccx.sess.bug(~"unexpected type in trans::copy_val_no_check: " + ppaux::ty_to_str(ccx.tcx, t)); } @@ -1370,7 +1371,7 @@ fn copy_val_no_check(bcx: block, action: copy_action, dst: ValueRef, fn move_val(cx: block, action: copy_action, dst: ValueRef, src: lval_result, t: ty::t) -> block { - let _icx = cx.insn_ctxt("move_val"); + let _icx = cx.insn_ctxt(~"move_val"); let mut src_val = src.val; let tcx = cx.tcx(); let mut cx = cx; @@ -1396,14 +1397,14 @@ fn move_val(cx: block, action: copy_action, dst: ValueRef, revoke_clean(cx, src_val); ret cx; } - cx.sess().bug("unexpected type in trans::move_val: " + + cx.sess().bug(~"unexpected type in trans::move_val: " + ppaux::ty_to_str(tcx, t)); } fn store_temp_expr(cx: block, action: copy_action, dst: ValueRef, src: lval_result, t: ty::t, last_use: bool) -> block { - let _icx = cx.insn_ctxt("trans_temp_expr"); + let _icx = cx.insn_ctxt(~"trans_temp_expr"); // Lvals in memory are not temporaries. Copy them. if src.kind != temporary && !last_use { let v = if src.kind == owned { @@ -1418,7 +1419,7 @@ fn store_temp_expr(cx: block, action: copy_action, dst: ValueRef, fn trans_crate_lit(cx: @crate_ctxt, e: @ast::expr, lit: ast::lit) -> ValueRef { - let _icx = cx.insn_ctxt("trans_crate_lit"); + let _icx = cx.insn_ctxt(~"trans_crate_lit"); alt lit.node { ast::lit_int(i, t) { C_integral(T_int_ty(cx, t), i as u64, True) } ast::lit_uint(u, t) { C_integral(T_uint_ty(cx, t), u, False) } @@ -1432,7 +1433,7 @@ fn trans_crate_lit(cx: @crate_ctxt, e: @ast::expr, lit: ast::lit) C_integral(T_uint_ty(cx, t), i as u64, False) } _ { cx.sess.span_bug(lit.span, - "integer literal doesn't have a type"); + ~"integer literal doesn't have a type"); } } } @@ -1440,13 +1441,13 @@ fn trans_crate_lit(cx: @crate_ctxt, e: @ast::expr, lit: ast::lit) ast::lit_bool(b) { C_bool(b) } ast::lit_nil { C_nil() } ast::lit_str(s) { - cx.sess.span_unimpl(lit.span, "unique string in this context"); + cx.sess.span_unimpl(lit.span, ~"unique string in this context"); } } } fn trans_lit(cx: block, e: @ast::expr, lit: ast::lit, dest: dest) -> block { - let _icx = cx.insn_ctxt("trans_lit"); + let _icx = cx.insn_ctxt(~"trans_lit"); if dest == ignore { ret cx; } alt lit.node { ast::lit_str(s) { tvec::trans_estr(cx, s, ast::vstore_uniq, dest) } @@ -1460,7 +1461,7 @@ fn trans_lit(cx: block, e: @ast::expr, lit: ast::lit, dest: dest) -> block { fn trans_boxed_expr(bcx: block, contents: @ast::expr, t: ty::t, heap: heap, dest: dest) -> block { - let _icx = bcx.insn_ctxt("trans_boxed_expr"); + let _icx = bcx.insn_ctxt(~"trans_boxed_expr"); let {box, body} = malloc_general(bcx, t, heap); add_clean_free(bcx, box, heap); let bcx = trans_expr_save_in(bcx, contents, body); @@ -1471,7 +1472,7 @@ fn trans_boxed_expr(bcx: block, contents: @ast::expr, fn trans_unary(bcx: block, op: ast::unop, e: @ast::expr, un_expr: @ast::expr, dest: dest) -> block { - let _icx = bcx.insn_ctxt("trans_unary"); + let _icx = bcx.insn_ctxt(~"trans_unary"); // Check for user-defined method call alt bcx.ccx().maps.method_map.find(un_expr.id) { some(mentry) { @@ -1507,7 +1508,7 @@ fn trans_unary(bcx: block, op: ast::unop, e: @ast::expr, trans_boxed_expr(bcx, e, e_ty, heap_exchange, dest) } ast::deref { - bcx.sess().bug("deref expressions should have been \ + bcx.sess().bug(~"deref expressions should have been \ translated using trans_lval(), not \ trans_unary()") } @@ -1515,7 +1516,7 @@ fn trans_unary(bcx: block, op: ast::unop, e: @ast::expr, } fn trans_addr_of(cx: block, e: @ast::expr, dest: dest) -> block { - let _icx = cx.insn_ctxt("trans_addr_of"); + let _icx = cx.insn_ctxt(~"trans_addr_of"); let mut {bcx, val, kind} = trans_temp_lval(cx, e); let ety = expr_ty(cx, e); let is_immediate = ty::type_is_immediate(ety); @@ -1527,7 +1528,7 @@ fn trans_addr_of(cx: block, e: @ast::expr, dest: dest) -> block { fn trans_compare(cx: block, op: ast::binop, lhs: ValueRef, _lhs_t: ty::t, rhs: ValueRef, rhs_t: ty::t) -> result { - let _icx = cx.insn_ctxt("trans_compare"); + let _icx = cx.insn_ctxt(~"trans_compare"); if ty::type_is_scalar(rhs_t) { let rs = compare_scalar_types(cx, lhs, rhs, rhs_t, op); ret rslt(rs.bcx, rs.val); @@ -1539,7 +1540,7 @@ fn trans_compare(cx: block, op: ast::binop, lhs: ValueRef, ast::eq | ast::ne { C_u8(abi::cmp_glue_op_eq) } ast::lt | ast::ge { C_u8(abi::cmp_glue_op_lt) } ast::le | ast::gt { C_u8(abi::cmp_glue_op_le) } - _ { cx.tcx().sess.bug("trans_compare got non-comparison-op"); } + _ { cx.tcx().sess.bug(~"trans_compare got non-comparison-op"); } } }; @@ -1549,7 +1550,7 @@ fn trans_compare(cx: block, op: ast::binop, lhs: ValueRef, alt op { ast::eq | ast::lt | ast::le { rslt(cx, cmpval) } ast::ne | ast::ge | ast::gt { rslt(cx, Not(cx, cmpval)) } - _ { cx.tcx().sess.bug("trans_compare got non-comparison-op"); } + _ { cx.tcx().sess.bug(~"trans_compare got non-comparison-op"); } } } @@ -1594,9 +1595,9 @@ fn cast_shift_rhs(op: ast::binop, fn fail_if_zero(cx: block, span: span, divmod: ast::binop, rhs: ValueRef, rhs_t: ty::t) -> block { let text = if divmod == ast::div { - "divide by zero" + ~"divide by zero" } else { - "modulo zero" + ~"modulo zero" }; let is_zero = alt ty::get(rhs_t).struct { ty::ty_int(t) { @@ -1608,7 +1609,7 @@ fn fail_if_zero(cx: block, span: span, divmod: ast::binop, ICmp(cx, lib::llvm::IntEQ, rhs, zero) } _ { - cx.tcx().sess.bug("fail-if-zero on unexpected type: " + + cx.tcx().sess.bug(~"fail-if-zero on unexpected type: " + ty_to_str(cx.ccx().tcx, rhs_t)); } }; @@ -1623,7 +1624,7 @@ fn trans_eager_binop(cx: block, span: span, op: ast::binop, lhs: ValueRef, lhs_t: ty::t, rhs: ValueRef, rhs_t: ty::t, dest: dest) -> block { let mut cx = cx; - let _icx = cx.insn_ctxt("trans_eager_binop"); + let _icx = cx.insn_ctxt(~"trans_eager_binop"); if dest == ignore { ret cx; } let intype = { if ty::type_is_bot(lhs_t) { rhs_t } @@ -1694,7 +1695,7 @@ fn trans_eager_binop(cx: block, span: span, op: ast::binop, lhs: ValueRef, fn trans_assign_op(bcx: block, ex: @ast::expr, op: ast::binop, dst: @ast::expr, src: @ast::expr) -> block { #debug["%s", expr_to_str(ex)]; - let _icx = bcx.insn_ctxt("trans_assign_op"); + let _icx = bcx.insn_ctxt(~"trans_assign_op"); let t = expr_ty(bcx, src); let lhs_res = trans_lval(bcx, dst); assert (lhs_res.kind == owned); @@ -1735,7 +1736,7 @@ fn trans_assign_op(bcx: block, ex: @ast::expr, op: ast::binop, fn root_value(bcx: block, val: ValueRef, ty: ty::t, scope_id: ast::node_id) { - let _icx = bcx.insn_ctxt("root_value"); + let _icx = bcx.insn_ctxt(~"root_value"); if bcx.sess().trace() { trans_trace( @@ -1753,7 +1754,7 @@ fn root_value(bcx: block, val: ValueRef, ty: ty::t, fn autoderef(cx: block, e_id: ast::node_id, v: ValueRef, t: ty::t, max: uint) -> result_t { - let _icx = cx.insn_ctxt("autoderef"); + let _icx = cx.insn_ctxt(~"autoderef"); let mut v1: ValueRef = v; let mut t1: ty::t = t; let ccx = cx.ccx(); @@ -1818,21 +1819,21 @@ enum lazy_binop_ty { lazy_and, lazy_or } fn trans_lazy_binop(bcx: block, op: lazy_binop_ty, a: @ast::expr, b: @ast::expr, dest: dest) -> block { - let _icx = bcx.insn_ctxt("trans_lazy_binop"); + let _icx = bcx.insn_ctxt(~"trans_lazy_binop"); let {bcx: past_lhs, val: lhs} = { - do with_scope_result(bcx, a.info(), "lhs") |bcx| { + do with_scope_result(bcx, a.info(), ~"lhs") |bcx| { trans_temp_expr(bcx, a) } }; if past_lhs.unreachable { ret past_lhs; } - let join = sub_block(bcx, "join"), before_rhs = sub_block(bcx, "rhs"); + let join = sub_block(bcx, ~"join"), before_rhs = sub_block(bcx, ~"rhs"); alt op { lazy_and { CondBr(past_lhs, lhs, before_rhs.llbb, join.llbb); } lazy_or { CondBr(past_lhs, lhs, join.llbb, before_rhs.llbb); } } let {bcx: past_rhs, val: rhs} = { - do with_scope_result(before_rhs, b.info(), "rhs") |bcx| { + do with_scope_result(before_rhs, b.info(), ~"rhs") |bcx| { trans_temp_expr(bcx, b) } }; @@ -1846,7 +1847,7 @@ fn trans_lazy_binop(bcx: block, op: lazy_binop_ty, a: @ast::expr, fn trans_binary(bcx: block, op: ast::binop, lhs: @ast::expr, rhs: @ast::expr, dest: dest, ex: @ast::expr) -> block { - let _icx = bcx.insn_ctxt("trans_binary"); + let _icx = bcx.insn_ctxt(~"trans_binary"); // User-defined operators alt bcx.ccx().maps.method_map.find(ex.id) { some(origin) { @@ -1885,13 +1886,13 @@ fn trans_binary(bcx: block, op: ast::binop, lhs: @ast::expr, fn trans_if(cx: block, cond: @ast::expr, thn: ast::blk, els: option<@ast::expr>, dest: dest) -> block { - let _icx = cx.insn_ctxt("trans_if"); + let _icx = cx.insn_ctxt(~"trans_if"); let {bcx, val: cond_val} = trans_temp_expr(cx, cond); let then_dest = dup_for_join(dest); let else_dest = dup_for_join(dest); - let then_cx = scope_block(bcx, thn.info(), "then"); - let else_cx = scope_block(bcx, els.info(), "else"); + let then_cx = scope_block(bcx, thn.info(), ~"then"); + let else_cx = scope_block(bcx, els.info(), ~"else"); CondBr(bcx, cond_val, then_cx.llbb, else_cx.llbb); let then_bcx = trans_block(then_cx, thn, then_dest); let then_bcx = trans_block_cleanups(then_bcx, then_cx); @@ -1910,7 +1911,7 @@ fn trans_if(cx: block, cond: @ast::expr, thn: ast::blk, trans_block(else_cx, blk, else_dest) } // would be nice to have a constraint on ifs - _ { cx.tcx().sess.bug("strange alternative in if"); } + _ { cx.tcx().sess.bug(~"strange alternative in if"); } } } _ { else_cx } @@ -1922,11 +1923,11 @@ fn trans_if(cx: block, cond: @ast::expr, thn: ast::blk, fn trans_while(cx: block, cond: @ast::expr, body: ast::blk) -> block { - let _icx = cx.insn_ctxt("trans_while"); - let next_cx = sub_block(cx, "while next"); - let loop_cx = loop_scope_block(cx, next_cx, "`while`", body.info()); - let cond_cx = scope_block(loop_cx, cond.info(), "while loop cond"); - let body_cx = scope_block(loop_cx, body.info(), "while loop body"); + let _icx = cx.insn_ctxt(~"trans_while"); + let next_cx = sub_block(cx, ~"while next"); + let loop_cx = loop_scope_block(cx, next_cx, ~"`while`", body.info()); + let cond_cx = scope_block(loop_cx, cond.info(), ~"while loop cond"); + let body_cx = scope_block(loop_cx, body.info(), ~"while loop body"); Br(cx, loop_cx.llbb); Br(loop_cx, cond_cx.llbb); let cond_res = trans_temp_expr(cond_cx, cond); @@ -1938,9 +1939,9 @@ fn trans_while(cx: block, cond: @ast::expr, body: ast::blk) } fn trans_loop(cx:block, body: ast::blk) -> block { - let _icx = cx.insn_ctxt("trans_loop"); - let next_cx = sub_block(cx, "next"); - let body_cx = loop_scope_block(cx, next_cx, "`loop`", body.info()); + let _icx = cx.insn_ctxt(~"trans_loop"); + let next_cx = sub_block(cx, ~"next"); + let body_cx = loop_scope_block(cx, next_cx, ~"`loop`", body.info()); let body_end = trans_block(body_cx, body, ignore); cleanup_and_Br(body_end, body_cx, body_cx.llbb); Br(cx, body_cx.llbb); @@ -2078,7 +2079,7 @@ fn monomorphic_fn(ccx: @crate_ctxt, fn_id: ast::def_id, vtables: option<typeck::vtable_res>, ref_id: option<ast::node_id>) -> {val: ValueRef, must_cast: bool} { - let _icx = ccx.insn_ctxt("monomorphic_fn"); + let _icx = ccx.insn_ctxt(~"monomorphic_fn"); let mut must_cast = false; let substs = vec::map(real_substs, |t| { alt normalize_for_monomorphization(ccx.tcx, t) { @@ -2131,17 +2132,19 @@ fn monomorphic_fn(ccx: @crate_ctxt, fn_id: ast::def_id, must_cast: true}; } ast_map::node_ctor(nm, _, ct, _, pt) { (pt, nm, ct.span) } - ast_map::node_dtor(_, dtor, _, pt) {(pt, @"drop"/~, dtor.span)} - ast_map::node_expr(*) { ccx.tcx.sess.bug("Can't monomorphize an expr") } + ast_map::node_dtor(_, dtor, _, pt) {(pt, @~"drop", dtor.span)} + ast_map::node_expr(*) { + ccx.tcx.sess.bug(~"Can't monomorphize an expr") + } ast_map::node_export(*) { - ccx.tcx.sess.bug("Can't monomorphize an export") + ccx.tcx.sess.bug(~"Can't monomorphize an export") } - ast_map::node_arg(*) { ccx.tcx.sess.bug("Can't monomorphize an arg") } + ast_map::node_arg(*) { ccx.tcx.sess.bug(~"Can't monomorphize an arg") } ast_map::node_block(*) { - ccx.tcx.sess.bug("Can't monomorphize a block") + ccx.tcx.sess.bug(~"Can't monomorphize a block") } ast_map::node_local(*) { - ccx.tcx.sess.bug("Can't monomorphize a local") + ccx.tcx.sess.bug(~"Can't monomorphize a local") } }; let mono_ty = ty::subst_tps(ccx.tcx, substs, llitem_ty); @@ -2153,7 +2156,7 @@ fn monomorphic_fn(ccx: @crate_ctxt, fn_id: ast::def_id, // causing an infinite expansion. if depth > 10u { ccx.sess.span_fatal( - span, "overly deep expansion of inlined function"); + span, ~"overly deep expansion of inlined function"); } ccx.monomorphizing.insert(fn_id, depth + 1u); @@ -2175,7 +2178,7 @@ fn monomorphic_fn(ccx: @crate_ctxt, fn_id: ast::def_id, d } ast_map::node_item(*) { - ccx.tcx.sess.bug("Can't monomorphize this kind of item") + ccx.tcx.sess.bug(~"Can't monomorphize this kind of item") } ast_map::node_foreign_item(i, _, _) { let d = mk_lldecl(); @@ -2216,23 +2219,25 @@ fn monomorphic_fn(ccx: @crate_ctxt, fn_id: ast::def_id, let parent_id = alt ty::ty_to_def_id(ty::node_id_to_type(ccx.tcx, dtor.node.self_id)) { some(did) { did } - none { ccx.sess.span_bug(dtor.span, "Bad self ty in \ + none { ccx.sess.span_bug(dtor.span, ~"Bad self ty in \ dtor"); } }; trans_class_dtor(ccx, *pt, dtor.node.body, dtor.node.id, psubsts, some(hash_id), parent_id) } // Ugh -- but this ensures any new variants won't be forgotten - ast_map::node_expr(*) { ccx.tcx.sess.bug("Can't monomorphize an expr") } + ast_map::node_expr(*) { + ccx.tcx.sess.bug(~"Can't monomorphize an expr") + } ast_map::node_export(*) { - ccx.tcx.sess.bug("Can't monomorphize an export") + ccx.tcx.sess.bug(~"Can't monomorphize an export") } - ast_map::node_arg(*) { ccx.tcx.sess.bug("Can't monomorphize an arg") } + ast_map::node_arg(*) { ccx.tcx.sess.bug(~"Can't monomorphize an arg") } ast_map::node_block(*) { - ccx.tcx.sess.bug("Can't monomorphize a block") + ccx.tcx.sess.bug(~"Can't monomorphize a block") } ast_map::node_local(*) { - ccx.tcx.sess.bug("Can't monomorphize a local") + ccx.tcx.sess.bug(~"Can't monomorphize a local") } }; ccx.monomorphizing.insert(fn_id, depth); @@ -2243,7 +2248,7 @@ fn monomorphic_fn(ccx: @crate_ctxt, fn_id: ast::def_id, fn maybe_instantiate_inline(ccx: @crate_ctxt, fn_id: ast::def_id) -> ast::def_id { - let _icx = ccx.insn_ctxt("maybe_instantiate_inline"); + let _icx = ccx.insn_ctxt(~"maybe_instantiate_inline"); alt ccx.external.find(fn_id) { some(some(node_id)) { // Already inline @@ -2293,7 +2298,7 @@ fn maybe_instantiate_inline(ccx: @crate_ctxt, fn_id: ast::def_id) local_def(my_id) } csearch::found_parent(_, _) { - ccx.sess.bug("maybe_get_item_ast returned a found_parent \ + ccx.sess.bug(~"maybe_get_item_ast returned a found_parent \ with a non-item parent"); } csearch::found(ast::ii_method(impl_did, mth)) { @@ -2321,7 +2326,7 @@ fn maybe_instantiate_inline(ccx: @crate_ctxt, fn_id: ast::def_id) fn lval_static_fn(bcx: block, fn_id: ast::def_id, id: ast::node_id) -> lval_maybe_callee { - let _icx = bcx.insn_ctxt("lval_static_fn"); + let _icx = bcx.insn_ctxt(~"lval_static_fn"); let vts = option::map(bcx.ccx().maps.vtable_map.find(id), |vts| { impl::resolve_vtables_in_fn_ctxt(bcx.fcx, vts) }); @@ -2331,7 +2336,7 @@ fn lval_static_fn(bcx: block, fn_id: ast::def_id, id: ast::node_id) fn lval_static_fn_inner(bcx: block, fn_id: ast::def_id, id: ast::node_id, tys: ~[ty::t], vtables: option<typeck::vtable_res>) -> lval_maybe_callee { - let _icx = bcx.insn_ctxt("lval_static_fn_inner"); + let _icx = bcx.insn_ctxt(~"lval_static_fn_inner"); let ccx = bcx.ccx(), tcx = ccx.tcx; let tpt = ty::lookup_item_type(tcx, fn_id); @@ -2381,7 +2386,7 @@ fn lval_static_fn_inner(bcx: block, fn_id: ast::def_id, id: ast::node_id, } fn lookup_discriminant(ccx: @crate_ctxt, vid: ast::def_id) -> ValueRef { - let _icx = ccx.insn_ctxt("lookup_discriminant"); + let _icx = ccx.insn_ctxt(~"lookup_discriminant"); alt ccx.discrims.find(vid) { none { // It's an external discriminant that we haven't seen yet. @@ -2404,13 +2409,13 @@ fn cast_self(cx: block, slf: val_self_pair) -> ValueRef { } fn trans_local_var(cx: block, def: ast::def) -> local_var_result { - let _icx = cx.insn_ctxt("trans_local_var"); + let _icx = cx.insn_ctxt(~"trans_local_var"); fn take_local(table: hashmap<ast::node_id, local_val>, id: ast::node_id) -> local_var_result { alt table.find(id) { some(local_mem(v)) { {val: v, kind: owned} } some(local_imm(v)) { {val: v, kind: owned_imm} } - r { fail("take_local: internal error"); } + r { fail(~"take_local: internal error"); } } } alt def { @@ -2429,7 +2434,7 @@ fn trans_local_var(cx: block, def: ast::def) -> local_var_result { ast::def_self(sid) { let slf = alt copy cx.fcx.llself { some(s) { cast_self(cx, s) } - none { cx.sess().bug("trans_local_var: reference to self \ + none { cx.sess().bug(~"trans_local_var: reference to self \ out of context"); } }; ret {val: slf, kind: owned}; @@ -2443,9 +2448,9 @@ fn trans_local_var(cx: block, def: ast::def) -> local_var_result { fn trans_path(cx: block, id: ast::node_id) -> lval_maybe_callee { - let _icx = cx.insn_ctxt("trans_path"); + let _icx = cx.insn_ctxt(~"trans_path"); alt cx.tcx().def_map.find(id) { - none { cx.sess().bug("trans_path: unbound node ID"); } + none { cx.sess().bug(~"trans_path: unbound node ID"); } some(df) { ret trans_var(cx, df, id); } @@ -2453,7 +2458,7 @@ fn trans_path(cx: block, id: ast::node_id) } fn trans_var(cx: block, def: ast::def, id: ast::node_id)-> lval_maybe_callee { - let _icx = cx.insn_ctxt("trans_var"); + let _icx = cx.insn_ctxt(~"trans_var"); let ccx = cx.ccx(); alt def { ast::def_fn(did, _) { @@ -2492,7 +2497,7 @@ fn trans_var(cx: block, def: ast::def, id: ast::node_id)-> lval_maybe_callee { fn trans_rec_field(bcx: block, base: @ast::expr, field: ast::ident) -> lval_result { - let _icx = bcx.insn_ctxt("trans_rec_field"); + let _icx = bcx.insn_ctxt(~"trans_rec_field"); let {bcx, val} = trans_temp_expr(bcx, base); let {bcx, val, ty} = autoderef(bcx, base.id, val, expr_ty(bcx, base), @@ -2512,7 +2517,7 @@ fn trans_rec_field_inner(bcx: block, val: ValueRef, ty: ty::t, ty::class_items_as_mutable_fields(bcx.tcx(), did, substs) } // Constraint? - _ { bcx.tcx().sess.span_bug(sp, "trans_rec_field:\ + _ { bcx.tcx().sess.span_bug(sp, ~"trans_rec_field:\ base expr has non-record type"); } }; // seems wrong? Doesn't take into account the field @@ -2537,7 +2542,7 @@ fn trans_rec_field_inner(bcx: block, val: ValueRef, ty: ty::t, fn trans_index(cx: block, ex: @ast::expr, base: @ast::expr, idx: @ast::expr) -> lval_result { - let _icx = cx.insn_ctxt("trans_index"); + let _icx = cx.insn_ctxt(~"trans_index"); let base_ty = expr_ty(cx, base); let exp = trans_temp_expr(cx, base); let lv = autoderef(exp.bcx, base.id, exp.val, base_ty, uint::max_value); @@ -2562,9 +2567,9 @@ fn trans_index(cx: block, ex: @ast::expr, base: @ast::expr, let unit_ty = node_id_type(cx, ex.id); let llunitty = type_of(ccx, unit_ty); let unit_sz = llsize_of(ccx, llunitty); - maybe_name_value(cx.ccx(), unit_sz, "unit_sz"); + maybe_name_value(cx.ccx(), unit_sz, ~"unit_sz"); let scaled_ix = Mul(bcx, ix_val, unit_sz); - maybe_name_value(cx.ccx(), scaled_ix, "scaled_ix"); + maybe_name_value(cx.ccx(), scaled_ix, ~"scaled_ix"); let mut (base, len) = tvec::get_base_and_len(bcx, v, base_ty); @@ -2578,7 +2583,7 @@ fn trans_index(cx: block, ex: @ast::expr, base: @ast::expr, let bounds_check = ICmp(bcx, lib::llvm::IntUGE, scaled_ix, len); let bcx = do with_cond(bcx, bounds_check) |bcx| { // fail: bad bounds check. - trans_fail(bcx, some(ex.span), "bounds check") + trans_fail(bcx, some(ex.span), ~"bounds check") }; let elt = InBoundsGEP(bcx, base, ~[ix_val]); ret lval_owned(bcx, PointerCast(bcx, elt, T_ptr(llunitty))); @@ -2594,7 +2599,7 @@ fn expr_is_lval(bcx: block, e: @ast::expr) -> bool { } fn trans_callee(bcx: block, e: @ast::expr) -> lval_maybe_callee { - let _icx = bcx.insn_ctxt("trans_callee"); + let _icx = bcx.insn_ctxt(~"trans_callee"); alt e.node { ast::expr_path(path) { ret trans_path(bcx, e.id); } ast::expr_field(base, _, _) { @@ -2605,7 +2610,7 @@ fn trans_callee(bcx: block, e: @ast::expr) -> lval_maybe_callee { ret impl::trans_method_callee(bcx, e.id, base, origin); } _ { - bcx.ccx().sess.span_bug(e.span, "trans_callee: weird expr"); + bcx.ccx().sess.span_bug(e.span, ~"trans_callee: weird expr"); } } } @@ -2635,7 +2640,7 @@ fn trans_lval(cx: block, e: @ast::expr) -> lval_result { scope_id]); } - let _icx = lv.bcx.insn_ctxt("root_value_lval"); + let _icx = lv.bcx.insn_ctxt(~"root_value_lval"); let ty = expr_ty(lv.bcx, e); let root_loc = alloca_zeroed(lv.bcx, type_of(cx.ccx(), ty)); let bcx = store_temp_expr(lv.bcx, INIT, root_loc, lv, ty, false); @@ -2645,7 +2650,7 @@ fn trans_lval(cx: block, e: @ast::expr) -> lval_result { }; fn unrooted(cx: block, e: @ast::expr) -> lval_result { - let _icx = cx.insn_ctxt("trans_lval"); + let _icx = cx.insn_ctxt(~"trans_lval"); alt e.node { ast::expr_path(_) { let v = trans_path(cx, e.id); @@ -2679,7 +2684,7 @@ fn trans_lval(cx: block, e: @ast::expr) -> lval_result { }; ret lval_owned(sub.bcx, val); } - _ { cx.sess().span_bug(e.span, "non-lval in trans_lval"); } + _ { cx.sess().span_bug(e.span, ~"non-lval in trans_lval"); } } } } @@ -2694,7 +2699,7 @@ fn trans_lval(cx: block, e: @ast::expr) -> lval_result { */ fn non_gc_box_cast(cx: block, val: ValueRef) -> ValueRef { #debug("non_gc_box_cast"); - add_comment(cx, "non_gc_box_cast"); + add_comment(cx, ~"non_gc_box_cast"); assert(llvm::LLVMGetPointerAddressSpace(val_ty(val)) as uint == 1u); let non_gc_t = T_ptr(llvm::LLVMGetElementType(val_ty(val))); PointerCast(cx, val, non_gc_t) @@ -2703,7 +2708,7 @@ fn non_gc_box_cast(cx: block, val: ValueRef) -> ValueRef { fn lval_maybe_callee_to_lval(c: lval_maybe_callee, sp: span) -> lval_result { alt c.env { self_env(*) { - c.bcx.sess().span_bug(sp, "implicitly binding method call"); + c.bcx.sess().span_bug(sp, ~"implicitly binding method call"); } is_closure { {bcx: c.bcx, val: c.val, kind: c.kind} } null_env { @@ -2717,7 +2722,7 @@ fn lval_maybe_callee_to_lval(c: lval_maybe_callee, sp: span) -> lval_result { fn int_cast(bcx: block, lldsttype: TypeRef, llsrctype: TypeRef, llsrc: ValueRef, signed: bool) -> ValueRef { - let _icx = bcx.insn_ctxt("int_cast"); + let _icx = bcx.insn_ctxt(~"int_cast"); let srcsz = llvm::LLVMGetIntTypeWidth(llsrctype); let dstsz = llvm::LLVMGetIntTypeWidth(lldsttype); ret if dstsz == srcsz { @@ -2731,7 +2736,7 @@ fn int_cast(bcx: block, lldsttype: TypeRef, llsrctype: TypeRef, fn float_cast(bcx: block, lldsttype: TypeRef, llsrctype: TypeRef, llsrc: ValueRef) -> ValueRef { - let _icx = bcx.insn_ctxt("float_cast"); + let _icx = bcx.insn_ctxt(~"float_cast"); let srcsz = lib::llvm::float_width(llsrctype); let dstsz = lib::llvm::float_width(lldsttype); ret if dstsz > srcsz { @@ -2759,7 +2764,7 @@ fn cast_type_kind(t: ty::t) -> cast_kind { fn trans_cast(cx: block, e: @ast::expr, id: ast::node_id, dest: dest) -> block { - let _icx = cx.insn_ctxt("trans_cast"); + let _icx = cx.insn_ctxt(~"trans_cast"); let ccx = cx.ccx(); let t_out = node_id_type(cx, id); alt ty::get(t_out).struct { @@ -2813,10 +2818,10 @@ fn trans_cast(cx: block, e: @ast::expr, id: ast::node_id, cast_integral {int_cast(e_res.bcx, ll_t_out, val_ty(lldiscrim_a), lldiscrim_a, true)} cast_float {SIToFP(e_res.bcx, lldiscrim_a, ll_t_out)} - _ { ccx.sess.bug("translating unsupported cast.") } + _ { ccx.sess.bug(~"translating unsupported cast.") } } } - _ { ccx.sess.bug("translating unsupported cast.") } + _ { ccx.sess.bug(~"translating unsupported cast.") } }; ret store_in_dest(e_res.bcx, newval, dest); } @@ -2843,7 +2848,7 @@ fn trans_arg_expr(cx: block, arg: ty::arg, lldestty: TypeRef, e: @ast::expr, derefs: uint) -> result { #debug("+++ trans_arg_expr on %s", expr_to_str(e)); - let _icx = cx.insn_ctxt("trans_arg_expr"); + let _icx = cx.insn_ctxt(~"trans_arg_expr"); let ccx = cx.ccx(); let e_ty = expr_ty(cx, e); let is_bot = ty::type_is_bot(e_ty); @@ -3021,7 +3026,7 @@ enum call_args { fn trans_args(cx: block, llenv: ValueRef, args: call_args, fn_ty: ty::t, dest: dest, ret_flag: option<ValueRef>) -> {bcx: block, args: ~[ValueRef], retslot: ValueRef} { - let _icx = cx.insn_ctxt("trans_args"); + let _icx = cx.insn_ctxt(~"trans_args"); let mut temp_cleanups = ~[]; let arg_tys = ty::ty_fn_args(fn_ty); let mut llargs: ~[ValueRef] = ~[]; @@ -3083,7 +3088,7 @@ fn trans_args(cx: block, llenv: ValueRef, args: call_args, fn_ty: ty::t, fn trans_call(in_cx: block, call_ex: @ast::expr, f: @ast::expr, args: call_args, id: ast::node_id, dest: dest) -> block { - let _icx = in_cx.insn_ctxt("trans_call"); + let _icx = in_cx.insn_ctxt(~"trans_call"); trans_call_inner( in_cx, call_ex.info(), expr_ty(in_cx, f), node_id_type(in_cx, id), |cx| trans_callee(cx, f), args, dest) @@ -3115,7 +3120,7 @@ fn trans_call_inner( args: call_args, dest: dest) -> block { - do with_scope(in_cx, call_info, "call") |cx| { + do with_scope(in_cx, call_info, ~"call") |cx| { let ret_in_loop = alt args { arg_exprs(args) { args.len() > 0u && alt vec::last(args).node { ast::expr_loop_body(@{node: ast::expr_fn_block(_, body, _), _}) { @@ -3198,15 +3203,15 @@ fn trans_call_inner( } fn invoke(bcx: block, llfn: ValueRef, llargs: ~[ValueRef]) -> block { - let _icx = bcx.insn_ctxt("invoke_"); + let _icx = bcx.insn_ctxt(~"invoke_"); if bcx.unreachable { ret bcx; } if need_invoke(bcx) { - log(debug, "invoking"); - let normal_bcx = sub_block(bcx, "normal return"); + log(debug, ~"invoking"); + let normal_bcx = sub_block(bcx, ~"normal return"); Invoke(bcx, llfn, llargs, normal_bcx.llbb, get_landing_pad(bcx)); ret normal_bcx; } else { - log(debug, "calling"); + log(debug, ~"calling"); Call(bcx, llfn, llargs); ret bcx; } @@ -3268,7 +3273,7 @@ fn in_lpad_scope_cx(bcx: block, f: fn(scope_info)) { } fn get_landing_pad(bcx: block) -> BasicBlockRef { - let _icx = bcx.insn_ctxt("get_landing_pad"); + let _icx = bcx.insn_ctxt(~"get_landing_pad"); let mut cached = none, pad_bcx = bcx; // Guaranteed to be set below do in_lpad_scope_cx(bcx) |inf| { @@ -3276,7 +3281,7 @@ fn get_landing_pad(bcx: block) -> BasicBlockRef { alt copy inf.landing_pad { some(target) { cached = some(target); } none { - pad_bcx = sub_block(bcx, "unwind"); + pad_bcx = sub_block(bcx, ~"unwind"); inf.landing_pad = some(pad_bcx.llbb); } } @@ -3317,7 +3322,7 @@ fn get_landing_pad(bcx: block) -> BasicBlockRef { } fn trans_tup(bcx: block, elts: ~[@ast::expr], dest: dest) -> block { - let _icx = bcx.insn_ctxt("trans_tup"); + let _icx = bcx.insn_ctxt(~"trans_tup"); let mut bcx = bcx; let addr = alt dest { ignore { @@ -3325,7 +3330,7 @@ fn trans_tup(bcx: block, elts: ~[@ast::expr], dest: dest) -> block { ret bcx; } save_in(pos) { pos } - _ { bcx.tcx().sess.bug("trans_tup: weird dest"); } + _ { bcx.tcx().sess.bug(~"trans_tup: weird dest"); } }; let mut temp_cleanups = ~[]; for vec::eachi(elts) |i, e| { @@ -3342,7 +3347,7 @@ fn trans_tup(bcx: block, elts: ~[@ast::expr], dest: dest) -> block { fn trans_rec(bcx: block, fields: ~[ast::field], base: option<@ast::expr>, id: ast::node_id, dest: dest) -> block { - let _icx = bcx.insn_ctxt("trans_rec"); + let _icx = bcx.insn_ctxt(~"trans_rec"); let t = node_id_type(bcx, id); let mut bcx = bcx; let addr = alt check dest { @@ -3405,7 +3410,7 @@ fn trans_expr_save_in(bcx: block, e: @ast::expr, dest: ValueRef) // trans_expr_save_in. For intermediates where you don't care about lval-ness, // use trans_temp_expr. fn trans_temp_lval(bcx: block, e: @ast::expr) -> lval_result { - let _icx = bcx.insn_ctxt("trans_temp_lval"); + let _icx = bcx.insn_ctxt(~"trans_temp_lval"); let mut bcx = bcx; if expr_is_lval(bcx, e) { ret trans_lval(bcx, e); @@ -3431,7 +3436,7 @@ fn trans_temp_lval(bcx: block, e: @ast::expr) -> lval_result { // Use only for intermediate values. See trans_expr and trans_expr_save_in for // expressions that must 'end up somewhere' (or get ignored). fn trans_temp_expr(bcx: block, e: @ast::expr) -> result { - let _icx = bcx.insn_ctxt("trans_temp_expr"); + let _icx = bcx.insn_ctxt(~"trans_temp_expr"); lval_result_to_result(trans_temp_lval(bcx, e), expr_ty(bcx, e)) } @@ -3492,7 +3497,7 @@ fn add_root_cleanup(bcx: block, scope_id: ast::node_id, // - exprs returning nil or bot always get dest=ignore // - exprs with non-immediate type never get dest=by_val fn trans_expr(bcx: block, e: @ast::expr, dest: dest) -> block { - let _icx = bcx.insn_ctxt("trans_expr"); + let _icx = bcx.insn_ctxt(~"trans_expr"); debuginfo::update_source_pos(bcx, e.span); if expr_is_lval(bcx, e) { @@ -3514,7 +3519,7 @@ fn trans_expr(bcx: block, e: @ast::expr, dest: dest) -> block { scope_id]); } - let _icx = bcx.insn_ctxt("root_value_expr"); + let _icx = bcx.insn_ctxt(~"root_value_expr"); add_root_cleanup(bcx, scope_id, root_loc, ty); let lv = {bcx: bcx, val: root_loc, kind: owned}; lval_result_to_dps(lv, ty, false, dest) @@ -3531,7 +3536,7 @@ fn trans_expr(bcx: block, e: @ast::expr, dest: dest) -> block { ret alt::trans_alt(bcx, e, expr, arms, mode, dest); } ast::expr_block(blk) { - ret do with_scope(bcx, blk.info(), "block-expr body") |bcx| { + ret do with_scope(bcx, blk.info(), ~"block-expr body") |bcx| { trans_block(bcx, blk, dest) }; } @@ -3627,11 +3632,11 @@ fn trans_expr(bcx: block, e: @ast::expr, dest: dest) -> block { } ast::expr_assert(a) { assert dest == ignore; - ret trans_check_expr(bcx, e, a, "Assertion"); + ret trans_check_expr(bcx, e, a, ~"Assertion"); } ast::expr_check(ast::checked_expr, a) { assert dest == ignore; - ret trans_check_expr(bcx, e, a, "Predicate"); + ret trans_check_expr(bcx, e, a, ~"Predicate"); } ast::expr_check(ast::claimed_expr, a) { assert dest == ignore; @@ -3641,9 +3646,9 @@ fn trans_expr(bcx: block, e: @ast::expr, dest: dest) -> block { if it's set to false and acting like a check otherwise. */ let c = get_extern_const(bcx.ccx().externs, bcx.ccx().llmod, - "check_claims", T_bool()); + ~"check_claims", T_bool()); ret do with_cond(bcx, Load(bcx, c)) |bcx| { - trans_check_expr(bcx, e, a, "Claim") + trans_check_expr(bcx, e, a, ~"Claim") }; } ast::expr_while(cond, body) { @@ -3728,7 +3733,7 @@ fn trans_expr(bcx: block, e: @ast::expr, dest: dest) -> block { store_in_dest(bcx, ptr_val, dest) } _ { - bcx.tcx().sess.span_bug(e.span, "trans_expr reached \ + bcx.tcx().sess.span_bug(e.span, ~"trans_expr reached \ fall-through case"); } } @@ -3795,20 +3800,20 @@ fn do_spill_noroot(++cx: block, v: ValueRef) -> ValueRef { } fn spill_if_immediate(cx: block, v: ValueRef, t: ty::t) -> ValueRef { - let _icx = cx.insn_ctxt("spill_if_immediate"); + let _icx = cx.insn_ctxt(~"spill_if_immediate"); if ty::type_is_immediate(t) { ret do_spill(cx, v, t); } ret v; } fn load_if_immediate(cx: block, v: ValueRef, t: ty::t) -> ValueRef { - let _icx = cx.insn_ctxt("load_if_immediate"); + let _icx = cx.insn_ctxt(~"load_if_immediate"); if ty::type_is_immediate(t) { ret Load(cx, v); } ret v; } fn trans_log(log_ex: @ast::expr, lvl: @ast::expr, bcx: block, e: @ast::expr) -> block { - let _icx = bcx.insn_ctxt("trans_log"); + let _icx = bcx.insn_ctxt(~"trans_log"); let ccx = bcx.ccx(); if ty::type_is_bot(expr_ty(bcx, lvl)) { ret trans_expr(bcx, lvl, ignore); @@ -3825,7 +3830,7 @@ fn trans_log(log_ex: @ast::expr, lvl: @ast::expr, ccx.module_data.get(modname) } else { let s = link::mangle_internal_name_by_path_and_seq( - ccx, modpath, @"loglevel"/~); + ccx, modpath, @~"loglevel"); let global = str::as_c_str(s, |buf| { llvm::LLVMAddGlobal(ccx.llmod, T_i32(), buf) }); @@ -3837,14 +3842,14 @@ fn trans_log(log_ex: @ast::expr, lvl: @ast::expr, }; let current_level = Load(bcx, global); let {bcx, val: level} = { - do with_scope_result(bcx, lvl.info(), "level") |bcx| { + do with_scope_result(bcx, lvl.info(), ~"level") |bcx| { trans_temp_expr(bcx, lvl) } }; do with_cond(bcx, ICmp(bcx, lib::llvm::IntUGE, current_level, level)) |bcx| { - do with_scope(bcx, log_ex.info(), "log") |bcx| { + do with_scope(bcx, log_ex.info(), ~"log") |bcx| { let {bcx, val, _} = trans_temp_expr(bcx, e); let e_ty = expr_ty(bcx, e); let tydesc = get_tydesc_simple(ccx, e_ty); @@ -3858,11 +3863,11 @@ fn trans_log(log_ex: @ast::expr, lvl: @ast::expr, } fn trans_check_expr(bcx: block, chk_expr: @ast::expr, - pred_expr: @ast::expr, s: str) -> block { - let _icx = bcx.insn_ctxt("trans_check_expr"); - let expr_str = s + " " + expr_to_str(pred_expr) + " failed"; + pred_expr: @ast::expr, s: ~str) -> block { + let _icx = bcx.insn_ctxt(~"trans_check_expr"); + let expr_str = s + ~" " + expr_to_str(pred_expr) + ~" failed"; let {bcx, val} = { - do with_scope_result(bcx, chk_expr.info(), "check") |bcx| { + do with_scope_result(bcx, chk_expr.info(), ~"check") |bcx| { trans_temp_expr(bcx, pred_expr) } }; @@ -3873,7 +3878,7 @@ fn trans_check_expr(bcx: block, chk_expr: @ast::expr, fn trans_fail_expr(bcx: block, sp_opt: option<span>, fail_expr: option<@ast::expr>) -> block { - let _icx = bcx.insn_ctxt("trans_fail_expr"); + let _icx = bcx.insn_ctxt(~"trans_fail_expr"); let mut bcx = bcx; alt fail_expr { some(expr) { @@ -3890,17 +3895,17 @@ fn trans_fail_expr(bcx: block, sp_opt: option<span>, ret bcx; } else { bcx.sess().span_bug( - expr.span, "fail called with unsupported type " + + expr.span, ~"fail called with unsupported type " + ppaux::ty_to_str(tcx, e_ty)); } } - _ { ret trans_fail(bcx, sp_opt, "explicit failure"); } + _ { ret trans_fail(bcx, sp_opt, ~"explicit failure"); } } } -fn trans_trace(bcx: block, sp_opt: option<span>, trace_str: str) { +fn trans_trace(bcx: block, sp_opt: option<span>, trace_str: ~str) { if !bcx.sess().trace() { ret; } - let _icx = bcx.insn_ctxt("trans_trace"); + let _icx = bcx.insn_ctxt(~"trans_trace"); add_comment(bcx, trace_str); let V_trace_str = C_cstr(bcx.ccx(), trace_str); let {V_filename, V_line} = alt sp_opt { @@ -3911,7 +3916,7 @@ fn trans_trace(bcx: block, sp_opt: option<span>, trace_str: str) { V_line: loc.line as int} } none { - {V_filename: C_cstr(bcx.ccx(), "<runtime>"), + {V_filename: C_cstr(bcx.ccx(), ~"<runtime>"), V_line: 0} } }; @@ -3922,16 +3927,16 @@ fn trans_trace(bcx: block, sp_opt: option<span>, trace_str: str) { Call(bcx, ccx.upcalls.trace, args); } -fn trans_fail(bcx: block, sp_opt: option<span>, fail_str: str) -> +fn trans_fail(bcx: block, sp_opt: option<span>, fail_str: ~str) -> block { - let _icx = bcx.insn_ctxt("trans_fail"); + let _icx = bcx.insn_ctxt(~"trans_fail"); let V_fail_str = C_cstr(bcx.ccx(), fail_str); ret trans_fail_value(bcx, sp_opt, V_fail_str); } fn trans_fail_value(bcx: block, sp_opt: option<span>, V_fail_str: ValueRef) -> block { - let _icx = bcx.insn_ctxt("trans_fail_value"); + let _icx = bcx.insn_ctxt(~"trans_fail_value"); let ccx = bcx.ccx(); let {V_filename, V_line} = alt sp_opt { some(sp) { @@ -3941,7 +3946,7 @@ fn trans_fail_value(bcx: block, sp_opt: option<span>, V_line: loc.line as int} } none { - {V_filename: C_cstr(bcx.ccx(), "<runtime>"), + {V_filename: C_cstr(bcx.ccx(), ~"<runtime>"), V_line: 0} } }; @@ -3955,7 +3960,7 @@ fn trans_fail_value(bcx: block, sp_opt: option<span>, fn trans_break_cont(bcx: block, to_end: bool) -> block { - let _icx = bcx.insn_ctxt("trans_break_cont"); + let _icx = bcx.insn_ctxt(~"trans_break_cont"); // Locate closest loop block, outputting cleanup as we go. let mut unwind = bcx; let mut target; @@ -3996,7 +4001,7 @@ fn trans_cont(cx: block) -> block { } fn trans_ret(bcx: block, e: option<@ast::expr>) -> block { - let _icx = bcx.insn_ctxt("trans_ret"); + let _icx = bcx.insn_ctxt(~"trans_ret"); let mut bcx = bcx; let retptr = alt copy bcx.fcx.loop_ret { some({flagptr, retptr}) { @@ -4025,17 +4030,17 @@ fn trans_ret(bcx: block, e: option<@ast::expr>) -> block { } fn build_return(bcx: block) { - let _icx = bcx.insn_ctxt("build_return"); + let _icx = bcx.insn_ctxt(~"build_return"); Br(bcx, bcx.fcx.llreturn); } fn init_local(bcx: block, local: @ast::local) -> block { - let _icx = bcx.insn_ctxt("init_local"); + let _icx = bcx.insn_ctxt(~"init_local"); let ty = node_id_type(bcx, local.node.id); let llptr = alt bcx.fcx.lllocals.find(local.node.id) { some(local_mem(v)) { v } _ { bcx.tcx().sess.span_bug(local.span, - "init_local: Someone forgot to document why it's\ + ~"init_local: Someone forgot to document why it's\ safe to assume local.node.init must be local_mem!"); } }; @@ -4058,7 +4063,7 @@ fn init_local(bcx: block, local: @ast::local) -> block { } fn trans_stmt(cx: block, s: ast::stmt) -> block { - let _icx = cx.insn_ctxt("trans_stmt"); + let _icx = cx.insn_ctxt(~"trans_stmt"); #debug["trans_stmt(%s)", stmt_to_str(s)]; if !cx.sess().no_asm_comments() { @@ -4093,11 +4098,11 @@ fn trans_stmt(cx: block, s: ast::stmt) -> block { // You probably don't want to use this one. See the // next three functions instead. fn new_block(cx: fn_ctxt, parent: option<block>, +kind: block_kind, - name: str, opt_node_info: option<node_info>) -> block { + name: ~str, opt_node_info: option<node_info>) -> block { let s = if cx.ccx.sess.opts.save_temps || cx.ccx.sess.opts.debuginfo { cx.ccx.names(name) - } else { "" }; + } else { ~"" }; let llbb: BasicBlockRef = str::as_c_str(s, |buf| { llvm::LLVMAppendBasicBlock(cx.llfn, buf) }); @@ -4116,17 +4121,17 @@ fn simple_block_scope() -> block_kind { // Use this when you're at the top block of a function or the like. fn top_scope_block(fcx: fn_ctxt, opt_node_info: option<node_info>) -> block { ret new_block(fcx, none, simple_block_scope(), - "function top level", opt_node_info); + ~"function top level", opt_node_info); } fn scope_block(bcx: block, opt_node_info: option<node_info>, - n: str) -> block { + n: ~str) -> block { ret new_block(bcx.fcx, some(bcx), simple_block_scope(), n, opt_node_info); } -fn loop_scope_block(bcx: block, loop_break: block, n: str, +fn loop_scope_block(bcx: block, loop_break: block, n: ~str, opt_node_info: option<node_info>) -> block { ret new_block(bcx.fcx, some(bcx), block_scope({ loop_break: some(loop_break), @@ -4138,7 +4143,7 @@ fn loop_scope_block(bcx: block, loop_break: block, n: str, // Use this when you're making a general CFG BB within a scope. -fn sub_block(bcx: block, n: str) -> block { +fn sub_block(bcx: block, n: ~str) -> block { new_block(bcx.fcx, some(bcx), block_non_scope, n, none) } @@ -4160,7 +4165,7 @@ fn trans_block_cleanups(bcx: block, cleanup_cx: block) -> block { fn trans_block_cleanups_(bcx: block, cleanup_cx: block, is_lpad: bool) -> block { - let _icx = bcx.insn_ctxt("trans_block_cleanups"); + let _icx = bcx.insn_ctxt(~"trans_block_cleanups"); if bcx.unreachable { ret bcx; } let mut bcx = bcx; alt check cleanup_cx.kind { @@ -4187,7 +4192,7 @@ fn trans_block_cleanups_(bcx: block, cleanup_cx: block, is_lpad: bool) -> // instruction. fn cleanup_and_leave(bcx: block, upto: option<BasicBlockRef>, leave: option<BasicBlockRef>) { - let _icx = bcx.insn_ctxt("cleanup_and_leave"); + let _icx = bcx.insn_ctxt(~"cleanup_and_leave"); let mut cur = bcx, bcx = bcx; let is_lpad = leave == none; loop { @@ -4206,7 +4211,7 @@ fn cleanup_and_leave(bcx: block, upto: option<BasicBlockRef>, Br(bcx, cp.dest); ret; } - let sub_cx = sub_block(bcx, "cleanup"); + let sub_cx = sub_block(bcx, ~"cleanup"); Br(bcx, sub_cx.llbb); vec::push(inf.cleanup_paths, {target: leave, dest: sub_cx.llbb}); bcx = trans_block_cleanups_(sub_cx, cur, is_lpad); @@ -4230,30 +4235,30 @@ fn cleanup_and_leave(bcx: block, upto: option<BasicBlockRef>, fn cleanup_and_Br(bcx: block, upto: block, target: BasicBlockRef) { - let _icx = bcx.insn_ctxt("cleanup_and_Br"); + let _icx = bcx.insn_ctxt(~"cleanup_and_Br"); cleanup_and_leave(bcx, some(upto.llbb), some(target)); } fn leave_block(bcx: block, out_of: block) -> block { - let _icx = bcx.insn_ctxt("leave_block"); - let next_cx = sub_block(block_parent(out_of), "next"); + let _icx = bcx.insn_ctxt(~"leave_block"); + let next_cx = sub_block(block_parent(out_of), ~"next"); if bcx.unreachable { Unreachable(next_cx); } cleanup_and_Br(bcx, out_of, next_cx.llbb); next_cx } fn with_scope(bcx: block, opt_node_info: option<node_info>, - name: str, f: fn(block) -> block) -> block { - let _icx = bcx.insn_ctxt("with_scope"); + name: ~str, f: fn(block) -> block) -> block { + let _icx = bcx.insn_ctxt(~"with_scope"); let scope_cx = scope_block(bcx, opt_node_info, name); Br(bcx, scope_cx.llbb); leave_block(f(scope_cx), scope_cx) } fn with_scope_result(bcx: block, opt_node_info: option<node_info>, - name: str, f: fn(block) -> result) + name: ~str, f: fn(block) -> result) -> result { - let _icx = bcx.insn_ctxt("with_scope_result"); + let _icx = bcx.insn_ctxt(~"with_scope_result"); let scope_cx = scope_block(bcx, opt_node_info, name); Br(bcx, scope_cx.llbb); let {bcx, val} = f(scope_cx); @@ -4261,8 +4266,8 @@ fn with_scope_result(bcx: block, opt_node_info: option<node_info>, } fn with_cond(bcx: block, val: ValueRef, f: fn(block) -> block) -> block { - let _icx = bcx.insn_ctxt("with_cond"); - let next_cx = sub_block(bcx, "next"), cond_cx = sub_block(bcx, "cond"); + let _icx = bcx.insn_ctxt(~"with_cond"); + let next_cx = sub_block(bcx, ~"next"), cond_cx = sub_block(bcx, ~"cond"); CondBr(bcx, val, cond_cx.llbb, next_cx.llbb); let after_cx = f(cond_cx); if !after_cx.terminated { Br(after_cx, next_cx.llbb); } @@ -4286,7 +4291,7 @@ fn block_locals(b: ast::blk, it: fn(@ast::local)) { } fn alloc_ty(bcx: block, t: ty::t) -> ValueRef { - let _icx = bcx.insn_ctxt("alloc_ty"); + let _icx = bcx.insn_ctxt(~"alloc_ty"); let ccx = bcx.ccx(); let llty = type_of(ccx, t); if ty::type_has_params(t) { log(error, ppaux::ty_to_str(ccx.tcx, t)); } @@ -4296,7 +4301,7 @@ fn alloc_ty(bcx: block, t: ty::t) -> ValueRef { } fn alloc_local(cx: block, local: @ast::local) -> block { - let _icx = cx.insn_ctxt("alloc_local"); + let _icx = cx.insn_ctxt(~"alloc_local"); let t = node_id_type(cx, local.node.id); let simple_name = alt local.node.pat.node { ast::pat_ident(pth, none) { some(path_to_ident(pth)) } @@ -4316,7 +4321,7 @@ fn alloc_local(cx: block, local: @ast::local) -> block { fn trans_block(bcx: block, b: ast::blk, dest: dest) -> block { - let _icx = bcx.insn_ctxt("trans_block"); + let _icx = bcx.insn_ctxt(~"trans_block"); let mut bcx = bcx; do block_locals(b) |local| { bcx = alloc_local(bcx, local); }; for vec::each(b.node.stmts) |s| { @@ -4337,11 +4342,11 @@ fn trans_block(bcx: block, b: ast::blk, dest: dest) // Creates the standard set of basic blocks for a function fn mk_standard_basic_blocks(llfn: ValueRef) -> {sa: BasicBlockRef, ca: BasicBlockRef, rt: BasicBlockRef} { - {sa: str::as_c_str("static_allocas", + {sa: str::as_c_str(~"static_allocas", |buf| llvm::LLVMAppendBasicBlock(llfn, buf)), - ca: str::as_c_str("load_env", + ca: str::as_c_str(~"load_env", |buf| llvm::LLVMAppendBasicBlock(llfn, buf)), - rt: str::as_c_str("return", + rt: str::as_c_str(~"return", |buf| llvm::LLVMAppendBasicBlock(llfn, buf))} } @@ -4398,7 +4403,7 @@ fn new_fn_ctxt(ccx: @crate_ctxt, path: path, llfndecl: ValueRef, fn create_llargs_for_fn_args(cx: fn_ctxt, ty_self: self_arg, args: ~[ast::arg]) { - let _icx = cx.insn_ctxt("create_llargs_for_fn_args"); + let _icx = cx.insn_ctxt(~"create_llargs_for_fn_args"); // Skip the implicit arguments 0, and 1. let mut arg_n = first_real_arg; alt ty_self { @@ -4423,11 +4428,11 @@ fn create_llargs_for_fn_args(cx: fn_ctxt, fn copy_args_to_allocas(fcx: fn_ctxt, bcx: block, args: ~[ast::arg], arg_tys: ~[ty::arg]) -> block { - let _icx = fcx.insn_ctxt("copy_args_to_allocas"); + let _icx = fcx.insn_ctxt(~"copy_args_to_allocas"); let tcx = bcx.tcx(); let mut arg_n: uint = 0u, bcx = bcx; let epic_fail = fn@() -> ! { - tcx.sess.bug("someone forgot\ + tcx.sess.bug(~"someone forgot\ to document an invariant in copy_args_to_allocas!"); }; for vec::each(arg_tys) |arg| { @@ -4459,14 +4464,14 @@ fn copy_args_to_allocas(fcx: fn_ctxt, bcx: block, args: ~[ast::arg], // Ties up the llstaticallocas -> llloadenv -> lltop edges, // and builds the return block. fn finish_fn(fcx: fn_ctxt, lltop: BasicBlockRef) { - let _icx = fcx.insn_ctxt("finish_fn"); + let _icx = fcx.insn_ctxt(~"finish_fn"); tie_up_header_blocks(fcx, lltop); let ret_cx = raw_block(fcx, fcx.llreturn); RetVoid(ret_cx); } fn tie_up_header_blocks(fcx: fn_ctxt, lltop: BasicBlockRef) { - let _icx = fcx.insn_ctxt("tie_up_header_blocks"); + let _icx = fcx.insn_ctxt(~"tie_up_header_blocks"); Br(raw_block(fcx, fcx.llstaticallocas), fcx.llloadenv); Br(raw_block(fcx, fcx.llloadenv), lltop); } @@ -4483,7 +4488,7 @@ fn trans_closure(ccx: @crate_ctxt, path: path, decl: ast::fn_decl, id: ast::node_id, maybe_load_env: fn(fn_ctxt), finish: fn(block)) { - let _icx = ccx.insn_ctxt("trans_closure"); + let _icx = ccx.insn_ctxt(~"trans_closure"); set_uwtable(llfndecl); // Set up arguments to the function. @@ -4539,7 +4544,7 @@ fn trans_fn(ccx: @crate_ctxt, let do_time = ccx.sess.trans_stats(); let start = if do_time { time::get_time() } else { {sec: 0i64, nsec: 0i32} }; - let _icx = ccx.insn_ctxt("trans_fn"); + let _icx = ccx.insn_ctxt(~"trans_fn"); trans_closure(ccx, path, decl, body, llfndecl, ty_self, param_substs, id, |fcx| { @@ -4558,12 +4563,12 @@ fn trans_enum_variant(ccx: @crate_ctxt, enum_id: ast::node_id, variant: ast::variant, disr: int, is_degen: bool, param_substs: option<param_substs>, llfndecl: ValueRef) { - let _icx = ccx.insn_ctxt("trans_enum_variant"); + let _icx = ccx.insn_ctxt(~"trans_enum_variant"); // Translate variant arguments to function arguments. let fn_args = vec::map(variant.node.args, |varg| {mode: ast::expl(ast::by_copy), ty: varg.ty, - ident: @"arg"/~, + ident: @~"arg", id: varg.id}); let fcx = new_fn_ctxt_w_id(ccx, ~[], llfndecl, variant.node.id, param_substs, none); @@ -4609,7 +4614,7 @@ fn trans_enum_variant(ccx: @crate_ctxt, enum_id: ast::node_id, // duplicate constants. I think. Maybe LLVM has a magical mode that does so // later on? fn trans_const_expr(cx: @crate_ctxt, e: @ast::expr) -> ValueRef { - let _icx = cx.insn_ctxt("trans_const_expr"); + let _icx = cx.insn_ctxt(~"trans_const_expr"); alt e.node { ast::expr_lit(lit) { trans_crate_lit(cx, e, *lit) } // If we have a vstore, just keep going; it has to be a string @@ -4649,7 +4654,7 @@ fn trans_const_expr(cx: @crate_ctxt, e: @ast::expr) -> ValueRef { else { llvm::LLVMConstURem(te1, te2) } } ast::and | - ast::or { cx.sess.span_unimpl(e.span, "binop logic"); } + ast::or { cx.sess.span_unimpl(e.span, ~"binop logic"); } ast::bitxor { llvm::LLVMConstXor(te1, te2) } ast::bitand { llvm::LLVMConstAnd(te1, te2) } ast::bitor { llvm::LLVMConstOr(te1, te2) } @@ -4663,7 +4668,7 @@ fn trans_const_expr(cx: @crate_ctxt, e: @ast::expr) -> ValueRef { ast::le | ast::ne | ast::ge | - ast::gt { cx.sess.span_unimpl(e.span, "binop comparator"); } + ast::gt { cx.sess.span_unimpl(e.span, ~"binop comparator"); } } } ast::expr_unary(u, e) { @@ -4674,7 +4679,7 @@ fn trans_const_expr(cx: @crate_ctxt, e: @ast::expr) -> ValueRef { ast::box(_) | ast::uniq(_) | ast::deref { cx.sess.span_bug(e.span, - "bad unop type in trans_const_expr"); } + ~"bad unop type in trans_const_expr"); } ast::not { llvm::LLVMConstNot(te) } ast::neg { if is_float { llvm::LLVMConstFNeg(te) } @@ -4717,20 +4722,20 @@ fn trans_const_expr(cx: @crate_ctxt, e: @ast::expr) -> ValueRef { trans_const_expr(cx, subexpr) } _ { - cx.sess.span_bug(e.span, "expected item"); + cx.sess.span_bug(e.span, ~"expected item"); } } } - _ { cx.sess.span_bug(e.span, "expected to find a const def") } + _ { cx.sess.span_bug(e.span, ~"expected to find a const def") } } } _ { cx.sess.span_bug(e.span, - "bad constant expression type in trans_const_expr"); } + ~"bad constant expression type in trans_const_expr"); } } } fn trans_const(ccx: @crate_ctxt, e: @ast::expr, id: ast::node_id) { - let _icx = ccx.insn_ctxt("trans_const"); + let _icx = ccx.insn_ctxt(~"trans_const"); let v = trans_const_expr(ccx, e); // The scalars come back as 1st class LLVM vals @@ -4845,7 +4850,7 @@ fn trans_class_dtor(ccx: @crate_ctxt, path: path, } fn trans_item(ccx: @crate_ctxt, item: ast::item) { - let _icx = ccx.insn_ctxt("trans_item"); + let _icx = ccx.insn_ctxt(~"trans_item"); let path = alt check ccx.tcx.items.get(item.id) { ast_map::node_item(_, p) { p } }; @@ -4933,7 +4938,7 @@ fn trans_item(ccx: @crate_ctxt, item: ast::item) { // only as a convenience for humans working with the code, to organize names // and control visibility. fn trans_mod(ccx: @crate_ctxt, m: ast::_mod) { - let _icx = ccx.insn_ctxt("trans_mod"); + let _icx = ccx.insn_ctxt(~"trans_mod"); for vec::each(m.items) |item| { trans_item(ccx, *item); } } @@ -4958,7 +4963,7 @@ fn register_fn_full(ccx: @crate_ctxt, sp: span, path: path, fn register_fn_fuller(ccx: @crate_ctxt, sp: span, path: path, node_id: ast::node_id, node_type: ty::t, cc: lib::llvm::CallConv, llfty: TypeRef) -> ValueRef { - let ps: str = mangle_exported_name(ccx, path, node_type); + let ps: ~str = mangle_exported_name(ccx, path, node_type); let llfn: ValueRef = decl_fn(ccx.llmod, ps, cc, llfty); ccx.item_symbols.insert(node_id, ps); @@ -4976,14 +4981,14 @@ fn create_main_wrapper(ccx: @crate_ctxt, sp: span, main_llfn: ValueRef, main_node_type: ty::t) { if ccx.main_fn != none::<ValueRef> { - ccx.sess.span_fatal(sp, "multiple 'main' functions"); + ccx.sess.span_fatal(sp, ~"multiple 'main' functions"); } let main_takes_argv = // invariant! alt ty::get(main_node_type).struct { ty::ty_fn({inputs, _}) { inputs.len() != 0u } - _ { ccx.sess.span_fatal(sp, "main has a non-function type"); } + _ { ccx.sess.span_fatal(sp, ~"main has a non-function type"); } }; let llfn = create_main(ccx, main_llfn, main_takes_argv); @@ -4998,7 +5003,7 @@ fn create_main_wrapper(ccx: @crate_ctxt, sp: span, main_llfn: ValueRef, ty: ty::mk_vec(ccx.tcx, {ty: unit_ty, mutbl: ast::m_imm})}; let nt = ty::mk_nil(ccx.tcx); let llfty = type_of_fn(ccx, ~[vecarg_ty], nt); - let llfdecl = decl_fn(ccx.llmod, "_rust_main", + let llfdecl = decl_fn(ccx.llmod, ~"_rust_main", lib::llvm::CCallConv, llfty); let fcx = new_fn_ctxt(ccx, ~[], llfdecl, none); @@ -5024,10 +5029,10 @@ fn create_main_wrapper(ccx: @crate_ctxt, sp: span, main_llfn: ValueRef, #[cfg(windows)] fn main_name() -> str { ret "WinMain@16"; } #[cfg(unix)] - fn main_name() -> str { ret "main"; } + fn main_name() -> ~str { ret ~"main"; } let llfty = T_fn(~[ccx.int_type, ccx.int_type], ccx.int_type); let llfn = decl_cdecl_fn(ccx.llmod, main_name(), llfty); - let llbb = str::as_c_str("top", |buf| { + let llbb = str::as_c_str(~"top", |buf| { llvm::LLVMAppendBasicBlock(llfn, buf) }); let bld = ccx.builder.B; @@ -5035,7 +5040,7 @@ fn create_main_wrapper(ccx: @crate_ctxt, sp: span, main_llfn: ValueRef, let crate_map = ccx.crate_map; let start_ty = T_fn(~[val_ty(rust_main), ccx.int_type, ccx.int_type, val_ty(crate_map)], ccx.int_type); - let start = decl_cdecl_fn(ccx.llmod, "rust_start", start_ty); + let start = decl_cdecl_fn(ccx.llmod, ~"rust_start", start_ty); let args = ~[rust_main, llvm::LLVMGetParam(llfn, 0 as c_uint), llvm::LLVMGetParam(llfn, 1 as c_uint), crate_map]; @@ -5078,14 +5083,14 @@ fn item_path(ccx: @crate_ctxt, i: @ast::item) -> path { /* If there's already a symbol for the dtor with <id> and substs <substs>, return it; otherwise, create one and register it, returning it as well */ fn get_dtor_symbol(ccx: @crate_ctxt, path: path, id: ast::node_id, - substs: option<param_substs>) -> str { + substs: option<param_substs>) -> ~str { let t = ty::node_id_to_type(ccx.tcx, id); alt ccx.item_symbols.find(id) { some(s) { s } none if is_none(substs) { let s = mangle_exported_name( ccx, - vec::append(path, ~[path_name(@ccx.names("dtor"))]), + vec::append(path, ~[path_name(@ccx.names(~"dtor"))]), t); ccx.item_symbols.insert(id, s); s @@ -5099,7 +5104,7 @@ fn get_dtor_symbol(ccx: @crate_ctxt, path: path, id: ast::node_id, mangle_exported_name( ccx, vec::append(path, - ~[path_name(@ccx.names("dtor"))]), + ~[path_name(@ccx.names(~"dtor"))]), mono_ty) } none { @@ -5144,7 +5149,7 @@ fn get_item_val(ccx: @crate_ctxt, id: ast::node_id) -> ValueRef { ast_map::node_method(m, impl_id, pth) { exprt = true; let mty = ty::node_id_to_type(ccx.tcx, id); - let pth = vec::append(*pth, ~[path_name(@ccx.names("meth")), + let pth = vec::append(*pth, ~[path_name(@ccx.names(~"meth")), path_name(m.ident)]); let llfn = register_fn_full(ccx, m.span, pth, id, mty); set_inline_hint_if_appr(m.attrs, llfn); @@ -5206,7 +5211,7 @@ fn get_item_val(ccx: @crate_ctxt, id: ast::node_id) -> ValueRef { // The constant translation pass. fn trans_constant(ccx: @crate_ctxt, it: @ast::item) { - let _icx = ccx.insn_ctxt("trans_constant"); + let _icx = ccx.insn_ctxt(~"trans_constant"); alt it.node { ast::item_enum(variants, _) { let vi = ty::enum_variants(ccx.tcx, {crate: ast::local_crate, @@ -5215,7 +5220,7 @@ fn trans_constant(ccx: @crate_ctxt, it: @ast::item) { let path = item_path(ccx, it); for vec::each(variants) |variant| { let p = vec::append(path, ~[path_name(variant.node.name), - path_name(@"discrim"/~)]); + path_name(@~"discrim")]); let s = mangle_exported_name(ccx, p, ty::mk_int(ccx.tcx)); let disr_val = vi[i].disr_val; note_unique_llvm_symbol(ccx, s); @@ -5250,7 +5255,7 @@ fn p2i(ccx: @crate_ctxt, v: ValueRef) -> ValueRef { ret llvm::LLVMConstPtrToInt(v, ccx.int_type); } -fn declare_intrinsics(llmod: ModuleRef) -> hashmap<str, ValueRef> { +fn declare_intrinsics(llmod: ModuleRef) -> hashmap<~str, ValueRef> { let T_memmove32_args: ~[TypeRef] = ~[T_ptr(T_i8()), T_ptr(T_i8()), T_i32(), T_i32(), T_i1()]; let T_memmove64_args: ~[TypeRef] = @@ -5262,67 +5267,67 @@ fn declare_intrinsics(llmod: ModuleRef) -> hashmap<str, ValueRef> { let T_trap_args: ~[TypeRef] = ~[]; let T_frameaddress_args: ~[TypeRef] = ~[T_i32()]; let gcroot = - decl_cdecl_fn(llmod, "llvm.gcroot", + decl_cdecl_fn(llmod, ~"llvm.gcroot", T_fn(~[T_ptr(T_ptr(T_i8())), T_ptr(T_i8())], T_void())); let gcread = - decl_cdecl_fn(llmod, "llvm.gcread", + decl_cdecl_fn(llmod, ~"llvm.gcread", T_fn(~[T_ptr(T_i8()), T_ptr(T_ptr(T_i8()))], T_void())); let memmove32 = - decl_cdecl_fn(llmod, "llvm.memmove.p0i8.p0i8.i32", + decl_cdecl_fn(llmod, ~"llvm.memmove.p0i8.p0i8.i32", T_fn(T_memmove32_args, T_void())); let memmove64 = - decl_cdecl_fn(llmod, "llvm.memmove.p0i8.p0i8.i64", + decl_cdecl_fn(llmod, ~"llvm.memmove.p0i8.p0i8.i64", T_fn(T_memmove64_args, T_void())); let memset32 = - decl_cdecl_fn(llmod, "llvm.memset.p0i8.i32", + decl_cdecl_fn(llmod, ~"llvm.memset.p0i8.i32", T_fn(T_memset32_args, T_void())); let memset64 = - decl_cdecl_fn(llmod, "llvm.memset.p0i8.i64", + decl_cdecl_fn(llmod, ~"llvm.memset.p0i8.i64", T_fn(T_memset64_args, T_void())); - let trap = decl_cdecl_fn(llmod, "llvm.trap", T_fn(T_trap_args, + let trap = decl_cdecl_fn(llmod, ~"llvm.trap", T_fn(T_trap_args, T_void())); - let frameaddress = decl_cdecl_fn(llmod, "llvm.frameaddress", + let frameaddress = decl_cdecl_fn(llmod, ~"llvm.frameaddress", T_fn(T_frameaddress_args, T_ptr(T_i8()))); let intrinsics = str_hash::<ValueRef>(); - intrinsics.insert("llvm.gcroot", gcroot); - intrinsics.insert("llvm.gcread", gcread); - intrinsics.insert("llvm.memmove.p0i8.p0i8.i32", memmove32); - intrinsics.insert("llvm.memmove.p0i8.p0i8.i64", memmove64); - intrinsics.insert("llvm.memset.p0i8.i32", memset32); - intrinsics.insert("llvm.memset.p0i8.i64", memset64); - intrinsics.insert("llvm.trap", trap); - intrinsics.insert("llvm.frameaddress", frameaddress); + intrinsics.insert(~"llvm.gcroot", gcroot); + intrinsics.insert(~"llvm.gcread", gcread); + intrinsics.insert(~"llvm.memmove.p0i8.p0i8.i32", memmove32); + intrinsics.insert(~"llvm.memmove.p0i8.p0i8.i64", memmove64); + intrinsics.insert(~"llvm.memset.p0i8.i32", memset32); + intrinsics.insert(~"llvm.memset.p0i8.i64", memset64); + intrinsics.insert(~"llvm.trap", trap); + intrinsics.insert(~"llvm.frameaddress", frameaddress); ret intrinsics; } fn declare_dbg_intrinsics(llmod: ModuleRef, - intrinsics: hashmap<str, ValueRef>) { + intrinsics: hashmap<~str, ValueRef>) { let declare = - decl_cdecl_fn(llmod, "llvm.dbg.declare", + decl_cdecl_fn(llmod, ~"llvm.dbg.declare", T_fn(~[T_metadata(), T_metadata()], T_void())); let value = - decl_cdecl_fn(llmod, "llvm.dbg.value", + decl_cdecl_fn(llmod, ~"llvm.dbg.value", T_fn(~[T_metadata(), T_i64(), T_metadata()], T_void())); - intrinsics.insert("llvm.dbg.declare", declare); - intrinsics.insert("llvm.dbg.value", value); + intrinsics.insert(~"llvm.dbg.declare", declare); + intrinsics.insert(~"llvm.dbg.value", value); } fn trap(bcx: block) { let v: ~[ValueRef] = ~[]; - alt bcx.ccx().intrinsics.find("llvm.trap") { + alt bcx.ccx().intrinsics.find(~"llvm.trap") { some(x) { Call(bcx, x, v); } - _ { bcx.sess().bug("unbound llvm.trap in trap"); } + _ { bcx.sess().bug(~"unbound llvm.trap in trap"); } } } fn create_module_map(ccx: @crate_ctxt) -> ValueRef { let elttype = T_struct(~[ccx.int_type, ccx.int_type]); let maptype = T_array(elttype, ccx.module_data.size() + 1u); - let map = str::as_c_str("_rust_mod_map", |buf| { + let map = str::as_c_str(~"_rust_mod_map", |buf| { llvm::LLVMAddGlobal(ccx.llmod, maptype, buf) }); lib::llvm::SetLinkage(map, lib::llvm::InternalLinkage); @@ -5347,9 +5352,9 @@ fn decl_crate_map(sess: session::session, mapmeta: link_meta, let cstore = sess.cstore; while cstore::have_crate_data(cstore, n_subcrates) { n_subcrates += 1; } let mapname = if sess.building_library { - *mapmeta.name + "_" + *mapmeta.vers + "_" + mapmeta.extras_hash - } else { "toplevel" }; - let sym_name = "_rust_crate_map_" + mapname; + *mapmeta.name + ~"_" + *mapmeta.vers + ~"_" + mapmeta.extras_hash + } else { ~"toplevel" }; + let sym_name = ~"_rust_crate_map_" + mapname; let arrtype = T_array(int_type, n_subcrates as uint); let maptype = T_struct(~[int_type, arrtype]); let map = str::as_c_str(sym_name, |buf| { @@ -5365,9 +5370,9 @@ fn fill_crate_map(ccx: @crate_ctxt, map: ValueRef) { let cstore = ccx.sess.cstore; while cstore::have_crate_data(cstore, i) { let cdata = cstore::get_crate_data(cstore, i); - let nm = "_rust_crate_map_" + cdata.name + - "_" + *cstore::get_crate_vers(cstore, i) + - "_" + *cstore::get_crate_hash(cstore, i); + let nm = ~"_rust_crate_map_" + cdata.name + + ~"_" + *cstore::get_crate_vers(cstore, i) + + ~"_" + *cstore::get_crate_hash(cstore, i); let cr = str::as_c_str(nm, |buf| { llvm::LLVMAddGlobal(ccx.llmod, ccx.int_type, buf) }); @@ -5399,7 +5404,7 @@ fn crate_ctxt_to_encode_parms(cx: @crate_ctxt) encode_inlined_item: encode_inlined_item }; - fn reexports(cx: @crate_ctxt) -> ~[(str, ast::def_id)] { + fn reexports(cx: @crate_ctxt) -> ~[(~str, ast::def_id)] { let mut reexports = ~[]; for cx.exp_map.each |exp_id, defs| { for defs.each |def| { @@ -5430,7 +5435,7 @@ fn write_metadata(cx: @crate_ctxt, crate: @ast::crate) { let encode_parms = crate_ctxt_to_encode_parms(cx); let llmeta = C_bytes(encoder::encode_metadata(encode_parms, crate)); let llconst = C_struct(~[llmeta]); - let mut llglobal = str::as_c_str("rust_metadata", |buf| { + let mut llglobal = str::as_c_str(~"rust_metadata", |buf| { llvm::LLVMAddGlobal(cx.llmod, val_ty(llconst), buf) }); llvm::LLVMSetInitializer(llglobal, llconst); @@ -5441,7 +5446,7 @@ fn write_metadata(cx: @crate_ctxt, crate: @ast::crate) { let t_ptr_i8 = T_ptr(T_i8()); llglobal = llvm::LLVMConstBitCast(llglobal, t_ptr_i8); - let llvm_used = str::as_c_str("llvm.used", |buf| { + let llvm_used = str::as_c_str(~"llvm.used", |buf| { llvm::LLVMAddGlobal(cx.llmod, T_array(t_ptr_i8, 1u), buf) }); lib::llvm::SetLinkage(llvm_used, lib::llvm::AppendingLinkage); @@ -5450,12 +5455,12 @@ fn write_metadata(cx: @crate_ctxt, crate: @ast::crate) { // Writes the current ABI version into the crate. fn write_abi_version(ccx: @crate_ctxt) { - mk_global(ccx, "rust_abi_version", C_uint(ccx, abi::abi_version), + mk_global(ccx, ~"rust_abi_version", C_uint(ccx, abi::abi_version), false); } fn trans_crate(sess: session::session, crate: @ast::crate, tcx: ty::ctxt, - output: str, emap: resolve::exp_map, + output: ~str, emap: resolve::exp_map, maps: astencode::maps) -> (ModuleRef, link_meta) { let sha = std::sha1::sha1(); @@ -5471,7 +5476,7 @@ fn trans_crate(sess: session::session, crate: @ast::crate, tcx: ty::ctxt, // crashes if the module identifer is same as other symbols // such as a function name in the module. // 1. http://llvm.org/bugs/show_bug.cgi?id=11479 - let llmod_id = *link_meta.name + ".rc"; + let llmod_id = *link_meta.name + ~".rc"; let llmod = str::as_c_str(llmod_id, |buf| { llvm::LLVMModuleCreateWithNameInContext @@ -5496,9 +5501,9 @@ fn trans_crate(sess: session::session, crate: @ast::crate, tcx: ty::ctxt, let float_type = T_float(targ_cfg); let task_type = T_task(targ_cfg); let taskptr_type = T_ptr(task_type); - lib::llvm::associate_type(tn, "taskptr", taskptr_type); + lib::llvm::associate_type(tn, ~"taskptr", taskptr_type); let tydesc_type = T_tydesc(targ_cfg); - lib::llvm::associate_type(tn, "tydesc", tydesc_type); + lib::llvm::associate_type(tn, ~"tydesc", tydesc_type); let crate_map = decl_crate_map(sess, link_meta, llmod); let dbg_cx = if sess.opts.debuginfo { option::some(debuginfo::mk_ctxt(llmod_id)) @@ -5516,12 +5521,12 @@ fn trans_crate(sess: session::session, crate: @ast::crate, tcx: ty::ctxt, item_vals: int_hash::<ValueRef>(), exp_map: emap, reachable: reachable, - item_symbols: int_hash::<str>(), + item_symbols: int_hash::<~str>(), mut main_fn: none::<ValueRef>, link_meta: link_meta, enum_sizes: ty::new_ty_hash(), discrims: ast_util::new_def_hash::<ValueRef>(), - discrim_symbols: int_hash::<str>(), + discrim_symbols: int_hash::<~str>(), tydescs: ty::new_ty_hash(), external: ast_util::new_def_hash(), monomorphized: map::hashmap(hash_mono_id, |a, b| a == b), @@ -5563,12 +5568,12 @@ fn trans_crate(sess: session::session, crate: @ast::crate, tcx: ty::ctxt, { - let _icx = ccx.insn_ctxt("data"); + let _icx = ccx.insn_ctxt(~"data"); trans_constants(ccx, crate); } { - let _icx = ccx.insn_ctxt("text"); + let _icx = ccx.insn_ctxt(~"text"); trans_mod(ccx, crate.node.module); } @@ -5580,7 +5585,7 @@ fn trans_crate(sess: session::session, crate: @ast::crate, tcx: ty::ctxt, // Translate the metadata. write_metadata(ccx, crate); if ccx.sess.trans_stats() { - io::println("--- trans stats ---"); + io::println(~"--- trans stats ---"); io::println(#fmt("n_static_tydescs: %u", ccx.stats.n_static_tydescs)); io::println(#fmt("n_glues_created: %u", diff --git a/src/rustc/middle/trans/build.rs b/src/rustc/middle/trans/build.rs index 8c261a402b4..3d6746aa2ea 100644 --- a/src/rustc/middle/trans/build.rs +++ b/src/rustc/middle/trans/build.rs @@ -15,7 +15,7 @@ fn B(cx: block) -> BuilderRef { ret b; } -fn count_insn(cx: block, category: str) { +fn count_insn(cx: block, category: ~str) { if cx.ccx().sess.count_llvm_insns() { let h = cx.ccx().stats.llvm_insns; @@ -36,17 +36,17 @@ fn count_insn(cx: block, category: str) { // Pass 2: concat strings for each elt, skipping // forwards over any cycles by advancing to rightmost // occurrence of each element in path. - let mut s = "."; + let mut s = ~"."; i = 0u; while i < len { let e = v[i]; i = mm.get(e); - s += "/"; + s += ~"/"; s += e; i += 1u; } - s += "/"; + s += ~"/"; s += category; let n = alt h.find(s) { some(n) { n } _ { 0u } }; @@ -67,7 +67,7 @@ fn RetVoid(cx: block) { if cx.unreachable { ret; } assert (!cx.terminated); cx.terminated = true; - count_insn(cx, "retvoid"); + count_insn(cx, ~"retvoid"); llvm::LLVMBuildRetVoid(B(cx)); } @@ -75,7 +75,7 @@ fn Ret(cx: block, V: ValueRef) { if cx.unreachable { ret; } assert (!cx.terminated); cx.terminated = true; - count_insn(cx, "ret"); + count_insn(cx, ~"ret"); llvm::LLVMBuildRet(B(cx), V); } @@ -93,7 +93,7 @@ fn Br(cx: block, Dest: BasicBlockRef) { if cx.unreachable { ret; } assert (!cx.terminated); cx.terminated = true; - count_insn(cx, "br"); + count_insn(cx, ~"br"); llvm::LLVMBuildBr(B(cx), Dest); } @@ -102,7 +102,7 @@ fn CondBr(cx: block, If: ValueRef, Then: BasicBlockRef, if cx.unreachable { ret; } assert (!cx.terminated); cx.terminated = true; - count_insn(cx, "condbr"); + count_insn(cx, ~"condbr"); llvm::LLVMBuildCondBr(B(cx), If, Then, Else); } @@ -123,7 +123,7 @@ fn IndirectBr(cx: block, Addr: ValueRef, NumDests: uint) { if cx.unreachable { ret; } assert (!cx.terminated); cx.terminated = true; - count_insn(cx, "indirectbr"); + count_insn(cx, ~"indirectbr"); llvm::LLVMBuildIndirectBr(B(cx), Addr, NumDests as c_uint); } @@ -142,9 +142,9 @@ fn Invoke(cx: block, Fn: ValueRef, Args: ~[ValueRef], #debug["Invoke(%s with arguments (%s))", val_str(cx.ccx().tn, Fn), str::connect(vec::map(Args, |a| val_str(cx.ccx().tn, a)), - ", ")]; + ~", ")]; unsafe { - count_insn(cx, "invoke"); + count_insn(cx, ~"invoke"); llvm::LLVMBuildInvoke(B(cx), Fn, vec::unsafe::to_ptr(Args), Args.len() as c_uint, Then, Catch, noname()); @@ -157,7 +157,7 @@ fn FastInvoke(cx: block, Fn: ValueRef, Args: ~[ValueRef], assert (!cx.terminated); cx.terminated = true; unsafe { - count_insn(cx, "fastinvoke"); + count_insn(cx, ~"fastinvoke"); let v = llvm::LLVMBuildInvoke(B(cx), Fn, vec::unsafe::to_ptr(Args), Args.len() as c_uint, Then, Catch, noname()); @@ -169,7 +169,7 @@ fn Unreachable(cx: block) { if cx.unreachable { ret; } cx.unreachable = true; if !cx.terminated { - count_insn(cx, "unreachable"); + count_insn(cx, ~"unreachable"); llvm::LLVMBuildUnreachable(B(cx)); } } @@ -181,218 +181,218 @@ fn _Undef(val: ValueRef) -> ValueRef { /* Arithmetic */ fn Add(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { if cx.unreachable { ret _Undef(LHS); } - count_insn(cx, "add"); + count_insn(cx, ~"add"); ret llvm::LLVMBuildAdd(B(cx), LHS, RHS, noname()); } fn NSWAdd(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { if cx.unreachable { ret _Undef(LHS); } - count_insn(cx, "nswadd"); + count_insn(cx, ~"nswadd"); ret llvm::LLVMBuildNSWAdd(B(cx), LHS, RHS, noname()); } fn NUWAdd(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { if cx.unreachable { ret _Undef(LHS); } - count_insn(cx, "nuwadd"); + count_insn(cx, ~"nuwadd"); ret llvm::LLVMBuildNUWAdd(B(cx), LHS, RHS, noname()); } fn FAdd(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { if cx.unreachable { ret _Undef(LHS); } - count_insn(cx, "fadd"); + count_insn(cx, ~"fadd"); ret llvm::LLVMBuildFAdd(B(cx), LHS, RHS, noname()); } fn Sub(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { if cx.unreachable { ret _Undef(LHS); } - count_insn(cx, "sub"); + count_insn(cx, ~"sub"); ret llvm::LLVMBuildSub(B(cx), LHS, RHS, noname()); } fn NSWSub(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { if cx.unreachable { ret _Undef(LHS); } - count_insn(cx, "nwsub"); + count_insn(cx, ~"nwsub"); ret llvm::LLVMBuildNSWSub(B(cx), LHS, RHS, noname()); } fn NUWSub(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { if cx.unreachable { ret _Undef(LHS); } - count_insn(cx, "nuwsub"); + count_insn(cx, ~"nuwsub"); ret llvm::LLVMBuildNUWSub(B(cx), LHS, RHS, noname()); } fn FSub(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { if cx.unreachable { ret _Undef(LHS); } - count_insn(cx, "sub"); + count_insn(cx, ~"sub"); ret llvm::LLVMBuildFSub(B(cx), LHS, RHS, noname()); } fn Mul(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { if cx.unreachable { ret _Undef(LHS); } - count_insn(cx, "mul"); + count_insn(cx, ~"mul"); ret llvm::LLVMBuildMul(B(cx), LHS, RHS, noname()); } fn NSWMul(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { if cx.unreachable { ret _Undef(LHS); } - count_insn(cx, "nswmul"); + count_insn(cx, ~"nswmul"); ret llvm::LLVMBuildNSWMul(B(cx), LHS, RHS, noname()); } fn NUWMul(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { if cx.unreachable { ret _Undef(LHS); } - count_insn(cx, "nuwmul"); + count_insn(cx, ~"nuwmul"); ret llvm::LLVMBuildNUWMul(B(cx), LHS, RHS, noname()); } fn FMul(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { if cx.unreachable { ret _Undef(LHS); } - count_insn(cx, "fmul"); + count_insn(cx, ~"fmul"); ret llvm::LLVMBuildFMul(B(cx), LHS, RHS, noname()); } fn UDiv(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { if cx.unreachable { ret _Undef(LHS); } - count_insn(cx, "udiv"); + count_insn(cx, ~"udiv"); ret llvm::LLVMBuildUDiv(B(cx), LHS, RHS, noname()); } fn SDiv(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { if cx.unreachable { ret _Undef(LHS); } - count_insn(cx, "sdiv"); + count_insn(cx, ~"sdiv"); ret llvm::LLVMBuildSDiv(B(cx), LHS, RHS, noname()); } fn ExactSDiv(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { if cx.unreachable { ret _Undef(LHS); } - count_insn(cx, "extractsdiv"); + count_insn(cx, ~"extractsdiv"); ret llvm::LLVMBuildExactSDiv(B(cx), LHS, RHS, noname()); } fn FDiv(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { if cx.unreachable { ret _Undef(LHS); } - count_insn(cx, "fdiv"); + count_insn(cx, ~"fdiv"); ret llvm::LLVMBuildFDiv(B(cx), LHS, RHS, noname()); } fn URem(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { if cx.unreachable { ret _Undef(LHS); } - count_insn(cx, "urem"); + count_insn(cx, ~"urem"); ret llvm::LLVMBuildURem(B(cx), LHS, RHS, noname()); } fn SRem(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { if cx.unreachable { ret _Undef(LHS); } - count_insn(cx, "srem"); + count_insn(cx, ~"srem"); ret llvm::LLVMBuildSRem(B(cx), LHS, RHS, noname()); } fn FRem(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { if cx.unreachable { ret _Undef(LHS); } - count_insn(cx, "frem"); + count_insn(cx, ~"frem"); ret llvm::LLVMBuildFRem(B(cx), LHS, RHS, noname()); } fn Shl(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { if cx.unreachable { ret _Undef(LHS); } - count_insn(cx, "shl"); + count_insn(cx, ~"shl"); ret llvm::LLVMBuildShl(B(cx), LHS, RHS, noname()); } fn LShr(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { if cx.unreachable { ret _Undef(LHS); } - count_insn(cx, "lshr"); + count_insn(cx, ~"lshr"); ret llvm::LLVMBuildLShr(B(cx), LHS, RHS, noname()); } fn AShr(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { if cx.unreachable { ret _Undef(LHS); } - count_insn(cx, "ashr"); + count_insn(cx, ~"ashr"); ret llvm::LLVMBuildAShr(B(cx), LHS, RHS, noname()); } fn And(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { if cx.unreachable { ret _Undef(LHS); } - count_insn(cx, "and"); + count_insn(cx, ~"and"); ret llvm::LLVMBuildAnd(B(cx), LHS, RHS, noname()); } fn Or(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { if cx.unreachable { ret _Undef(LHS); } - count_insn(cx, "or"); + count_insn(cx, ~"or"); ret llvm::LLVMBuildOr(B(cx), LHS, RHS, noname()); } fn Xor(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { if cx.unreachable { ret _Undef(LHS); } - count_insn(cx, "xor"); + count_insn(cx, ~"xor"); ret llvm::LLVMBuildXor(B(cx), LHS, RHS, noname()); } fn BinOp(cx: block, Op: Opcode, LHS: ValueRef, RHS: ValueRef) -> ValueRef { if cx.unreachable { ret _Undef(LHS); } - count_insn(cx, "binop"); + count_insn(cx, ~"binop"); ret llvm::LLVMBuildBinOp(B(cx), Op, LHS, RHS, noname()); } fn Neg(cx: block, V: ValueRef) -> ValueRef { if cx.unreachable { ret _Undef(V); } - count_insn(cx, "neg"); + count_insn(cx, ~"neg"); ret llvm::LLVMBuildNeg(B(cx), V, noname()); } fn NSWNeg(cx: block, V: ValueRef) -> ValueRef { if cx.unreachable { ret _Undef(V); } - count_insn(cx, "nswneg"); + count_insn(cx, ~"nswneg"); ret llvm::LLVMBuildNSWNeg(B(cx), V, noname()); } fn NUWNeg(cx: block, V: ValueRef) -> ValueRef { if cx.unreachable { ret _Undef(V); } - count_insn(cx, "nuwneg"); + count_insn(cx, ~"nuwneg"); ret llvm::LLVMBuildNUWNeg(B(cx), V, noname()); } fn FNeg(cx: block, V: ValueRef) -> ValueRef { if cx.unreachable { ret _Undef(V); } - count_insn(cx, "fneg"); + count_insn(cx, ~"fneg"); ret llvm::LLVMBuildFNeg(B(cx), V, noname()); } fn Not(cx: block, V: ValueRef) -> ValueRef { if cx.unreachable { ret _Undef(V); } - count_insn(cx, "not"); + count_insn(cx, ~"not"); ret llvm::LLVMBuildNot(B(cx), V, noname()); } /* Memory */ fn Malloc(cx: block, Ty: TypeRef) -> ValueRef { if cx.unreachable { ret llvm::LLVMGetUndef(T_ptr(T_i8())); } - count_insn(cx, "malloc"); + count_insn(cx, ~"malloc"); ret llvm::LLVMBuildMalloc(B(cx), Ty, noname()); } fn ArrayMalloc(cx: block, Ty: TypeRef, Val: ValueRef) -> ValueRef { if cx.unreachable { ret llvm::LLVMGetUndef(T_ptr(T_i8())); } - count_insn(cx, "arraymalloc"); + count_insn(cx, ~"arraymalloc"); ret llvm::LLVMBuildArrayMalloc(B(cx), Ty, Val, noname()); } fn Alloca(cx: block, Ty: TypeRef) -> ValueRef { if cx.unreachable { ret llvm::LLVMGetUndef(T_ptr(Ty)); } - count_insn(cx, "alloca"); + count_insn(cx, ~"alloca"); ret llvm::LLVMBuildAlloca(B(cx), Ty, noname()); } fn ArrayAlloca(cx: block, Ty: TypeRef, Val: ValueRef) -> ValueRef { if cx.unreachable { ret llvm::LLVMGetUndef(T_ptr(Ty)); } - count_insn(cx, "arrayalloca"); + count_insn(cx, ~"arrayalloca"); ret llvm::LLVMBuildArrayAlloca(B(cx), Ty, Val, noname()); } fn Free(cx: block, PointerVal: ValueRef) { if cx.unreachable { ret; } - count_insn(cx, "free"); + count_insn(cx, ~"free"); llvm::LLVMBuildFree(B(cx), PointerVal); } @@ -404,7 +404,7 @@ fn Load(cx: block, PointerVal: ValueRef) -> ValueRef { llvm::LLVMGetElementType(ty) } else { ccx.int_type }; ret llvm::LLVMGetUndef(eltty); } - count_insn(cx, "load"); + count_insn(cx, ~"load"); ret llvm::LLVMBuildLoad(B(cx), PointerVal, noname()); } @@ -413,14 +413,14 @@ fn Store(cx: block, Val: ValueRef, Ptr: ValueRef) { #debug["Store %s -> %s", val_str(cx.ccx().tn, Val), val_str(cx.ccx().tn, Ptr)]; - count_insn(cx, "store"); + count_insn(cx, ~"store"); llvm::LLVMBuildStore(B(cx), Val, Ptr); } fn GEP(cx: block, Pointer: ValueRef, Indices: ~[ValueRef]) -> ValueRef { if cx.unreachable { ret llvm::LLVMGetUndef(T_ptr(T_nil())); } unsafe { - count_insn(cx, "gep"); + count_insn(cx, ~"gep"); ret llvm::LLVMBuildGEP(B(cx), Pointer, vec::unsafe::to_ptr(Indices), Indices.len() as c_uint, noname()); } @@ -431,7 +431,7 @@ fn GEP(cx: block, Pointer: ValueRef, Indices: ~[ValueRef]) -> ValueRef { fn GEPi(cx: block, base: ValueRef, ixs: ~[uint]) -> ValueRef { let mut v: ~[ValueRef] = ~[]; for vec::each(ixs) |i| { vec::push(v, C_i32(i as i32)); } - count_insn(cx, "gepi"); + count_insn(cx, ~"gepi"); ret InBoundsGEP(cx, base, v); } @@ -439,7 +439,7 @@ fn InBoundsGEP(cx: block, Pointer: ValueRef, Indices: ~[ValueRef]) -> ValueRef { if cx.unreachable { ret llvm::LLVMGetUndef(T_ptr(T_nil())); } unsafe { - count_insn(cx, "inboundsgep"); + count_insn(cx, ~"inboundsgep"); ret llvm::LLVMBuildInBoundsGEP(B(cx), Pointer, vec::unsafe::to_ptr(Indices), Indices.len() as c_uint, @@ -449,138 +449,138 @@ fn InBoundsGEP(cx: block, Pointer: ValueRef, Indices: ~[ValueRef]) -> fn StructGEP(cx: block, Pointer: ValueRef, Idx: uint) -> ValueRef { if cx.unreachable { ret llvm::LLVMGetUndef(T_ptr(T_nil())); } - count_insn(cx, "structgep"); + count_insn(cx, ~"structgep"); ret llvm::LLVMBuildStructGEP(B(cx), Pointer, Idx as c_uint, noname()); } fn GlobalString(cx: block, _Str: *libc::c_char) -> ValueRef { if cx.unreachable { ret llvm::LLVMGetUndef(T_ptr(T_i8())); } - count_insn(cx, "globalstring"); + count_insn(cx, ~"globalstring"); ret llvm::LLVMBuildGlobalString(B(cx), _Str, noname()); } fn GlobalStringPtr(cx: block, _Str: *libc::c_char) -> ValueRef { if cx.unreachable { ret llvm::LLVMGetUndef(T_ptr(T_i8())); } - count_insn(cx, "globalstringptr"); + count_insn(cx, ~"globalstringptr"); ret llvm::LLVMBuildGlobalStringPtr(B(cx), _Str, noname()); } /* Casts */ fn Trunc(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef { if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } - count_insn(cx, "trunc"); + count_insn(cx, ~"trunc"); ret llvm::LLVMBuildTrunc(B(cx), Val, DestTy, noname()); } fn ZExt(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef { if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } - count_insn(cx, "zext"); + count_insn(cx, ~"zext"); ret llvm::LLVMBuildZExt(B(cx), Val, DestTy, noname()); } fn SExt(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef { if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } - count_insn(cx, "sext"); + count_insn(cx, ~"sext"); ret llvm::LLVMBuildSExt(B(cx), Val, DestTy, noname()); } fn FPToUI(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef { if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } - count_insn(cx, "fptoui"); + count_insn(cx, ~"fptoui"); ret llvm::LLVMBuildFPToUI(B(cx), Val, DestTy, noname()); } fn FPToSI(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef { if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } - count_insn(cx, "fptosi"); + count_insn(cx, ~"fptosi"); ret llvm::LLVMBuildFPToSI(B(cx), Val, DestTy, noname()); } fn UIToFP(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef { if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } - count_insn(cx, "uitofp"); + count_insn(cx, ~"uitofp"); ret llvm::LLVMBuildUIToFP(B(cx), Val, DestTy, noname()); } fn SIToFP(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef { if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } - count_insn(cx, "sitofp"); + count_insn(cx, ~"sitofp"); ret llvm::LLVMBuildSIToFP(B(cx), Val, DestTy, noname()); } fn FPTrunc(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef { if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } - count_insn(cx, "fptrunc"); + count_insn(cx, ~"fptrunc"); ret llvm::LLVMBuildFPTrunc(B(cx), Val, DestTy, noname()); } fn FPExt(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef { if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } - count_insn(cx, "fpext"); + count_insn(cx, ~"fpext"); ret llvm::LLVMBuildFPExt(B(cx), Val, DestTy, noname()); } fn PtrToInt(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef { if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } - count_insn(cx, "ptrtoint"); + count_insn(cx, ~"ptrtoint"); ret llvm::LLVMBuildPtrToInt(B(cx), Val, DestTy, noname()); } fn IntToPtr(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef { if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } - count_insn(cx, "inttoptr"); + count_insn(cx, ~"inttoptr"); ret llvm::LLVMBuildIntToPtr(B(cx), Val, DestTy, noname()); } fn BitCast(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef { if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } - count_insn(cx, "bitcast"); + count_insn(cx, ~"bitcast"); ret llvm::LLVMBuildBitCast(B(cx), Val, DestTy, noname()); } fn ZExtOrBitCast(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef { if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } - count_insn(cx, "zextorbitcast"); + count_insn(cx, ~"zextorbitcast"); ret llvm::LLVMBuildZExtOrBitCast(B(cx), Val, DestTy, noname()); } fn SExtOrBitCast(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef { if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } - count_insn(cx, "sextorbitcast"); + count_insn(cx, ~"sextorbitcast"); ret llvm::LLVMBuildSExtOrBitCast(B(cx), Val, DestTy, noname()); } fn TruncOrBitCast(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef { if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } - count_insn(cx, "truncorbitcast"); + count_insn(cx, ~"truncorbitcast"); ret llvm::LLVMBuildTruncOrBitCast(B(cx), Val, DestTy, noname()); } fn Cast(cx: block, Op: Opcode, Val: ValueRef, DestTy: TypeRef, _Name: *u8) -> ValueRef { if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } - count_insn(cx, "cast"); + count_insn(cx, ~"cast"); ret llvm::LLVMBuildCast(B(cx), Op, Val, DestTy, noname()); } fn PointerCast(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef { if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } - count_insn(cx, "pointercast"); + count_insn(cx, ~"pointercast"); ret llvm::LLVMBuildPointerCast(B(cx), Val, DestTy, noname()); } fn IntCast(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef { if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } - count_insn(cx, "intcast"); + count_insn(cx, ~"intcast"); ret llvm::LLVMBuildIntCast(B(cx), Val, DestTy, noname()); } fn FPCast(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef { if cx.unreachable { ret llvm::LLVMGetUndef(DestTy); } - count_insn(cx, "fpcast"); + count_insn(cx, ~"fpcast"); ret llvm::LLVMBuildFPCast(B(cx), Val, DestTy, noname()); } @@ -589,21 +589,21 @@ fn FPCast(cx: block, Val: ValueRef, DestTy: TypeRef) -> ValueRef { fn ICmp(cx: block, Op: IntPredicate, LHS: ValueRef, RHS: ValueRef) -> ValueRef { if cx.unreachable { ret llvm::LLVMGetUndef(T_i1()); } - count_insn(cx, "icmp"); + count_insn(cx, ~"icmp"); ret llvm::LLVMBuildICmp(B(cx), Op as c_uint, LHS, RHS, noname()); } fn FCmp(cx: block, Op: RealPredicate, LHS: ValueRef, RHS: ValueRef) -> ValueRef { if cx.unreachable { ret llvm::LLVMGetUndef(T_i1()); } - count_insn(cx, "fcmp"); + count_insn(cx, ~"fcmp"); ret llvm::LLVMBuildFCmp(B(cx), Op as c_uint, LHS, RHS, noname()); } /* Miscellaneous instructions */ fn EmptyPhi(cx: block, Ty: TypeRef) -> ValueRef { if cx.unreachable { ret llvm::LLVMGetUndef(Ty); } - count_insn(cx, "emptyphi"); + count_insn(cx, ~"emptyphi"); ret llvm::LLVMBuildPhi(B(cx), Ty, noname()); } @@ -613,7 +613,7 @@ fn Phi(cx: block, Ty: TypeRef, vals: ~[ValueRef], bbs: ~[BasicBlockRef]) assert vals.len() == bbs.len(); let phi = EmptyPhi(cx, Ty); unsafe { - count_insn(cx, "addincoming"); + count_insn(cx, ~"addincoming"); llvm::LLVMAddIncoming(phi, vec::unsafe::to_ptr(vals), vec::unsafe::to_ptr(bbs), vals.len() as c_uint); @@ -635,28 +635,28 @@ fn _UndefReturn(cx: block, Fn: ValueRef) -> ValueRef { let ty = val_ty(Fn); let retty = if llvm::LLVMGetTypeKind(ty) == lib::llvm::Integer { llvm::LLVMGetReturnType(ty) } else { ccx.int_type }; - count_insn(cx, ""); + count_insn(cx, ~""); ret llvm::LLVMGetUndef(retty); } -fn add_span_comment(bcx: block, sp: span, text: str) { +fn add_span_comment(bcx: block, sp: span, text: ~str) { let ccx = bcx.ccx(); if !ccx.sess.no_asm_comments() { - let s = text + " (" + codemap::span_to_str(sp, ccx.sess.codemap) - + ")"; + let s = text + ~" (" + codemap::span_to_str(sp, ccx.sess.codemap) + + ~")"; log(debug, s); add_comment(bcx, s); } } -fn add_comment(bcx: block, text: str) { +fn add_comment(bcx: block, text: ~str) { let ccx = bcx.ccx(); if !ccx.sess.no_asm_comments() { - let sanitized = str::replace(text, "$", ""); - let comment_text = "# " + sanitized; + let sanitized = str::replace(text, ~"$", ~""); + let comment_text = ~"# " + sanitized; let asm = str::as_c_str(comment_text, |c| { - str::as_c_str("", |e| { - count_insn(bcx, "inlineasm"); + str::as_c_str(~"", |e| { + count_insn(bcx, ~"inlineasm"); llvm::LLVMConstInlineAsm(T_fn(~[], T_void()), c, e, False, False) }) @@ -668,7 +668,7 @@ fn add_comment(bcx: block, text: str) { fn Call(cx: block, Fn: ValueRef, Args: ~[ValueRef]) -> ValueRef { if cx.unreachable { ret _UndefReturn(cx, Fn); } unsafe { - count_insn(cx, "call"); + count_insn(cx, ~"call"); #debug["Call(Fn=%s, Args=%?)", val_str(cx.ccx().tn, Fn), @@ -682,7 +682,7 @@ fn Call(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"); + count_insn(cx, ~"fastcall"); let v = llvm::LLVMBuildCall(B(cx), Fn, vec::unsafe::to_ptr(Args), Args.len() as c_uint, noname()); lib::llvm::SetInstructionCallConv(v, lib::llvm::FastCallConv); @@ -694,7 +694,7 @@ fn CallWithConv(cx: block, Fn: ValueRef, Args: ~[ValueRef], Conv: CallConv) -> ValueRef { if cx.unreachable { ret _UndefReturn(cx, Fn); } unsafe { - count_insn(cx, "callwithconv"); + count_insn(cx, ~"callwithconv"); let v = llvm::LLVMBuildCall(B(cx), Fn, vec::unsafe::to_ptr(Args), Args.len() as c_uint, noname()); lib::llvm::SetInstructionCallConv(v, Conv); @@ -705,67 +705,67 @@ fn CallWithConv(cx: block, Fn: ValueRef, Args: ~[ValueRef], fn Select(cx: block, If: ValueRef, Then: ValueRef, Else: ValueRef) -> ValueRef { if cx.unreachable { ret _Undef(Then); } - count_insn(cx, "select"); + count_insn(cx, ~"select"); ret llvm::LLVMBuildSelect(B(cx), If, Then, Else, noname()); } fn VAArg(cx: block, list: ValueRef, Ty: TypeRef) -> ValueRef { if cx.unreachable { ret llvm::LLVMGetUndef(Ty); } - count_insn(cx, "vaarg"); + count_insn(cx, ~"vaarg"); ret llvm::LLVMBuildVAArg(B(cx), list, Ty, noname()); } fn ExtractElement(cx: block, VecVal: ValueRef, Index: ValueRef) -> ValueRef { if cx.unreachable { ret llvm::LLVMGetUndef(T_nil()); } - count_insn(cx, "extractelement"); + count_insn(cx, ~"extractelement"); ret llvm::LLVMBuildExtractElement(B(cx), VecVal, Index, noname()); } fn InsertElement(cx: block, VecVal: ValueRef, EltVal: ValueRef, Index: ValueRef) { if cx.unreachable { ret; } - count_insn(cx, "insertelement"); + count_insn(cx, ~"insertelement"); llvm::LLVMBuildInsertElement(B(cx), VecVal, EltVal, Index, noname()); } fn ShuffleVector(cx: block, V1: ValueRef, V2: ValueRef, Mask: ValueRef) { if cx.unreachable { ret; } - count_insn(cx, "shufflevector"); + count_insn(cx, ~"shufflevector"); llvm::LLVMBuildShuffleVector(B(cx), V1, V2, Mask, noname()); } fn ExtractValue(cx: block, AggVal: ValueRef, Index: uint) -> ValueRef { if cx.unreachable { ret llvm::LLVMGetUndef(T_nil()); } - count_insn(cx, "extractvalue"); + count_insn(cx, ~"extractvalue"); ret llvm::LLVMBuildExtractValue(B(cx), AggVal, Index as c_uint, noname()); } fn InsertValue(cx: block, AggVal: ValueRef, EltVal: ValueRef, Index: uint) { if cx.unreachable { ret; } - count_insn(cx, "insertvalue"); + count_insn(cx, ~"insertvalue"); llvm::LLVMBuildInsertValue(B(cx), AggVal, EltVal, Index as c_uint, noname()); } fn IsNull(cx: block, Val: ValueRef) -> ValueRef { if cx.unreachable { ret llvm::LLVMGetUndef(T_i1()); } - count_insn(cx, "isnull"); + count_insn(cx, ~"isnull"); ret llvm::LLVMBuildIsNull(B(cx), Val, noname()); } fn IsNotNull(cx: block, Val: ValueRef) -> ValueRef { if cx.unreachable { ret llvm::LLVMGetUndef(T_i1()); } - count_insn(cx, "isnotnull"); + count_insn(cx, ~"isnotnull"); ret llvm::LLVMBuildIsNotNull(B(cx), Val, noname()); } fn PtrDiff(cx: block, LHS: ValueRef, RHS: ValueRef) -> ValueRef { let ccx = cx.fcx.ccx; if cx.unreachable { ret llvm::LLVMGetUndef(ccx.int_type); } - count_insn(cx, "ptrdiff"); + count_insn(cx, ~"ptrdiff"); ret llvm::LLVMBuildPtrDiff(B(cx), LHS, RHS, noname()); } @@ -775,13 +775,13 @@ fn Trap(cx: block) { let BB: BasicBlockRef = llvm::LLVMGetInsertBlock(b); let FN: ValueRef = llvm::LLVMGetBasicBlockParent(BB); let M: ModuleRef = llvm::LLVMGetGlobalParent(FN); - let T: ValueRef = str::as_c_str("llvm.trap", |buf| { + let T: ValueRef = str::as_c_str(~"llvm.trap", |buf| { llvm::LLVMGetNamedFunction(M, buf) }); assert (T as int != 0); let Args: ~[ValueRef] = ~[]; unsafe { - count_insn(cx, "trap"); + count_insn(cx, ~"trap"); llvm::LLVMBuildCall(b, T, vec::unsafe::to_ptr(Args), Args.len() as c_uint, noname()); } @@ -790,20 +790,20 @@ fn Trap(cx: block) { fn LandingPad(cx: block, Ty: TypeRef, PersFn: ValueRef, NumClauses: uint) -> ValueRef { assert !cx.terminated && !cx.unreachable; - count_insn(cx, "landingpad"); + count_insn(cx, ~"landingpad"); ret llvm::LLVMBuildLandingPad(B(cx), Ty, PersFn, NumClauses as c_uint, noname()); } fn SetCleanup(cx: block, LandingPad: ValueRef) { - count_insn(cx, "setcleanup"); + count_insn(cx, ~"setcleanup"); llvm::LLVMSetCleanup(LandingPad, lib::llvm::True); } fn Resume(cx: block, Exn: ValueRef) -> ValueRef { assert (!cx.terminated); cx.terminated = true; - count_insn(cx, "resume"); + count_insn(cx, ~"resume"); ret llvm::LLVMBuildResume(B(cx), Exn); } diff --git a/src/rustc/middle/trans/closure.rs b/src/rustc/middle/trans/closure.rs index 6b90ec30ab3..22d16efbae5 100644 --- a/src/rustc/middle/trans/closure.rs +++ b/src/rustc/middle/trans/closure.rs @@ -100,7 +100,7 @@ enum environment_value { env_ref(ValueRef, ty::t, lval_kind), } -fn ev_to_str(ccx: @crate_ctxt, ev: environment_value) -> str { +fn ev_to_str(ccx: @crate_ctxt, ev: environment_value) -> ~str { alt ev { env_copy(v, t, lk) { #fmt("copy(%s,%s)", val_str(ccx.tn, v), ty_to_str(ccx.tcx, t)) } @@ -139,11 +139,11 @@ fn allocate_cbox(bcx: block, ck: ty::closure_kind, cdata_ty: ty::t) -> ValueRef { - let _icx = bcx.insn_ctxt("closure::allocate_cbox"); + let _icx = bcx.insn_ctxt(~"closure::allocate_cbox"); let ccx = bcx.ccx(), tcx = ccx.tcx; fn nuke_ref_count(bcx: block, llbox: ValueRef) { - let _icx = bcx.insn_ctxt("closure::nuke_ref_count"); + let _icx = bcx.insn_ctxt(~"closure::nuke_ref_count"); // Initialize ref count to arbitrary value for debugging: let ccx = bcx.ccx(); let llbox = PointerCast(bcx, llbox, T_opaque_box_ptr(ccx)); @@ -184,7 +184,7 @@ type closure_result = { fn store_environment(bcx: block, bound_values: ~[environment_value], ck: ty::closure_kind) -> closure_result { - let _icx = bcx.insn_ctxt("closure::store_environment"); + let _icx = bcx.insn_ctxt(~"closure::store_environment"); let ccx = bcx.ccx(), tcx = ccx.tcx; // compute the shape of the closure @@ -224,7 +224,7 @@ fn store_environment(bcx: block, bcx = base::copy_val(bcx, INIT, bound_data, val, ty); } env_copy(_, _, temporary) { - fail "cannot capture temporary upvar"; + fail ~"cannot capture temporary upvar"; } env_move(val, ty, kind) { let src = {bcx:bcx, val:val, kind:kind}; @@ -241,7 +241,7 @@ fn store_environment(bcx: block, Store(bcx, addr, bound_data); } env_ref(_, _, temporary) { - fail "cannot capture temporary upvar"; + fail ~"cannot capture temporary upvar"; } } } @@ -257,7 +257,7 @@ fn build_closure(bcx0: block, ck: ty::closure_kind, id: ast::node_id, include_ret_handle: option<ValueRef>) -> closure_result { - let _icx = bcx0.insn_ctxt("closure::build_closure"); + 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 bcx = bcx0; @@ -318,7 +318,7 @@ fn load_environment(fcx: fn_ctxt, cap_vars: ~[capture::capture_var], load_ret_handle: bool, ck: ty::closure_kind) { - let _icx = fcx.insn_ctxt("closure::load_environment"); + let _icx = fcx.insn_ctxt(~"closure::load_environment"); let bcx = raw_block(fcx, fcx.llloadenv); // Load a pointer to the closure data, skipping over the box header: @@ -360,12 +360,12 @@ fn trans_expr_fn(bcx: block, cap_clause: ast::capture_clause, is_loop_body: option<option<ValueRef>>, dest: dest) -> block { - let _icx = bcx.insn_ctxt("closure::trans_expr_fn"); + let _icx = bcx.insn_ctxt(~"closure::trans_expr_fn"); if dest == ignore { ret bcx; } 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 = vec::append_one(bcx.fcx.path, path_name(@"anon"/~)); + let sub_path = vec::append_one(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); @@ -407,7 +407,7 @@ fn make_fn_glue( t: ty::t, glue_fn: fn@(block, v: ValueRef, t: ty::t) -> block) -> block { - let _icx = cx.insn_ctxt("closure::make_fn_glue"); + let _icx = cx.insn_ctxt(~"closure::make_fn_glue"); let bcx = cx; let tcx = cx.tcx(); @@ -426,7 +426,7 @@ fn make_fn_glue( ty::ty_fn({proto: ast::proto_any, _}) { bcx } ty::ty_fn({proto: ast::proto_uniq, _}) { fn_env(ty::ck_uniq) } ty::ty_fn({proto: ast::proto_box, _}) { fn_env(ty::ck_box) } - _ { fail "make_fn_glue invoked on non-function type" } + _ { fail ~"make_fn_glue invoked on non-function type" } }; } @@ -436,7 +436,7 @@ fn make_opaque_cbox_take_glue( cboxptr: ValueRef) // ptr to ptr to the opaque closure -> block { // Easy cases: - let _icx = bcx.insn_ctxt("closure::make_opaque_cbox_take_glue"); + let _icx = bcx.insn_ctxt(~"closure::make_opaque_cbox_take_glue"); alt ck { ty::ck_block { ret bcx; } ty::ck_box { incr_refcnt_of_boxed(bcx, Load(bcx, cboxptr)); ret bcx; } @@ -482,7 +482,7 @@ fn make_opaque_cbox_drop_glue( ck: ty::closure_kind, cboxptr: ValueRef) // ptr to the opaque closure -> block { - let _icx = bcx.insn_ctxt("closure::make_opaque_cbox_drop_glue"); + let _icx = bcx.insn_ctxt(~"closure::make_opaque_cbox_drop_glue"); alt ck { ty::ck_block { bcx } ty::ck_box { @@ -501,7 +501,7 @@ fn make_opaque_cbox_free_glue( ck: ty::closure_kind, cbox: ValueRef) // ptr to the opaque closure -> block { - let _icx = bcx.insn_ctxt("closure::make_opaque_cbox_free_glue"); + let _icx = bcx.insn_ctxt(~"closure::make_opaque_cbox_free_glue"); alt ck { ty::ck_block { ret bcx; } ty::ck_box | ty::ck_uniq { /* hard cases: */ } @@ -523,7 +523,7 @@ fn make_opaque_cbox_free_glue( // Free the ty descr (if necc) and the box itself alt ck { - ty::ck_block { fail "Impossible"; } + ty::ck_block { fail ~"Impossible"; } ty::ck_box { trans_free(bcx, cbox) } diff --git a/src/rustc/middle/trans/common.rs b/src/rustc/middle/trans/common.rs index 4995713fbdb..13f5b2f8470 100644 --- a/src/rustc/middle/trans/common.rs +++ b/src/rustc/middle/trans/common.rs @@ -21,10 +21,10 @@ import metadata::common::link_meta; import syntax::ast_map::path; import util::ppaux::ty_to_str; -type namegen = fn@(str) -> str; +type namegen = fn@(~str) -> ~str; fn new_namegen() -> namegen { let i = @mut 0; - ret fn@(prefix: str) -> str { *i += 1; prefix + int::str(*i) }; + ret fn@(prefix: ~str) -> ~str { *i += 1; prefix + int::str(*i) }; } type tydesc_info = @@ -68,9 +68,9 @@ type stats = mut n_glues_created: uint, mut n_null_glues: uint, mut n_real_glues: uint, - llvm_insn_ctxt: @mut ~[str], - llvm_insns: hashmap<str, uint>, - fn_times: @mut ~[{ident: str, time: int}]}; + llvm_insn_ctxt: @mut ~[~str], + llvm_insns: hashmap<~str, uint>, + fn_times: @mut ~[{ident: ~str, time: int}]}; class BuilderRef_res { let B: BuilderRef; @@ -84,17 +84,17 @@ type crate_ctxt = { llmod: ModuleRef, td: target_data, tn: type_names, - externs: hashmap<str, ValueRef>, - intrinsics: hashmap<str, ValueRef>, + externs: hashmap<~str, ValueRef>, + intrinsics: hashmap<~str, ValueRef>, item_vals: hashmap<ast::node_id, ValueRef>, exp_map: resolve::exp_map, reachable: reachable::map, - item_symbols: hashmap<ast::node_id, str>, + item_symbols: hashmap<ast::node_id, ~str>, mut main_fn: option<ValueRef>, link_meta: link_meta, enum_sizes: hashmap<ty::t, uint>, discrims: hashmap<ast::def_id, ValueRef>, - discrim_symbols: hashmap<ast::node_id, str>, + discrim_symbols: hashmap<ast::node_id, ~str>, tydescs: hashmap<ty::t, @tydesc_info>, // Track mapping of external ids to local items imported for inlining external: hashmap<ast::def_id, option<ast::node_id>>, @@ -106,14 +106,14 @@ type crate_ctxt = { // Cache generated vtables vtables: hashmap<mono_id, ValueRef>, // Cache of constant strings, - const_cstr_cache: hashmap<str, ValueRef>, - module_data: hashmap<str, ValueRef>, + const_cstr_cache: hashmap<~str, ValueRef>, + module_data: hashmap<~str, ValueRef>, lltypes: hashmap<ty::t, TypeRef>, names: namegen, sha: std::sha1::sha1, - type_sha1s: hashmap<ty::t, str>, - type_short_names: hashmap<ty::t, str>, - all_llvm_symbols: set<str>, + type_sha1s: hashmap<ty::t, ~str>, + type_short_names: hashmap<ty::t, ~str>, + all_llvm_symbols: set<~str>, tcx: ty::ctxt, maps: astencode::maps, stats: stats, @@ -204,10 +204,10 @@ type fn_ctxt = @{ ccx: @crate_ctxt }; -fn warn_not_to_commit(ccx: @crate_ctxt, msg: str) { +fn warn_not_to_commit(ccx: @crate_ctxt, msg: ~str) { if !ccx.do_not_commit_warning_issued { ccx.do_not_commit_warning_issued = true; - ccx.sess.warn(msg + " -- do not commit like this!"); + ccx.sess.warn(msg + ~" -- do not commit like this!"); } } @@ -421,13 +421,13 @@ fn rslt(bcx: block, val: ValueRef) -> result { {bcx: bcx, val: val} } -fn ty_str(tn: type_names, t: TypeRef) -> str { +fn ty_str(tn: type_names, t: TypeRef) -> ~str { ret lib::llvm::type_to_str(tn, t); } fn val_ty(v: ValueRef) -> TypeRef { ret llvm::LLVMTypeOf(v); } -fn val_str(tn: type_names, v: ValueRef) -> str { ret ty_str(tn, val_ty(v)); } +fn val_str(tn: type_names, v: ValueRef) -> ~str { ret ty_str(tn, val_ty(v)); } // Returns the nth element of the given LLVM structure type. fn struct_elt(llstructty: TypeRef, n: uint) -> TypeRef unsafe { @@ -464,13 +464,13 @@ impl bcx_cxs for block { pure fn tcx() -> ty::ctxt { self.fcx.ccx.tcx } pure fn sess() -> session { self.fcx.ccx.sess } - fn val_str(val: ValueRef) -> str { + fn val_str(val: ValueRef) -> ~str { val_str(self.ccx().tn, val) } - fn ty_to_str(t: ty::t) -> str { + fn ty_to_str(t: ty::t) -> ~str { ty_to_str(self.tcx(), t) } - fn to_str() -> str { + fn to_str() -> ~str { alt self.node_info { some(node_info) { #fmt["[block %d]", node_info.id] @@ -591,7 +591,7 @@ fn T_struct(elts: ~[TypeRef]) -> TypeRef unsafe { ret llvm::LLVMStructType(to_ptr(elts), elts.len() as c_uint, False); } -fn T_named_struct(name: str) -> TypeRef { +fn T_named_struct(name: ~str) -> TypeRef { let c = llvm::LLVMGetGlobalContext(); ret str::as_c_str(name, |buf| llvm::LLVMStructCreateNamed(c, buf)); } @@ -610,7 +610,7 @@ fn T_empty_struct() -> TypeRef { ret T_struct(~[]); } fn T_vtable() -> TypeRef { T_array(T_ptr(T_i8()), 1u) } fn T_task(targ_cfg: @session::config) -> TypeRef { - let t = T_named_struct("task"); + let t = T_named_struct(~"task"); // Refcount // Delegate pointer @@ -644,7 +644,7 @@ fn T_tydesc_field(cx: @crate_ctxt, field: uint) -> TypeRef unsafe { } fn T_glue_fn(cx: @crate_ctxt) -> TypeRef { - let s = "glue_fn"; + let s = ~"glue_fn"; alt name_has_type(cx.tn, s) { some(t) { ret t; } _ {} } let t = T_tydesc_field(cx, abi::tydesc_field_drop_glue); associate_type(cx.tn, s, t); @@ -652,7 +652,7 @@ fn T_glue_fn(cx: @crate_ctxt) -> TypeRef { } fn T_tydesc(targ_cfg: @session::config) -> TypeRef { - let tydesc = T_named_struct("tydesc"); + let tydesc = T_named_struct(~"tydesc"); let tydescpp = T_ptr(T_ptr(tydesc)); let pvoid = T_ptr(T_i8()); let glue_fn_ty = @@ -748,7 +748,7 @@ fn T_taskptr(cx: @crate_ctxt) -> TypeRef { ret T_ptr(cx.task_type); } // This type must never be used directly; it must always be cast away. fn T_typaram(tn: type_names) -> TypeRef { - let s = "typaram"; + let s = ~"typaram"; alt name_has_type(tn, s) { some(t) { ret t; } _ {} } let t = T_i8(); associate_type(tn, s, t); @@ -768,7 +768,7 @@ fn T_enum_discrim(cx: @crate_ctxt) -> TypeRef { } fn T_opaque_enum(cx: @crate_ctxt) -> TypeRef { - let s = "opaque_enum"; + 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()]); associate_type(cx.tn, s, t); @@ -799,7 +799,7 @@ fn C_integral(t: TypeRef, u: u64, sign_extend: Bool) -> ValueRef { ret llvm::LLVMConstInt(t, u, sign_extend); } -fn C_floating(s: str, t: TypeRef) -> ValueRef { +fn C_floating(s: ~str, t: TypeRef) -> ValueRef { ret str::as_c_str(s, |buf| llvm::LLVMConstRealOfString(t, buf)); } @@ -834,7 +834,7 @@ fn C_u8(i: uint) -> ValueRef { ret C_integral(T_i8(), i as u64, False); } // This is a 'c-like' raw string, which differs from // our boxed-and-length-annotated strings. -fn C_cstr(cx: @crate_ctxt, s: str) -> ValueRef { +fn C_cstr(cx: @crate_ctxt, s: ~str) -> ValueRef { alt cx.const_cstr_cache.find(s) { some(llval) { ret llval; } none { } @@ -844,7 +844,7 @@ fn C_cstr(cx: @crate_ctxt, s: str) -> ValueRef { llvm::LLVMConstString(buf, str::len(s) as c_uint, False) }; let g = - str::as_c_str(cx.names("str"), + str::as_c_str(cx.names(~"str"), |buf| llvm::LLVMAddGlobal(cx.llmod, val_ty(sc), buf)); llvm::LLVMSetInitializer(g, sc); llvm::LLVMSetGlobalConstant(g, True); @@ -855,13 +855,13 @@ fn C_cstr(cx: @crate_ctxt, s: str) -> ValueRef { ret g; } -fn C_estr_slice(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 */)]) } // Returns a Plain Old LLVM String: -fn C_postr(s: str) -> ValueRef { +fn C_postr(s: ~str) -> ValueRef { ret do str::as_c_str(s) |buf| { llvm::LLVMConstString(buf, str::len(s) as c_uint, False) }; @@ -898,7 +898,7 @@ fn C_bytes(bytes: ~[u8]) -> ValueRef unsafe { fn C_shape(ccx: @crate_ctxt, bytes: ~[u8]) -> ValueRef { let llshape = C_bytes(bytes); - let llglobal = str::as_c_str(ccx.names("shape"), |buf| { + let llglobal = str::as_c_str(ccx.names(~"shape"), |buf| { llvm::LLVMAddGlobal(ccx.llmod, val_ty(llshape), buf) }); llvm::LLVMSetInitializer(llglobal, llshape); @@ -952,12 +952,12 @@ fn align_to(cx: block, off: ValueRef, align: ValueRef) -> ValueRef { ret build::And(cx, bumped, build::Not(cx, mask)); } -fn path_str(p: path) -> str { - let mut r = "", first = true; +fn path_str(p: path) -> ~str { + let mut r = ~"", first = true; for vec::each(p) |e| { alt e { ast_map::path_name(s) | ast_map::path_mod(s) { if first { first = false; } - else { r += "::"; } + else { r += ~"::"; } r += *s; } } } diff --git a/src/rustc/middle/trans/debuginfo.rs b/src/rustc/middle/trans/debuginfo.rs index bbef68aaad6..b18569a093b 100644 --- a/src/rustc/middle/trans/debuginfo.rs +++ b/src/rustc/middle/trans/debuginfo.rs @@ -47,7 +47,7 @@ const DW_ATE_signed_char: int = 0x06; const DW_ATE_unsigned: int = 0x07; const DW_ATE_unsigned_char: int = 0x08; -fn llstr(s: str) -> ValueRef { +fn llstr(s: ~str) -> ValueRef { str::as_c_str(s, |sbuf| { llvm::LLVMMDString(sbuf, str::len(s) as libc::c_uint) }) @@ -75,7 +75,7 @@ fn llnull() -> ValueRef unsafe { unsafe::reinterpret_cast(ptr::null::<ValueRef>()) } -fn add_named_metadata(cx: @crate_ctxt, name: str, val: ValueRef) { +fn add_named_metadata(cx: @crate_ctxt, name: ~str, val: ValueRef) { str::as_c_str(name, |sbuf| { llvm::LLVMAddNamedMetadataOperand(cx.llmod, sbuf, val) }) @@ -86,10 +86,10 @@ fn add_named_metadata(cx: @crate_ctxt, name: str, val: ValueRef) { type debug_ctxt = { llmetadata: metadata_cache, names: namegen, - crate_file: str + crate_file: ~str }; -fn mk_ctxt(crate: str) -> debug_ctxt { +fn mk_ctxt(crate: ~str) -> debug_ctxt { {llmetadata: map::int_hash(), names: new_namegen(), crate_file: crate} @@ -106,8 +106,8 @@ fn update_cache(cache: metadata_cache, mdtag: int, val: debug_metadata) { type metadata<T> = {node: ValueRef, data: T}; -type file_md = {path: str}; -type compile_unit_md = {name: str}; +type file_md = {path: ~str}; +type compile_unit_md = {name: ~str}; type subprogram_md = {id: ast::node_id}; type local_var_md = {id: ast::node_id}; type tydesc_md = {hash: uint}; @@ -181,11 +181,11 @@ fn create_compile_unit(cx: @crate_ctxt) llstr(#env["CFG_VERSION"]), lli1(true), // deprecated: main compile unit lli1(cx.sess.opts.optimize != 0u), - llstr(""), // flags (???) + llstr(~""), // flags (???) lli32(0) // runtime version (???) ]; let unit_node = llmdnode(unit_metadata); - add_named_metadata(cx, "llvm.dbg.cu", unit_node); + add_named_metadata(cx, ~"llvm.dbg.cu", unit_node); let mdval = @{node: unit_node, data: {name: crate_name}}; update_cache(cache, tg, compile_unit_metadata(mdval)); @@ -196,7 +196,7 @@ fn get_cache(cx: @crate_ctxt) -> metadata_cache { option::get(cx.dbg_cx).llmetadata } -fn get_file_path_and_dir(work_dir: str, full_path: str) -> (str, str) { +fn get_file_path_and_dir(work_dir: ~str, full_path: ~str) -> (~str, ~str) { (if str::starts_with(full_path, work_dir) { str::slice(full_path, str::len(work_dir) + 1u, str::len(full_path)) @@ -205,7 +205,7 @@ fn get_file_path_and_dir(work_dir: str, full_path: str) -> (str, str) { }, work_dir) } -fn create_file(cx: @crate_ctxt, full_path: str) -> @metadata<file_md> { +fn create_file(cx: @crate_ctxt, full_path: ~str) -> @metadata<file_md> { let cache = get_cache(cx);; let tg = FileDescriptorTag; alt cached_metadata::<@metadata<file_md>>( @@ -292,26 +292,26 @@ fn create_basic_type(cx: @crate_ctxt, t: ty::t, ty: ast::prim_ty, span: span) } let (name, encoding) = alt check ty { - ast::ty_bool {("bool", DW_ATE_boolean)} + ast::ty_bool {(~"bool", DW_ATE_boolean)} ast::ty_int(m) { alt m { - ast::ty_char {("char", DW_ATE_unsigned)} - ast::ty_i {("int", DW_ATE_signed)} - ast::ty_i8 {("i8", DW_ATE_signed_char)} - ast::ty_i16 {("i16", DW_ATE_signed)} - ast::ty_i32 {("i32", DW_ATE_signed)} - ast::ty_i64 {("i64", DW_ATE_signed)} + ast::ty_char {(~"char", DW_ATE_unsigned)} + ast::ty_i {(~"int", DW_ATE_signed)} + ast::ty_i8 {(~"i8", DW_ATE_signed_char)} + ast::ty_i16 {(~"i16", DW_ATE_signed)} + ast::ty_i32 {(~"i32", DW_ATE_signed)} + ast::ty_i64 {(~"i64", DW_ATE_signed)} }} ast::ty_uint(m) { alt m { - ast::ty_u {("uint", DW_ATE_unsigned)} - ast::ty_u8 {("u8", DW_ATE_unsigned_char)} - ast::ty_u16 {("u16", DW_ATE_unsigned)} - ast::ty_u32 {("u32", DW_ATE_unsigned)} - ast::ty_u64 {("u64", DW_ATE_unsigned)} + ast::ty_u {(~"uint", DW_ATE_unsigned)} + ast::ty_u8 {(~"u8", DW_ATE_unsigned_char)} + ast::ty_u16 {(~"u16", DW_ATE_unsigned)} + ast::ty_u32 {(~"u32", DW_ATE_unsigned)} + ast::ty_u64 {(~"u64", DW_ATE_unsigned)} }} ast::ty_float(m) { alt m { - ast::ty_f {("float", DW_ATE_float)} - ast::ty_f32 {("f32", DW_ATE_float)} - ast::ty_f64 {("f64", DW_ATE_float)} + ast::ty_f {(~"float", DW_ATE_float)} + ast::ty_f32 {(~"f32", DW_ATE_float)} + ast::ty_f64 {(~"f64", DW_ATE_float)} }} }; @@ -332,7 +332,7 @@ fn create_basic_type(cx: @crate_ctxt, t: ty::t, ty: ast::prim_ty, span: span) let llnode = llmdnode(lldata); let mdval = @{node: llnode, data: {hash: ty::type_id(t)}}; update_cache(cache, tg, tydesc_metadata(mdval)); - add_named_metadata(cx, "llvm.dbg.ty", llnode); + add_named_metadata(cx, ~"llvm.dbg.ty", llnode); ret mdval; } @@ -350,17 +350,17 @@ fn create_pointer_type(cx: @crate_ctxt, t: ty::t, span: span, let fname = filename_from_span(cx, span); let file_node = create_file(cx, fname); //let cu_node = create_compile_unit(cx, fname); - let llnode = create_derived_type(tg, file_node.node, "", 0, size * 8, + let llnode = create_derived_type(tg, file_node.node, ~"", 0, size * 8, align * 8, 0, pointee.node); let mdval = @{node: llnode, data: {hash: ty::type_id(t)}}; //update_cache(cache, tg, tydesc_metadata(mdval)); - add_named_metadata(cx, "llvm.dbg.ty", llnode); + add_named_metadata(cx, ~"llvm.dbg.ty", llnode); ret mdval; } type struct_ctxt = { file: ValueRef, - name: str, + name: ~str, line: int, mut members: ~[ValueRef], mut total_size: int, @@ -373,7 +373,7 @@ fn finish_structure(cx: @struct_ctxt) -> ValueRef { option::some(cx.members)); } -fn create_structure(file: @metadata<file_md>, name: str, line: int) +fn create_structure(file: @metadata<file_md>, name: ~str, line: int) -> @struct_ctxt { let cx = @{file: file.node, name: name, @@ -385,7 +385,7 @@ fn create_structure(file: @metadata<file_md>, name: str, line: int) ret cx; } -fn create_derived_type(type_tag: int, file: ValueRef, name: str, line: int, +fn create_derived_type(type_tag: int, file: ValueRef, name: ~str, line: int, size: int, align: int, offset: int, ty: ValueRef) -> ValueRef { let lldata = ~[lltag(type_tag), @@ -401,7 +401,7 @@ fn create_derived_type(type_tag: int, file: ValueRef, name: str, line: int, ret llmdnode(lldata); } -fn add_member(cx: @struct_ctxt, name: str, line: int, size: int, align: int, +fn add_member(cx: @struct_ctxt, name: ~str, line: int, size: int, align: int, ty: ValueRef) { vec::push(cx.members, create_derived_type(MemberTag, cx.file, name, line, size * 8, align * 8, cx.total_size, @@ -414,7 +414,7 @@ fn create_record(cx: @crate_ctxt, t: ty::t, fields: ~[ast::ty_field], let fname = filename_from_span(cx, span); let file_node = create_file(cx, fname); let scx = create_structure(file_node, - option::get(cx.dbg_cx).names("rec"), + option::get(cx.dbg_cx).names(~"rec"), line_from_span(cx.sess.codemap, span) as int); for fields.each |field| { @@ -446,19 +446,19 @@ fn create_boxed_type(cx: @crate_ctxt, outer: ty::t, _inner: ty::t, let refcount_type = create_basic_type(cx, uint_t, ast::ty_uint(ast::ty_u), span); let scx = create_structure(file_node, ty_to_str(cx.tcx, outer), 0); - add_member(scx, "refcnt", 0, sys::size_of::<uint>() as int, + add_member(scx, ~"refcnt", 0, sys::size_of::<uint>() as int, sys::min_align_of::<uint>() as int, refcount_type.node); - add_member(scx, "boxed", 0, 8, //XXX member_size_and_align(??) + add_member(scx, ~"boxed", 0, 8, //XXX member_size_and_align(??) 8, //XXX just a guess boxed.node); let llnode = finish_structure(scx); let mdval = @{node: llnode, data: {hash: ty::type_id(outer)}}; //update_cache(cache, tg, tydesc_metadata(mdval)); - add_named_metadata(cx, "llvm.dbg.ty", llnode); + add_named_metadata(cx, ~"llvm.dbg.ty", llnode); ret mdval; } -fn create_composite_type(type_tag: int, name: str, file: ValueRef, line: int, +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]>) @@ -497,17 +497,17 @@ fn create_vec(cx: @crate_ctxt, vec_t: ty::t, elem_t: ty::t, let scx = create_structure(file_node, ty_to_str(cx.tcx, vec_t), 0); let size_t_type = create_basic_type(cx, ty::mk_uint(cx.tcx), ast::ty_uint(ast::ty_u), vec_ty_span); - add_member(scx, "fill", 0, sys::size_of::<libc::size_t>() as int, + add_member(scx, ~"fill", 0, sys::size_of::<libc::size_t>() as int, 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, + 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 (arr_size, arr_align) = size_and_align_of(cx, elem_t); - let data_ptr = create_composite_type(ArrayTypeTag, "", file_node.node, 0, + 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])); - add_member(scx, "data", 0, 0, // clang says the size should be 0 + 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); ret @{node: llnode, data: {hash: ty::type_id(vec_t)}}; @@ -617,11 +617,11 @@ fn create_ty(_cx: @crate_ctxt, _t: ty::t, _ty: @ast::ty) */ } -fn filename_from_span(cx: @crate_ctxt, sp: codemap::span) -> str { +fn filename_from_span(cx: @crate_ctxt, sp: codemap::span) -> ~str { codemap::lookup_char_pos(cx.sess.codemap, sp.lo).file.name } -fn create_var(type_tag: int, context: ValueRef, name: str, file: ValueRef, +fn create_var(type_tag: int, context: ValueRef, name: ~str, file: ValueRef, line: int, ret_ty: ValueRef) -> ValueRef { let lldata = ~[lltag(type_tag), context, @@ -648,7 +648,7 @@ fn create_local_var(bcx: block, local: @ast::local) let name = alt local.node.pat.node { ast::pat_ident(pth, _) { ast_util::path_to_ident(pth) } // FIXME this should be handled (#2533) - _ { fail "no single variable name for local"; } + _ { fail ~"no single variable name for local"; } }; let loc = codemap::lookup_char_pos(cx.sess.codemap, local.span.lo); @@ -667,19 +667,19 @@ fn create_local_var(bcx: block, local: @ast::local) let llptr = alt bcx.fcx.lllocals.find(local.node.id) { option::some(local_mem(v)) { v } option::some(_) { - bcx.tcx().sess.span_bug(local.span, "local is bound to \ + bcx.tcx().sess.span_bug(local.span, ~"local is bound to \ something weird"); } option::none { alt bcx.fcx.lllocals.get(local.node.pat.id) { local_imm(v) { v } - _ { bcx.tcx().sess.span_bug(local.span, "local is bound to \ + _ { bcx.tcx().sess.span_bug(local.span, ~"local is bound to \ something weird"); } } } }; let declargs = ~[llmdnode(~[llptr]), mdnode]; - trans::build::Call(bcx, cx.intrinsics.get("llvm.dbg.declare"), + trans::build::Call(bcx, cx.intrinsics.get(~"llvm.dbg.declare"), declargs); ret mdval; } @@ -710,7 +710,7 @@ fn create_arg(bcx: block, arg: ast::arg, sp: span) local_mem(v) | local_imm(v) { v } }; let declargs = ~[llmdnode(~[llptr]), mdnode]; - trans::build::Call(bcx, cx.intrinsics.get("llvm.dbg.declare"), + trans::build::Call(bcx, cx.intrinsics.get(~"llvm.dbg.declare"), declargs); ret mdval; } @@ -746,7 +746,7 @@ fn create_function(fcx: fn_ctxt) -> @metadata<subprogram_md> { ast::item_fn(decl, _, _) { (item.ident, decl.output, item.id) } - _ { fcx.ccx.sess.span_bug(item.span, "create_function: item \ + _ { fcx.ccx.sess.span_bug(item.span, ~"create_function: item \ bound to non-function"); } } } @@ -760,16 +760,16 @@ fn create_function(fcx: fn_ctxt) -> @metadata<subprogram_md> { ast_map::node_expr(expr) { alt expr.node { ast::expr_fn(_, decl, _, _) { - (@dbg_cx.names("fn"), decl.output, expr.id) + (@dbg_cx.names(~"fn"), decl.output, expr.id) } ast::expr_fn_block(decl, _, _) { - (@dbg_cx.names("fn"), decl.output, expr.id) + (@dbg_cx.names(~"fn"), decl.output, expr.id) } - _ { fcx.ccx.sess.span_bug(expr.span, "create_function: \ + _ { fcx.ccx.sess.span_bug(expr.span, ~"create_function: \ expected an expr_fn or fn_block here"); } } } - _ { fcx.ccx.sess.bug("create_function: unexpected \ + _ { fcx.ccx.sess.bug(~"create_function: unexpected \ sort of node"); } }; @@ -794,7 +794,7 @@ fn create_function(fcx: fn_ctxt) -> @metadata<subprogram_md> { } else { llnull() }; - let sub_node = create_composite_type(SubroutineTag, "", file_node, 0, 0, + let sub_node = create_composite_type(SubroutineTag, ~"", file_node, 0, 0, 0, 0, option::none, option::some(~[ty_node])); @@ -803,7 +803,7 @@ fn create_function(fcx: fn_ctxt) -> @metadata<subprogram_md> { file_node, llstr(*ident), llstr(*ident), //XXX fully-qualified C++ name - llstr(""), //XXX MIPS name????? + llstr(~""), //XXX MIPS name????? file_node, lli32(loc.line as int), sub_node, @@ -820,7 +820,7 @@ fn create_function(fcx: fn_ctxt) -> @metadata<subprogram_md> { //list of func vars ]; let val = llmdnode(fn_metadata); - add_named_metadata(cx, "llvm.dbg.sp", val); + add_named_metadata(cx, ~"llvm.dbg.sp", val); let mdval = @{node: val, data: {id: id}}; update_cache(cache, SubprogramTag, subprogram_metadata(mdval)); diff --git a/src/rustc/middle/trans/foreign.rs b/src/rustc/middle/trans/foreign.rs index 2a054b9fe7b..847aca0db2c 100644 --- a/src/rustc/middle/trans/foreign.rs +++ b/src/rustc/middle/trans/foreign.rs @@ -90,7 +90,7 @@ fn classify_ty(ty: TypeRef) -> ~[x86_64_reg_class] { ty_align(elt) } _ { - fail "ty_size: unhandled type" + fail ~"ty_size: unhandled type" } }; } @@ -115,7 +115,7 @@ fn classify_ty(ty: TypeRef) -> ~[x86_64_reg_class] { len * eltsz } _ { - fail "ty_size: unhandled type" + fail ~"ty_size: unhandled type" } }; } @@ -212,7 +212,7 @@ fn classify_ty(ty: TypeRef) -> ~[x86_64_reg_class] { } } _ { - fail "classify: unhandled type"; + fail ~"classify: unhandled type"; } } } @@ -310,7 +310,7 @@ fn llreg_ty(cls: ~[x86_64_reg_class]) -> TypeRef { vec::push(tys, T_f64()); } _ { - fail "llregtype: unhandled class"; + fail ~"llregtype: unhandled class"; } } i += 1u; @@ -420,8 +420,8 @@ fn decl_x86_64_fn(tys: x86_64_tys, ret llfn; } -fn link_name(i: @ast::foreign_item) -> str { - alt attr::first_attr_value_str_by_name(i.attrs, "link_name") { +fn link_name(i: @ast::foreign_item) -> ~str { + alt attr::first_attr_value_str_by_name(i.attrs, ~"link_name") { none { ret *i.ident; } option::some(ln) { ret *ln; } } @@ -444,7 +444,7 @@ fn c_arg_and_ret_lltys(ccx: @crate_ctxt, let llretty = type_of::type_of(ccx, ret_ty); (llargtys, llretty, ret_ty) } - _ { ccx.sess.bug("c_arg_and_ret_lltys called on non-function type"); } + _ { ccx.sess.bug(~"c_arg_and_ret_lltys called on non-function type"); } } } @@ -475,7 +475,7 @@ type shim_ret_builder = fn(bcx: block, tys: @c_stack_tys, llargbundle: ValueRef, llretval: ValueRef); fn build_shim_fn_(ccx: @crate_ctxt, - shim_name: str, + shim_name: ~str, llbasefn: ValueRef, tys: @c_stack_tys, cc: lib::llvm::CallConv, @@ -519,7 +519,7 @@ fn build_wrap_fn_(ccx: @crate_ctxt, arg_builder: wrap_arg_builder, ret_builder: wrap_ret_builder) { - let _icx = ccx.insn_ctxt("foreign::build_wrap_fn_"); + let _icx = ccx.insn_ctxt(~"foreign::build_wrap_fn_"); let fcx = new_fn_ctxt(ccx, ~[], llwrapfn, none); let bcx = top_scope_block(fcx, none); let lltop = bcx.llbb; @@ -579,18 +579,18 @@ fn build_wrap_fn_(ccx: @crate_ctxt, fn trans_foreign_mod(ccx: @crate_ctxt, foreign_mod: ast::foreign_mod, abi: ast::foreign_abi) { - let _icx = ccx.insn_ctxt("foreign::trans_foreign_mod"); + let _icx = ccx.insn_ctxt(~"foreign::trans_foreign_mod"); fn build_shim_fn(ccx: @crate_ctxt, foreign_item: @ast::foreign_item, tys: @c_stack_tys, cc: lib::llvm::CallConv) -> ValueRef { - let _icx = ccx.insn_ctxt("foreign::build_shim_fn"); + let _icx = ccx.insn_ctxt(~"foreign::build_shim_fn"); fn build_args(bcx: block, tys: @c_stack_tys, llargbundle: ValueRef) -> ~[ValueRef] { - let _icx = bcx.insn_ctxt("foreign::shim::build_args"); + let _icx = bcx.insn_ctxt(~"foreign::shim::build_args"); let mut llargvals = ~[]; let mut i = 0u; let n = vec::len(tys.arg_tys); @@ -636,7 +636,7 @@ fn trans_foreign_mod(ccx: @crate_ctxt, fn build_ret(bcx: block, tys: @c_stack_tys, llargbundle: ValueRef, llretval: ValueRef) { - let _icx = bcx.insn_ctxt("foreign::shim::build_ret"); + let _icx = bcx.insn_ctxt(~"foreign::shim::build_ret"); alt tys.x86_64_tys { some(x86_64) { do vec::iteri(x86_64.attrs) |i, a| { @@ -680,12 +680,12 @@ fn trans_foreign_mod(ccx: @crate_ctxt, let lname = link_name(foreign_item); let llbasefn = base_fn(ccx, lname, tys, cc); // Name the shim function - let shim_name = lname + "__c_stack_shim"; + let shim_name = lname + ~"__c_stack_shim"; ret build_shim_fn_(ccx, shim_name, llbasefn, tys, cc, build_args, build_ret); } - fn base_fn(ccx: @crate_ctxt, lname: str, tys: @c_stack_tys, + fn base_fn(ccx: @crate_ctxt, lname: ~str, tys: @c_stack_tys, cc: lib::llvm::CallConv) -> ValueRef { // Declare the "prototype" for the base function F: alt tys.x86_64_tys { @@ -727,11 +727,11 @@ fn trans_foreign_mod(ccx: @crate_ctxt, llshimfn: ValueRef, llwrapfn: ValueRef) { - let _icx = ccx.insn_ctxt("foreign::build_wrap_fn"); + let _icx = ccx.insn_ctxt(~"foreign::build_wrap_fn"); fn build_args(bcx: block, tys: @c_stack_tys, llwrapfn: ValueRef, llargbundle: ValueRef) { - let _icx = bcx.insn_ctxt("foreign::wrap::build_args"); + let _icx = bcx.insn_ctxt(~"foreign::wrap::build_args"); let mut i = 0u; let n = vec::len(tys.arg_tys); let implicit_args = first_real_arg; // ret + env @@ -746,7 +746,7 @@ fn trans_foreign_mod(ccx: @crate_ctxt, fn build_ret(bcx: block, _tys: @c_stack_tys, _llargbundle: ValueRef) { - let _icx = bcx.insn_ctxt("foreign::wrap::build_ret"); + let _icx = bcx.insn_ctxt(~"foreign::wrap::build_ret"); RetVoid(bcx); } @@ -768,7 +768,8 @@ fn trans_foreign_mod(ccx: @crate_ctxt, if abi != ast::foreign_abi_rust_intrinsic { let llwrapfn = get_item_val(ccx, id); let tys = c_stack_tys(ccx, id); - if attr::attrs_contains_name(foreign_item.attrs, "rust_stack") { + if attr::attrs_contains_name(foreign_item.attrs, + ~"rust_stack") { build_direct_fn(ccx, llwrapfn, foreign_item, tys, cc); } else { let llshimfn = build_shim_fn(ccx, foreign_item, tys, cc); @@ -783,7 +784,7 @@ fn trans_foreign_mod(ccx: @crate_ctxt, some(ast_map::node_foreign_item(_, _, pt)) { pt } _ { ccx.sess.span_bug(foreign_item.span, - "can't find intrinsic path") + ~"can't find intrinsic path") } }; let psubsts = { @@ -807,76 +808,76 @@ fn trans_intrinsic(ccx: @crate_ctxt, decl: ValueRef, item: @ast::foreign_item, some(substs), some(item.span)); let mut bcx = top_scope_block(fcx, none), lltop = bcx.llbb; alt check *item.ident { - "atomic_xchng" { + ~"atomic_xchng" { let old = AtomicRMW(bcx, Xchg, get_param(decl, first_real_arg), get_param(decl, first_real_arg + 1u), SequentiallyConsistent); Store(bcx, old, fcx.llretptr); } - "atomic_xchng_acq" { + ~"atomic_xchng_acq" { let old = AtomicRMW(bcx, Xchg, get_param(decl, first_real_arg), get_param(decl, first_real_arg + 1u), Acquire); Store(bcx, old, fcx.llretptr); } - "atomic_xchng_rel" { + ~"atomic_xchng_rel" { let old = AtomicRMW(bcx, Xchg, get_param(decl, first_real_arg), get_param(decl, first_real_arg + 1u), Release); Store(bcx, old, fcx.llretptr); } - "atomic_add" { + ~"atomic_add" { let old = AtomicRMW(bcx, lib::llvm::Add, get_param(decl, first_real_arg), get_param(decl, first_real_arg + 1u), SequentiallyConsistent); Store(bcx, old, fcx.llretptr); } - "atomic_add_acq" { + ~"atomic_add_acq" { let old = AtomicRMW(bcx, lib::llvm::Add, get_param(decl, first_real_arg), get_param(decl, first_real_arg + 1u), Acquire); Store(bcx, old, fcx.llretptr); } - "atomic_add_rel" { + ~"atomic_add_rel" { let old = AtomicRMW(bcx, lib::llvm::Add, get_param(decl, first_real_arg), get_param(decl, first_real_arg + 1u), Release); Store(bcx, old, fcx.llretptr); } - "atomic_sub" { + ~"atomic_sub" { let old = AtomicRMW(bcx, lib::llvm::Sub, get_param(decl, first_real_arg), get_param(decl, first_real_arg + 1u), SequentiallyConsistent); Store(bcx, old, fcx.llretptr); } - "atomic_sub_acq" { + ~"atomic_sub_acq" { let old = AtomicRMW(bcx, lib::llvm::Sub, get_param(decl, first_real_arg), get_param(decl, first_real_arg + 1u), Acquire); Store(bcx, old, fcx.llretptr); } - "atomic_sub_rel" { + ~"atomic_sub_rel" { let old = AtomicRMW(bcx, lib::llvm::Sub, get_param(decl, first_real_arg), get_param(decl, first_real_arg + 1u), Release); Store(bcx, old, fcx.llretptr); } - "size_of" { + ~"size_of" { let tp_ty = substs.tys[0]; let lltp_ty = type_of::type_of(ccx, tp_ty); Store(bcx, C_uint(ccx, shape::llsize_of_real(ccx, lltp_ty)), fcx.llretptr); } - "move_val" { + ~"move_val" { let tp_ty = substs.tys[0]; let src = {bcx: bcx, val: get_param(decl, first_real_arg + 1u), @@ -886,7 +887,7 @@ fn trans_intrinsic(ccx: @crate_ctxt, decl: ValueRef, item: @ast::foreign_item, src, tp_ty); } - "move_val_init" { + ~"move_val_init" { let tp_ty = substs.tys[0]; let src = {bcx: bcx, val: get_param(decl, first_real_arg + 1u), @@ -896,19 +897,19 @@ fn trans_intrinsic(ccx: @crate_ctxt, decl: ValueRef, item: @ast::foreign_item, src, tp_ty); } - "min_align_of" { + ~"min_align_of" { let tp_ty = substs.tys[0]; let lltp_ty = type_of::type_of(ccx, tp_ty); Store(bcx, C_uint(ccx, shape::llalign_of_min(ccx, lltp_ty)), fcx.llretptr); } - "pref_align_of" { + ~"pref_align_of" { let tp_ty = substs.tys[0]; let lltp_ty = type_of::type_of(ccx, tp_ty); Store(bcx, C_uint(ccx, shape::llalign_of_pref(ccx, lltp_ty)), fcx.llretptr); } - "get_tydesc" { + ~"get_tydesc" { let tp_ty = substs.tys[0]; let static_ti = get_tydesc(ccx, tp_ty); lazily_emit_all_tydesc_glue(ccx, static_ti); @@ -917,15 +918,15 @@ fn trans_intrinsic(ccx: @crate_ctxt, decl: ValueRef, item: @ast::foreign_item, let td = PointerCast(bcx, static_ti.tydesc, T_ptr(T_nil())); Store(bcx, td, fcx.llretptr); } - "init" { + ~"init" { let tp_ty = substs.tys[0]; let lltp_ty = type_of::type_of(ccx, tp_ty); if !ty::type_is_nil(tp_ty) { Store(bcx, C_null(lltp_ty), fcx.llretptr); } } - "forget" {} - "reinterpret_cast" { + ~"forget" {} + ~"reinterpret_cast" { let tp_ty = substs.tys[0]; let lltp_ty = type_of::type_of(ccx, tp_ty); let llout_ty = type_of::type_of(ccx, substs.tys[1]); @@ -947,23 +948,23 @@ fn trans_intrinsic(ccx: @crate_ctxt, decl: ValueRef, item: @ast::foreign_item, Store(bcx, Load(bcx, cast), fcx.llretptr); } } - "addr_of" { + ~"addr_of" { Store(bcx, get_param(decl, first_real_arg), fcx.llretptr); } - "needs_drop" { + ~"needs_drop" { let tp_ty = substs.tys[0]; Store(bcx, C_bool(ty::type_needs_drop(ccx.tcx, tp_ty)), fcx.llretptr); } - "visit_tydesc" { + ~"visit_tydesc" { let td = get_param(decl, first_real_arg); let visitor = get_param(decl, first_real_arg + 1u); let td = PointerCast(bcx, td, T_ptr(ccx.tydesc_type)); call_tydesc_glue_full(bcx, visitor, td, abi::tydesc_field_visit_glue, none); } - "frame_address" { - let frameaddress = ccx.intrinsics.get("llvm.frameaddress"); + ~"frame_address" { + let frameaddress = ccx.intrinsics.get(~"llvm.frameaddress"); let frameaddress_val = Call(bcx, frameaddress, ~[C_i32(0i32)]); let fty = ty::mk_fn(bcx.tcx(), { purity: ast::impure_fn, @@ -993,15 +994,15 @@ fn trans_intrinsic(ccx: @crate_ctxt, decl: ValueRef, item: @ast::foreign_item, fn trans_foreign_fn(ccx: @crate_ctxt, path: ast_map::path, decl: ast::fn_decl, body: ast::blk, llwrapfn: ValueRef, id: ast::node_id) { - let _icx = ccx.insn_ctxt("foreign::build_foreign_fn"); + let _icx = ccx.insn_ctxt(~"foreign::build_foreign_fn"); fn build_rust_fn(ccx: @crate_ctxt, path: ast_map::path, decl: ast::fn_decl, body: ast::blk, id: ast::node_id) -> ValueRef { - let _icx = ccx.insn_ctxt("foreign::foreign::build_rust_fn"); + let _icx = ccx.insn_ctxt(~"foreign::foreign::build_rust_fn"); let t = ty::node_id_to_type(ccx.tcx, id); let ps = link::mangle_internal_name_by_path( - ccx, vec::append_one(path, ast_map::path_name(@"__rust_abi"/~))); + ccx, vec::append_one(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); @@ -1011,11 +1012,11 @@ fn trans_foreign_fn(ccx: @crate_ctxt, path: ast_map::path, decl: ast::fn_decl, fn build_shim_fn(ccx: @crate_ctxt, path: ast_map::path, llrustfn: ValueRef, tys: @c_stack_tys) -> ValueRef { - let _icx = ccx.insn_ctxt("foreign::foreign::build_shim_fn"); + let _icx = ccx.insn_ctxt(~"foreign::foreign::build_shim_fn"); fn build_args(bcx: block, tys: @c_stack_tys, llargbundle: ValueRef) -> ~[ValueRef] { - let _icx = bcx.insn_ctxt("foreign::extern::shim::build_args"); + let _icx = bcx.insn_ctxt(~"foreign::extern::shim::build_args"); let mut llargvals = ~[]; let mut i = 0u; let n = vec::len(tys.arg_tys); @@ -1039,7 +1040,7 @@ fn trans_foreign_fn(ccx: @crate_ctxt, path: ast_map::path, decl: ast::fn_decl, let shim_name = link::mangle_internal_name_by_path( ccx, vec::append_one(path, - ast_map::path_name(@"__rust_stack_shim"/~))); + ast_map::path_name(@~"__rust_stack_shim"))); ret build_shim_fn_(ccx, shim_name, llrustfn, tys, lib::llvm::CCallConv, build_args, build_ret); @@ -1048,11 +1049,11 @@ fn trans_foreign_fn(ccx: @crate_ctxt, path: ast_map::path, decl: ast::fn_decl, fn build_wrap_fn(ccx: @crate_ctxt, llshimfn: ValueRef, llwrapfn: ValueRef, tys: @c_stack_tys) { - let _icx = ccx.insn_ctxt("foreign::foreign::build_wrap_fn"); + let _icx = ccx.insn_ctxt(~"foreign::foreign::build_wrap_fn"); fn build_args(bcx: block, tys: @c_stack_tys, llwrapfn: ValueRef, llargbundle: ValueRef) { - let _icx = bcx.insn_ctxt("foreign::foreign::wrap::build_args"); + let _icx = bcx.insn_ctxt(~"foreign::foreign::wrap::build_args"); alt tys.x86_64_tys { option::some(x86_64) { let mut atys = x86_64.arg_tys; @@ -1106,7 +1107,7 @@ fn trans_foreign_fn(ccx: @crate_ctxt, path: ast_map::path, decl: ast::fn_decl, fn build_ret(bcx: block, tys: @c_stack_tys, llargbundle: ValueRef) { - let _icx = bcx.insn_ctxt("foreign::foreign::wrap::build_ret"); + let _icx = bcx.insn_ctxt(~"foreign::foreign::wrap::build_ret"); alt tys.x86_64_tys { option::some(x86_64) { if x86_64.sret || !tys.ret_def { @@ -1150,7 +1151,7 @@ fn trans_foreign_fn(ccx: @crate_ctxt, path: ast_map::path, decl: ast::fn_decl, fn register_foreign_fn(ccx: @crate_ctxt, sp: span, path: ast_map::path, node_id: ast::node_id) -> ValueRef { - let _icx = ccx.insn_ctxt("foreign::register_foreign_fn"); + let _icx = ccx.insn_ctxt(~"foreign::register_foreign_fn"); let t = ty::node_id_to_type(ccx.tcx, node_id); let (llargtys, llretty, ret_ty) = c_arg_and_ret_lltys(ccx, node_id); ret if ccx.sess.targ_cfg.arch == arch_x86_64 { @@ -1169,7 +1170,7 @@ fn register_foreign_fn(ccx: @crate_ctxt, sp: span, fn abi_of_foreign_fn(ccx: @crate_ctxt, i: @ast::foreign_item) -> ast::foreign_abi { - alt attr::first_attr_value_str_by_name(i.attrs, "abi") { + alt attr::first_attr_value_str_by_name(i.attrs, ~"abi") { none { alt check ccx.tcx.items.get(i.id) { ast_map::node_foreign_item(_, abi, _) { abi } diff --git a/src/rustc/middle/trans/impl.rs b/src/rustc/middle/trans/impl.rs index 2ebddb0038f..8ea0583b81b 100644 --- a/src/rustc/middle/trans/impl.rs +++ b/src/rustc/middle/trans/impl.rs @@ -17,7 +17,7 @@ import std::map::hashmap; fn trans_impl(ccx: @crate_ctxt, path: path, name: ast::ident, methods: ~[@ast::method], tps: ~[ast::ty_param]) { - let _icx = ccx.insn_ctxt("impl::trans_impl"); + let _icx = ccx.insn_ctxt(~"impl::trans_impl"); if tps.len() > 0u { ret; } let sub_path = vec::append_one(path, path_name(name)); for vec::each(methods) |m| { @@ -33,7 +33,7 @@ fn trans_impl(ccx: @crate_ctxt, path: path, name: ast::ident, } fn trans_self_arg(bcx: block, base: @ast::expr, derefs: uint) -> result { - let _icx = bcx.insn_ctxt("impl::trans_self_arg"); + 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 = ~[]; @@ -51,7 +51,7 @@ fn trans_self_arg(bcx: block, base: @ast::expr, derefs: uint) -> result { fn trans_method_callee(bcx: block, callee_id: ast::node_id, self: @ast::expr, mentry: typeck::method_map_entry) -> lval_maybe_callee { - let _icx = bcx.insn_ctxt("impl::trans_method_callee"); + let _icx = bcx.insn_ctxt(~"impl::trans_method_callee"); alt mentry.origin { typeck::method_static(did) { let {bcx, val} = trans_self_arg(bcx, self, mentry.derefs); @@ -115,7 +115,7 @@ fn trans_monomorphized_callee(bcx: block, callee_id: ast::node_id, trait_id: ast::def_id, n_method: uint, n_param: uint, n_bound: uint, substs: param_substs) -> lval_maybe_callee { - let _icx = bcx.insn_ctxt("impl::trans_monomorphized_callee"); + let _icx = bcx.insn_ctxt(~"impl::trans_monomorphized_callee"); alt find_vtable_in_fn_ctxt(substs, n_param, n_bound) { typeck::vtable_static(impl_did, impl_substs, sub_origins) { let ccx = bcx.ccx(); @@ -141,7 +141,7 @@ fn trans_monomorphized_callee(bcx: block, callee_id: ast::node_id, trans_trait_callee(bcx, val, fty, n_method) } typeck::vtable_param(n_param, n_bound) { - fail "vtable_param left in monomorphized function's vtable substs"; + fail ~"vtable_param left in monomorphized function's vtable substs"; } } } @@ -150,7 +150,7 @@ fn trans_monomorphized_callee(bcx: block, callee_id: ast::node_id, fn trans_trait_callee(bcx: block, val: ValueRef, callee_ty: ty::t, n_method: uint) -> lval_maybe_callee { - let _icx = bcx.insn_ctxt("impl::trans_trait_callee"); + let _icx = bcx.insn_ctxt(~"impl::trans_trait_callee"); let ccx = bcx.ccx(); let vtable = Load(bcx, PointerCast(bcx, GEPi(bcx, val, ~[0u, 0u]), T_ptr(T_ptr(T_vtable())))); @@ -238,9 +238,9 @@ fn get_vtable(ccx: @crate_ctxt, origin: typeck::vtable_origin) } fn make_vtable(ccx: @crate_ctxt, ptrs: ~[ValueRef]) -> ValueRef { - let _icx = ccx.insn_ctxt("impl::make_vtable"); + let _icx = ccx.insn_ctxt(~"impl::make_vtable"); let tbl = C_struct(ptrs); - let vt_gvar = str::as_c_str(ccx.names("vtable"), |buf| { + let vt_gvar = str::as_c_str(ccx.names(~"vtable"), |buf| { llvm::LLVMAddGlobal(ccx.llmod, val_ty(tbl), buf) }); llvm::LLVMSetInitializer(vt_gvar, tbl); @@ -251,12 +251,12 @@ fn make_vtable(ccx: @crate_ctxt, ptrs: ~[ValueRef]) -> ValueRef { 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 _icx = ccx.insn_ctxt(~"impl::make_impl_vtable"); let tcx = ccx.tcx; let ifce_id = expect(ccx.sess, ty::ty_to_def_id(option::get(ty::impl_trait(tcx, impl_id))), - || "make_impl_vtable: non-trait-type implemented"); + || ~"make_impl_vtable: non-trait-type implemented"); let has_tps = (*ty::lookup_item_type(ccx.tcx, impl_id).bounds).len() > 0u; make_vtable(ccx, vec::map(*ty::trait_methods(tcx, ifce_id), |im| { let fty = ty::subst_tps(tcx, substs, ty::mk_fn(tcx, im.fty)); @@ -282,7 +282,7 @@ fn make_impl_vtable(ccx: @crate_ctxt, impl_id: ast::def_id, substs: ~[ty::t], fn trans_cast(bcx: block, val: @ast::expr, id: ast::node_id, dest: dest) -> block { - let _icx = bcx.insn_ctxt("impl::trans_cast"); + let _icx = bcx.insn_ctxt(~"impl::trans_cast"); if dest == ignore { ret trans_expr(bcx, val, ignore); } let ccx = bcx.ccx(); let v_ty = expr_ty(bcx, val); diff --git a/src/rustc/middle/trans/reachable.rs b/src/rustc/middle/trans/reachable.rs index 39e0461dee6..7a371e7a5fd 100644 --- a/src/rustc/middle/trans/reachable.rs +++ b/src/rustc/middle/trans/reachable.rs @@ -136,7 +136,7 @@ fn traverse_public_item(cx: ctx, item: @item) { } item_const(*) | item_enum(*) | item_trait(*) {} - item_mac(*) { fail "item macros unimplemented" } + item_mac(*) { fail ~"item macros unimplemented" } } } diff --git a/src/rustc/middle/trans/reflect.rs b/src/rustc/middle/trans/reflect.rs index ec9e68ae1c0..56ad6f13632 100644 --- a/src/rustc/middle/trans/reflect.rs +++ b/src/rustc/middle/trans/reflect.rs @@ -28,7 +28,7 @@ impl methods for reflector { C_int(self.bcx.ccx(), i) } - fn c_slice(s: str) -> ValueRef { + fn c_slice(s: ~str) -> ValueRef { let ss = C_estr_slice(self.bcx.ccx(), s); do_spill_noroot(self.bcx, ss) } @@ -53,9 +53,9 @@ impl methods for reflector { self.c_tydesc(mt.ty)] } - 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), + let mth_idx = option::get(ty::method_idx(@(~"visit_" + ty_name), *self.visitor_methods)); let mth_ty = ty::mk_fn(tcx, self.visitor_methods[mth_idx].fty); let v = self.visitor_val; @@ -76,34 +76,34 @@ impl methods for reflector { let bcx = trans_call_inner(self.bcx, none, mth_ty, ty::mk_bool(tcx), get_lval, arg_vals(args), by_val(d)); - let next_bcx = sub_block(bcx, "next"); + let next_bcx = sub_block(bcx, ~"next"); CondBr(bcx, *d, next_bcx.llbb, self.final_bcx.llbb); self.bcx = next_bcx } - fn bracketed(bracket_name: str, extra: ~[ValueRef], + fn bracketed(bracket_name: ~str, extra: ~[ValueRef], inner: fn()) { - self.visit("enter_" + bracket_name, extra); + self.visit(~"enter_" + bracket_name, extra); inner(); - self.visit("leave_" + bracket_name, extra); + self.visit(~"leave_" + bracket_name, 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 = vec::append(~[self.c_uint(n)], self.c_size_and_align(t)); - f("fixed", extra) + 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) { + fn leaf(name: ~str) { self.visit(name, ~[]); } @@ -115,49 +115,49 @@ impl methods for reflector { ty_to_str(bcx.ccx().tcx, t)); alt ty::get(t).struct { - ty::ty_bot { self.leaf("bot") } - ty::ty_nil { self.leaf("nil") } - ty::ty_bool { self.leaf("bool") } - ty::ty_int(ast::ty_i) { self.leaf("int") } - ty::ty_int(ast::ty_char) { self.leaf("char") } - ty::ty_int(ast::ty_i8) { self.leaf("i8") } - ty::ty_int(ast::ty_i16) { self.leaf("i16") } - ty::ty_int(ast::ty_i32) { self.leaf("i32") } - ty::ty_int(ast::ty_i64) { self.leaf("i64") } - ty::ty_uint(ast::ty_u) { self.leaf("uint") } - ty::ty_uint(ast::ty_u8) { self.leaf("u8") } - ty::ty_uint(ast::ty_u16) { self.leaf("u16") } - ty::ty_uint(ast::ty_u32) { self.leaf("u32") } - ty::ty_uint(ast::ty_u64) { self.leaf("u64") } - ty::ty_float(ast::ty_f) { self.leaf("float") } - ty::ty_float(ast::ty_f32) { self.leaf("f32") } - ty::ty_float(ast::ty_f64) { self.leaf("f64") } - ty::ty_str { self.leaf("str") } + ty::ty_bot { self.leaf(~"bot") } + ty::ty_nil { self.leaf(~"nil") } + ty::ty_bool { self.leaf(~"bool") } + ty::ty_int(ast::ty_i) { self.leaf(~"int") } + ty::ty_int(ast::ty_char) { self.leaf(~"char") } + ty::ty_int(ast::ty_i8) { self.leaf(~"i8") } + ty::ty_int(ast::ty_i16) { self.leaf(~"i16") } + ty::ty_int(ast::ty_i32) { self.leaf(~"i32") } + ty::ty_int(ast::ty_i64) { self.leaf(~"i64") } + ty::ty_uint(ast::ty_u) { self.leaf(~"uint") } + ty::ty_uint(ast::ty_u8) { self.leaf(~"u8") } + ty::ty_uint(ast::ty_u16) { self.leaf(~"u16") } + ty::ty_uint(ast::ty_u32) { self.leaf(~"u32") } + ty::ty_uint(ast::ty_u64) { self.leaf(~"u64") } + ty::ty_float(ast::ty_f) { self.leaf(~"float") } + ty::ty_float(ast::ty_f32) { self.leaf(~"f32") } + ty::ty_float(ast::ty_f64) { self.leaf(~"f64") } + ty::ty_str { self.leaf(~"str") } - ty::ty_vec(mt) { self.visit("vec", self.c_mt(mt)) } - ty::ty_unboxed_vec(mt) { self.visit("vec", self.c_mt(mt)) } + ty::ty_vec(mt) { self.visit(~"vec", self.c_mt(mt)) } + ty::ty_unboxed_vec(mt) { self.visit(~"vec", self.c_mt(mt)) } ty::ty_estr(vst) { do self.vstore_name_and_extra(t, vst) |name, extra| { - self.visit("estr_" + name, extra) + self.visit(~"estr_" + name, extra) } } ty::ty_evec(mt, vst) { do self.vstore_name_and_extra(t, vst) |name, extra| { - self.visit("evec_" + name, extra + + self.visit(~"evec_" + name, extra + self.c_mt(mt)) } } - ty::ty_box(mt) { self.visit("box", self.c_mt(mt)) } - ty::ty_uniq(mt) { self.visit("uniq", self.c_mt(mt)) } - ty::ty_ptr(mt) { self.visit("ptr", self.c_mt(mt)) } - ty::ty_rptr(_, mt) { self.visit("rptr", self.c_mt(mt)) } + ty::ty_box(mt) { self.visit(~"box", self.c_mt(mt)) } + ty::ty_uniq(mt) { self.visit(~"uniq", self.c_mt(mt)) } + ty::ty_ptr(mt) { self.visit(~"ptr", self.c_mt(mt)) } + ty::ty_rptr(_, mt) { self.visit(~"rptr", self.c_mt(mt)) } ty::ty_rec(fields) { - do self.bracketed("rec", + do self.bracketed(~"rec", ~[self.c_uint(vec::len(fields))] + self.c_size_and_align(t)) { for fields.eachi |i, field| { - self.visit("rec_field", + self.visit(~"rec_field", ~[self.c_uint(i), self.c_slice(*field.ident)] + self.c_mt(field.mt)); @@ -166,11 +166,11 @@ impl methods for reflector { } ty::ty_tup(tys) { - do self.bracketed("tup", + do self.bracketed(~"tup", ~[self.c_uint(vec::len(tys))] + self.c_size_and_align(t)) { for tys.eachi |i, t| { - self.visit("tup_field", + self.visit(~"tup_field", ~[self.c_uint(i), self.c_tydesc(t)]); } @@ -201,7 +201,7 @@ impl methods for reflector { self.c_uint(protoval), self.c_uint(vec::len(fty.inputs)), self.c_uint(retval)]; - self.visit("enter_fn", extra); + self.visit(~"enter_fn", extra); for fty.inputs.eachi |i, arg| { let modeval = alt arg.mode { ast::infer(_) { 0u } @@ -215,15 +215,15 @@ impl methods for reflector { } } }; - self.visit("fn_input", + self.visit(~"fn_input", ~[self.c_uint(i), self.c_uint(modeval), self.c_tydesc(arg.ty)]); } - self.visit("fn_output", + self.visit(~"fn_output", ~[self.c_uint(retval), self.c_tydesc(fty.output)]); - self.visit("leave_fn", extra); + self.visit(~"leave_fn", extra); } ty::ty_class(did, substs) { @@ -231,10 +231,10 @@ impl methods for reflector { let tcx = bcx.ccx().tcx; let fields = ty::class_items_as_fields(tcx, did, substs); - do self.bracketed("class", ~[self.c_uint(vec::len(fields))] + do self.bracketed(~"class", ~[self.c_uint(vec::len(fields))] + self.c_size_and_align(t)) { for fields.eachi |i, field| { - self.visit("class_field", + self.visit(~"class_field", ~[self.c_uint(i), self.c_slice(*field.ident)] + self.c_mt(field.mt)); @@ -251,17 +251,17 @@ impl methods for reflector { let tcx = bcx.ccx().tcx; let variants = ty::substd_enum_variants(tcx, did, substs); - do self.bracketed("enum", + do self.bracketed(~"enum", ~[self.c_uint(vec::len(variants))] + self.c_size_and_align(t)) { for variants.eachi |i, v| { - do self.bracketed("enum_variant", + do self.bracketed(~"enum_variant", ~[self.c_uint(i), self.c_int(v.disr_val), self.c_uint(vec::len(v.args)), self.c_slice(*v.name)]) { for v.args.eachi |j, a| { - self.visit("enum_variant_field", + self.visit(~"enum_variant_field", ~[self.c_uint(j), self.c_tydesc(a)]); } @@ -271,21 +271,21 @@ impl methods for reflector { } // Miscallaneous extra types - ty::ty_trait(_, _) { self.leaf("trait") } - 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_self { self.leaf("self") } - ty::ty_type { self.leaf("type") } - ty::ty_opaque_box { self.leaf("opaque_box") } - ty::ty_constr(t, _) { self.visit("constr", ~[self.c_tydesc(t)]) } + ty::ty_trait(_, _) { self.leaf(~"trait") } + 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_self { self.leaf(~"self") } + ty::ty_type { self.leaf(~"type") } + ty::ty_opaque_box { self.leaf(~"opaque_box") } + ty::ty_constr(t, _) { self.visit(~"constr", ~[self.c_tydesc(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)]) } } } @@ -296,9 +296,9 @@ fn emit_calls_to_trait_visit_ty(bcx: block, t: ty::t, visitor_val: ValueRef, visitor_iid: def_id) -> block { - let final = sub_block(bcx, "final"); - assert bcx.ccx().tcx.intrinsic_defs.contains_key(@"tydesc"/~); - let (_, tydesc_ty) = bcx.ccx().tcx.intrinsic_defs.get(@"tydesc"/~); + let final = sub_block(bcx, ~"final"); + assert bcx.ccx().tcx.intrinsic_defs.contains_key(@~"tydesc"); + let (_, tydesc_ty) = bcx.ccx().tcx.intrinsic_defs.get(@~"tydesc"); let tydesc_ty = type_of::type_of(bcx.ccx(), tydesc_ty); let r = reflector({ visitor_val: visitor_val, diff --git a/src/rustc/middle/trans/shape.rs b/src/rustc/middle/trans/shape.rs index 607c20573ec..24a1591a6c8 100644 --- a/src/rustc/middle/trans/shape.rs +++ b/src/rustc/middle/trans/shape.rs @@ -97,7 +97,7 @@ const shape_fixedvec: u8 = 32u8; const shape_slice: u8 = 33u8; const shape_unboxed_vec: u8 = 34u8; -fn mk_global(ccx: @crate_ctxt, name: str, llval: ValueRef, internal: bool) -> +fn mk_global(ccx: @crate_ctxt, name: ~str, llval: ValueRef, internal: bool) -> ValueRef { let llglobal = str::as_c_str(name, @@ -184,8 +184,8 @@ fn s_send_tydesc(_tcx: ty_ctxt) -> u8 { } fn mk_ctxt(llmod: ModuleRef) -> ctxt { - let llshapetablesty = trans::common::T_named_struct("shapes"); - let llshapetables = str::as_c_str("shapes", |buf| { + let llshapetablesty = trans::common::T_named_struct(~"shapes"); + let llshapetables = str::as_c_str(~"shapes", |buf| { lib::llvm::llvm::LLVMAddGlobal(llmod, llshapetablesty, buf) }); @@ -351,7 +351,7 @@ fn shape_of(ccx: @crate_ctxt, t: ty::t) -> ~[u8] { s } ty::ty_param(*) { - ccx.tcx.sess.bug("non-monomorphized type parameter"); + 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] } @@ -361,7 +361,7 @@ fn shape_of(ccx: @crate_ctxt, t: ty::t) -> ~[u8] { 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"); + ccx.sess.bug(~"shape_of: unexpected type struct found"); } } } @@ -458,7 +458,7 @@ fn gen_enum_shapes(ccx: @crate_ctxt) -> ValueRef { header += data; header += lv_table; - ret mk_global(ccx, "tag_shapes", C_bytes(header), true); + ret mk_global(ccx, ~"tag_shapes", C_bytes(header), true); /* tjc: Not annotating FIXMEs in this module because of #1498 */ fn largest_variants(ccx: @crate_ctxt, @@ -579,7 +579,7 @@ fn gen_resource_shapes(ccx: @crate_ctxt) -> ValueRef { dtors += ~[trans::base::get_res_dtor(ccx, ri.did, id, ri.tps)]; } } - ret mk_global(ccx, "resource_shapes", C_struct(dtors), true); + ret mk_global(ccx, ~"resource_shapes", C_struct(dtors), true); } fn gen_shape_tables(ccx: @crate_ctxt) { @@ -699,7 +699,7 @@ fn static_size_of_enum(cx: @crate_ctxt, t: ty::t) -> uint { cx.enum_sizes.insert(t, max_size); ret max_size; } - _ { cx.sess.bug("static_size_of_enum called on non-enum"); } + _ { cx.sess.bug(~"static_size_of_enum called on non-enum"); } } } @@ -730,7 +730,7 @@ fn simplify_type(tcx: ty::ctxt, typ: ty::t) -> ty::t { ty::ty_class(did, substs) { let simpl_fields = (if is_some(ty::ty_dtor(tcx, did)) { // remember the drop flag - ~[{ident: @"drop"/~, mt: {ty: + ~[{ident: @~"drop", mt: {ty: ty::mk_u8(tcx), mutbl: ast::m_mutbl}}] } else { ~[] }) + diff --git a/src/rustc/middle/trans/tvec.rs b/src/rustc/middle/trans/tvec.rs index a6e317f9cc3..0c233d2c1bc 100644 --- a/src/rustc/middle/trans/tvec.rs +++ b/src/rustc/middle/trans/tvec.rs @@ -27,14 +27,14 @@ fn expand_boxed_vec_ty(tcx: ty::ctxt, t: ty::t) -> ty::t { ty::ty_estr(ty::vstore_box) | ty::ty_evec(_, ty::vstore_box) { ty::mk_imm_box(tcx, unboxed_vec_ty) } - _ { tcx.sess.bug("non boxed-vec type \ + _ { tcx.sess.bug(~"non boxed-vec type \ in tvec::expand_boxed_vec_ty"); } } } fn get_fill(bcx: block, vptr: ValueRef) -> ValueRef { - let _icx = bcx.insn_ctxt("tvec::get_fill"); + let _icx = bcx.insn_ctxt(~"tvec::get_fill"); Load(bcx, GEPi(bcx, vptr, ~[0u, abi::vec_elt_fill])) } fn set_fill(bcx: block, vptr: ValueRef, fill: ValueRef) { @@ -50,12 +50,12 @@ fn get_bodyptr(bcx: block, vptr: ValueRef) -> ValueRef { fn get_dataptr(bcx: block, vptr: ValueRef) -> ValueRef { - let _icx = bcx.insn_ctxt("tvec::get_dataptr"); + let _icx = bcx.insn_ctxt(~"tvec::get_dataptr"); 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 _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); @@ -63,7 +63,7 @@ fn pointer_add(bcx: block, ptr: ValueRef, bytes: ValueRef) -> ValueRef { fn alloc_raw(bcx: block, unit_ty: ty::t, fill: ValueRef, alloc: ValueRef, heap: heap) -> result { - let _icx = bcx.insn_ctxt("tvec::alloc_uniq"); + let _icx = bcx.insn_ctxt(~"tvec::alloc_uniq"); let ccx = bcx.ccx(); let vecbodyty = ty::mk_mut_unboxed_vec(bcx.tcx(), unit_ty); @@ -80,7 +80,7 @@ fn alloc_uniq_raw(bcx: block, unit_ty: ty::t, } fn alloc_vec(bcx: block, unit_ty: ty::t, elts: uint, heap: heap) -> result { - let _icx = bcx.insn_ctxt("tvec::alloc_uniq"); + let _icx = bcx.insn_ctxt(~"tvec::alloc_uniq"); let ccx = bcx.ccx(); let llunitty = type_of::type_of(ccx, unit_ty); let unit_sz = llsize_of(ccx, llunitty); @@ -93,7 +93,7 @@ fn alloc_vec(bcx: block, unit_ty: ty::t, elts: uint, heap: heap) -> result { } fn duplicate_uniq(bcx: block, vptr: ValueRef, vec_ty: ty::t) -> result { - let _icx = bcx.insn_ctxt("tvec::duplicate_uniq"); + let _icx = bcx.insn_ctxt(~"tvec::duplicate_uniq"); let fill = get_fill(bcx, get_bodyptr(bcx, vptr)); let unit_ty = ty::sequence_element_type(bcx.tcx(), vec_ty); @@ -111,7 +111,7 @@ fn duplicate_uniq(bcx: block, vptr: ValueRef, vec_ty: ty::t) -> result { fn make_drop_glue_unboxed(bcx: block, vptr: ValueRef, vec_ty: ty::t) -> block { - let _icx = bcx.insn_ctxt("tvec::make_drop_glue_unboxed"); + let _icx = bcx.insn_ctxt(~"tvec::make_drop_glue_unboxed"); let tcx = bcx.tcx(), unit_ty = ty::sequence_element_type(tcx, vec_ty); if ty::type_needs_drop(tcx, unit_ty) { iter_vec_unboxed(bcx, vptr, vec_ty, base::drop_ty) @@ -120,7 +120,7 @@ fn make_drop_glue_unboxed(bcx: block, vptr: ValueRef, vec_ty: ty::t) -> 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 _icx = bcx.insn_ctxt(~"tvec::trans_evec"); let ccx = bcx.ccx(); let mut bcx = bcx; if dest == base::ignore { @@ -144,7 +144,7 @@ fn trans_evec(bcx: block, args: ~[@ast::expr], PointerCast(bcx, v, T_ptr(llunitty)) } _ { - bcx.ccx().sess.bug("bad dest for vstore_fixed \ + bcx.ccx().sess.bug(~"bad dest for vstore_fixed \ in tvec::trans_evec"); } }; @@ -226,7 +226,7 @@ fn trans_vstore(bcx: block, e: @ast::expr, ret trans_evec(bcx, es, v, e.id, dest); } _ { - bcx.sess().span_bug(e.span, "vstore on non-sequence type"); + bcx.sess().span_bug(e.span, ~"vstore on non-sequence type"); } } } @@ -266,9 +266,9 @@ fn get_base_and_len(cx: block, v: ValueRef, e_ty: ty::t) } } -fn trans_estr(bcx: block, s: @str/~, vstore: ast::vstore, +fn trans_estr(bcx: block, s: @~str, vstore: ast::vstore, dest: dest) -> block { - let _icx = bcx.insn_ctxt("tvec::trans_estr"); + let _icx = bcx.insn_ctxt(~"tvec::trans_estr"); if dest == base::ignore { ret bcx; } let ccx = bcx.ccx(); @@ -313,7 +313,7 @@ type iter_vec_block = fn(block, ValueRef, ty::t) -> block; fn iter_vec_raw(bcx: block, data_ptr: ValueRef, vec_ty: ty::t, fill: ValueRef, f: iter_vec_block) -> block { - let _icx = bcx.insn_ctxt("tvec::iter_vec_raw"); + let _icx = bcx.insn_ctxt(~"tvec::iter_vec_raw"); let unit_ty = ty::sequence_element_type(bcx.tcx(), vec_ty); @@ -324,14 +324,14 @@ fn iter_vec_raw(bcx: block, data_ptr: ValueRef, vec_ty: ty::t, let data_end_ptr = pointer_add(bcx, data_ptr, fill); // Now perform the iteration. - let header_cx = sub_block(bcx, "iter_vec_loop_header"); + 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 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"); - let next_cx = sub_block(header_cx, "iter_vec_next"); + let body_cx = sub_block(header_cx, ~"iter_vec_loop_body"); + let next_cx = sub_block(header_cx, ~"iter_vec_next"); 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, @@ -344,14 +344,14 @@ fn iter_vec_raw(bcx: block, data_ptr: ValueRef, vec_ty: ty::t, fn iter_vec_uniq(bcx: block, vptr: ValueRef, vec_ty: ty::t, fill: ValueRef, f: iter_vec_block) -> block { - let _icx = bcx.insn_ctxt("tvec::iter_vec_uniq"); + let _icx = bcx.insn_ctxt(~"tvec::iter_vec_uniq"); let data_ptr = get_dataptr(bcx, get_bodyptr(bcx, vptr)); iter_vec_raw(bcx, data_ptr, vec_ty, fill, f) } fn iter_vec_unboxed(bcx: block, body_ptr: ValueRef, vec_ty: ty::t, f: iter_vec_block) -> block { - let _icx = bcx.insn_ctxt("tvec::iter_vec_unboxed"); + let _icx = bcx.insn_ctxt(~"tvec::iter_vec_unboxed"); let fill = get_fill(bcx, body_ptr); let dataptr = get_dataptr(bcx, body_ptr); ret iter_vec_raw(bcx, dataptr, vec_ty, fill, f); diff --git a/src/rustc/middle/trans/type_of.rs b/src/rustc/middle/trans/type_of.rs index cfc1f621efd..aac6f2d97ba 100644 --- a/src/rustc/middle/trans/type_of.rs +++ b/src/rustc/middle/trans/type_of.rs @@ -59,7 +59,7 @@ fn type_of_non_gc_box(cx: @crate_ctxt, t: ty::t) -> TypeRef { T_ptr(T_unique(cx, type_of(cx, mt.ty))) } _ { - cx.sess.bug("non-box in type_of_non_gc_box"); + cx.sess.bug(~"non-box in type_of_non_gc_box"); } } } @@ -158,11 +158,11 @@ fn type_of(cx: @crate_ctxt, t: ty::t) -> TypeRef { common::T_named_struct(llvm_type_name(cx, t)) } - ty::ty_self { cx.tcx.sess.unimpl("type_of: ty_self"); } - ty::ty_var(_) { cx.tcx.sess.bug("type_of shouldn't see a ty_var"); } - ty::ty_param(*) { cx.tcx.sess.bug("type_of with ty_param"); } + ty::ty_self { cx.tcx.sess.unimpl(~"type_of: ty_self"); } + ty::ty_var(_) { cx.tcx.sess.bug(~"type_of with ty_var"); } + ty::ty_param(*) { cx.tcx.sess.bug(~"type_of with ty_param"); } ty::ty_var_integral(_) { - cx.tcx.sess.bug("type_of shouldn't see a ty_var_integral"); + cx.tcx.sess.bug(~"type_of shouldn't see a ty_var_integral"); } }; @@ -227,13 +227,13 @@ fn type_of_enum(cx: @crate_ctxt, did: ast::def_id, t: ty::t) ret named_llty; } -fn llvm_type_name(cx: @crate_ctxt, t: ty::t) -> str { +fn llvm_type_name(cx: @crate_ctxt, t: ty::t) -> ~str { let (name, did, tps) = alt check ty::get(t).struct { ty::ty_enum(did, substs) { - ("enum", did, substs.tps) + (~"enum", did, substs.tps) } ty::ty_class(did, substs) { - ("class", did, substs.tps) + (~"class", did, substs.tps) } }; ret #fmt( diff --git a/src/rustc/middle/trans/type_use.rs b/src/rustc/middle/trans/type_use.rs index ef2a95005da..8d741655d35 100644 --- a/src/rustc/middle/trans/type_use.rs +++ b/src/rustc/middle/trans/type_use.rs @@ -76,17 +76,18 @@ fn type_uses_for(ccx: @crate_ctxt, fn_id: def_id, n_tps: uint) abi, _) { if abi == foreign_abi_rust_intrinsic { let flags = alt check *i.ident { - "size_of" | "pref_align_of" | "min_align_of" | - "init" | "reinterpret_cast" | "move_val" | "move_val_init" { + ~"size_of" | ~"pref_align_of" | ~"min_align_of" | + ~"init" | ~"reinterpret_cast" | + ~"move_val" | ~"move_val_init" { use_repr } - "get_tydesc" | "needs_drop" { use_tydesc } - "atomic_xchng" | "atomic_add" | "atomic_sub" | - "atomic_xchng_acq" | "atomic_add_acq" | "atomic_sub_acq" | - "atomic_xchng_rel" | "atomic_add_rel" | "atomic_sub_rel" { + ~"get_tydesc" | ~"needs_drop" { use_tydesc } + ~"atomic_xchng" | ~"atomic_add" | ~"atomic_sub" | + ~"atomic_xchng_acq" | ~"atomic_add_acq" | ~"atomic_sub_acq" | + ~"atomic_xchng_rel" | ~"atomic_add_rel" | ~"atomic_sub_rel" { 0u } - "visit_tydesc" | "forget" | "addr_of" { 0u } + ~"visit_tydesc" | ~"forget" | ~"addr_of" { 0u } }; for uint::range(0u, n_tps) |n| { cx.uses[n] |= flags;} } diff --git a/src/rustc/middle/trans/uniq.rs b/src/rustc/middle/trans/uniq.rs index 992ed26ee73..b044d0ac23c 100644 --- a/src/rustc/middle/trans/uniq.rs +++ b/src/rustc/middle/trans/uniq.rs @@ -9,7 +9,7 @@ export make_free_glue, autoderef, duplicate; fn make_free_glue(bcx: block, vptr: ValueRef, t: ty::t) -> block { - let _icx = bcx.insn_ctxt("uniq::make_free_glue"); + let _icx = bcx.insn_ctxt(~"uniq::make_free_glue"); do with_cond(bcx, IsNotNull(bcx, vptr)) |bcx| { let content_ty = content_ty(t); let body_ptr = opaque_box_body(bcx, content_ty, vptr); @@ -32,7 +32,7 @@ fn autoderef(bcx: block, v: ValueRef, t: ty::t) -> {v: ValueRef, t: ty::t} { } fn duplicate(bcx: block, v: ValueRef, t: ty::t) -> result { - let _icx = bcx.insn_ctxt("uniq::duplicate"); + let _icx = bcx.insn_ctxt(~"uniq::duplicate"); let content_ty = content_ty(t); let {box: dst_box, body: dst_body} = malloc_unique(bcx, content_ty); diff --git a/src/rustc/middle/tstate/ann.rs b/src/rustc/middle/tstate/ann.rs index f20ad0f73dc..d1f19ba6e1f 100644 --- a/src/rustc/middle/tstate/ann.rs +++ b/src/rustc/middle/tstate/ann.rs @@ -239,8 +239,8 @@ fn implies(a: t, b: t) -> bool { ret tritv_doesntcare(tmp); } -fn trit_str(t: trit) -> str { - alt t { dont_care { "?" } ttrue { "1" } tfalse { "0" } } +fn trit_str(t: trit) -> ~str { + alt t { dont_care { ~"?" } ttrue { ~"1" } tfalse { ~"0" } } } // FIXME (#2538): Would be nice to have unit tests for some of these diff --git a/src/rustc/middle/tstate/annotate.rs b/src/rustc/middle/tstate/annotate.rs index e6beae9e014..de9a4540d21 100644 --- a/src/rustc/middle/tstate/annotate.rs +++ b/src/rustc/middle/tstate/annotate.rs @@ -40,7 +40,7 @@ fn node_ids_in_fn(tcx: ty::ctxt, body: blk, rs: @mut ~[node_id]) { 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)); + log(debug, int::str(i) + ~" |-> " + uint::str(len)); add_node(ccx, i, empty_ann(len)); } } diff --git a/src/rustc/middle/tstate/auxiliary.rs b/src/rustc/middle/tstate/auxiliary.rs index d50e445482a..a098757175c 100644 --- a/src/rustc/middle/tstate/auxiliary.rs +++ b/src/rustc/middle/tstate/auxiliary.rs @@ -30,17 +30,17 @@ enum oper_type { } /* logging funs */ -fn def_id_to_str(d: def_id) -> str { - ret int::str(d.crate) + "," + int::str(d.node); +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 { - let mut rslt = ""; +fn comma_str(args: ~[@constr_arg_use]) -> ~str { + let mut rslt = ~""; let mut comma = false; for args.each |a| { - if comma { rslt += ", "; } else { comma = true; } + if comma { rslt += ~", "; } else { comma = true; } alt a.node { - carg_base { rslt += "*"; } + carg_base { rslt += ~"*"; } carg_ident(i) { rslt += *i.ident; } carg_lit(l) { rslt += lit_to_str(l); } } @@ -48,23 +48,23 @@ fn comma_str(args: ~[@constr_arg_use]) -> str { ret rslt; } -fn constraint_to_str(tcx: ty::ctxt, c: sp_constr) -> str { +fn constraint_to_str(tcx: ty::ctxt, c: sp_constr) -> ~str { ret #fmt("%s(%s) - arising from %s", path_to_str(c.node.path), comma_str(c.node.args), codemap::span_to_str(c.span, tcx.sess.codemap)); } -fn tritv_to_str(fcx: fn_ctxt, v: tritv::t) -> str { - let mut s = ""; +fn tritv_to_str(fcx: fn_ctxt, v: tritv::t) -> ~str { + let mut s = ~""; let mut comma = false; for constraints(fcx).each |p| { alt tritv_get(v, p.bit_num) { dont_care { } tt { s += - if comma { ", " } else { comma = true; "" } + - if tt == tfalse { "!" } else { "" } + + if comma { ~", " } else { comma = true; ~"" } + + if tt == tfalse { ~"!" } else { ~"" } + constraint_to_str(fcx.ccx.tcx, p.c); } } @@ -77,8 +77,8 @@ fn log_tritv(fcx: fn_ctxt, v: tritv::t) { } fn first_difference_string(fcx: fn_ctxt, expected: tritv::t, actual: tritv::t) - -> str { - let mut s = ""; + -> ~str { + let mut s = ~""; for constraints(fcx).each |c| { if tritv_get(expected, c.bit_num) == ttrue && tritv_get(actual, c.bit_num) != ttrue { @@ -93,12 +93,12 @@ fn log_tritv_err(fcx: fn_ctxt, v: tritv::t) { log(error, tritv_to_str(fcx, v)); } -fn tos(v: ~[uint]) -> str { - let mut rslt = ""; +fn tos(v: ~[uint]) -> ~str { + let mut rslt = ~""; for v.each |i| { if i == 0u { - rslt += "0"; - } else if i == 1u { rslt += "1"; } else { rslt += "?"; } + rslt += ~"0"; + } else if i == 1u { rslt += ~"1"; } else { rslt += ~"?"; } } ret rslt; } @@ -143,11 +143,11 @@ fn log_states_err(pp: pre_and_post_state) { log_cond_err(p2); } -fn print_ident(i: ident) { log(debug, " " + *i + " "); } +fn print_ident(i: ident) { log(debug, ~" " + *i + ~" "); } fn print_idents(&idents: ~[ident]) { if vec::len::<ident>(idents) == 0u { ret; } - log(debug, "an ident: " + *vec::pop::<ident>(idents)); + log(debug, ~"an ident: " + *vec::pop::<ident>(idents)); print_idents(idents); } @@ -499,23 +499,23 @@ fn constraints(fcx: fn_ctxt) -> ~[norm_constraint] { fn match_args(fcx: fn_ctxt, occs: @dvec<pred_args>, occ: ~[@constr_arg_use]) -> uint { #debug("match_args: looking at %s", - constr_args_to_str(fn@(i: inst) -> str { ret *i.ident; }, occ)); + constr_args_to_str(fn@(i: inst) -> ~str { ret *i.ident; }, occ)); for (*occs).each |pd| { log(debug, - "match_args: candidate " + pred_args_to_str(pd)); + ~"match_args: candidate " + pred_args_to_str(pd)); fn eq(p: inst, q: inst) -> bool { ret p.node == q.node; } if ty::args_eq(eq, pd.node.args, occ) { ret pd.node.bit_num; } } - fcx.ccx.tcx.sess.bug("match_args: no match for occurring args"); + fcx.ccx.tcx.sess.bug(~"match_args: no match for occurring args"); } fn def_id_for_constr(tcx: ty::ctxt, t: node_id) -> def_id { alt tcx.def_map.find(t) { none { - tcx.sess.bug("node_id_for_constr: bad node_id " + int::str(t)); + tcx.sess.bug(~"node_id_for_constr: bad node_id " + int::str(t)); } some(def_fn(i, _)) { ret i; } - _ { tcx.sess.bug("node_id_for_constr: pred is not a function"); } + _ { tcx.sess.bug(~"node_id_for_constr: pred is not a function"); } } } @@ -535,7 +535,7 @@ fn expr_to_constr_arg(tcx: ty::ctxt, e: @expr) -> @constr_arg_use { } none { tcx.sess.span_bug(e.span, - "exprs_to_constr_args: unbound id as pred arg"); + ~"exprs_to_constr_args: unbound id as pred arg"); } } @@ -543,8 +543,8 @@ fn expr_to_constr_arg(tcx: ty::ctxt, e: @expr) -> @constr_arg_use { expr_lit(l) { ret @respan(e.span, carg_lit(l)); } _ { tcx.sess.span_fatal(e.span, - "arguments to constrained functions must be " + - "literals or local variables"); + ~"arguments to constrained functions must be " + + ~"literals or local variables"); } } } @@ -569,20 +569,21 @@ fn expr_to_constr(tcx: ty::ctxt, e: @expr) -> sp_constr { } _ { tcx.sess.span_bug(operator.span, - "ill-formed operator in predicate"); + ~"ill-formed operator in predicate"); } } } _ { - tcx.sess.span_bug(e.span, "ill-formed predicate"); + tcx.sess.span_bug(e.span, ~"ill-formed predicate"); } } } -fn pred_args_to_str(p: pred_args) -> str { - "<" + uint::str(p.node.bit_num) + ", " + - constr_args_to_str(fn@(i: inst) -> str { ret *i.ident; }, p.node.args) - + ">" +fn pred_args_to_str(p: pred_args) -> ~str { + ~"<" + uint::str(p.node.bit_num) + ~", " + + constr_args_to_str(fn@(i: inst) -> ~str {ret *i.ident; }, + p.node.args) + + ~">" } fn substitute_constr_args(cx: ty::ctxt, actuals: ~[@expr], c: @ty::constr) -> @@ -604,7 +605,7 @@ fn substitute_arg(cx: ty::ctxt, actuals: ~[@expr], a: @constr_arg) -> if i < num_actuals { ret expr_to_constr_arg(cx, actuals[i]); } else { - cx.sess.span_fatal(a.span, "constraint argument out of bounds"); + cx.sess.span_fatal(a.span, ~"constraint argument out of bounds"); } } carg_base { ret @respan(a.span, carg_base); } @@ -689,18 +690,18 @@ 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 { - let mut rslt = "<"; +fn insts_to_str(stuff: ~[constr_arg_general_<inst>]) -> ~str { + let mut rslt = ~"<"; for stuff.each |i| { rslt += - " " + + ~" " + alt i { carg_ident(p) { *p.ident } - carg_base { "*" } - carg_lit(_) { "~[lit]" } - } + " "; + carg_base { ~"*" } + carg_lit(_) { ~"~[lit]" } + } + ~" "; } - rslt += ">"; + rslt += ~">"; rslt } @@ -741,13 +742,13 @@ fn local_node_id_to_def_id_strict(fcx: fn_ctxt, sp: span, i: node_id) -> } some(_) { fcx.ccx.tcx.sess.span_fatal(sp, - "local_node_id_to_def_id: id \ + ~"local_node_id_to_def_id: id \ isn't a local"); } none { // should really be bug. span_bug()? fcx.ccx.tcx.sess.span_fatal(sp, - "local_node_id_to_def_id: id \ + ~"local_node_id_to_def_id: id \ is unbound"); } } @@ -898,7 +899,7 @@ fn args_to_constr_args(tcx: ty::ctxt, args: ~[arg], node: args[i].id}) } else { tcx.sess.span_bug(a.span, - "index out of bounds in \ + ~"index out of bounds in \ constraint arg"); } } @@ -949,7 +950,7 @@ fn callee_modes(fcx: fn_ctxt, callee: node_id) -> ~[mode] { } _ { // Shouldn't happen; callee should be ty_fn. - fcx.ccx.tcx.sess.bug("non-fn callee type in callee_modes: " + + fcx.ccx.tcx.sess.bug(~"non-fn callee type in callee_modes: " + util::ppaux::ty_to_str(fcx.ccx.tcx, ty)); } } diff --git a/src/rustc/middle/tstate/ck.rs b/src/rustc/middle/tstate/ck.rs index b5e9c5d32c8..d534b764c07 100644 --- a/src/rustc/middle/tstate/ck.rs +++ b/src/rustc/middle/tstate/ck.rs @@ -25,15 +25,15 @@ fn check_states_expr(e: @expr, fcx: fn_ctxt, v: visit::vt<fn_ctxt>) { let pres: prestate = expr_prestate(fcx.ccx, e); if !implies(pres, prec) { - let mut s = ""; + let mut s = ~""; let diff = first_difference_string(fcx, prec, pres); s += - "unsatisfied precondition constraint (for example, " + diff + - ") for expression:\n"; + ~"unsatisfied precondition constraint (for example, " + diff + + ~") for expression:\n"; s += syntax::print::pprust::expr_to_str(e); - s += "\nprecondition:\n"; + s += ~"\nprecondition:\n"; s += tritv_to_str(fcx, prec); - s += "\nprestate:\n"; + s += ~"\nprestate:\n"; s += tritv_to_str(fcx, pres); fcx.ccx.tcx.sess.span_fatal(e.span, s); } @@ -54,15 +54,15 @@ fn check_states_stmt(s: @stmt, fcx: fn_ctxt, v: visit::vt<fn_ctxt>) { log_tritv(fcx, pres); if !implies(pres, prec) { - let mut ss = ""; + let mut ss = ~""; let diff = first_difference_string(fcx, prec, pres); ss += - "unsatisfied precondition constraint (for example, " + diff + - ") for statement:\n"; + ~"unsatisfied precondition constraint (for example, " + diff + + ~") for statement:\n"; ss += syntax::print::pprust::stmt_to_str(*s); - ss += "\nprecondition:\n"; + ss += ~"\nprecondition:\n"; ss += tritv_to_str(fcx, prec); - ss += "\nprestate: \n"; + ss += ~"\nprestate: \n"; ss += tritv_to_str(fcx, pres); fcx.ccx.tcx.sess.span_fatal(s.span, ss); } diff --git a/src/rustc/middle/tstate/collect_locals.rs b/src/rustc/middle/tstate/collect_locals.rs index 6c5eebbcb0b..d7bfd031307 100644 --- a/src/rustc/middle/tstate/collect_locals.rs +++ b/src/rustc/middle/tstate/collect_locals.rs @@ -55,7 +55,7 @@ fn find_locals(tcx: ty::ctxt, fn add_constraint(tcx: ty::ctxt, c: sp_constr, next: uint, tbl: constr_map) -> uint { log(debug, - constraint_to_str(tcx, c) + " |-> " + uint::str(next)); + constraint_to_str(tcx, c) + ~" |-> " + uint::str(next)); let {path: p, def_id: d_id, args: args} = c.node; alt tbl.find(d_id) { diff --git a/src/rustc/middle/tstate/pre_post_conditions.rs b/src/rustc/middle/tstate/pre_post_conditions.rs index fe502e18476..591f152acb3 100644 --- a/src/rustc/middle/tstate/pre_post_conditions.rs +++ b/src/rustc/middle/tstate/pre_post_conditions.rs @@ -50,12 +50,12 @@ fn find_pre_post_item(ccx: crate_ctxt, i: item) { item_foreign_mod(nm) { find_pre_post_foreign_mod(nm); } item_ty(*) | item_enum(*) | item_trait(*) { ret; } item_class(*) { - fail "find_pre_post_item: shouldn't be called on item_class"; + fail ~"find_pre_post_item: shouldn't be called on item_class"; } item_impl(_, _, _, ms) { for ms.each |m| { find_pre_post_method(ccx, m); } } - item_mac(*) { fail "item macros unimplemented" } + item_mac(*) { fail ~"item macros unimplemented" } } } @@ -303,7 +303,7 @@ fn find_pre_post_expr(fcx: fn_ctxt, e: @expr) { for (*cap_clause).each |cap_item| { if cap_item.is_move { - log(debug, ("forget_in_postcond: ", cap_item)); + log(debug, (~"forget_in_postcond: ", cap_item)); forget_in_postcond(fcx, e.id, cap_item.id); } } @@ -447,7 +447,7 @@ fn find_pre_post_expr(fcx: fn_ctxt, e: @expr) { } expr_break { clear_pp(expr_pp(fcx.ccx, e)); } expr_again { clear_pp(expr_pp(fcx.ccx, e)); } - expr_mac(_) { fcx.ccx.tcx.sess.bug("unexpanded macro"); } + expr_mac(_) { fcx.ccx.tcx.sess.bug(~"unexpanded macro"); } } } diff --git a/src/rustc/middle/tstate/states.rs b/src/rustc/middle/tstate/states.rs index f6cf240eeca..ebe476b3d7f 100644 --- a/src/rustc/middle/tstate/states.rs +++ b/src/rustc/middle/tstate/states.rs @@ -20,7 +20,7 @@ fn forbid_upvar(fcx: fn_ctxt, rhs_id: node_id, sp: span, t: oper_type) { alt local_node_id_to_def(fcx, rhs_id) { some(def_upvar(_, _, _)) { fcx.ccx.tcx.sess.span_err(sp, - "tried to deinitialize a variable \ + ~"tried to deinitialize a variable \ declared in a different scope"); } _ { } @@ -309,7 +309,7 @@ fn find_pre_post_state_expr(fcx: fn_ctxt, pres: prestate, e: @expr) -> bool { expr_log(_, lvl, ex) { ret find_pre_post_state_two(fcx, pres, lvl, ex, e.id, oper_pure); } - expr_mac(_) { fcx.ccx.tcx.sess.bug("unexpanded macro"); } + expr_mac(_) { fcx.ccx.tcx.sess.bug(~"unexpanded macro"); } expr_lit(l) { ret pure_exp(fcx.ccx, e.id, pres); } expr_fn(_, _, _, cap_clause) { ret find_pre_post_state_cap_clause(fcx, e.id, pres, cap_clause); diff --git a/src/rustc/middle/tstate/tritv.rs b/src/rustc/middle/tstate/tritv.rs index c3e221ef32c..fc158262cb6 100644 --- a/src/rustc/middle/tstate/tritv.rs +++ b/src/rustc/middle/tstate/tritv.rs @@ -264,15 +264,15 @@ fn to_vec(v: t) -> ~[uint] { ret rslt; } -fn to_str(v: t) -> str { +fn to_str(v: t) -> ~str { let mut i: uint = 0u; - let mut rs: str = ""; + let mut rs: ~str = ~""; while i < v.nbits { rs += alt tritv_get(v, i) { - dont_care { "?" } - ttrue { "1" } - tfalse { "0" } + dont_care { ~"?" } + ttrue { ~"1" } + tfalse { ~"0" } }; i += 1u; } diff --git a/src/rustc/middle/ty.rs b/src/rustc/middle/ty.rs index a0a3c818e5f..c3bcefb9fa5 100644 --- a/src/rustc/middle/ty.rs +++ b/src/rustc/middle/ty.rs @@ -253,7 +253,7 @@ type ctxt = freevars: freevars::freevar_map, tcache: type_cache, rcache: creader_cache, - short_names_cache: hashmap<t, @str/~>, + short_names_cache: hashmap<t, @~str>, needs_drop_cache: hashmap<t, bool>, needs_unwind_cleanup_cache: hashmap<t, bool>, kind_cache: hashmap<t, kind>, @@ -444,26 +444,26 @@ enum region_vid = uint; iface vid { fn to_uint() -> uint; - fn to_str() -> str; + fn to_str() -> ~str; } impl of vid for tv_vid { fn to_uint() -> uint { *self } - fn to_str() -> str { #fmt["<V%u>", self.to_uint()] } + fn to_str() -> ~str { #fmt["<V%u>", self.to_uint()] } } impl of vid for tvi_vid { fn to_uint() -> uint { *self } - fn to_str() -> str { #fmt["<VI%u>", self.to_uint()] } + fn to_str() -> ~str { #fmt["<VI%u>", self.to_uint()] } } impl of vid for region_vid { fn to_uint() -> uint { *self } - fn to_str() -> str { #fmt["<R%u>", self.to_uint()] } + fn to_str() -> ~str { #fmt["<R%u>", self.to_uint()] } } impl of to_str::to_str for purity { - fn to_str() -> str { + fn to_str() -> ~str { purity_to_str(self) } } @@ -1020,10 +1020,10 @@ fn substs_is_noop(substs: substs) -> bool { substs.self_ty.is_none() } -fn substs_to_str(cx: ctxt, substs: substs) -> str { +fn substs_to_str(cx: ctxt, substs: substs) -> ~str { #fmt["substs(self_r=%s, self_ty=%s, tps=%?)", - substs.self_r.map_default("none", |r| region_to_str(cx, r)), - substs.self_ty.map_default("none", |t| ty_to_str(cx, t)), + substs.self_r.map_default(~"none", |r| region_to_str(cx, r)), + substs.self_ty.map_default(~"none", |t| ty_to_str(cx, t)), substs.tps.map(|t| ty_to_str(cx, t))] } @@ -1117,7 +1117,9 @@ fn sequence_element_type(cx: ctxt, ty: t) -> t { alt get(ty).struct { ty_str | ty_estr(_) { ret mk_mach_uint(cx, ast::ty_u8); } ty_vec(mt) | ty_evec(mt, _) | ty_unboxed_vec(mt) { ret mt.ty; } - _ { cx.sess.bug("sequence_element_type called on non-sequence value"); } + _ { cx.sess.bug( + ~"sequence_element_type called on non-sequence value"); + } } } @@ -1125,7 +1127,7 @@ fn get_element_type(ty: t, i: uint) -> t { alt get(ty).struct { ty_rec(flds) { ret flds[i].mt.ty; } ty_tup(ts) { ret ts[i]; } - _ { fail "get_element_type called on invalid type"; } + _ { fail ~"get_element_type called on invalid type"; } } } @@ -1603,10 +1605,10 @@ fn type_kind(cx: ctxt, ty: t) -> kind { // FIXME (#2663): is self ever const? ty_self { kind_noncopyable() } ty_var(_) | ty_var_integral(_) { - cx.sess.bug("Asked to compute kind of a type variable"); + cx.sess.bug(~"Asked to compute kind of a type variable"); } ty_type | ty_opaque_closure_ptr(_) | ty_opaque_box | ty_unboxed_vec(_) { - cx.sess.bug("Asked to compute kind of fictitious type"); + cx.sess.bug(~"Asked to compute kind of fictitious type"); } }; @@ -1785,7 +1787,7 @@ fn type_allows_implicit_copy(cx: ctxt, ty: t) -> bool { ty_param(_, _) { true } ty_evec(_, _) | ty_estr(_) { - cx.sess.unimpl("estr/evec in type_allows_implicit_copy"); + cx.sess.unimpl(~"estr/evec in type_allows_implicit_copy"); } ty_vec(mt) { @@ -1889,7 +1891,7 @@ fn type_is_pod(cx: ctxt, ty: t) -> bool { } ty_var(*) | ty_var_integral(*) | ty_self(*) { - cx.sess.bug("non concrete type in type_is_pod"); + cx.sess.bug(~"non concrete type in type_is_pod"); } } @@ -2010,7 +2012,7 @@ fn hash_type_structure(st: sty) -> uint { for c.node.args.each |a| { alt a.node { carg_base { h += h << 2u; } - carg_lit(_) { fail "lit args not implemented yet"; } + carg_lit(_) { fail ~"lit args not implemented yet"; } carg_ident(p) { h += h << 2u; } } } @@ -2166,28 +2168,28 @@ fn node_id_has_type_params(cx: ctxt, id: ast::node_id) -> bool { 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"; } + _ { fail ~"ty_fn_args() called on non-fn type"; } } } fn ty_fn_proto(fty: t) -> ast::proto { alt get(fty).struct { ty_fn(f) { f.proto } - _ { fail "ty_fn_proto() called on non-fn type"; } + _ { fail ~"ty_fn_proto() called on non-fn type"; } } } pure fn ty_fn_ret(fty: t) -> t { alt get(fty).struct { ty_fn(f) { f.output } - _ { fail "ty_fn_ret() called on non-fn type"; } + _ { fail ~"ty_fn_ret() called on non-fn type"; } } } fn ty_fn_ret_style(fty: t) -> ast::ret_style { alt get(fty).struct { ty_fn(f) { f.ret_style } - _ { fail "ty_fn_ret_style() called on non-fn type"; } + _ { fail ~"ty_fn_ret_style() called on non-fn type"; } } } @@ -2321,11 +2323,11 @@ fn occurs_check(tcx: ctxt, sp: span, vid: tv_vid, rt: t) { // assertion later on that the type doesn't contain // variables, so in this case we have to be sure to die. tcx.sess.span_fatal - (sp, "type inference failed because I \ + (sp, ~"type inference failed because I \ could not find a type\n that's both of the form " + ty_to_str(tcx, mk_var(tcx, vid)) + - " and of the form " + ty_to_str(tcx, rt) + - " - such a type would have to be infinitely large."); + ~" and of the form " + ty_to_str(tcx, rt) + + ~" - such a type would have to be infinitely large."); } } @@ -2400,7 +2402,7 @@ fn set_default_mode(cx: ctxt, m: ast::mode, m_def: ast::rmode) { } } -fn ty_sort_str(cx: ctxt, t: t) -> str { +fn ty_sort_str(cx: ctxt, t: t) -> ~str { alt get(t).struct { ty_nil | ty_bot | ty_bool | ty_int(_) | ty_uint(_) | ty_float(_) | ty_estr(_) | ty_str | @@ -2409,41 +2411,41 @@ fn ty_sort_str(cx: ctxt, t: t) -> str { } ty_enum(id, _) { #fmt["enum %s", item_path_str(cx, id)] } - ty_box(_) { "@-ptr" } - ty_uniq(_) { "~-ptr" } - ty_evec(_, _) | ty_vec(_) { "vector" } - ty_unboxed_vec(_) { "unboxed vector" } - ty_ptr(_) { "*-ptr" } - ty_rptr(_, _) { "&-ptr" } - ty_rec(_) { "record" } - ty_fn(_) { "fn" } + ty_box(_) { ~"@-ptr" } + ty_uniq(_) { ~"~-ptr" } + ty_evec(_, _) | ty_vec(_) { ~"vector" } + ty_unboxed_vec(_) { ~"unboxed vector" } + ty_ptr(_) { ~"*-ptr" } + ty_rptr(_, _) { ~"&-ptr" } + ty_rec(_) { ~"record" } + ty_fn(_) { ~"fn" } ty_trait(id, _) { #fmt["trait %s", item_path_str(cx, id)] } ty_class(id, _) { #fmt["class %s", item_path_str(cx, id)] } - ty_tup(_) { "tuple" } - ty_var(_) { "variable" } - ty_var_integral(_) { "integral variable" } - ty_param(_, _) { "type parameter" } - ty_self { "self" } + ty_tup(_) { ~"tuple" } + ty_var(_) { ~"variable" } + ty_var_integral(_) { ~"integral variable" } + ty_param(_, _) { ~"type parameter" } + ty_self { ~"self" } ty_constr(t, _) { ty_sort_str(cx, t) } } } -fn type_err_to_str(cx: ctxt, err: type_err) -> str { - fn terr_vstore_kind_to_str(k: terr_vstore_kind) -> str { - alt k { terr_vec { "[]" } terr_str { "str" } } +fn type_err_to_str(cx: ctxt, err: type_err) -> ~str { + fn terr_vstore_kind_to_str(k: terr_vstore_kind) -> ~str { + alt k { terr_vec { ~"[]" } terr_str { ~"str" } } } alt err { - terr_mismatch { ret "types differ"; } + terr_mismatch { ret ~"types differ"; } terr_ret_style_mismatch(expect, actual) { - fn to_str(s: ast::ret_style) -> str { + fn to_str(s: ast::ret_style) -> ~str { alt s { - ast::noreturn { "non-returning" } - ast::return_val { "return-by-value" } + ast::noreturn { ~"non-returning" } + ast::return_val { ~"return-by-value" } } } - ret to_str(actual) + " function found where " + to_str(expect) + - " function was expected"; + ret to_str(actual) + ~" function found where " + to_str(expect) + + ~" function was expected"; } terr_purity_mismatch(f1, f2) { ret #fmt["expected %s fn but found %s fn", f1.to_str(), f2.to_str()]; @@ -2452,45 +2454,45 @@ fn type_err_to_str(cx: ctxt, err: type_err) -> str { ret #fmt["closure protocol mismatch (%s vs %s)", proto_to_str(e), proto_to_str(a)]; } - terr_mutability { ret "values differ in mutability"; } - terr_box_mutability { ret "boxed values differ in mutability"; } - terr_vec_mutability { ret "vectors differ in mutability"; } - terr_ptr_mutability { ret "pointers differ in mutability"; } - terr_ref_mutability { ret "references differ in mutability"; } + terr_mutability { ret ~"values differ in mutability"; } + terr_box_mutability { ret ~"boxed values differ in mutability"; } + terr_vec_mutability { ret ~"vectors differ in mutability"; } + terr_ptr_mutability { ret ~"pointers differ in mutability"; } + terr_ref_mutability { ret ~"references differ in mutability"; } terr_ty_param_size(e_sz, a_sz) { - ret "expected a type with " + uint::to_str(e_sz, 10u) + - " type params but found one with " + uint::to_str(a_sz, 10u) + - " type params"; + ret ~"expected a type with " + uint::to_str(e_sz, 10u) + + ~" type params but found one with " + uint::to_str(a_sz, 10u) + + ~" type params"; } terr_tuple_size(e_sz, a_sz) { - ret "expected a tuple with " + uint::to_str(e_sz, 10u) + - " elements but found one with " + uint::to_str(a_sz, 10u) + - " elements"; + ret ~"expected a tuple with " + uint::to_str(e_sz, 10u) + + ~" elements but found one with " + uint::to_str(a_sz, 10u) + + ~" elements"; } terr_record_size(e_sz, a_sz) { - ret "expected a record with " + uint::to_str(e_sz, 10u) + - " fields but found one with " + uint::to_str(a_sz, 10u) + - " fields"; + ret ~"expected a record with " + uint::to_str(e_sz, 10u) + + ~" fields but found one with " + uint::to_str(a_sz, 10u) + + ~" fields"; } - terr_record_mutability { ret "record elements differ in mutability"; } + terr_record_mutability { ret ~"record elements differ in mutability"; } terr_record_fields(e_fld, a_fld) { - ret "expected a record with field `" + *e_fld + - "` but found one with field `" + *a_fld + "`"; + ret ~"expected a record with field `" + *e_fld + + ~"` but found one with field `" + *a_fld + ~"`"; } - terr_arg_count { ret "incorrect number of function parameters"; } + terr_arg_count { ret ~"incorrect number of function parameters"; } terr_mode_mismatch(e_mode, a_mode) { - ret "expected argument mode " + mode_to_str(e_mode) + " but found " + - mode_to_str(a_mode); + ret ~"expected argument mode " + mode_to_str(e_mode) + + ~" but found " + mode_to_str(a_mode); } terr_constr_len(e_len, a_len) { - ret "expected a type with " + uint::str(e_len) + - " constraints, but found one with " + uint::str(a_len) + - " constraints"; + ret ~"expected a type with " + uint::str(e_len) + + ~" constraints, but found one with " + uint::str(a_len) + + ~" constraints"; } terr_constr_mismatch(e_constr, a_constr) { - ret "expected a type with constraint " + ty_constr_to_str(e_constr) + - " but found one with constraint " + - ty_constr_to_str(a_constr); + ret ~"expected a type with constraint " + ty_constr_to_str(e_constr) + + ~" but found one with constraint " + + ty_constr_to_str(a_constr); } terr_regions_differ(subregion, superregion) { ret #fmt("references with lifetime %s do not necessarily \ @@ -2511,10 +2513,10 @@ fn type_err_to_str(cx: ctxt, err: type_err) -> str { ret #fmt("%s vs %s", ty_sort_str(cx, exp), ty_sort_str(cx, act)); } terr_self_substs { - ret "inconsistent self substitution"; // XXX this is more of a bug + ret ~"inconsistent self substitution"; // XXX this is more of a bug } terr_no_integral_type { - ret "couldn't determine an appropriate integral type for integer \ + ret ~"couldn't determine an appropriate integral type for integer \ literal"; } } @@ -2602,7 +2604,7 @@ fn substd_enum_variants(cx: ctxt, } } -fn item_path_str(cx: ctxt, id: ast::def_id) -> str { +fn item_path_str(cx: ctxt, id: ast::def_id) -> ~str { ast_map::path_to_str(item_path(cx, id)) } @@ -2661,7 +2663,7 @@ fn item_path(cx: ctxt, id: ast::def_id) -> ast_map::path { vec::append_one(*path, ast_map::path_name(nm)) } ast_map::node_dtor(_, _, _, path) { - vec::append_one(*path, ast_map::path_name(@"dtor"/~)) + vec::append_one(*path, ast_map::path_name(@~"dtor")) } @@ -2707,7 +2709,7 @@ fn enum_variants(cx: ctxt, id: ast::def_id) -> @~[variant_info] { // FIXME: issue #1417 disr_val = alt const_eval::eval_const_expr(cx, ex) { const_eval::const_int(val) {val as int} - _ { cx.sess.bug("tag_variants: bad disr expr"); } + _ { cx.sess.bug(~"tag_variants: bad disr expr"); } } } _ {disr_val += 1;} @@ -2720,7 +2722,7 @@ fn enum_variants(cx: ctxt, id: ast::def_id) -> @~[variant_info] { } }) } - _ { cx.sess.bug("tag_variants: id not bound to an enum"); } + _ { cx.sess.bug(~"tag_variants: id not bound to an enum"); } } }; cx.enum_var_cache.insert(id, result); @@ -2738,7 +2740,7 @@ fn enum_variant_with_id(cx: ctxt, enum_id: ast::def_id, if ast_util::def_eq(variant.id, variant_id) { ret variant; } i += 1u; } - cx.sess.bug("enum_variant_with_id(): no variant exists with that ID"); + cx.sess.bug(~"enum_variant_with_id(): no variant exists with that ID"); } @@ -2789,7 +2791,7 @@ fn lookup_class_fields(cx: ctxt, did: ast::def_id) -> ~[field_ty] { ast::item_class(_, _, items, _, _) { class_field_tys(items) } - _ { cx.sess.bug("class ID bound to non-class"); } + _ { cx.sess.bug(~"class ID bound to non-class"); } } } _ { @@ -2808,7 +2810,7 @@ fn lookup_class_field(cx: ctxt, parent: ast::def_id, field_id: ast::def_id) alt vec::find(lookup_class_fields(cx, parent), |f| f.id.node == field_id.node) { some(t) { t } - none { cx.sess.bug("class ID not found in parent's fields"); } + none { cx.sess.bug(~"class ID not found in parent's fields"); } } } @@ -2834,7 +2836,7 @@ fn lookup_class_method_ids(cx: ctxt, did: ast::def_id) vis: m.vis}) } _ { - cx.sess.bug("lookup_class_method_ids: id not bound to a class"); + cx.sess.bug(~"lookup_class_method_ids: id not bound to a class"); } } } @@ -2995,8 +2997,8 @@ fn ast_constr_to_constr<T>(tcx: ctxt, c: @ast::constr_general<T>) -> } _ { tcx.sess.span_fatal(c.span, - "predicate " + path_to_str(c.node.path) + - " is unbound or bound to a non-function or an \ + ~"predicate " + path_to_str(c.node.path) + + ~" is unbound or bound to a non-function or an \ impure function"); } } diff --git a/src/rustc/middle/typeck.rs b/src/rustc/middle/typeck.rs index 0daf663315b..1d86c47dddb 100644 --- a/src/rustc/middle/typeck.rs +++ b/src/rustc/middle/typeck.rs @@ -176,7 +176,7 @@ fn lookup_def_tcx(tcx: ty::ctxt, sp: span, id: ast::node_id) -> ast::def { alt tcx.def_map.find(id) { some(x) { x } _ { - tcx.sess.span_fatal(sp, "internal error looking up a definition") + tcx.sess.span_fatal(sp, ~"internal error looking up a definition") } } } @@ -195,7 +195,7 @@ fn require_same_types( span: span, t1: ty::t, t2: ty::t, - msg: fn() -> str) -> bool { + msg: fn() -> ~str) -> bool { let l_tcx, l_infcx; alt maybe_infcx { @@ -212,7 +212,7 @@ fn require_same_types( alt infer::mk_eqty(l_infcx, t1, t2) { result::ok(()) { true } result::err(terr) { - l_tcx.sess.span_err(span, msg() + ": " + + l_tcx.sess.span_err(span, msg() + ~": " + ty::type_err_to_str(l_tcx, terr)); false } @@ -246,7 +246,7 @@ fn check_main_fn_ty(ccx: @crate_ctxt, alt it.node { ast::item_fn(_,ps,_) if vec::is_not_empty(ps) { tcx.sess.span_err(main_span, - "main function is not allowed to have type parameters"); + ~"main function is not allowed to have type parameters"); ret; } _ {} @@ -269,8 +269,8 @@ fn check_main_fn_ty(ccx: @crate_ctxt, } _ { tcx.sess.span_bug(main_span, - "main has a non-function type: found `" + - ty_to_str(tcx, main_t) + "`"); + ~"main has a non-function type: found `" + + ty_to_str(tcx, main_t) + ~"`"); } } } @@ -280,7 +280,7 @@ fn check_for_main_fn(ccx: @crate_ctxt) { if !tcx.sess.building_library { alt copy tcx.sess.main_fn { some((id, sp)) { check_main_fn_ty(ccx, id, sp); } - none { tcx.sess.err("main function not found"); } + none { tcx.sess.err(~"main function not found"); } } } } diff --git a/src/rustc/middle/typeck/astconv.rs b/src/rustc/middle/typeck/astconv.rs index c785e44b80a..7d09c57dc92 100644 --- a/src/rustc/middle/typeck/astconv.rs +++ b/src/rustc/middle/typeck/astconv.rs @@ -57,7 +57,7 @@ iface ast_conv { fn get_region_reporting_err(tcx: ty::ctxt, span: span, - res: result<ty::region, str>) -> ty::region { + res: result<ty::region, ~str>) -> ty::region { alt res { result::ok(r) { r } @@ -197,7 +197,7 @@ fn ast_ty_to_ty<AC: ast_conv, RS: region_scope copy>( if path.types.len() > 0u { tcx.sess.span_err( path.span, - "type parameters are not allowed on this type"); + ~"type parameters are not allowed on this type"); } } @@ -205,7 +205,7 @@ fn ast_ty_to_ty<AC: ast_conv, RS: region_scope copy>( if path.rp.is_some() { tcx.sess.span_err( path.span, - "region parameters are not allowed on this type"); + ~"region parameters are not allowed on this type"); } } } @@ -215,7 +215,7 @@ fn ast_ty_to_ty<AC: ast_conv, RS: region_scope copy>( alt tcx.ast_ty_to_ty_cache.find(ast_ty) { some(ty::atttce_resolved(ty)) { ret ty; } some(ty::atttce_unresolved) { - tcx.sess.span_fatal(ast_ty.span, "illegal recursive type; \ + tcx.sess.span_fatal(ast_ty.span, ~"illegal recursive type; \ insert an enum in the cycle, \ if this is desired"); } @@ -289,7 +289,7 @@ fn ast_ty_to_ty<AC: ast_conv, RS: region_scope copy>( } ast::ty_str { check_path_args(tcx, path, NO_TPS); - // This is a bit of a hack, but basically str/& needs to be + // This is a bit of a hack, but basically &str needs to be // converted into a vstore: alt path.rp { none { @@ -317,7 +317,7 @@ fn ast_ty_to_ty<AC: ast_conv, RS: region_scope copy>( } _ { tcx.sess.span_fatal(ast_ty.span, - "found type name used as a variable"); + ~"found type name used as a variable"); } } } @@ -372,7 +372,7 @@ fn ast_ty_to_ty<AC: ast_conv, RS: region_scope copy>( ast::ty_vstore(_, ast::vstore_fixed(none)) { tcx.sess.span_bug( ast_ty.span, - "implied fixed length for bound"); + ~"implied fixed length for bound"); } /* ast::ty_vstore(_, _) { @@ -393,11 +393,11 @@ fn ast_ty_to_ty<AC: ast_conv, RS: region_scope copy>( // routine. self.tcx().sess.span_bug( ast_ty.span, - "found `ty_infer` in unexpected place"); + ~"found `ty_infer` in unexpected place"); } ast::ty_mac(_) { tcx.sess.span_bug(ast_ty.span, - "found `ty_mac` in unexpected place"); + ~"found `ty_mac` in unexpected place"); } }; diff --git a/src/rustc/middle/typeck/check.rs b/src/rustc/middle/typeck/check.rs index 10b7ff78df7..fa43449f30e 100644 --- a/src/rustc/middle/typeck/check.rs +++ b/src/rustc/middle/typeck/check.rs @@ -384,8 +384,9 @@ fn check_item(ccx: @crate_ctxt, it: @ast::item) { // Check that there's at least one field let (fields,_) = split_class_items(members); if fields.len() < 1u { - ccx.tcx.sess.span_err(it.span, "a class must have at least one \ - field"); + ccx.tcx.sess.span_err( + it.span, + ~"a class must have at least one field"); } // Check that the class is instantiable check_instantiable(ccx.tcx, it.span, it.id); @@ -429,14 +430,14 @@ impl of ast_conv for @fn_ctxt { } impl of region_scope for @fn_ctxt { - fn anon_region() -> result<ty::region, str> { + fn anon_region() -> result<ty::region, ~str> { result::ok(self.infcx.next_region_var()) } - fn named_region(id: ast::ident) -> result<ty::region, str> { + fn named_region(id: ast::ident) -> result<ty::region, ~str> { do empty_rscope.named_region(id).chain_err |_e| { alt self.in_scope_regions.find(ty::br_named(id)) { some(r) { result::ok(r) } - none if *id == "blk" { self.block_region() } + none if *id == ~"blk" { self.block_region() } none { result::err(#fmt["named region `%s` not in scope here", *id]) } @@ -446,11 +447,11 @@ impl of region_scope for @fn_ctxt { } impl methods for @fn_ctxt { - fn tag() -> str { #fmt["%x", ptr::addr_of(*self) as uint] } - fn block_region() -> result<ty::region, str> { + fn tag() -> ~str { #fmt["%x", ptr::addr_of(*self) as uint] } + fn block_region() -> result<ty::region, ~str> { alt vec::last_opt(self.blocks) { some(bid) { result::ok(ty::re_scope(bid)) } - none { result::err("no block is in scope here") } + none { result::err(~"no block is in scope here") } } } #[inline(always)] @@ -554,7 +555,7 @@ impl methods for @fn_ctxt { infer::mk_subr(self.infcx, sub, sup) } - fn require_unsafe(sp: span, op: str) { + fn require_unsafe(sp: span, op: ~str) { alt self.purity { ast::unsafe_fn {/*ok*/} _ { @@ -672,7 +673,7 @@ fn impl_self_ty(fcx: @fn_ctxt, did: ast::def_id) -> ty_param_substs_and_ty { self_ty: none, tps: ty::ty_params_to_tys(tcx, ts)})} } - _ { tcx.sess.bug("impl_self_ty: unbound item or item that \ + _ { tcx.sess.bug(~"impl_self_ty: unbound item or item that \ doesn't have a self_ty"); } } } else { @@ -739,7 +740,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, // I would like to make this span_err, but it's // really hard due to the way that expr_bind() is // written. - fcx.ccx.tcx.sess.span_fatal(sp, "mismatched types: \ + fcx.ccx.tcx.sess.span_fatal(sp, ~"mismatched types: \ expected function or foreign \ function but found " + fcx.infcx.ty_to_str(in_fty)); @@ -762,15 +763,15 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, sp, #fmt["this function takes %u parameter%s but %u \ parameter%s supplied", expected_arg_count, if expected_arg_count == 1u { - "" + ~"" } else { - "s" + ~"s" }, supplied_arg_count, if supplied_arg_count == 1u { - " was" + ~" was" } else { - "s were" + ~"s were" }]); fcx.infcx.next_ty_vars(supplied_arg_count) }; @@ -839,7 +840,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, fcx.write_ty(call_expr_id, f.output); ret bot; } - _ { fcx.ccx.tcx.sess.span_fatal(sp, "calling non-function"); } + _ { fcx.ccx.tcx.sess.span_fatal(sp, ~"calling non-function"); } } } @@ -881,7 +882,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, ret if_bot; } - fn binop_method(op: ast::binop) -> option<str> { + fn binop_method(op: ast::binop) -> option<~str> { alt op { ast::add | ast::subtract | ast::mul | ast::div | ast::rem | ast::bitxor | ast::bitand | ast::bitor | ast::shl | ast::shr @@ -891,7 +892,7 @@ 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: ~[@ast::expr]) + opname: ~str, args: ~[@ast::expr]) -> option<(ty::t, bool)> { let lkup = method::lookup(fcx, op_ex, self_ex, op_ex.id, op_ex.callee_id, @opname, self_t, ~[], false); @@ -975,10 +976,10 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, check_expr(fcx, rhs, none); tcx.sess.span_err( - ex.span, "binary operation " + ast_util::binop_to_str(op) + - " cannot be applied to type `" + + ex.span, ~"binary operation " + ast_util::binop_to_str(op) + + ~" cannot be applied to type `" + fcx.infcx.ty_to_str(lhs_resolved_t) + - "`"); + ~"`"); // If the or operator is used it might be that the user forgot to // supply the do keyword. Let's be more helpful in that situation. @@ -986,7 +987,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, alt ty::get(lhs_resolved_t).struct { ty::ty_fn(f) { tcx.sess.span_note( - ex.span, "did you forget the 'do' keyword for the call?"); + ex.span, ~"did you forget the 'do' keyword for the call?"); } _ {} } @@ -994,7 +995,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, (lhs_resolved_t, false) } - fn check_user_unop(fcx: @fn_ctxt, op_str: str, mname: str, + 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, ~[]) { @@ -1074,7 +1075,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, some(ix) { if n_tys > 0u { tcx.sess.span_err(expr.span, - "can't provide type parameters \ + ~"can't provide type parameters \ to a field access"); } fcx.write_ty(expr.id, fields[ix].mt.ty); @@ -1133,7 +1134,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, if !is_callee { tcx.sess.span_err( expr.span, - "attempted to take value of method \ + ~"attempted to take value of method \ (try writing an anonymous function)"); } } @@ -1170,7 +1171,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, ty::mk_evec(tcx, {ty: t, mutbl: mutbl}, tt) } _ { - tcx.sess.span_bug(expr.span, "vstore modifier on non-sequence") + tcx.sess.span_bug(expr.span, ~"vstore modifier on non-sequence") } }; fcx.write_ty(ev.id, typ); @@ -1245,7 +1246,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, ty::ty_ptr(*) { fcx.require_unsafe( expr.span, - "dereference of unsafe pointer"); + ~"dereference of unsafe pointer"); } _ { /*ok*/ } } @@ -1257,7 +1258,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, ty::ty_enum(*) { tcx.sess.span_err( expr.span, - "can only dereference enums \ + ~"can only dereference enums \ with a single variant which has a \ single argument"); } @@ -1275,7 +1276,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, oprnd_t = structurally_resolved_type(fcx, oprnd.span, oprnd_t); if !(ty::type_is_integral(oprnd_t) || ty::get(oprnd_t).struct == ty::ty_bool) { - oprnd_t = check_user_unop(fcx, "!", "!", expr, + oprnd_t = check_user_unop(fcx, ~"!", ~"!", expr, oprnd, oprnd_t); } } @@ -1283,7 +1284,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, oprnd_t = structurally_resolved_type(fcx, oprnd.span, oprnd_t); if !(ty::type_is_integral(oprnd_t) || ty::type_is_fp(oprnd_t)) { - oprnd_t = check_user_unop(fcx, "-", "unary-", expr, + oprnd_t = check_user_unop(fcx, ~"-", ~"unary-", expr, oprnd, oprnd_t); } } @@ -1305,7 +1306,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, let tpt = ty_param_bounds_and_ty_for_def(fcx, expr.span, defn); instantiate_path(fcx, pth, tpt, expr.span, expr.id); } - ast::expr_mac(_) { tcx.sess.bug("unexpanded macro"); } + ast::expr_mac(_) { tcx.sess.bug(~"unexpanded macro"); } ast::expr_fail(expr_opt) { bot = true; alt expr_opt { @@ -1327,7 +1328,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, result::ok(_) { /* fall through */ } result::err(_) { tcx.sess.span_err(expr.span, - "`ret;` in function returning non-nil"); } + ~"`ret;` in function returning non-nil"); } } } some(e) { check_expr_with(fcx, e, ret_ty); } @@ -1417,7 +1418,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, (ty::mk_fn(tcx, {output: ty::mk_nil(tcx) with fty}), fty.proto) } _ { - tcx.sess.span_fatal(expr.span, "a `loop` function's last \ + tcx.sess.span_fatal(expr.span, ~"a `loop` function's last \ argument should be of function \ type"); } @@ -1445,7 +1446,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, (ty::mk_fn(tcx, fty), fty.proto) } _ { - tcx.sess.span_fatal(expr.span, "a `do` function's last argument \ + tcx.sess.span_fatal(expr.span, ~"a `do` function's last argument \ should be of function type"); } }; @@ -1491,12 +1492,12 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, _ { if ty::type_is_nil(t_e) { - tcx.sess.span_err(expr.span, "cast from nil: " + - fcx.infcx.ty_to_str(t_e) + " as " + + tcx.sess.span_err(expr.span, ~"cast from nil: " + + fcx.infcx.ty_to_str(t_e) + ~" as " + fcx.infcx.ty_to_str(t_1)); } else if ty::type_is_nil(t_1) { - tcx.sess.span_err(expr.span, "cast to nil: " + - fcx.infcx.ty_to_str(t_e) + " as " + + tcx.sess.span_err(expr.span, ~"cast to nil: " + + fcx.infcx.ty_to_str(t_e) + ~" as " + fcx.infcx.ty_to_str(t_1)); } @@ -1510,8 +1511,8 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, issue number in this comment. */ tcx.sess.span_err(expr.span, - "non-scalar cast: " + - fcx.infcx.ty_to_str(t_e) + " as " + + ~"non-scalar cast: " + + fcx.infcx.ty_to_str(t_e) + ~" as " + fcx.infcx.ty_to_str(t_1)); } } @@ -1568,7 +1569,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, ty::ty_rec(flds) { flds } _ { tcx.sess.span_fatal(expr.span, - "record update has non-record base"); + ~"record update has non-record base"); } }; fcx.write_ty(id, bexpr_t); @@ -1582,7 +1583,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, } if !found { tcx.sess.span_fatal(f.span, - "unknown field in record update: " + + ~"unknown field in record update: " + *f.node.ident); } } @@ -1606,13 +1607,13 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, none { let resolved = structurally_resolved_type(fcx, expr.span, raw_base_t); - alt lookup_op_method(fcx, expr, base, resolved, "[]", + alt lookup_op_method(fcx, expr, base, resolved, ~"[]", ~[idx]) { some((ret_ty, _)) { fcx.write_ty(id, ret_ty); } _ { tcx.sess.span_fatal( - expr.span, "cannot index a value of type `" + - fcx.infcx.ty_to_str(base_t) + "`"); + expr.span, ~"cannot index a value of type `" + + fcx.infcx.ty_to_str(base_t) + ~"`"); } } } @@ -1625,7 +1626,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); @@ -1672,7 +1673,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, ty_to_str(tcx, fcx.expr_ty(expr)), alt expected { some(t) { ty_to_str(tcx, t) } - _ { "empty" } + _ { ~"empty" } }); unifier(); @@ -1683,9 +1684,9 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, fn require_integral(fcx: @fn_ctxt, sp: span, t: ty::t) { if !type_is_integral(fcx, sp, t) { - fcx.ccx.tcx.sess.span_err(sp, "mismatched types: expected \ + fcx.ccx.tcx.sess.span_err(sp, ~"mismatched types: expected \ integral type but found `" - + fcx.infcx.ty_to_str(t) + "`"); + + fcx.infcx.ty_to_str(t) + ~"`"); } } @@ -1774,7 +1775,7 @@ fn check_block(fcx0: @fn_ctxt, blk: ast::blk) -> bool { } _ { false } } { - fcx.ccx.tcx.sess.span_warn(s.span, "unreachable statement"); + fcx.ccx.tcx.sess.span_warn(s.span, ~"unreachable statement"); warned = true; } bot |= check_stmt(fcx, s); @@ -1783,7 +1784,7 @@ fn check_block(fcx0: @fn_ctxt, blk: ast::blk) -> bool { none { fcx.write_nil(blk.node.id); } some(e) { if bot && !warned { - fcx.ccx.tcx.sess.span_warn(e.span, "unreachable expression"); + fcx.ccx.tcx.sess.span_warn(e.span, ~"unreachable expression"); } bot |= check_expr(fcx, e, none); let ety = fcx.expr_ty(e); @@ -1846,7 +1847,7 @@ fn check_enum_variants(ccx: @crate_ctxt, } _ { ccx.tcx.sess.span_err(e.span, - "expected signed integer constant"); + ~"expected signed integer constant"); } } } @@ -1854,7 +1855,7 @@ fn check_enum_variants(ccx: @crate_ctxt, } if vec::contains(disr_vals, disr_val) { ccx.tcx.sess.span_err(v.span, - "discriminator value already exists"); + ~"discriminator value already exists"); } vec::push(disr_vals, disr_val); let ctor_ty = ty::node_id_to_type(ccx.tcx, v.node.id); @@ -1881,7 +1882,7 @@ fn check_enum_variants(ccx: @crate_ctxt, _ { false } } }) { - ccx.tcx.sess.span_err(sp, "illegal recursive enum type; \ + ccx.tcx.sess.span_err(sp, ~"illegal recursive enum type; \ wrap the inner value in a box to \ make it representable"); } @@ -1902,7 +1903,7 @@ fn check_pred_expr(fcx: @fn_ctxt, e: @ast::expr) -> bool { if !ty::is_pred_ty(fcx.expr_ty(operator)) { fcx.ccx.tcx.sess.span_err (operator.span, - "operator in constraint has non-boolean return type"); + ~"operator in constraint has non-boolean return type"); } alt operator.node { @@ -1913,26 +1914,26 @@ fn check_pred_expr(fcx: @fn_ctxt, e: @ast::expr) -> bool { } _ { fcx.ccx.tcx.sess.span_err(operator.span, - "impure function as operator \ + ~"impure function as operator \ in constraint"); } } for operands.each |operand| { if !ast_util::is_constraint_arg(operand) { let s = - "constraint args must be slot variables or literals"; + ~"constraint args must be slot variables or literals"; fcx.ccx.tcx.sess.span_err(e.span, s); } } } _ { - let s = "in a constraint, expected the \ + let s = ~"in a constraint, expected the \ constraint name to be an explicit name"; fcx.ccx.tcx.sess.span_err(e.span, s); } } } - _ { fcx.ccx.tcx.sess.span_err(e.span, "check on non-predicate"); } + _ { fcx.ccx.tcx.sess.span_err(e.span, ~"check on non-predicate"); } } ret bot; } @@ -1957,7 +1958,7 @@ fn check_constraints(fcx: @fn_ctxt, cs: ~[@ast::constr], @alt a.node { ast::carg_base { fcx.ccx.tcx.sess.span_bug(a.span, - "check_constraints:\ + ~"check_constraints:\ unexpected carg_base"); } ast::carg_lit(l) { @@ -1982,7 +1983,7 @@ fn check_constraints(fcx: @fn_ctxt, cs: ~[@ast::constr], span: a.span} } else { fcx.ccx.tcx.sess.span_bug( - a.span, "check_constraints:\ + a.span, ~"check_constraints:\ carg_ident index out of bounds"); } } @@ -2018,7 +2019,7 @@ fn lookup_local(fcx: @fn_ctxt, sp: span, id: ast::node_id) -> tv_vid { some(x) { x } _ { fcx.ccx.tcx.sess.span_fatal(sp, - "internal error looking up a local var") + ~"internal error looking up a local var") } } } @@ -2048,7 +2049,7 @@ fn ty_param_bounds_and_ty_for_def(fcx: @fn_ctxt, sp: span, defn: ast::def) -> ret no_params(self_ty); } none { - fcx.ccx.tcx.sess.span_bug(sp, "def_self with no self_ty"); + fcx.ccx.tcx.sess.span_bug(sp, ~"def_self with no self_ty"); } } } @@ -2068,7 +2069,7 @@ fn ty_param_bounds_and_ty_for_def(fcx: @fn_ctxt, sp: span, defn: ast::def) -> ast::def_fn(id, ast::unsafe_fn) { // Unsafe functions can only be touched in an unsafe context - fcx.require_unsafe(sp, "access to unsafe function"); + fcx.require_unsafe(sp, ~"access to unsafe function"); ret ty::lookup_item_type(fcx.ccx.tcx, id); } @@ -2082,7 +2083,7 @@ fn ty_param_bounds_and_ty_for_def(fcx: @fn_ctxt, sp: span, defn: ast::def) -> ret no_params(typ); } ast::def_ty(_) | ast::def_prim_ty(_) { - fcx.ccx.tcx.sess.span_fatal(sp, "expected value but found type"); + fcx.ccx.tcx.sess.span_fatal(sp, ~"expected value but found type"); } ast::def_upvar(_, inner, _) { ret ty_param_bounds_and_ty_for_def(fcx, sp, *inner); @@ -2091,13 +2092,13 @@ fn ty_param_bounds_and_ty_for_def(fcx: @fn_ctxt, sp: span, defn: ast::def) -> ret no_params(ty::mk_param(fcx.ccx.tcx, n, did)); } ast::def_mod(*) | ast::def_foreign_mod(*) { - fcx.ccx.tcx.sess.span_fatal(sp, "expected value but found module"); + fcx.ccx.tcx.sess.span_fatal(sp, ~"expected value but found module"); } ast::def_use(*) { - fcx.ccx.tcx.sess.span_fatal(sp, "expected value but found use"); + fcx.ccx.tcx.sess.span_fatal(sp, ~"expected value but found use"); } ast::def_region(*) { - fcx.ccx.tcx.sess.span_fatal(sp, "expected value but found region"); + fcx.ccx.tcx.sess.span_fatal(sp, ~"expected value but found region"); } } } @@ -2117,7 +2118,7 @@ fn instantiate_path(fcx: @fn_ctxt, let self_r = alt pth.rp { some(r) if !tpt.rp => { fcx.ccx.tcx.sess.span_err - (sp, "this item is not region-parameterized"); + (sp, ~"this item is not region-parameterized"); none } some(r) => { @@ -2137,15 +2138,15 @@ fn instantiate_path(fcx: @fn_ctxt, fcx.infcx.next_ty_vars(ty_param_count) } else if ty_param_count == 0u { fcx.ccx.tcx.sess.span_err - (sp, "this item does not take type parameters"); + (sp, ~"this item does not take type parameters"); fcx.infcx.next_ty_vars(ty_param_count) } else if ty_substs_len > ty_param_count { fcx.ccx.tcx.sess.span_err - (sp, "too many type parameters provided for this item"); + (sp, ~"too many type parameters provided for this item"); fcx.infcx.next_ty_vars(ty_param_count) } else if ty_substs_len < ty_param_count { fcx.ccx.tcx.sess.span_err - (sp, "not enough type parameters provided for this item"); + (sp, ~"not enough type parameters provided for this item"); fcx.infcx.next_ty_vars(ty_param_count) } else { pth.types.map(|aty| fcx.to_ty(aty)) @@ -2163,7 +2164,7 @@ fn structurally_resolved_type(fcx: @fn_ctxt, sp: span, tp: ty::t) -> ty::t { result::ok(t_s) if !ty::type_is_var(t_s) { ret t_s; } _ { fcx.ccx.tcx.sess.span_fatal - (sp, "the type of this value must be known in this context"); + (sp, ~"the type of this value must be known in this context"); } } } @@ -2253,45 +2254,45 @@ fn check_intrinsic_type(ccx: @crate_ctxt, it: @ast::foreign_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)) } - "init" { (1u, ~[], param(ccx, 0u)) } - "forget" { (1u, ~[arg(ast::by_move, param(ccx, 0u))], + ~"size_of" | + ~"pref_align_of" | ~"min_align_of" { (1u, ~[], ty::mk_uint(ccx.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" { + ~"move_val" | ~"move_val_init" { (1u, ~[arg(ast::by_mutbl_ref, 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)) } - "atomic_xchng" | "atomic_add" | "atomic_sub" | - "atomic_xchng_acq" | "atomic_add_acq" | "atomic_sub_acq" | - "atomic_xchng_rel" | "atomic_add_rel" | "atomic_sub_rel" { + ~"atomic_xchng" | ~"atomic_add" | ~"atomic_sub" | + ~"atomic_xchng_acq" | ~"atomic_add_acq" | ~"atomic_sub_acq" | + ~"atomic_xchng_rel" | ~"atomic_add_rel" | ~"atomic_sub_rel" { (0u, ~[arg(ast::by_mutbl_ref, ty::mk_int(tcx)), arg(ast::by_val, ty::mk_int(tcx))], ty::mk_int(tcx)) } - "get_tydesc" { + ~"get_tydesc" { // FIXME (#2712): return *intrinsic::tydesc, not *() (1u, ~[], ty::mk_nil_ptr(tcx)) } - "visit_tydesc" { - assert ccx.tcx.intrinsic_defs.contains_key(@"tydesc"/~); - assert ccx.tcx.intrinsic_defs.contains_key(@"ty_visitor"/~); - let (_, tydesc_ty) = ccx.tcx.intrinsic_defs.get(@"tydesc"/~); - let (_, visitor_trait) = ccx.tcx.intrinsic_defs.get(@"ty_visitor"/~); + ~"visit_tydesc" { + assert ccx.tcx.intrinsic_defs.contains_key(@~"tydesc"); + assert ccx.tcx.intrinsic_defs.contains_key(@~"ty_visitor"); + let (_, tydesc_ty) = ccx.tcx.intrinsic_defs.get(@~"tydesc"); + let (_, visitor_trait) = ccx.tcx.intrinsic_defs.get(@~"ty_visitor"); let td_ptr = ty::mk_ptr(ccx.tcx, {ty: tydesc_ty, mutbl: ast::m_imm}); (0u, ~[arg(ast::by_val, td_ptr), arg(ast::by_ref, visitor_trait)], ty::mk_nil(tcx)) } - "frame_address" { + ~"frame_address" { let fty = ty::mk_fn(ccx.tcx, { purity: ast::impure_fn, proto: ast::proto_any, @@ -2308,8 +2309,8 @@ fn check_intrinsic_type(ccx: @crate_ctxt, it: @ast::foreign_item) { (0u, ~[arg(ast::by_ref, fty)], ty::mk_nil(tcx)) } other { - tcx.sess.span_err(it.span, "unrecognized intrinsic function: `" + - other + "`"); + tcx.sess.span_err(it.span, ~"unrecognized intrinsic function: `" + + other + ~"`"); ret; } }; diff --git a/src/rustc/middle/typeck/check/alt.rs b/src/rustc/middle/typeck/check/alt.rs index e45c5f308ea..158d19bb6e2 100644 --- a/src/rustc/middle/typeck/check/alt.rs +++ b/src/rustc/middle/typeck/check/alt.rs @@ -90,9 +90,9 @@ fn check_pat_variant(pcx: pat_ctxt, pat: @ast::pat, path: @ast::path, let s = #fmt["this pattern has %u field%s, but the \ corresponding variant has %u field%s", subpats_len, - if subpats_len == 1u { "" } else { "s" }, + if subpats_len == 1u { ~"" } else { ~"s" }, arg_len, - if arg_len == 1u { "" } else { "s" }]; + if arg_len == 1u { ~"" } else { ~"s" }]; tcx.sess.span_fatal(pat.span, s); } @@ -106,8 +106,8 @@ fn check_pat_variant(pcx: pat_ctxt, pat: @ast::pat, path: @ast::path, (pat.span, #fmt["this pattern has %u field%s, \ but the corresponding variant has no fields", subpats_len, - if subpats_len == 1u { "" } - else { "s" }]); + if subpats_len == 1u { ~"" } + else { ~"s" }]); } } _ { @@ -143,12 +143,12 @@ fn check_pat(pcx: pat_ctxt, pat: @ast::pat, expected: ty::t) { #debug["pat_range ending type: %?", e_ty]; if !require_same_types( tcx, some(fcx.infcx), pat.span, b_ty, e_ty, - || "mismatched types in range") { + || ~"mismatched types in range") { // no-op } else if !ty::type_is_numeric(b_ty) { - tcx.sess.span_err(pat.span, "non-numeric type used in range"); + tcx.sess.span_err(pat.span, ~"non-numeric type used in range"); } else if !valid_range_bounds(fcx.ccx, begin, end) { - tcx.sess.span_err(begin.span, "lower range bound must be less \ + tcx.sess.span_err(begin.span, ~"lower range bound must be less \ than upper"); } fcx.write_ty(pat.id, b_ty); @@ -246,9 +246,9 @@ fn check_pat(pcx: pat_ctxt, pat: @ast::pat, expected: ty::t) { _ { tcx.sess.span_fatal( pat.span, - "mismatched types: expected `" + + ~"mismatched types: expected `" + fcx.infcx.ty_to_str(expected) + - "` found box"); + ~"` found box"); } } } @@ -261,9 +261,9 @@ fn check_pat(pcx: pat_ctxt, pat: @ast::pat, expected: ty::t) { _ { tcx.sess.span_fatal( pat.span, - "mismatched types: expected `" + + ~"mismatched types: expected `" + fcx.infcx.ty_to_str(expected) + - "` found uniq"); + ~"` found uniq"); } } } diff --git a/src/rustc/middle/typeck/check/method.rs b/src/rustc/middle/typeck/check/method.rs index c3829f60c40..2dc80593e02 100644 --- a/src/rustc/middle/typeck/check/method.rs +++ b/src/rustc/middle/typeck/check/method.rs @@ -107,7 +107,7 @@ class lookup { if self.candidates.len() > 1u { self.tcx().sess.span_err( self.expr.span, - "multiple applicable methods in scope"); + ~"multiple applicable methods in scope"); for self.candidates.eachi |i, candidate| { alt candidate.entry.origin { @@ -222,14 +222,14 @@ class lookup { if ty::type_has_self(m_fty) { self.tcx().sess.span_err( self.expr.span, - "can not call a method that contains a \ + ~"can not call a method that contains a \ self type through a boxed iface"); } if (*m.tps).len() > 0u { self.tcx().sess.span_err( self.expr.span, - "can not call a generic method through a \ + ~"can not call a generic method through a \ boxed trait"); } @@ -256,7 +256,7 @@ class lookup { if m.vis == ast::private && !self.include_private { self.tcx().sess.span_fatal( self.expr.span, - "Call to private method not allowed outside \ + ~"Call to private method not allowed outside \ its defining class"); } @@ -399,12 +399,12 @@ class lookup { } else if n_tps_m == 0u { tcx.sess.span_err( self.expr.span, - "this method does not take type parameters"); + ~"this method does not take type parameters"); self.fcx.infcx.next_ty_vars(n_tps_m) } else if n_tps_supplied != n_tps_m { tcx.sess.span_err( self.expr.span, - "incorrect number of type \ + ~"incorrect number of type \ parameters given for this method"); self.fcx.infcx.next_ty_vars(n_tps_m) } else { diff --git a/src/rustc/middle/typeck/check/vtable.rs b/src/rustc/middle/typeck/check/vtable.rs index d5401e3a4e7..a883946252c 100644 --- a/src/rustc/middle/typeck/check/vtable.rs +++ b/src/rustc/middle/typeck/check/vtable.rs @@ -96,11 +96,11 @@ fn lookup_vtable(fcx: @fn_ctxt, isc: resolve::iscopes, sp: span, for vec::each(*ty::trait_methods(tcx, did)) |m| { if ty::type_has_self(ty::mk_fn(tcx, m.fty)) { tcx.sess.span_err( - sp, "a boxed iface with self types may not be \ + sp, ~"a boxed iface with self types may not be \ passed as a bounded type"); } else if (*m.tps).len() > 0u { tcx.sess.span_err( - sp, "a boxed iface with generic methods may not \ + sp, ~"a boxed iface with generic methods may not \ be passed as a bounded type"); } @@ -162,7 +162,7 @@ fn lookup_vtable(fcx: @fn_ctxt, isc: resolve::iscopes, sp: span, 1u { ret found[0]; } _ { fcx.ccx.tcx.sess.span_err( - sp, "multiple applicable methods in scope"); + sp, ~"multiple applicable methods in scope"); ret found[0]; } } @@ -171,8 +171,8 @@ fn lookup_vtable(fcx: @fn_ctxt, isc: resolve::iscopes, sp: span, } tcx.sess.span_fatal( - sp, "failed to find an implementation of interface " + - ty_to_str(tcx, trait_ty) + " for " + + sp, ~"failed to find an implementation of interface " + + ty_to_str(tcx, trait_ty) + ~" for " + ty_to_str(tcx, ty)); } diff --git a/src/rustc/middle/typeck/coherence.rs b/src/rustc/middle/typeck/coherence.rs index 4773788593a..d563a4a9916 100644 --- a/src/rustc/middle/typeck/coherence.rs +++ b/src/rustc/middle/typeck/coherence.rs @@ -106,7 +106,7 @@ class CoherenceChecker { none { let session = self.crate_context.tcx.sess; session.span_warn(item.span, - "no base type found for inherent \ + ~"no base type found for inherent \ implementation; implement a trait \ instead"); } @@ -194,8 +194,8 @@ class CoherenceChecker { ret some(def_id); } _ { - fail "get_base_type() returned a type that wasn't an \ - enum, class, or trait"; + fail ~"get_base_type() returned a type that \ + wasn't an enum, class, or trait"; } } } @@ -217,10 +217,11 @@ class CoherenceChecker { if self.polytypes_unify(polytype_a, polytype_b) { let session = self.crate_context.tcx.sess; session.span_err(implementation_b.span, - "conflicting implementations for a \ + ~"conflicting implementations for a \ trait"); - session.span_note(implementation_a.span, - "note conflicting implementation here"); + session.span_note( + implementation_a.span, + ~"note conflicting implementation here"); } } } @@ -265,8 +266,9 @@ class CoherenceChecker { ret self.crate_context.tcx.tcache.get(def); } _ { - self.crate_context.tcx.sess.span_bug(implementation.span, - "not an implementation"); + self.crate_context.tcx.sess.span_bug( + implementation.span, + ~"not an implementation"); } } } @@ -328,7 +330,7 @@ class CoherenceChecker { let session = self.crate_context.tcx.sess; session.span_warn(item.span, - "cannot \ + ~"cannot \ implement \ inherent \ methods for a \ @@ -356,7 +358,7 @@ class CoherenceChecker { let session = self .crate_context.tcx.sess; session.span_warn(item.span, - "cannot \ + ~"cannot \ provide \ an \ extension \ diff --git a/src/rustc/middle/typeck/collect.rs b/src/rustc/middle/typeck/collect.rs index 5d3842e6085..4004d301646 100644 --- a/src/rustc/middle/typeck/collect.rs +++ b/src/rustc/middle/typeck/collect.rs @@ -29,7 +29,7 @@ fn collect_item_types(ccx: @crate_ctxt, crate: @ast::crate) { // There ought to be a better approach. Attributes? for crate.node.module.items.each |crate_item| { - if *crate_item.ident == "intrinsic" { + if *crate_item.ident == ~"intrinsic" { alt crate_item.node { ast::item_mod(m) { for m.items.each |intrinsic_item| { @@ -99,7 +99,7 @@ impl of ast_conv for @crate_ctxt { fn ty_infer(span: span) -> ty::t { self.tcx.sess.span_bug(span, - "found `ty_infer` in unexpected place"); + ~"found `ty_infer` in unexpected place"); } } @@ -187,8 +187,8 @@ fn compare_impl_method(tcx: ty::ctxt, sp: span, self_ty: ty::t) { if impl_m.tps != if_m.tps { - tcx.sess.span_err(sp, "method `" + *if_m.ident + - "` has an incompatible set of type parameters"); + tcx.sess.span_err(sp, ~"method `" + *if_m.ident + + ~"` has an incompatible set of type parameters"); ret; } @@ -228,7 +228,7 @@ fn compare_impl_method(tcx: ty::ctxt, sp: span, }; require_same_types( tcx, none, sp, impl_fty, if_fty, - || "method `" + *if_m.ident + "` has an incompatible type"); + || ~"method `" + *if_m.ident + ~"` has an incompatible type"); ret; // Replaces bound references to the self region with `with_r`. @@ -449,7 +449,7 @@ fn ty_of_ty_method(self: @crate_ctxt, fn instantiate_trait_ref(ccx: @crate_ctxt, t: @ast::trait_ref, rp: bool) -> (ast::def_id, ty_param_substs_and_ty) { - let sp = t.path.span, err = "can only implement interface types", + let sp = t.path.span, err = ~"can only implement interface types", sess = ccx.tcx.sess; let rscope = type_rscope(rp); @@ -548,7 +548,7 @@ fn ty_of_item(ccx: @crate_ctxt, it: @ast::item) } ast::item_impl(*) | ast::item_mod(_) | ast::item_foreign_mod(_) { fail; } - ast::item_mac(*) { fail "item macros unimplemented" } + ast::item_mac(*) { fail ~"item macros unimplemented" } } } @@ -579,7 +579,7 @@ fn ty_param_bounds(ccx: @crate_ctxt, } _ { ccx.tcx.sess.span_err( - t.span, "type parameter bounds must be \ + t.span, ~"type parameter bounds must be \ interface types"); ~[] } diff --git a/src/rustc/middle/typeck/infer.rs b/src/rustc/middle/typeck/infer.rs index ab72c5637ff..da28e657758 100644 --- a/src/rustc/middle/typeck/infer.rs +++ b/src/rustc/middle/typeck/infer.rs @@ -257,7 +257,7 @@ fn convert_integral_ty_to_int_ty_set(tcx: ty::ctxt, t: ty::t) ast::ty_i64 { int_ty_set(INT_TY_SET_i64) } ast::ty_i { int_ty_set(INT_TY_SET_i) } ast::ty_char { tcx.sess.bug( - "char type passed to convert_integral_ty_to_int_ty_set()"); } + ~"char type passed to convert_integral_ty_to_int_ty_set()"); } } } ty_uint(uint_ty) { @@ -269,7 +269,7 @@ fn convert_integral_ty_to_int_ty_set(tcx: ty::ctxt, t: ty::t) ast::ty_u { int_ty_set(INT_TY_SET_u) } } } - _ { tcx.sess.bug("non-integral type passed to \ + _ { tcx.sess.bug(~"non-integral type passed to \ convert_integral_ty_to_int_ty_set()"); } } } @@ -331,13 +331,13 @@ enum fixup_err { cyclic_region(region_vid) } -fn fixup_err_to_str(f: fixup_err) -> str { +fn fixup_err_to_str(f: fixup_err) -> ~str { alt f { - unresolved_int_ty(_) { "unconstrained integral type" } - unresolved_ty(_) { "unconstrained type" } - cyclic_ty(_) { "cyclic type of infinite size" } - unresolved_region(_) { "unconstrained region" } - cyclic_region(_) { "cyclic region" } + unresolved_int_ty(_) { ~"unconstrained integral type" } + unresolved_ty(_) { ~"unconstrained type" } + cyclic_ty(_) { ~"cyclic type of infinite size" } + unresolved_region(_) { ~"unconstrained region" } + cyclic_region(_) { ~"cyclic region" } } } @@ -442,38 +442,38 @@ impl methods<T:copy> for cres<T> { } iface to_str { - fn to_str(cx: infer_ctxt) -> str; + fn to_str(cx: infer_ctxt) -> ~str; } impl of to_str for ty::t { - fn to_str(cx: infer_ctxt) -> str { + fn to_str(cx: infer_ctxt) -> ~str { ty_to_str(cx.tcx, self) } } impl of to_str for ty::mt { - fn to_str(cx: infer_ctxt) -> str { + fn to_str(cx: infer_ctxt) -> ~str { mt_to_str(cx.tcx, self) } } impl of to_str for ty::region { - fn to_str(cx: infer_ctxt) -> str { + fn to_str(cx: infer_ctxt) -> ~str { util::ppaux::region_to_str(cx.tcx, self) } } impl<V:copy to_str> of to_str for bound<V> { - fn to_str(cx: infer_ctxt) -> str { + fn to_str(cx: infer_ctxt) -> ~str { alt self { some(v) { v.to_str(cx) } - none { "none" } + none { ~"none" } } } } impl<T:copy to_str> of to_str for bounds<T> { - fn to_str(cx: infer_ctxt) -> str { + fn to_str(cx: infer_ctxt) -> ~str { #fmt["{%s <: %s}", self.lb.to_str(cx), self.ub.to_str(cx)] @@ -481,7 +481,7 @@ impl<T:copy to_str> of to_str for bounds<T> { } impl of to_str for int_ty_set { - fn to_str(_cx: infer_ctxt) -> str { + fn to_str(_cx: infer_ctxt) -> ~str { alt self { int_ty_set(v) { uint::to_str(v, 10u) } } @@ -489,7 +489,7 @@ impl of to_str for int_ty_set { } impl<V:copy vid, T:copy to_str> of to_str for var_value<V,T> { - fn to_str(cx: infer_ctxt) -> str { + fn to_str(cx: infer_ctxt) -> ~str { alt self { redirect(vid) { #fmt("redirect(%s)", vid.to_str()) } root(pt, rk) { #fmt("root(%s, %s)", pt.to_str(cx), @@ -633,7 +633,7 @@ impl methods for infer_ctxt { ty::re_var(self.next_region_var_id()) } - fn ty_to_str(t: ty::t) -> str { + fn ty_to_str(t: ty::t) -> ~str { ty_to_str(self.tcx, self.resolve_type_vars_if_possible(t)) } @@ -1523,7 +1523,7 @@ type cres<T> = result<T,ty::type_err>; iface combine { fn infcx() -> infer_ctxt; - fn tag() -> str; + fn tag() -> ~str; fn mts(a: ty::mt, b: ty::mt) -> cres<ty::mt>; fn contratys(a: ty::t, b: ty::t) -> cres<ty::t>; @@ -1880,7 +1880,7 @@ fn super_tys<C:combine>( impl of combine for sub { fn infcx() -> infer_ctxt { *self } - fn tag() -> str { "sub" } + fn tag() -> ~str { ~"sub" } fn lub() -> lub { lub(*self) } @@ -2059,7 +2059,7 @@ impl of combine for sub { impl of combine for lub { fn infcx() -> infer_ctxt { *self } - fn tag() -> str { "lub" } + fn tag() -> ~str { ~"lub" } fn bot_ty(b: ty::t) -> cres<ty::t> { ok(b) } fn ty_bot(b: ty::t) -> cres<ty::t> { self.bot_ty(b) } // commutative @@ -2243,7 +2243,7 @@ impl of combine for lub { impl of combine for glb { fn infcx() -> infer_ctxt { *self } - fn tag() -> str { "glb" } + fn tag() -> ~str { ~"glb" } fn mts(a: ty::mt, b: ty::mt) -> cres<ty::mt> { let tcx = self.infcx().tcx; diff --git a/src/rustc/middle/typeck/rscope.rs b/src/rustc/middle/typeck/rscope.rs index ec0dbe7ea8e..759ec5496b1 100644 --- a/src/rustc/middle/typeck/rscope.rs +++ b/src/rustc/middle/typeck/rscope.rs @@ -1,36 +1,36 @@ import result::result; iface region_scope { - fn anon_region() -> result<ty::region, str>; - fn named_region(id: ast::ident) -> result<ty::region, str>; + fn anon_region() -> result<ty::region, ~str>; + fn named_region(id: ast::ident) -> result<ty::region, ~str>; } enum empty_rscope { empty_rscope } impl of region_scope for empty_rscope { - fn anon_region() -> result<ty::region, str> { - result::err("region types are not allowed here") + fn anon_region() -> result<ty::region, ~str> { + result::err(~"region types are not allowed here") } - fn named_region(id: ast::ident) -> result<ty::region, str> { - if *id == "static" { result::ok(ty::re_static) } - else { result::err("only the static region is allowed here") } + fn named_region(id: ast::ident) -> result<ty::region, ~str> { + if *id == ~"static" { result::ok(ty::re_static) } + else { result::err(~"only the static region is allowed here") } } } enum type_rscope = bool; impl of region_scope for type_rscope { - fn anon_region() -> result<ty::region, str> { + fn anon_region() -> result<ty::region, ~str> { if *self { result::ok(ty::re_bound(ty::br_self)) } else { - result::err("to use region types here, the containing type \ + result::err(~"to use region types here, the containing type \ must be declared with a region bound") } } - fn named_region(id: ast::ident) -> result<ty::region, str> { + fn named_region(id: ast::ident) -> result<ty::region, ~str> { do empty_rscope.named_region(id).chain_err |_e| { - if *id == "self" { self.anon_region() } + if *id == ~"self" { self.anon_region() } else { - result::err("named regions other than `self` are not \ + result::err(~"named regions other than `self` are not \ allowed as part of a type declaration") } } @@ -43,10 +43,10 @@ fn in_anon_rscope<RS: region_scope copy>(self: RS, r: ty::region) @anon_rscope({anon: r, base: self as region_scope}) } impl of region_scope for @anon_rscope { - fn anon_region() -> result<ty::region, str> { + fn anon_region() -> result<ty::region, ~str> { result::ok(self.anon) } - fn named_region(id: ast::ident) -> result<ty::region, str> { + fn named_region(id: ast::ident) -> result<ty::region, ~str> { self.base.named_region(id) } } @@ -57,10 +57,10 @@ fn in_binding_rscope<RS: region_scope copy>(self: RS) -> @binding_rscope { @binding_rscope({base: base}) } impl of region_scope for @binding_rscope { - fn anon_region() -> result<ty::region, str> { + fn anon_region() -> result<ty::region, ~str> { result::ok(ty::re_bound(ty::br_anon)) } - fn named_region(id: ast::ident) -> result<ty::region, str> { + fn named_region(id: ast::ident) -> result<ty::region, ~str> { do self.base.named_region(id).chain_err |_e| { result::ok(ty::re_bound(ty::br_named(id))) } diff --git a/src/rustc/util/common.rs b/src/rustc/util/common.rs index 90ff2fd3228..011b482f577 100644 --- a/src/rustc/util/common.rs +++ b/src/rustc/util/common.rs @@ -25,7 +25,7 @@ fn indenter() -> _indenter { _indenter(()) } -type flag = hashmap<str, ()>; +type flag = hashmap<~str, ()>; fn field_expr(f: ast::field) -> @ast::expr { ret f.node.expr; } @@ -74,7 +74,7 @@ fn local_rhs_span(l: @ast::local, def: span) -> span { fn is_main_name(path: syntax::ast_map::path) -> bool { // FIXME (#34): path should be a constrained type, so we know // the call to last doesn't fail. - vec::last(path) == syntax::ast_map::path_name(@"main"/~) + vec::last(path) == syntax::ast_map::path_name(@~"main") } // diff --git a/src/rustc/util/ppaux.rs b/src/rustc/util/ppaux.rs index 01593ecea2c..5d62bc31450 100644 --- a/src/rustc/util/ppaux.rs +++ b/src/rustc/util/ppaux.rs @@ -18,16 +18,16 @@ import syntax::{ast, ast_util}; import syntax::ast_map; import driver::session::session; -fn bound_region_to_str(cx: ctxt, br: bound_region) -> str { +fn bound_region_to_str(cx: ctxt, br: bound_region) -> ~str { alt br { - br_anon { "&" } + br_anon { ~"&" } br_named(str) { #fmt["&%s", *str] } - br_self if cx.sess.ppregions() { "&<self>" } - br_self { "&self" } + br_self if cx.sess.ppregions() { ~"&<self>" } + br_self { ~"&self" } } } -fn re_scope_id_to_str(cx: ctxt, node_id: ast::node_id) -> str { +fn re_scope_id_to_str(cx: ctxt, node_id: ast::node_id) -> ~str { alt cx.items.find(node_id) { some(ast_map::node_block(blk)) { #fmt("<block at %s>", @@ -62,7 +62,7 @@ fn re_scope_id_to_str(cx: ctxt, node_id: ast::node_id) -> str { } } -fn region_to_str(cx: ctxt, region: region) -> str { +fn region_to_str(cx: ctxt, region: region) -> ~str { alt region { re_scope(node_id) { #fmt["&%s", re_scope_id_to_str(cx, node_id)] } re_bound(br) { bound_region_to_str(cx, br) } @@ -78,29 +78,29 @@ fn region_to_str(cx: ctxt, region: region) -> str { // These two should not be seen by end-users (very often, anyhow): re_var(id) { #fmt("&%s", id.to_str()) } - re_static { "&static" } + re_static { ~"&static" } } } -fn mt_to_str(cx: ctxt, m: mt) -> str { +fn mt_to_str(cx: ctxt, m: mt) -> ~str { let mstr = alt m.mutbl { - ast::m_mutbl { "mut " } - ast::m_imm { "" } - ast::m_const { "const " } + ast::m_mutbl { ~"mut " } + ast::m_imm { ~"" } + ast::m_const { ~"const " } }; ret mstr + ty_to_str(cx, m.ty); } -fn vstore_to_str(cx: ctxt, vs: ty::vstore) -> str { +fn vstore_to_str(cx: ctxt, vs: ty::vstore) -> ~str { alt vs { ty::vstore_fixed(n) { #fmt["%u", n] } - ty::vstore_uniq { "~" } - ty::vstore_box { "@" } + ty::vstore_uniq { ~"~" } + ty::vstore_box { ~"@" } ty::vstore_slice(r) { region_to_str(cx, r) } } } -fn vstore_ty_to_str(cx: ctxt, ty: str, vs: ty::vstore) -> str { +fn vstore_ty_to_str(cx: ctxt, ty: ~str, vs: ty::vstore) -> ~str { alt vs { ty::vstore_fixed(_) { #fmt["%s/%s", ty, vstore_to_str(cx, vs)] @@ -109,22 +109,22 @@ fn vstore_ty_to_str(cx: ctxt, ty: str, vs: ty::vstore) -> str { } } -fn tys_to_str(cx: ctxt, ts: ~[t]) -> str { - let mut rs = ""; +fn tys_to_str(cx: ctxt, ts: ~[t]) -> ~str { + let mut rs = ~""; for ts.each |t| { rs += ty_to_str(cx, t); } rs } -fn ty_to_str(cx: ctxt, typ: t) -> str { +fn ty_to_str(cx: ctxt, typ: t) -> ~str { fn fn_input_to_str(cx: ctxt, input: {mode: ast::mode, ty: t}) -> - str { + ~str { let {mode, ty} = input; let modestr = alt canon_mode(cx, mode) { - ast::infer(_) { "" } + ast::infer(_) { ~"" } ast::expl(m) { if !ty::type_needs_infer(ty) && m == ty::default_arg_mode_for_ty(ty) { - "" + ~"" } else { mode_to_str(ast::expl(m)) } @@ -135,37 +135,37 @@ 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 { + constrs: ~[@constr]) -> ~str { let mut s; s = alt purity { - ast::impure_fn {""} - _ {purity_to_str(purity) + " "} + ast::impure_fn {~""} + _ {purity_to_str(purity) + ~" "} }; s += proto_to_str(proto); - alt ident { some(i) { s += " "; s += *i; } _ { } } - s += "("; + alt ident { some(i) { s += ~" "; s += *i; } _ { } } + s += ~"("; let mut strs = ~[]; for inputs.each |a| { vec::push(strs, fn_input_to_str(cx, a)); } - s += str::connect(strs, ", "); - s += ")"; + s += str::connect(strs, ~", "); + s += ~")"; if ty::get(output).struct != ty_nil { - s += " -> "; + s += ~" -> "; alt cf { - ast::noreturn { s += "!"; } + ast::noreturn { s += ~"!"; } ast::return_val { s += ty_to_str(cx, output); } } } s += constrs_str(constrs); ret s; } - fn method_to_str(cx: ctxt, m: method) -> str { + fn method_to_str(cx: ctxt, m: method) -> ~str { ret fn_to_str( cx, m.fty.purity, m.fty.proto, some(m.ident), m.fty.inputs, - m.fty.output, m.fty.ret_style, m.fty.constraints) + ";"; + m.fty.output, m.fty.ret_style, m.fty.constraints) + ~";"; } - fn field_to_str(cx: ctxt, f: field) -> str { - ret *f.ident + ": " + mt_to_str(cx, f.mt); + fn field_to_str(cx: ctxt, f: field) -> ~str { + ret *f.ident + ~": " + mt_to_str(cx, f.mt); } // if there is an id, print that instead of the structural type: @@ -176,40 +176,40 @@ fn ty_to_str(cx: ctxt, typ: t) -> str { // pretty print the structural type representation: ret alt ty::get(typ).struct { - ty_nil { "()" } - ty_bot { "_|_" } - ty_bool { "bool" } - ty_int(ast::ty_i) { "int" } - ty_int(ast::ty_char) { "char" } + ty_nil { ~"()" } + ty_bot { ~"_|_" } + ty_bool { ~"bool" } + ty_int(ast::ty_i) { ~"int" } + ty_int(ast::ty_char) { ~"char" } ty_int(t) { ast_util::int_ty_to_str(t) } - ty_uint(ast::ty_u) { "uint" } + ty_uint(ast::ty_u) { ~"uint" } ty_uint(t) { ast_util::uint_ty_to_str(t) } - ty_float(ast::ty_f) { "float" } + ty_float(ast::ty_f) { ~"float" } ty_float(t) { ast_util::float_ty_to_str(t) } - ty_str { "str" } - ty_box(tm) { "@" + mt_to_str(cx, tm) } - ty_uniq(tm) { "~" + mt_to_str(cx, tm) } - ty_ptr(tm) { "*" + mt_to_str(cx, tm) } + ty_str { ~"str" } + ty_box(tm) { ~"@" + mt_to_str(cx, tm) } + ty_uniq(tm) { ~"~" + mt_to_str(cx, tm) } + ty_ptr(tm) { ~"*" + mt_to_str(cx, tm) } ty_rptr(r, tm) { let rs = region_to_str(cx, r); - if rs == "&" { + if rs == ~"&" { rs + mt_to_str(cx, tm) } else { - rs + "/" + mt_to_str(cx, tm) + rs + ~"/" + mt_to_str(cx, tm) } } - ty_vec(tm) { "[" + mt_to_str(cx, tm) + "]" } - ty_unboxed_vec(tm) { "unboxed_vec<" + mt_to_str(cx, tm) + ">" } - ty_type { "type" } + ty_vec(tm) { ~"[" + mt_to_str(cx, tm) + ~"]" } + ty_unboxed_vec(tm) { ~"unboxed_vec<" + mt_to_str(cx, tm) + ~">" } + ty_type { ~"type" } ty_rec(elems) { - let mut strs: ~[str] = ~[]; + let mut strs: ~[~str] = ~[]; for elems.each |fld| { vec::push(strs, field_to_str(cx, fld)); } - "{" + str::connect(strs, ",") + "}" + ~"{" + str::connect(strs, ~",") + ~"}" } ty_tup(elems) { let mut strs = ~[]; for elems.each |elem| { vec::push(strs, ty_to_str(cx, elem)); } - "(" + str::connect(strs, ",") + ")" + ~"(" + str::connect(strs, ~",") + ~")" } ty_fn(f) { fn_to_str(cx, f.purity, f.proto, none, f.inputs, @@ -218,9 +218,9 @@ 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_self { ~"self" } ty_enum(did, substs) | ty_class(did, substs) { let path = ty::item_path(cx, did); let base = ast_map::path_to_str(path); @@ -234,22 +234,22 @@ fn ty_to_str(cx: ctxt, typ: t) -> str { ty_evec(mt, vs) { vstore_ty_to_str(cx, #fmt["[%s]", mt_to_str(cx, mt)], vs) } - ty_estr(vs) { vstore_ty_to_str(cx, "str", vs) } - ty_opaque_box { "@?" } - ty_constr(t, _) { "@?" } - ty_opaque_closure_ptr(ck_block) { "closure&" } - ty_opaque_closure_ptr(ck_box) { "closure@" } - ty_opaque_closure_ptr(ck_uniq) { "closure~" } + ty_estr(vs) { vstore_ty_to_str(cx, ~"str", vs) } + ty_opaque_box { ~"@?" } + ty_constr(t, _) { ~"@?" } + ty_opaque_closure_ptr(ck_block) { ~"closure&" } + ty_opaque_closure_ptr(ck_box) { ~"closure@" } + ty_opaque_closure_ptr(ck_uniq) { ~"closure~" } } } fn parameterized(cx: ctxt, - base: str, + base: ~str, self_r: option<ty::region>, - tps: ~[ty::t]) -> str { + tps: ~[ty::t]) -> ~str { let r_str = alt self_r { - none { "" } + none { ~"" } some(r) { #fmt["/%s", region_to_str(cx, r)] } @@ -257,35 +257,35 @@ fn parameterized(cx: ctxt, if vec::len(tps) > 0u { let strs = vec::map(tps, |t| ty_to_str(cx, t) ); - #fmt["%s%s<%s>", base, r_str, str::connect(strs, ",")] + #fmt["%s%s<%s>", base, r_str, str::connect(strs, ~",")] } else { #fmt["%s%s", base, r_str] } } -fn ty_to_short_str(cx: ctxt, typ: t) -> str { +fn ty_to_short_str(cx: ctxt, typ: t) -> ~str { let mut s = encoder::encoded_ty(cx, typ); if str::len(s) >= 32u { s = str::slice(s, 0u, 32u); } ret s; } -fn constr_to_str(c: @constr) -> str { +fn constr_to_str(c: @constr) -> ~str { ret path_to_str(c.node.path) + pprust::constr_args_to_str(pprust::uint_to_str, c.node.args); } -fn constrs_str(constrs: ~[@constr]) -> str { - let mut s = ""; +fn constrs_str(constrs: ~[@constr]) -> ~str { + let mut s = ~""; let mut colon = true; for constrs.each |c| { - if colon { s += " : "; colon = false; } else { s += ", "; } + if colon { s += ~" : "; colon = false; } else { s += ~", "; } s += constr_to_str(c); } ret s; } fn ty_constr_to_str<Q>(c: @ast::spanned<ast::constr_general_<@ast::path, Q>>) - -> str { + -> ~str { ret path_to_str(c.node.path) + constr_args_to_str::<@ast::path>(path_to_str, c.node.args); } diff --git a/src/rustdoc/astsrv.rs b/src/rustdoc/astsrv.rs index 91522e50a32..46884bcbe12 100644 --- a/src/rustdoc/astsrv.rs +++ b/src/rustdoc/astsrv.rs @@ -38,7 +38,7 @@ type ctxt = { type srv_owner<T> = fn(srv: srv) -> T; type ctxt_handler<T> = fn~(ctxt: ctxt) -> T; -type parser = fn~(session, str) -> @ast::crate; +type parser = fn~(session, ~str) -> @ast::crate; enum msg { handle_request(fn~(ctxt)), @@ -49,15 +49,15 @@ enum srv = { ch: comm::chan<msg> }; -fn from_str<T>(source: str, owner: srv_owner<T>) -> T { +fn from_str<T>(source: ~str, owner: srv_owner<T>) -> T { run(owner, source, parse::from_str_sess) } -fn from_file<T>(file: str, owner: srv_owner<T>) -> T { +fn from_file<T>(file: ~str, owner: srv_owner<T>) -> T { run(owner, file, parse::from_file_sess) } -fn run<T>(owner: srv_owner<T>, source: str, +parse: parser) -> T { +fn run<T>(owner: srv_owner<T>, source: ~str, +parse: parser) -> T { let srv_ = srv({ ch: do task::spawn_listener |po| { @@ -70,7 +70,7 @@ fn run<T>(owner: srv_owner<T>, source: str, +parse: parser) -> T { ret res; } -fn act(po: comm::port<msg>, source: str, parse: parser) { +fn act(po: comm::port<msg>, source: ~str, parse: parser) { let (sess, ignore_errors) = build_session(); let ctxt = build_ctxt( @@ -155,8 +155,8 @@ fn build_error_handlers( }; impl of diagnostic::handler for diagnostic_handler { - fn fatal(msg: str) -> ! { self.inner.fatal(msg) } - fn err(msg: str) { self.inner.err(msg) } + fn fatal(msg: ~str) -> ! { self.inner.fatal(msg) } + fn err(msg: ~str) { self.inner.err(msg) } fn bump_err_count() { if !(*self.ignore_errors) { self.inner.bump_err_count(); @@ -164,19 +164,19 @@ fn build_error_handlers( } fn has_errors() -> bool { self.inner.has_errors() } fn abort_if_errors() { self.inner.abort_if_errors() } - fn warn(msg: str) { self.inner.warn(msg) } - fn note(msg: str) { self.inner.note(msg) } - fn bug(msg: str) -> ! { self.inner.bug(msg) } - fn unimpl(msg: str) -> ! { self.inner.unimpl(msg) } + fn warn(msg: ~str) { self.inner.warn(msg) } + fn note(msg: ~str) { self.inner.note(msg) } + fn bug(msg: ~str) -> ! { self.inner.bug(msg) } + fn unimpl(msg: ~str) -> ! { self.inner.unimpl(msg) } fn emit(cmsp: option<(codemap::codemap, codemap::span)>, - msg: str, lvl: diagnostic::level) { + msg: ~str, lvl: diagnostic::level) { self.inner.emit(cmsp, msg, lvl) } } let ignore_errors = @mut false; let emitter = fn@(cmsp: option<(codemap::codemap, codemap::span)>, - msg: str, lvl: diagnostic::level) { + msg: ~str, lvl: diagnostic::level) { if !(*ignore_errors) { diagnostic::emit(cmsp, msg, lvl); } @@ -198,7 +198,7 @@ fn build_error_handlers( #[test] fn should_prune_unconfigured_items() { - let source = "#[cfg(shut_up_and_leave_me_alone)]fn a() { }"; + let source = ~"#[cfg(shut_up_and_leave_me_alone)]fn a() { }"; do from_str(source) |srv| { do exec(srv) |ctxt| { assert vec::is_empty(ctxt.ast.node.module.items); @@ -208,7 +208,7 @@ fn should_prune_unconfigured_items() { #[test] fn srv_should_build_ast_map() { - let source = "fn a() { }"; + let source = ~"fn a() { }"; do from_str(source) |srv| { do exec(srv) |ctxt| { assert ctxt.ast_map.size() != 0u @@ -218,7 +218,7 @@ fn srv_should_build_ast_map() { #[test] fn srv_should_build_reexport_map() { - let source = "import a::b; export b; mod a { mod b { } }"; + let source = ~"import a::b; export b; mod a { mod b { } }"; do from_str(source) |srv| { do exec(srv) |ctxt| { assert ctxt.exp_map.size() != 0u @@ -228,7 +228,7 @@ fn srv_should_build_reexport_map() { #[test] fn srv_should_resolve_external_crates() { - let source = "use std;\ + let source = ~"use std;\ fn f() -> std::sha1::sha1 {\ std::sha1::mk_sha1() }"; // Just testing that resolve doesn't crash @@ -237,7 +237,7 @@ fn srv_should_resolve_external_crates() { #[test] fn srv_should_resolve_core_crate() { - let source = "fn a() -> option { fail }"; + let source = ~"fn a() -> option { fail }"; // Just testing that resolve doesn't crash from_str(source, |_srv| { } ) } @@ -246,25 +246,25 @@ fn srv_should_resolve_core_crate() { fn srv_should_resolve_non_existant_imports() { // We want to ignore things we can't resolve. Shouldn't // need to be able to find external crates to create docs. - let source = "import wooboo; fn a() { }"; + let source = ~"import wooboo; fn a() { }"; from_str(source, |_srv| { } ) } #[test] fn srv_should_resolve_non_existant_uses() { - let source = "use forble; fn a() { }"; + let source = ~"use forble; fn a() { }"; from_str(source, |_srv| { } ) } #[test] fn should_ignore_external_import_paths_that_dont_exist() { - let source = "use forble; import forble::bippy;"; + let source = ~"use forble; import forble::bippy;"; from_str(source, |_srv| { } ) } #[test] fn srv_should_return_request_result() { - let source = "fn a() { }"; + let source = ~"fn a() { }"; do from_str(source) |srv| { let result = exec(srv, |_ctxt| 1000 ); assert result == 1000; diff --git a/src/rustdoc/attr_parser.rs b/src/rustdoc/attr_parser.rs index 32c5f7ccf53..931df85fa2a 100644 --- a/src/rustdoc/attr_parser.rs +++ b/src/rustdoc/attr_parser.rs @@ -14,13 +14,13 @@ export parse_crate, parse_desc; export parse_hidden; type crate_attrs = { - name: option<str> + name: option<~str> }; #[cfg(test)] mod test { - fn parse_attributes(source: str) -> ~[ast::attribute] { + fn parse_attributes(source: ~str) -> ~[ast::attribute] { import syntax::parse; import parse::parser; import parse::attr::parser_attr; @@ -29,7 +29,7 @@ mod test { let parse_sess = syntax::parse::new_parse_sess(none); let parser = parse::new_parser_from_source_str( - parse_sess, ~[], "-", codemap::fss_none, @source); + parse_sess, ~[], ~"-", codemap::fss_none, @source); parser.parse_outer_attributes() } @@ -44,7 +44,7 @@ fn doc_meta( * doc attribute */ - let doc_attrs = attr::find_attrs_by_name(attrs, "doc"); + let doc_attrs = attr::find_attrs_by_name(attrs, ~"doc"); let doc_metas = do doc_attrs.map |attr| { attr::attr_meta(attr::desugar_doc_attr(attr)) }; @@ -64,21 +64,21 @@ fn parse_crate(attrs: ~[ast::attribute]) -> crate_attrs { { name: attr::last_meta_item_value_str_by_name( - link_metas, "name").map(|x| *x ) + link_metas, ~"name").map(|x| *x ) } } #[test] fn should_extract_crate_name_from_link_attribute() { - let source = "#[link(name = \"snuggles\")]"; + let source = ~"#[link(name = \"snuggles\")]"; let attrs = test::parse_attributes(source); let attrs = parse_crate(attrs); - assert attrs.name == some("snuggles"); + assert attrs.name == some(~"snuggles"); } #[test] fn should_not_extract_crate_name_if_no_link_attribute() { - let source = ""; + let source = ~""; let attrs = test::parse_attributes(source); let attrs = parse_crate(attrs); assert attrs.name == none; @@ -86,13 +86,13 @@ fn should_not_extract_crate_name_if_no_link_attribute() { #[test] fn should_not_extract_crate_name_if_no_name_value_in_link_attribute() { - let source = "#[link(whatever)]"; + let source = ~"#[link(whatever)]"; let attrs = test::parse_attributes(source); let attrs = parse_crate(attrs); assert attrs.name == none; } -fn parse_desc(attrs: ~[ast::attribute]) -> option<str> { +fn parse_desc(attrs: ~[ast::attribute]) -> option<~str> { alt doc_meta(attrs) { some(meta) { attr::get_meta_item_value_str(meta).map(|x| *x ) @@ -103,7 +103,7 @@ fn parse_desc(attrs: ~[ast::attribute]) -> option<str> { #[test] fn parse_desc_should_handle_undocumented_mods() { - let source = ""; + let source = ~""; let attrs = test::parse_attributes(source); let attrs = parse_desc(attrs); assert attrs == none; @@ -111,10 +111,10 @@ fn parse_desc_should_handle_undocumented_mods() { #[test] fn parse_desc_should_parse_simple_doc_attributes() { - let source = "#[doc = \"basic\"]"; + let source = ~"#[doc = \"basic\"]"; let attrs = test::parse_attributes(source); let attrs = parse_desc(attrs); - assert attrs == some("basic"); + assert attrs == some(~"basic"); } fn parse_hidden(attrs: ~[ast::attribute]) -> bool { @@ -122,7 +122,7 @@ fn parse_hidden(attrs: ~[ast::attribute]) -> bool { some(meta) { alt attr::get_meta_item_list(meta) { some(metas) { - let hiddens = attr::find_meta_items_by_name(metas, "hidden"); + let hiddens = attr::find_meta_items_by_name(metas, ~"hidden"); vec::is_not_empty(hiddens) } none { false } @@ -134,14 +134,14 @@ fn parse_hidden(attrs: ~[ast::attribute]) -> bool { #[test] fn shoulde_parse_hidden_attribute() { - let source = "#[doc(hidden)]"; + let source = ~"#[doc(hidden)]"; let attrs = test::parse_attributes(source); assert parse_hidden(attrs) == true; } #[test] fn shoulde_not_parse_non_hidden_attribute() { - let source = "#[doc = \"\"]"; + let source = ~"#[doc = \"\"]"; let attrs = test::parse_attributes(source); assert parse_hidden(attrs) == false; } diff --git a/src/rustdoc/attr_pass.rs b/src/rustdoc/attr_pass.rs index 0d950b33fe7..c884c40e70f 100644 --- a/src/rustdoc/attr_pass.rs +++ b/src/rustdoc/attr_pass.rs @@ -14,7 +14,7 @@ export mk_pass; fn mk_pass() -> pass { { - name: "attr", + name: ~"attr", f: run } } @@ -60,8 +60,8 @@ fn fold_crate( #[test] fn should_replace_top_module_name_with_crate_name() { - let doc = test::mk_doc("#[link(name = \"bond\")];"); - assert doc.cratemod().name() == "bond"; + let doc = test::mk_doc(~"#[link(name = \"bond\")];"); + assert doc.cratemod().name() == ~"bond"; } fn fold_item( @@ -96,7 +96,7 @@ fn parse_item_attrs<T:send>( ast_map::node_item(item, _) { item.attrs } ast_map::node_foreign_item(item, _, _) { item.attrs } _ { - fail "parse_item_attrs: not an item"; + fail ~"parse_item_attrs: not an item"; } }; parse_attrs(attrs) @@ -105,32 +105,32 @@ fn parse_item_attrs<T:send>( #[test] fn should_should_extract_mod_attributes() { - let doc = test::mk_doc("#[doc = \"test\"] mod a { }"); - assert doc.cratemod().mods()[0].desc() == some("test"); + let doc = test::mk_doc(~"#[doc = \"test\"] mod a { }"); + assert doc.cratemod().mods()[0].desc() == some(~"test"); } #[test] fn should_extract_top_mod_attributes() { - let doc = test::mk_doc("#[doc = \"test\"];"); - assert doc.cratemod().desc() == some("test"); + let doc = test::mk_doc(~"#[doc = \"test\"];"); + assert doc.cratemod().desc() == some(~"test"); } #[test] fn should_extract_foreign_mod_attributes() { - let doc = test::mk_doc("#[doc = \"test\"] extern mod a { }"); - assert doc.cratemod().nmods()[0].desc() == some("test"); + let doc = test::mk_doc(~"#[doc = \"test\"] extern mod a { }"); + assert doc.cratemod().nmods()[0].desc() == some(~"test"); } #[test] fn should_extract_foreign_fn_attributes() { - let doc = test::mk_doc("extern mod a { #[doc = \"test\"] fn a(); }"); - assert doc.cratemod().nmods()[0].fns[0].desc() == some("test"); + let doc = test::mk_doc(~"extern mod a { #[doc = \"test\"] fn a(); }"); + assert doc.cratemod().nmods()[0].fns[0].desc() == some(~"test"); } #[test] fn should_extract_fn_attributes() { - let doc = test::mk_doc("#[doc = \"test\"] fn a() -> int { }"); - assert doc.cratemod().fns()[0].desc() == some("test"); + let doc = test::mk_doc(~"#[doc = \"test\"] fn a() -> int { }"); + assert doc.cratemod().fns()[0].desc() == some(~"test"); } fn fold_enum( @@ -170,15 +170,15 @@ fn fold_enum( #[test] fn should_extract_enum_docs() { - let doc = test::mk_doc("#[doc = \"b\"]\ + let doc = test::mk_doc(~"#[doc = \"b\"]\ enum a { v }"); - assert doc.cratemod().enums()[0].desc() == some("b"); + assert doc.cratemod().enums()[0].desc() == some(~"b"); } #[test] fn should_extract_variant_docs() { - let doc = test::mk_doc("enum a { #[doc = \"c\"] v }"); - assert doc.cratemod().enums()[0].variants[0].desc == some("c"); + let doc = test::mk_doc(~"enum a { #[doc = \"c\"] v }"); + assert doc.cratemod().enums()[0].variants[0].desc == some(~"c"); } fn fold_trait( @@ -201,7 +201,7 @@ fn merge_method_attrs( ) -> ~[doc::methoddoc] { // Create an assoc list from method name to attributes - let attrs: ~[(str, option<str>)] = do astsrv::exec(srv) |ctxt| { + let attrs: ~[(~str, option<~str>)] = do astsrv::exec(srv) |ctxt| { alt ctxt.ast_map.get(item_id) { ast_map::node_item(@{ node: ast::item_trait(_, methods), _ @@ -224,7 +224,7 @@ fn merge_method_attrs( (*method.ident, attr_parser::parse_desc(method.attrs)) }) } - _ { fail "unexpected item" } + _ { fail ~"unexpected item" } } }; @@ -241,18 +241,18 @@ fn merge_method_attrs( #[test] fn should_extract_trait_docs() { - let doc = test::mk_doc("#[doc = \"whatever\"] iface i { fn a(); }"); - assert doc.cratemod().traits()[0].desc() == some("whatever"); + let doc = test::mk_doc(~"#[doc = \"whatever\"] iface i { fn a(); }"); + assert doc.cratemod().traits()[0].desc() == some(~"whatever"); } #[test] fn should_extract_trait_method_docs() { let doc = test::mk_doc( - "iface i {\ + ~"iface i {\ #[doc = \"desc\"]\ fn f(a: bool) -> bool;\ }"); - assert doc.cratemod().traits()[0].methods[0].desc == some("desc"); + assert doc.cratemod().traits()[0].methods[0].desc == some(~"desc"); } @@ -272,25 +272,25 @@ fn fold_impl( #[test] fn should_extract_impl_docs() { let doc = test::mk_doc( - "#[doc = \"whatever\"] impl i for int { fn a() { } }"); - assert doc.cratemod().impls()[0].desc() == some("whatever"); + ~"#[doc = \"whatever\"] impl i for int { fn a() { } }"); + assert doc.cratemod().impls()[0].desc() == some(~"whatever"); } #[test] fn should_extract_impl_method_docs() { let doc = test::mk_doc( - "impl i for int {\ + ~"impl i for int {\ #[doc = \"desc\"]\ fn f(a: bool) -> bool { }\ }"); - assert doc.cratemod().impls()[0].methods[0].desc == some("desc"); + assert doc.cratemod().impls()[0].methods[0].desc == some(~"desc"); } #[cfg(test)] mod test { - fn mk_doc(source: str) -> doc::doc { + fn mk_doc(source: ~str) -> doc::doc { do astsrv::from_str(source) |srv| { - let doc = extract::from_srv(srv, ""); + let doc = extract::from_srv(srv, ~""); run(srv, doc) } } diff --git a/src/rustdoc/config.rs b/src/rustdoc/config.rs index ea397a4398e..10bcbdb1404 100644 --- a/src/rustdoc/config.rs +++ b/src/rustdoc/config.rs @@ -28,75 +28,76 @@ enum output_style { /// The configuration for a rustdoc session type config = { - input_crate: str, - output_dir: str, + input_crate: ~str, + output_dir: ~str, output_format: output_format, output_style: output_style, - pandoc_cmd: option<str> + pandoc_cmd: option<~str> }; -fn opt_output_dir() -> str { "output-dir" } -fn opt_output_format() -> str { "output-format" } -fn opt_output_style() -> str { "output-style" } -fn opt_pandoc_cmd() -> str { "pandoc-cmd" } -fn opt_help() -> str { "h" } +fn opt_output_dir() -> ~str { ~"output-dir" } +fn opt_output_format() -> ~str { ~"output-format" } +fn opt_output_style() -> ~str { ~"output-style" } +fn opt_pandoc_cmd() -> ~str { ~"pandoc-cmd" } +fn opt_help() -> ~str { ~"h" } -fn opts() -> ~[(getopts::opt, str)] { +fn opts() -> ~[(getopts::opt, ~str)] { ~[ (getopts::optopt(opt_output_dir()), - "--output-dir <val> put documents here"), + ~"--output-dir <val> put documents here"), (getopts::optopt(opt_output_format()), - "--output-format <val> either 'markdown' or 'html'"), + ~"--output-format <val> either 'markdown' or 'html'"), (getopts::optopt(opt_output_style()), - "--output-style <val> either 'doc-per-crate' or 'doc-per-mod'"), + ~"--output-style <val> either 'doc-per-crate' or 'doc-per-mod'"), (getopts::optopt(opt_pandoc_cmd()), - "--pandoc-cmd <val> the command for running pandoc"), + ~"--pandoc-cmd <val> the command for running pandoc"), (getopts::optflag(opt_help()), - "-h print help") + ~"-h print help") ] } fn usage() { import io::println; - println("Usage: rustdoc ~[options] <cratefile>\n"); - println("Options:\n"); + println(~"Usage: rustdoc ~[options] <cratefile>\n"); + println(~"Options:\n"); for opts().each |opt| { println(#fmt(" %s", tuple::second(opt))); } - println(""); + println(~""); } -fn default_config(input_crate: str) -> config { +fn default_config(input_crate: ~str) -> config { { input_crate: input_crate, - output_dir: ".", + output_dir: ~".", output_format: pandoc_html, output_style: doc_per_mod, pandoc_cmd: none } } -type program_output = fn~(str, ~[str]) -> {status: int, out: str, err: str}; +type program_output = fn~(~str, ~[~str]) -> + {status: int, out: ~str, err: ~str}; -fn mock_program_output(_prog: str, _args: ~[str]) -> { - status: int, out: str, err: str +fn mock_program_output(_prog: ~str, _args: ~[~str]) -> { + status: int, out: ~str, err: ~str } { { status: 0, - out: "", - err: "" + out: ~"", + err: ~"" } } -fn parse_config(args: ~[str]) -> result<config, str> { +fn parse_config(args: ~[~str]) -> result<config, ~str> { parse_config_(args, run::program_output) } fn parse_config_( - args: ~[str], + args: ~[~str], program_output: program_output -) -> result<config, str> { +) -> result<config, ~str> { let args = vec::tail(args); let opts = tuple::first(vec::unzip(opts())); alt getopts::getopts(args, opts) { @@ -105,9 +106,9 @@ fn parse_config_( let input_crate = vec::head(match.free); config_from_opts(input_crate, match, program_output) } else if vec::is_empty(match.free) { - result::err("no crates specified") + result::err(~"no crates specified") } else { - result::err("multiple crates specified") + result::err(~"multiple crates specified") } } result::err(f) { @@ -117,10 +118,10 @@ fn parse_config_( } fn config_from_opts( - input_crate: str, + input_crate: ~str, match: getopts::match, program_output: program_output -) -> result<config, str> { +) -> result<config, ~str> { let config = default_config(input_crate); let result = result::ok(config); @@ -173,27 +174,27 @@ fn config_from_opts( ret result; } -fn parse_output_format(output_format: str) -> result<output_format, str> { +fn parse_output_format(output_format: ~str) -> result<output_format, ~str> { alt output_format { - "markdown" { result::ok(markdown) } - "html" { result::ok(pandoc_html) } + ~"markdown" { result::ok(markdown) } + ~"html" { result::ok(pandoc_html) } _ { result::err(#fmt("unknown output format '%s'", output_format)) } } } -fn parse_output_style(output_style: str) -> result<output_style, str> { +fn parse_output_style(output_style: ~str) -> result<output_style, ~str> { alt output_style { - "doc-per-crate" { result::ok(doc_per_crate) } - "doc-per-mod" { result::ok(doc_per_mod) } + ~"doc-per-crate" { result::ok(doc_per_crate) } + ~"doc-per-mod" { result::ok(doc_per_mod) } _ { result::err(#fmt("unknown output style '%s'", output_style)) } } } fn maybe_find_pandoc( config: config, - maybe_pandoc_cmd: option<str>, + maybe_pandoc_cmd: option<~str>, program_output: program_output -) -> result<option<str>, str> { +) -> result<option<~str>, ~str> { if config.output_format != pandoc_html { ret result::ok(maybe_pandoc_cmd); } @@ -201,9 +202,9 @@ fn maybe_find_pandoc( let possible_pandocs = alt maybe_pandoc_cmd { some(pandoc_cmd) { ~[pandoc_cmd] } none { - ~["pandoc"] + alt os::homedir() { + ~[~"pandoc"] + alt os::homedir() { some(dir) { - ~[path::connect(dir, ".cabal/bin/pandoc")] + ~[path::connect(dir, ~".cabal/bin/pandoc")] } none { ~[] } } @@ -211,7 +212,7 @@ fn maybe_find_pandoc( }; let pandoc = do vec::find(possible_pandocs) |pandoc| { - let output = program_output(pandoc, ~["--version"]); + let output = program_output(pandoc, ~[~"--version"]); #debug("testing pandoc cmd %s: %?", pandoc, output); output.status == 0 }; @@ -219,7 +220,7 @@ fn maybe_find_pandoc( if option::is_some(pandoc) { result::ok(pandoc) } else { - result::err("couldn't find pandoc") + result::err(~"couldn't find pandoc") } } @@ -227,80 +228,80 @@ fn maybe_find_pandoc( fn should_find_pandoc() { let config = { output_format: pandoc_html - with default_config("test") + with default_config(~"test") }; - let mock_program_output = fn~(_prog: str, _args: ~[str]) -> { - status: int, out: str, err: str + let mock_program_output = fn~(_prog: ~str, _args: ~[~str]) -> { + status: int, out: ~str, err: ~str } { { - status: 0, out: "pandoc 1.8.2.1", err: "" + status: 0, out: ~"pandoc 1.8.2.1", err: ~"" } }; let result = maybe_find_pandoc(config, none, mock_program_output); - assert result == result::ok(some("pandoc")); + assert result == result::ok(some(~"pandoc")); } #[test] fn should_error_with_no_pandoc() { let config = { output_format: pandoc_html - with default_config("test") + with default_config(~"test") }; - let mock_program_output = fn~(_prog: str, _args: ~[str]) -> { - status: int, out: str, err: str + let mock_program_output = fn~(_prog: ~str, _args: ~[~str]) -> { + status: int, out: ~str, err: ~str } { { - status: 1, out: "", err: "" + status: 1, out: ~"", err: ~"" } }; let result = maybe_find_pandoc(config, none, mock_program_output); - assert result == result::err("couldn't find pandoc"); + assert result == result::err(~"couldn't find pandoc"); } #[cfg(test)] mod test { - fn parse_config(args: ~[str]) -> result<config, str> { + fn parse_config(args: ~[~str]) -> result<config, ~str> { parse_config_(args, mock_program_output) } } #[test] fn should_error_with_no_crates() { - let config = test::parse_config(~["rustdoc"]); - assert result::get_err(config) == "no crates specified"; + let config = test::parse_config(~[~"rustdoc"]); + assert result::get_err(config) == ~"no crates specified"; } #[test] fn should_error_with_multiple_crates() { let config = - test::parse_config(~["rustdoc", "crate1.rc", "crate2.rc"]); - assert result::get_err(config) == "multiple crates specified"; + test::parse_config(~[~"rustdoc", ~"crate1.rc", ~"crate2.rc"]); + assert result::get_err(config) == ~"multiple crates specified"; } #[test] fn should_set_output_dir_to_cwd_if_not_provided() { - let config = test::parse_config(~["rustdoc", "crate.rc"]); - assert result::get(config).output_dir == "."; + let config = test::parse_config(~[~"rustdoc", ~"crate.rc"]); + assert result::get(config).output_dir == ~"."; } #[test] fn should_set_output_dir_if_provided() { let config = test::parse_config(~[ - "rustdoc", "crate.rc", "--output-dir", "snuggles" + ~"rustdoc", ~"crate.rc", ~"--output-dir", ~"snuggles" ]); - assert result::get(config).output_dir == "snuggles"; + assert result::get(config).output_dir == ~"snuggles"; } #[test] fn should_set_output_format_to_pandoc_html_if_not_provided() { - let config = test::parse_config(~["rustdoc", "crate.rc"]); + let config = test::parse_config(~[~"rustdoc", ~"crate.rc"]); assert result::get(config).output_format == pandoc_html; } #[test] fn should_set_output_format_to_markdown_if_requested() { let config = test::parse_config(~[ - "rustdoc", "crate.rc", "--output-format", "markdown" + ~"rustdoc", ~"crate.rc", ~"--output-format", ~"markdown" ]); assert result::get(config).output_format == markdown; } @@ -308,7 +309,7 @@ fn should_set_output_format_to_markdown_if_requested() { #[test] fn should_set_output_format_to_pandoc_html_if_requested() { let config = test::parse_config(~[ - "rustdoc", "crate.rc", "--output-format", "html" + ~"rustdoc", ~"crate.rc", ~"--output-format", ~"html" ]); assert result::get(config).output_format == pandoc_html; } @@ -316,21 +317,21 @@ fn should_set_output_format_to_pandoc_html_if_requested() { #[test] fn should_error_on_bogus_format() { let config = test::parse_config(~[ - "rustdoc", "crate.rc", "--output-format", "bogus" + ~"rustdoc", ~"crate.rc", ~"--output-format", ~"bogus" ]); - assert result::get_err(config) == "unknown output format 'bogus'"; + assert result::get_err(config) == ~"unknown output format 'bogus'"; } #[test] fn should_set_output_style_to_doc_per_mod_by_default() { - let config = test::parse_config(~["rustdoc", "crate.rc"]); + let config = test::parse_config(~[~"rustdoc", ~"crate.rc"]); assert result::get(config).output_style == doc_per_mod; } #[test] fn should_set_output_style_to_one_doc_if_requested() { let config = test::parse_config(~[ - "rustdoc", "crate.rc", "--output-style", "doc-per-crate" + ~"rustdoc", ~"crate.rc", ~"--output-style", ~"doc-per-crate" ]); assert result::get(config).output_style == doc_per_crate; } @@ -338,7 +339,7 @@ fn should_set_output_style_to_one_doc_if_requested() { #[test] fn should_set_output_style_to_doc_per_mod_if_requested() { let config = test::parse_config(~[ - "rustdoc", "crate.rc", "--output-style", "doc-per-mod" + ~"rustdoc", ~"crate.rc", ~"--output-style", ~"doc-per-mod" ]); assert result::get(config).output_style == doc_per_mod; } @@ -346,21 +347,21 @@ fn should_set_output_style_to_doc_per_mod_if_requested() { #[test] fn should_error_on_bogus_output_style() { let config = test::parse_config(~[ - "rustdoc", "crate.rc", "--output-style", "bogus" + ~"rustdoc", ~"crate.rc", ~"--output-style", ~"bogus" ]); - assert result::get_err(config) == "unknown output style 'bogus'"; + assert result::get_err(config) == ~"unknown output style 'bogus'"; } #[test] fn should_set_pandoc_command_if_requested() { let config = test::parse_config(~[ - "rustdoc", "crate.rc", "--pandoc-cmd", "panda-bear-doc" + ~"rustdoc", ~"crate.rc", ~"--pandoc-cmd", ~"panda-bear-doc" ]); - assert result::get(config).pandoc_cmd == some("panda-bear-doc"); + assert result::get(config).pandoc_cmd == some(~"panda-bear-doc"); } #[test] fn should_set_pandoc_command_when_using_pandoc() { - let config = test::parse_config(~["rustdoc", "crate.rc"]); - assert result::get(config).pandoc_cmd == some("pandoc"); + let config = test::parse_config(~[~"rustdoc", ~"crate.rc"]); + assert result::get(config).pandoc_cmd == some(~"pandoc"); } diff --git a/src/rustdoc/demo.rs b/src/rustdoc/demo.rs index e84551b6a53..bedb3605309 100644 --- a/src/rustdoc/demo.rs +++ b/src/rustdoc/demo.rs @@ -15,7 +15,7 @@ const price_of_a_muffin: float = 70f; type waitress = { - hair_color: str + hair_color: ~str }; /// The type of things that produce omnomnom diff --git a/src/rustdoc/desc_to_brief_pass.rs b/src/rustdoc/desc_to_brief_pass.rs index e70cdb41872..449ea1b5856 100644 --- a/src/rustdoc/desc_to_brief_pass.rs +++ b/src/rustdoc/desc_to_brief_pass.rs @@ -9,7 +9,7 @@ export mk_pass; fn mk_pass() -> pass { { - name: "desc_to_brief", + name: ~"desc_to_brief", f: run } } @@ -62,35 +62,35 @@ fn fold_impl(fold: fold::fold<()>, doc: doc::impldoc) -> doc::impldoc { #[test] fn should_promote_desc() { - let doc = test::mk_doc("#[doc = \"desc\"] mod m { }"); - assert doc.cratemod().mods()[0].brief() == some("desc"); + let doc = test::mk_doc(~"#[doc = \"desc\"] mod m { }"); + assert doc.cratemod().mods()[0].brief() == some(~"desc"); } #[test] fn should_promote_trait_method_desc() { - let doc = test::mk_doc("iface i { #[doc = \"desc\"] fn a(); }"); - assert doc.cratemod().traits()[0].methods[0].brief == some("desc"); + let doc = test::mk_doc(~"iface i { #[doc = \"desc\"] fn a(); }"); + assert doc.cratemod().traits()[0].methods[0].brief == some(~"desc"); } #[test] fn should_promote_impl_method_desc() { let doc = test::mk_doc( - "impl i for int { #[doc = \"desc\"] fn a() { } }"); - assert doc.cratemod().impls()[0].methods[0].brief == some("desc"); + ~"impl i for int { #[doc = \"desc\"] fn a() { } }"); + assert doc.cratemod().impls()[0].methods[0].brief == some(~"desc"); } #[cfg(test)] mod test { - fn mk_doc(source: str) -> doc::doc { + fn mk_doc(source: ~str) -> doc::doc { do astsrv::from_str(source) |srv| { - let doc = extract::from_srv(srv, ""); + let doc = extract::from_srv(srv, ~""); let doc = attr_pass::mk_pass().f(srv, doc); run(srv, doc) } } } -fn extract(desc: option<str>) -> option<str> { +fn extract(desc: option<~str>) -> option<~str> { if option::is_none(desc) { ret none } @@ -98,7 +98,7 @@ fn extract(desc: option<str>) -> option<str> { parse_desc(option::get(desc)) } -fn parse_desc(desc: str) -> option<str> { +fn parse_desc(desc: ~str) -> option<~str> { const max_brief_len: uint = 120u; @@ -114,17 +114,17 @@ fn parse_desc(desc: str) -> option<str> { } } -fn first_sentence(s: str) -> option<str> { +fn first_sentence(s: ~str) -> option<~str> { let paras = paragraphs(s); if vec::is_not_empty(paras) { let first_para = vec::head(paras); - some(str::replace(first_sentence_(first_para), "\n", " ")) + some(str::replace(first_sentence_(first_para), ~"\n", ~" ")) } else { none } } -fn first_sentence_(s: str) -> str { +fn first_sentence_(s: ~str) -> ~str { let mut dotcount = 0; // The index of the character following a single dot. This allows // Things like [0..1) to appear in the brief description @@ -146,7 +146,7 @@ fn first_sentence_(s: str) -> str { str::slice(s, 0u, idx - 1u) } _ { - if str::ends_with(s, ".") { + if str::ends_with(s, ~".") { str::slice(s, 0u, str::len(s)) } else { s @@ -155,10 +155,10 @@ fn first_sentence_(s: str) -> str { } } -fn paragraphs(s: str) -> ~[str] { +fn paragraphs(s: ~str) -> ~[~str] { let lines = str::lines_any(s); let mut whitespace_lines = 0; - let mut accum = ""; + let mut accum = ~""; let paras = do vec::foldl(~[], lines) |paras, line| { let mut res = paras; @@ -168,7 +168,7 @@ fn paragraphs(s: str) -> ~[str] { if whitespace_lines > 0 { if str::is_not_empty(accum) { res += ~[accum]; - accum = ""; + accum = ~""; } } @@ -177,7 +177,7 @@ fn paragraphs(s: str) -> ~[str] { accum = if str::is_empty(accum) { line } else { - accum + "\n" + line + accum + ~"\n" + line } } @@ -193,26 +193,26 @@ fn paragraphs(s: str) -> ~[str] { #[test] fn test_paragraphs_1() { - let paras = paragraphs("1\n\n2"); - assert paras == ~["1", "2"]; + let paras = paragraphs(~"1\n\n2"); + assert paras == ~[~"1", ~"2"]; } #[test] fn test_paragraphs_2() { - let paras = paragraphs("\n\n1\n1\n\n2\n\n"); - assert paras == ~["1\n1", "2"]; + let paras = paragraphs(~"\n\n1\n1\n\n2\n\n"); + assert paras == ~[~"1\n1", ~"2"]; } #[test] fn should_promote_short_descs() { - let desc = some("desc"); + let desc = some(~"desc"); let brief = extract(desc); assert brief == desc; } #[test] fn should_not_promote_long_descs() { - let desc = some("Warkworth Castle is a ruined medieval building + let desc = some(~"Warkworth Castle is a ruined medieval building in the town of the same name in the English county of Northumberland, and the town and castle occupy a loop of the River Coquet, less than a mile from England's north-east coast. When the castle was founded is uncertain, @@ -226,7 +226,7 @@ counties."); #[test] fn should_promote_first_sentence() { - let desc = some("Warkworth Castle is a ruined medieval building + let desc = some(~"Warkworth Castle is a ruined medieval building in the town. of the same name in the English county of Northumberland, and the town and castle occupy a loop of the River Coquet, less than a mile from England's north-east coast. When the castle was founded is uncertain, @@ -236,12 +236,12 @@ King Henry II of England when he took control of England'snorthern counties."); let brief = extract(desc); assert brief == some( - "Warkworth Castle is a ruined medieval building in the town"); + ~"Warkworth Castle is a ruined medieval building in the town"); } #[test] fn should_not_consider_double_period_to_end_sentence() { - let desc = some("Warkworth..Castle is a ruined medieval building + let desc = some(~"Warkworth..Castle is a ruined medieval building in the town. of the same name in the English county of Northumberland, and the town and castle occupy a loop of the River Coquet, less than a mile from England's north-east coast. When the castle was founded is uncertain, @@ -251,12 +251,12 @@ King Henry II of England when he took control of England'snorthern counties."); let brief = extract(desc); assert brief == some( - "Warkworth..Castle is a ruined medieval building in the town"); + ~"Warkworth..Castle is a ruined medieval building in the town"); } #[test] fn should_not_consider_triple_period_to_end_sentence() { - let desc = some("Warkworth... Castle is a ruined medieval building + let desc = some(~"Warkworth... Castle is a ruined medieval building in the town. of the same name in the English county of Northumberland, and the town and castle occupy a loop of the River Coquet, less than a mile from England's north-east coast. When the castle was founded is uncertain, @@ -266,5 +266,5 @@ King Henry II of England when he took control of England'snorthern counties."); let brief = extract(desc); assert brief == some( - "Warkworth... Castle is a ruined medieval building in the town"); + ~"Warkworth... Castle is a ruined medieval building in the town"); } diff --git a/src/rustdoc/doc.rs b/src/rustdoc/doc.rs index 9db3f9a607e..d6b78095a15 100644 --- a/src/rustdoc/doc.rs +++ b/src/rustdoc/doc.rs @@ -21,8 +21,8 @@ enum implementation { * headers */ type section = { - header: str, - body: str + header: ~str, + body: ~str }; // FIXME (#2596): We currently give topmod the name of the crate. There @@ -45,10 +45,10 @@ enum itemtag { type itemdoc = { id: ast_id, - name: str, - path: ~[str], - brief: option<str>, - desc: option<str>, + name: ~str, + path: ~[~str], + brief: option<~str>, + desc: option<~str>, sections: ~[section], // Indicates that this node is a reexport of a different item reexport: bool @@ -56,7 +56,7 @@ type itemdoc = { type simpleitemdoc = { item: itemdoc, - sig: option<str> + sig: option<~str> }; type moddoc = { @@ -81,9 +81,9 @@ type enumdoc = { }; type variantdoc = { - name: str, - desc: option<str>, - sig: option<str> + name: ~str, + desc: option<~str>, + sig: option<~str> }; type traitdoc = { @@ -92,18 +92,18 @@ type traitdoc = { }; type methoddoc = { - name: str, - brief: option<str>, - desc: option<str>, + name: ~str, + brief: option<~str>, + desc: option<~str>, sections: ~[section], - sig: option<str>, + sig: option<~str>, implementation: implementation, }; type impldoc = { item: itemdoc, - trait_ty: option<str>, - self_ty: option<str>, + trait_ty: option<~str>, + self_ty: option<~str>, methods: ~[methoddoc] }; @@ -124,10 +124,10 @@ type index = { * * link - A format-specific string representing the link target */ type index_entry = { - kind: str, - name: str, - brief: option<str>, - link: str + kind: ~str, + name: ~str, + brief: option<~str>, + link: ~str }; impl util for doc { @@ -344,19 +344,19 @@ impl util<A:item> for A { self.item().id } - fn name() -> str { + fn name() -> ~str { self.item().name } - fn path() -> ~[str] { + fn path() -> ~[~str] { self.item().path } - fn brief() -> option<str> { + fn brief() -> option<~str> { self.item().brief } - fn desc() -> option<str> { + fn desc() -> option<~str> { self.item().desc } diff --git a/src/rustdoc/escape_pass.rs b/src/rustdoc/escape_pass.rs index 1cefe410e8e..dbc8a513f33 100644 --- a/src/rustdoc/escape_pass.rs +++ b/src/rustdoc/escape_pass.rs @@ -3,16 +3,16 @@ export mk_pass; fn mk_pass() -> pass { - text_pass::mk_pass("escape", escape) + text_pass::mk_pass(~"escape", escape) } -fn escape(s: str) -> str { - str::replace(s, "\\", "\\\\") +fn escape(s: ~str) -> ~str { + str::replace(s, ~"\\", ~"\\\\") } #[test] fn should_escape_backslashes() { - let s = "\\n"; + let s = ~"\\n"; let r = escape(s); - assert r == "\\\\n"; + assert r == ~"\\\\n"; } diff --git a/src/rustdoc/extract.rs b/src/rustdoc/extract.rs index 72b7150a72e..b3fd5257475 100644 --- a/src/rustdoc/extract.rs +++ b/src/rustdoc/extract.rs @@ -6,7 +6,7 @@ export from_srv, extract; fn from_srv( srv: astsrv::srv, - default_name: str + default_name: ~str ) -> doc::doc { //! Use the AST service to create a document tree @@ -18,7 +18,7 @@ fn from_srv( fn extract( crate: @ast::crate, - default_name: str + default_name: ~str ) -> doc::doc { { pages: ~[ @@ -31,7 +31,7 @@ fn extract( fn top_moddoc_from_crate( crate: @ast::crate, - default_name: str + default_name: ~str ) -> doc::moddoc { moddoc_from_mod(mk_itemdoc(ast::crate_node_id, @default_name), crate.node.module) @@ -141,9 +141,9 @@ fn constdoc_from_const(itemdoc: doc::itemdoc) -> doc::constdoc { #[test] fn should_extract_const_name_and_id() { - let doc = test::mk_doc("const a: int = 0;"); + let doc = test::mk_doc(~"const a: int = 0;"); assert doc.cratemod().consts()[0].id() != 0; - assert doc.cratemod().consts()[0].name() == "a"; + assert doc.cratemod().consts()[0].name() == ~"a"; } fn enumdoc_from_enum( @@ -172,15 +172,15 @@ fn variantdoc_from_variant(variant: ast::variant) -> doc::variantdoc { #[test] fn should_extract_enums() { - let doc = test::mk_doc("enum e { v }"); + let doc = test::mk_doc(~"enum e { v }"); assert doc.cratemod().enums()[0].id() != 0; - assert doc.cratemod().enums()[0].name() == "e"; + assert doc.cratemod().enums()[0].name() == ~"e"; } #[test] fn should_extract_enum_variants() { - let doc = test::mk_doc("enum e { v }"); - assert doc.cratemod().enums()[0].variants[0].name == "v"; + let doc = test::mk_doc(~"enum e { v }"); + assert doc.cratemod().enums()[0].variants[0].name == ~"v"; } fn traitdoc_from_trait( @@ -218,14 +218,14 @@ fn traitdoc_from_trait( #[test] fn should_extract_traits() { - let doc = test::mk_doc("trait i { fn f(); }"); - assert doc.cratemod().traits()[0].name() == "i"; + let doc = test::mk_doc(~"trait i { fn f(); }"); + assert doc.cratemod().traits()[0].name() == ~"i"; } #[test] fn should_extract_trait_methods() { - let doc = test::mk_doc("trait i { fn f(); }"); - assert doc.cratemod().traits()[0].methods[0].name == "f"; + let doc = test::mk_doc(~"trait i { fn f(); }"); + assert doc.cratemod().traits()[0].methods[0].name == ~"f"; } fn impldoc_from_impl( @@ -251,20 +251,20 @@ fn impldoc_from_impl( #[test] fn should_extract_impls_with_names() { - let doc = test::mk_doc("impl i for int { fn a() { } }"); - assert doc.cratemod().impls()[0].name() == "i"; + let doc = test::mk_doc(~"impl i for int { fn a() { } }"); + assert doc.cratemod().impls()[0].name() == ~"i"; } #[test] fn should_extract_impls_without_names() { - let doc = test::mk_doc("impl of i for int { fn a() { } }"); - assert doc.cratemod().impls()[0].name() == "i"; + let doc = test::mk_doc(~"impl of i for int { fn a() { } }"); + assert doc.cratemod().impls()[0].name() == ~"i"; } #[test] fn should_extract_impl_methods() { - let doc = test::mk_doc("impl i for int { fn f() { } }"); - assert doc.cratemod().impls()[0].methods[0].name == "f"; + let doc = test::mk_doc(~"impl i for int { fn f() { } }"); + assert doc.cratemod().impls()[0].methods[0].name == ~"f"; } fn tydoc_from_ty( @@ -278,86 +278,86 @@ fn tydoc_from_ty( #[test] fn should_extract_tys() { - let doc = test::mk_doc("type a = int;"); - assert doc.cratemod().types()[0].name() == "a"; + let doc = test::mk_doc(~"type a = int;"); + assert doc.cratemod().types()[0].name() == ~"a"; } #[cfg(test)] mod test { - fn mk_doc(source: str) -> doc::doc { + fn mk_doc(source: ~str) -> doc::doc { let ast = parse::from_str(source); - extract(ast, "") + extract(ast, ~"") } #[test] fn extract_empty_crate() { - let doc = mk_doc(""); + let doc = mk_doc(~""); assert vec::is_empty(doc.cratemod().mods()); assert vec::is_empty(doc.cratemod().fns()); } #[test] fn extract_mods() { - let doc = mk_doc("mod a { mod b { } mod c { } }"); - assert doc.cratemod().mods()[0].name() == "a"; - assert doc.cratemod().mods()[0].mods()[0].name() == "b"; - assert doc.cratemod().mods()[0].mods()[1].name() == "c"; + let doc = mk_doc(~"mod a { mod b { } mod c { } }"); + assert doc.cratemod().mods()[0].name() == ~"a"; + assert doc.cratemod().mods()[0].mods()[0].name() == ~"b"; + assert doc.cratemod().mods()[0].mods()[1].name() == ~"c"; } #[test] fn extract_foreign_mods() { - let doc = mk_doc("extern mod a { }"); - assert doc.cratemod().nmods()[0].name() == "a"; + let doc = mk_doc(~"extern mod a { }"); + assert doc.cratemod().nmods()[0].name() == ~"a"; } #[test] fn extract_fns_from_foreign_mods() { - let doc = mk_doc("extern mod a { fn a(); }"); - assert doc.cratemod().nmods()[0].fns[0].name() == "a"; + let doc = mk_doc(~"extern mod a { fn a(); }"); + assert doc.cratemod().nmods()[0].fns[0].name() == ~"a"; } #[test] fn extract_mods_deep() { - let doc = mk_doc("mod a { mod b { mod c { } } }"); - assert doc.cratemod().mods()[0].mods()[0].mods()[0].name() == "c"; + let doc = mk_doc(~"mod a { mod b { mod c { } } }"); + assert doc.cratemod().mods()[0].mods()[0].mods()[0].name() == ~"c"; } #[test] fn extract_should_set_mod_ast_id() { - let doc = mk_doc("mod a { }"); + let doc = mk_doc(~"mod a { }"); assert doc.cratemod().mods()[0].id() != 0; } #[test] fn extract_fns() { let doc = mk_doc( - "fn a() { } \ + ~"fn a() { } \ mod b { fn c() { } }"); - assert doc.cratemod().fns()[0].name() == "a"; - assert doc.cratemod().mods()[0].fns()[0].name() == "c"; + assert doc.cratemod().fns()[0].name() == ~"a"; + assert doc.cratemod().mods()[0].fns()[0].name() == ~"c"; } #[test] fn extract_should_set_fn_ast_id() { - let doc = mk_doc("fn a() { }"); + let doc = mk_doc(~"fn a() { }"); assert doc.cratemod().fns()[0].id() != 0; } #[test] fn extract_should_use_default_crate_name() { - let source = ""; + let source = ~""; let ast = parse::from_str(source); - let doc = extract(ast, "burp"); - assert doc.cratemod().name() == "burp"; + let doc = extract(ast, ~"burp"); + assert doc.cratemod().name() == ~"burp"; } #[test] fn extract_from_seq_srv() { - let source = ""; + let source = ~""; do astsrv::from_str(source) |srv| { - let doc = from_srv(srv, "name"); - assert doc.cratemod().name() == "name"; + let doc = from_srv(srv, ~"name"); + assert doc.cratemod().name() == ~"name"; } } } diff --git a/src/rustdoc/fold.rs b/src/rustdoc/fold.rs index be24edf22b6..e9d8615d1d4 100644 --- a/src/rustdoc/fold.rs +++ b/src/rustdoc/fold.rs @@ -332,9 +332,9 @@ fn default_seq_fold_type<T>( #[test] fn default_fold_should_produce_same_doc() { - let source = "mod a { fn b() { } mod c { fn d() { } } }"; + let source = ~"mod a { fn b() { } mod c { fn d() { } } }"; let ast = parse::from_str(source); - let doc = extract::extract(ast, ""); + let doc = extract::extract(ast, ~""); let fld = default_seq_fold(()); let folded = fld.fold_doc(fld, doc); assert doc == folded; @@ -342,9 +342,9 @@ fn default_fold_should_produce_same_doc() { #[test] fn default_fold_should_produce_same_consts() { - let source = "const a: int = 0;"; + let source = ~"const a: int = 0;"; let ast = parse::from_str(source); - let doc = extract::extract(ast, ""); + let doc = extract::extract(ast, ~""); let fld = default_seq_fold(()); let folded = fld.fold_doc(fld, doc); assert doc == folded; @@ -352,9 +352,9 @@ fn default_fold_should_produce_same_consts() { #[test] fn default_fold_should_produce_same_enums() { - let source = "enum a { b }"; + let source = ~"enum a { b }"; let ast = parse::from_str(source); - let doc = extract::extract(ast, ""); + let doc = extract::extract(ast, ~""); let fld = default_seq_fold(()); let folded = fld.fold_doc(fld, doc); assert doc == folded; @@ -362,9 +362,9 @@ fn default_fold_should_produce_same_enums() { #[test] fn default_parallel_fold_should_produce_same_doc() { - let source = "mod a { fn b() { } mod c { fn d() { } } }"; + let source = ~"mod a { fn b() { } mod c { fn d() { } } }"; let ast = parse::from_str(source); - let doc = extract::extract(ast, ""); + let doc = extract::extract(ast, ~""); let fld = default_par_fold(()); let folded = fld.fold_doc(fld, doc); assert doc == folded; diff --git a/src/rustdoc/markdown_index_pass.rs b/src/rustdoc/markdown_index_pass.rs index 52dc7cabee0..a98fe47ec0f 100644 --- a/src/rustdoc/markdown_index_pass.rs +++ b/src/rustdoc/markdown_index_pass.rs @@ -4,7 +4,7 @@ export mk_pass; fn mk_pass(config: config::config) -> pass { { - name: "markdown_index", + name: ~"markdown_index", f: fn~(srv: astsrv::srv, doc: doc::doc) -> doc::doc { run(srv, doc, config) } @@ -82,7 +82,7 @@ fn item_to_entry( markdown_writer::make_filename(config, doc::itempage(doc)) } _ { - "#" + pandoc_header_id(markdown_pass::header_text(doc)) + ~"#" + pandoc_header_id(markdown_pass::header_text(doc)) } }; @@ -94,7 +94,7 @@ fn item_to_entry( } } -fn pandoc_header_id(header: str) -> str { +fn pandoc_header_id(header: ~str) -> ~str { // http://johnmacfarlane.net/pandoc/README.html#headers @@ -106,61 +106,61 @@ fn pandoc_header_id(header: str) -> str { let header = maybe_use_section_id(header); ret header; - fn remove_formatting(s: str) -> str { - str::replace(s, "`", "") + fn remove_formatting(s: ~str) -> ~str { + str::replace(s, ~"`", ~"") } - fn remove_punctuation(s: str) -> str { - let s = str::replace(s, "<", ""); - let s = str::replace(s, ">", ""); - let s = str::replace(s, "[", ""); - let s = str::replace(s, "]", ""); - let s = str::replace(s, "(", ""); - let s = str::replace(s, ")", ""); - let s = str::replace(s, "@", "/~"/~); - let s = str::replace(s, "~", ""); - let s = str::replace(s, "/", ""); - let s = str::replace(s, ":", ""); - let s = str::replace(s, "&", ""); - let s = str::replace(s, "^", ""); + fn remove_punctuation(s: ~str) -> ~str { + let s = str::replace(s, ~"<", ~""); + let s = str::replace(s, ~">", ~""); + let s = str::replace(s, ~"[", ~""); + let s = str::replace(s, ~"]", ~""); + let s = str::replace(s, ~"(", ~""); + let s = str::replace(s, ~")", ~""); + let s = str::replace(s, ~"@~", ~""); + let s = str::replace(s, ~"~", ~""); + let s = str::replace(s, ~"/", ~""); + let s = str::replace(s, ~":", ~""); + let s = str::replace(s, ~"&", ~""); + let s = str::replace(s, ~"^", ~""); ret s; } - fn replace_with_hyphens(s: str) -> str { - str::replace(s, " ", "-") + fn replace_with_hyphens(s: ~str) -> ~str { + str::replace(s, ~" ", ~"-") } - fn convert_to_lowercase(s: str) -> str { str::to_lower(s) } - fn remove_up_to_first_letter(s: str) -> str { s } - fn maybe_use_section_id(s: str) -> str { s } + fn convert_to_lowercase(s: ~str) -> ~str { str::to_lower(s) } + fn remove_up_to_first_letter(s: ~str) -> ~str { s } + fn maybe_use_section_id(s: ~str) -> ~str { s } } #[test] fn should_remove_punctuation_from_headers() { - assert pandoc_header_id("impl foo of bar<A>") == "impl-foo-of-bara"; - assert pandoc_header_id("fn@(~[~A])") == "fna"; - assert pandoc_header_id("impl of num::num for int") - == "impl-of-numnum-for-int"; - assert pandoc_header_id("impl of num::num for int/&") - == "impl-of-numnum-for-int"; - assert pandoc_header_id("impl of num::num for ^int") - == "impl-of-numnum-for-int"; + assert pandoc_header_id(~"impl foo of bar<A>") == ~"impl-foo-of-bara"; + assert pandoc_header_id(~"fn@(~[~A])") == ~"fna"; + assert pandoc_header_id(~"impl of num::num for int") + == ~"impl-of-numnum-for-int"; + assert pandoc_header_id(~"impl of num::num for int/&") + == ~"impl-of-numnum-for-int"; + assert pandoc_header_id(~"impl of num::num for ^int") + == ~"impl-of-numnum-for-int"; } #[test] fn should_index_mod_contents() { let doc = test::mk_doc( config::doc_per_crate, - "mod a { } fn b() { }" + ~"mod a { } fn b() { }" ); assert option::get(doc.cratemod().index).entries[0] == { - kind: "Module", - name: "a", + kind: ~"Module", + name: ~"a", brief: none, - link: "#module-a" + link: ~"#module-a" }; assert option::get(doc.cratemod().index).entries[1] == { - kind: "Function", - name: "b", + kind: ~"Function", + name: ~"b", brief: none, - link: "#function-b" + link: ~"#function-b" }; } @@ -168,19 +168,19 @@ fn should_index_mod_contents() { fn should_index_mod_contents_multi_page() { let doc = test::mk_doc( config::doc_per_mod, - "mod a { } fn b() { }" + ~"mod a { } fn b() { }" ); assert option::get(doc.cratemod().index).entries[0] == { - kind: "Module", - name: "a", + kind: ~"Module", + name: ~"a", brief: none, - link: "a.html" + link: ~"a.html" }; assert option::get(doc.cratemod().index).entries[1] == { - kind: "Function", - name: "b", + kind: ~"Function", + name: ~"b", brief: none, - link: "#function-b" + link: ~"#function-b" }; } @@ -188,13 +188,13 @@ fn should_index_mod_contents_multi_page() { fn should_index_foreign_mod_pages() { let doc = test::mk_doc( config::doc_per_mod, - "extern mod a { }" + ~"extern mod a { }" ); assert option::get(doc.cratemod().index).entries[0] == { - kind: "Foreign module", - name: "a", + kind: ~"Foreign module", + name: ~"a", brief: none, - link: "a.html" + link: ~"a.html" }; } @@ -202,34 +202,35 @@ fn should_index_foreign_mod_pages() { fn should_add_brief_desc_to_index() { let doc = test::mk_doc( config::doc_per_mod, - "#[doc = \"test\"] mod a { }" + ~"#[doc = \"test\"] mod a { }" ); - assert option::get(doc.cratemod().index).entries[0].brief == some("test"); + assert option::get(doc.cratemod().index).entries[0].brief + == some(~"test"); } #[test] fn should_index_foreign_mod_contents() { let doc = test::mk_doc( config::doc_per_crate, - "extern mod a { fn b(); }" + ~"extern mod a { fn b(); }" ); assert option::get(doc.cratemod().nmods()[0].index).entries[0] == { - kind: "Function", - name: "b", + kind: ~"Function", + name: ~"b", brief: none, - link: "#function-b" + link: ~"#function-b" }; } #[cfg(test)] mod test { - fn mk_doc(output_style: config::output_style, source: str) -> doc::doc { + fn mk_doc(output_style: config::output_style, source: ~str) -> doc::doc { do astsrv::from_str(source) |srv| { let config = { output_style: output_style - with config::default_config("whatever") + with config::default_config(~"whatever") }; - let doc = extract::from_srv(srv, ""); + let doc = extract::from_srv(srv, ~""); let doc = attr_pass::mk_pass().f(srv, doc); let doc = desc_to_brief_pass::mk_pass().f(srv, doc); let doc = path_pass::mk_pass().f(srv, doc); diff --git a/src/rustdoc/markdown_pass.rs b/src/rustdoc/markdown_pass.rs index 10869161e8a..9c36af9237b 100644 --- a/src/rustdoc/markdown_pass.rs +++ b/src/rustdoc/markdown_pass.rs @@ -13,7 +13,7 @@ fn mk_pass(+writer_factory: writer_factory) -> pass { }; { - name: "markdown", + name: ~"markdown", f: f } } @@ -40,7 +40,7 @@ fn run( // output at the same header level so sorting mods last // makes the headers come out nested correctly. let sorted_doc = sort_pass::mk_pass( - "mods last", mods_last + ~"mods last", mods_last ).f(srv, doc); write_markdown(sorted_doc, writer_factory); @@ -58,16 +58,16 @@ fn should_write_modules_last() { modules appearing to contain items that they do not. */ let markdown = test::render( - "mod a { }\ + ~"mod a { }\ fn b() { }\ mod c { }\ fn d() { }" ); - let idx_a = option::get(str::find_str(markdown, "# Module `a`")); - let idx_b = option::get(str::find_str(markdown, "## Function `b`")); - let idx_c = option::get(str::find_str(markdown, "# Module `c`")); - let idx_d = option::get(str::find_str(markdown, "## Function `d`")); + let idx_a = option::get(str::find_str(markdown, ~"# Module `a`")); + let idx_b = option::get(str::find_str(markdown, ~"## Function `b`")); + let idx_c = option::get(str::find_str(markdown, ~"# Module `c`")); + let idx_d = option::get(str::find_str(markdown, ~"## Function `d`")); assert idx_b < idx_d; assert idx_d < idx_a; @@ -110,7 +110,7 @@ fn should_request_new_writer_for_each_page() { // This port will send us a (page, str) pair for every writer // that was created let (writer_factory, po) = markdown_writer::future_writer_factory(); - let (srv, doc) = test::create_doc_srv("mod a { }"); + let (srv, doc) = test::create_doc_srv(~"mod a { }"); // Split the document up into pages let doc = page_pass::mk_pass(config::doc_per_mod).f(srv, doc); write_markdown(doc, writer_factory); @@ -122,10 +122,10 @@ fn should_request_new_writer_for_each_page() { fn write_title(ctxt: ctxt, page: doc::page) { ctxt.w.write_line(#fmt("%% %s", make_title(page))); - ctxt.w.write_line(""); + ctxt.w.write_line(~""); } -fn make_title(page: doc::page) -> str { +fn make_title(page: doc::page) -> ~str { let item = alt page { doc::cratepage(cratedoc) { doc::modtag(cratedoc.topmod) @@ -135,7 +135,7 @@ fn make_title(page: doc::page) -> str { } }; let title = markdown_pass::header_text(item); - let title = str::replace(title, "`", ""); + let title = str::replace(title, ~"`", ~""); ret title; } @@ -143,17 +143,17 @@ fn make_title(page: doc::page) -> str { fn should_write_title_for_each_page() { let (writer_factory, po) = markdown_writer::future_writer_factory(); let (srv, doc) = test::create_doc_srv( - "#[link(name = \"core\")]; mod a { }"); + ~"#[link(name = \"core\")]; mod a { }"); let doc = page_pass::mk_pass(config::doc_per_mod).f(srv, doc); write_markdown(doc, writer_factory); for iter::repeat(2u) { let (page, markdown) = comm::recv(po); alt page { doc::cratepage(_) { - assert str::contains(markdown, "% Crate core"); + assert str::contains(markdown, ~"% Crate core"); } doc::itempage(_) { - assert str::contains(markdown, "% Module a"); + assert str::contains(markdown, ~"% Module a"); } } } @@ -171,47 +171,47 @@ fn write_header(ctxt: ctxt, lvl: hlvl, doc: doc::itemtag) { write_header_(ctxt, lvl, text); } -fn write_header_(ctxt: ctxt, lvl: hlvl, title: str) { +fn write_header_(ctxt: ctxt, lvl: hlvl, title: ~str) { let hashes = str::from_chars(vec::from_elem(lvl as uint, '#')); ctxt.w.write_line(#fmt("%s %s", hashes, title)); - ctxt.w.write_line(""); + ctxt.w.write_line(~""); } -fn header_kind(doc: doc::itemtag) -> str { +fn header_kind(doc: doc::itemtag) -> ~str { alt doc { doc::modtag(_) { if doc.id() == syntax::ast::crate_node_id { - "Crate" + ~"Crate" } else { - "Module" + ~"Module" } } doc::nmodtag(_) { - "Foreign module" + ~"Foreign module" } doc::fntag(_) { - "Function" + ~"Function" } doc::consttag(_) { - "Const" + ~"Const" } doc::enumtag(_) { - "Enum" + ~"Enum" } doc::traittag(_) { - "Interface" + ~"Interface" } doc::impltag(doc) { - "Implementation" + ~"Implementation" } doc::tytag(_) { - "Type" + ~"Type" } } } -fn header_name(doc: doc::itemtag) -> str { - let fullpath = str::connect(doc.path() + ~[doc.name()], "::"); +fn header_name(doc: doc::itemtag) -> ~str { + let fullpath = str::connect(doc.path() + ~[doc.name()], ~"::"); alt doc { doc::modtag(_) if doc.id() != syntax::ast::crate_node_id { fullpath @@ -237,11 +237,11 @@ fn header_name(doc: doc::itemtag) -> str { } } -fn header_text(doc: doc::itemtag) -> str { +fn header_text(doc: doc::itemtag) -> ~str { header_text_(header_kind(doc), header_name(doc)) } -fn header_text_(kind: str, name: str) -> str { +fn header_text_(kind: ~str, name: ~str) -> ~str { #fmt("%s `%s`", kind, name) } @@ -268,13 +268,13 @@ fn write_mod( #[test] fn should_write_full_path_to_mod() { - let markdown = test::render("mod a { mod b { mod c { } } }"); - assert str::contains(markdown, "# Module `a::b::c`"); + let markdown = test::render(~"mod a { mod b { mod c { } } }"); + assert str::contains(markdown, ~"# Module `a::b::c`"); } fn write_common( ctxt: ctxt, - desc: option<str>, + desc: option<~str>, sections: ~[doc::section] ) { write_desc(ctxt, desc); @@ -283,12 +283,12 @@ fn write_common( fn write_desc( ctxt: ctxt, - desc: option<str> + desc: option<~str> ) { alt desc { some(desc) { ctxt.w.write_line(desc); - ctxt.w.write_line(""); + ctxt.w.write_line(~""); } none { } } @@ -303,17 +303,17 @@ fn write_sections(ctxt: ctxt, sections: ~[doc::section]) { fn write_section(ctxt: ctxt, section: doc::section) { write_header_(ctxt, h4, section.header); ctxt.w.write_line(section.body); - ctxt.w.write_line(""); + ctxt.w.write_line(~""); } #[test] fn should_write_sections() { let markdown = test::render( - "#[doc = \"\ + ~"#[doc = \"\ # Header\n\ Body\"]\ mod a { }"); - assert str::contains(markdown, "#### Header\n\nBody\n\n"); + assert str::contains(markdown, ~"#### Header\n\nBody\n\n"); } fn write_mod_contents( @@ -368,8 +368,8 @@ fn item_header_lvl(doc: doc::itemtag) -> hlvl { #[test] fn should_write_crate_description() { - let markdown = test::render("#[doc = \"this is the crate\"];"); - assert str::contains(markdown, "this is the crate"); + let markdown = test::render(~"#[doc = \"this is the crate\"];"); + assert str::contains(markdown, ~"this is the crate"); } fn write_index(ctxt: ctxt, index: doc::index) { @@ -387,37 +387,37 @@ fn write_index(ctxt: ctxt, index: doc::index) { ctxt.w.write_line(#fmt("* [%s](%s)", header, id)); } } - ctxt.w.write_line(""); + ctxt.w.write_line(~""); } #[test] fn should_write_index() { - let markdown = test::render("mod a { } mod b { }"); + let markdown = test::render(~"mod a { } mod b { }"); assert str::contains( markdown, - "\n\n* [Module `a`](#module-a)\n\ + ~"\n\n* [Module `a`](#module-a)\n\ * [Module `b`](#module-b)\n\n" ); } #[test] fn should_write_index_brief() { - let markdown = test::render("#[doc = \"test\"] mod a { }"); - assert str::contains(markdown, "(#module-a) - test\n"); + let markdown = test::render(~"#[doc = \"test\"] mod a { }"); + assert str::contains(markdown, ~"(#module-a) - test\n"); } #[test] fn should_not_write_index_if_no_entries() { - let markdown = test::render(""); - assert !str::contains(markdown, "\n\n\n"); + let markdown = test::render(~""); + assert !str::contains(markdown, ~"\n\n\n"); } #[test] fn should_write_index_for_foreign_mods() { - let markdown = test::render("extern mod a { fn a(); }"); + let markdown = test::render(~"extern mod a { fn a(); }"); assert str::contains( markdown, - "\n\n* [Function `a`](#function-a)\n\n" + ~"\n\n* [Function `a`](#function-a)\n\n" ); } @@ -435,21 +435,23 @@ fn write_nmod(ctxt: ctxt, doc: doc::nmoddoc) { #[test] fn should_write_foreign_mods() { - let markdown = test::render("#[doc = \"test\"] extern mod a { }"); - assert str::contains(markdown, "Foreign module `a`"); - assert str::contains(markdown, "test"); + let markdown = test::render(~"#[doc = \"test\"] extern mod a { }"); + assert str::contains(markdown, ~"Foreign module `a`"); + assert str::contains(markdown, ~"test"); } #[test] fn should_write_foreign_fns() { - let markdown = test::render("extern mod a { #[doc = \"test\"] fn a(); }"); - assert str::contains(markdown, "test"); + let markdown = test::render( + ~"extern mod a { #[doc = \"test\"] fn a(); }"); + assert str::contains(markdown, ~"test"); } #[test] fn should_write_foreign_fn_headers() { - let markdown = test::render("extern mod a { #[doc = \"test\"] fn a(); }"); - assert str::contains(markdown, "## Function `a`"); + let markdown = test::render( + ~"extern mod a { #[doc = \"test\"] fn a(); }"); + assert str::contains(markdown, ~"## Function `a`"); } fn write_fn( @@ -466,57 +468,57 @@ fn write_fn( fn write_fnlike( ctxt: ctxt, - sig: option<str>, - desc: option<str>, + sig: option<~str>, + desc: option<~str>, sections: ~[doc::section] ) { write_sig(ctxt, sig); write_common(ctxt, desc, sections); } -fn write_sig(ctxt: ctxt, sig: option<str>) { +fn write_sig(ctxt: ctxt, sig: option<~str>) { alt sig { some(sig) { ctxt.w.write_line(code_block_indent(sig)); - ctxt.w.write_line(""); + ctxt.w.write_line(~""); } - none { fail "unimplemented" } + none { fail ~"unimplemented" } } } -fn code_block_indent(s: str) -> str { +fn code_block_indent(s: ~str) -> ~str { let lines = str::lines_any(s); let indented = par::seqmap(lines, |line| #fmt(" %s", line) ); - str::connect(indented, "\n") + str::connect(indented, ~"\n") } #[test] fn write_markdown_should_write_function_header() { - let markdown = test::render("fn func() { }"); - assert str::contains(markdown, "## Function `func`"); + let markdown = test::render(~"fn func() { }"); + assert str::contains(markdown, ~"## Function `func`"); } #[test] fn should_write_the_function_signature() { - let markdown = test::render("#[doc = \"f\"] fn a() { }"); - assert str::contains(markdown, "\n fn a()\n"); + let markdown = test::render(~"#[doc = \"f\"] fn a() { }"); + assert str::contains(markdown, ~"\n fn a()\n"); } #[test] fn should_insert_blank_line_after_fn_signature() { - let markdown = test::render("#[doc = \"f\"] fn a() { }"); - assert str::contains(markdown, "fn a()\n\n"); + let markdown = test::render(~"#[doc = \"f\"] fn a() { }"); + assert str::contains(markdown, ~"fn a()\n\n"); } #[test] fn should_correctly_indent_fn_signature() { - let doc = test::create_doc("fn a() { }"); + let doc = test::create_doc(~"fn a() { }"); let doc = { pages: ~[ doc::cratepage({ topmod: { items: ~[doc::fntag({ - sig: some("line 1\nline 2") + sig: some(~"line 1\nline 2") with doc.cratemod().fns()[0] })] with doc.cratemod() @@ -526,13 +528,13 @@ fn should_correctly_indent_fn_signature() { ] }; let markdown = test::write_markdown_str(doc); - assert str::contains(markdown, " line 1\n line 2"); + assert str::contains(markdown, ~" line 1\n line 2"); } #[test] fn should_leave_blank_line_between_fn_header_and_sig() { - let markdown = test::render("fn a() { }"); - assert str::contains(markdown, "Function `a`\n\n fn a()"); + let markdown = test::render(~"fn a() { }"); + assert str::contains(markdown, ~"Function `a`\n\n fn a()"); } fn write_const( @@ -545,16 +547,16 @@ fn write_const( #[test] fn should_write_const_header() { - let markdown = test::render("const a: bool = true;"); - assert str::contains(markdown, "## Const `a`\n\n"); + let markdown = test::render(~"const a: bool = true;"); + assert str::contains(markdown, ~"## Const `a`\n\n"); } #[test] fn should_write_const_description() { let markdown = test::render( - "#[doc = \"b\"]\ + ~"#[doc = \"b\"]\ const a: bool = true;"); - assert str::contains(markdown, "\n\nb\n\n"); + assert str::contains(markdown, ~"\n\nb\n\n"); } fn write_enum( @@ -567,15 +569,15 @@ fn write_enum( #[test] fn should_write_enum_header() { - let markdown = test::render("enum a { b }"); - assert str::contains(markdown, "## Enum `a`\n\n"); + let markdown = test::render(~"enum a { b }"); + assert str::contains(markdown, ~"## Enum `a`\n\n"); } #[test] fn should_write_enum_description() { let markdown = test::render( - "#[doc = \"b\"] enum a { b }"); - assert str::contains(markdown, "\n\nb\n\n"); + ~"#[doc = \"b\"] enum a { b }"); + assert str::contains(markdown, ~"\n\nb\n\n"); } fn write_variants( @@ -586,11 +588,11 @@ fn write_variants( ret; } - write_header_(ctxt, h4, "Variants"); + write_header_(ctxt, h4, ~"Variants"); vec::iter(docs, |variant| write_variant(ctxt, variant) ); - ctxt.w.write_line(""); + ctxt.w.write_line(~""); } fn write_variant(ctxt: ctxt, doc: doc::variantdoc) { @@ -609,32 +611,32 @@ fn write_variant(ctxt: ctxt, doc: doc::variantdoc) { #[test] fn should_write_variant_list() { let markdown = test::render( - "enum a { \ + ~"enum a { \ #[doc = \"test\"] b, \ #[doc = \"test\"] c }"); assert str::contains( markdown, - "\n\n#### Variants\n\ + ~"\n\n#### Variants\n\ \n* `b` - test\ \n* `c` - test\n\n"); } #[test] fn should_write_variant_list_without_descs() { - let markdown = test::render("enum a { b, c }"); + let markdown = test::render(~"enum a { b, c }"); assert str::contains( markdown, - "\n\n#### Variants\n\ + ~"\n\n#### Variants\n\ \n* `b`\ \n* `c`\n\n"); } #[test] fn should_write_variant_list_with_signatures() { - let markdown = test::render("enum a { b(int), #[doc = \"a\"] c(int) }"); + let markdown = test::render(~"enum a { b(int), #[doc = \"a\"] c(int) }"); assert str::contains( markdown, - "\n\n#### Variants\n\ + ~"\n\n#### Variants\n\ \n* `b(int)`\ \n* `c(int)` - a\n\n"); } @@ -649,7 +651,7 @@ fn write_methods(ctxt: ctxt, docs: ~[doc::methoddoc]) { } fn write_method(ctxt: ctxt, doc: doc::methoddoc) { - write_header_(ctxt, h3, header_text_("Method", doc.name)); + write_header_(ctxt, h3, header_text_(~"Method", doc.name)); write_fnlike( ctxt, doc.sig, @@ -660,29 +662,29 @@ fn write_method(ctxt: ctxt, doc: doc::methoddoc) { #[test] fn should_write_trait_header() { - let markdown = test::render("iface i { fn a(); }"); - assert str::contains(markdown, "## Interface `i`"); + let markdown = test::render(~"iface i { fn a(); }"); + assert str::contains(markdown, ~"## Interface `i`"); } #[test] fn should_write_trait_desc() { let markdown = test::render( - "#[doc = \"desc\"] iface i { fn a(); }"); - assert str::contains(markdown, "desc"); + ~"#[doc = \"desc\"] iface i { fn a(); }"); + assert str::contains(markdown, ~"desc"); } #[test] fn should_write_trait_method_header() { let markdown = test::render( - "iface i { fn a(); }"); - assert str::contains(markdown, "### Method `a`"); + ~"iface i { fn a(); }"); + assert str::contains(markdown, ~"### Method `a`"); } #[test] fn should_write_trait_method_signature() { let markdown = test::render( - "iface i { fn a(); }"); - assert str::contains(markdown, "\n fn a()"); + ~"iface i { fn a(); }"); + assert str::contains(markdown, ~"\n fn a()"); } fn write_impl(ctxt: ctxt, doc: doc::impldoc) { @@ -692,35 +694,35 @@ fn write_impl(ctxt: ctxt, doc: doc::impldoc) { #[test] fn should_write_impl_header() { - let markdown = test::render("impl i for int { fn a() { } }"); - assert str::contains(markdown, "## Implementation `i for int`"); + let markdown = test::render(~"impl i for int { fn a() { } }"); + assert str::contains(markdown, ~"## Implementation `i for int`"); } #[test] fn should_write_impl_header_with_trait() { - let markdown = test::render("impl i of j for int { fn a() { } }"); - assert str::contains(markdown, "## Implementation `i of j for int`"); + let markdown = test::render(~"impl i of j for int { fn a() { } }"); + assert str::contains(markdown, ~"## Implementation `i of j for int`"); } #[test] fn should_write_impl_desc() { let markdown = test::render( - "#[doc = \"desc\"] impl i for int { fn a() { } }"); - assert str::contains(markdown, "desc"); + ~"#[doc = \"desc\"] impl i for int { fn a() { } }"); + assert str::contains(markdown, ~"desc"); } #[test] fn should_write_impl_method_header() { let markdown = test::render( - "impl i for int { fn a() { } }"); - assert str::contains(markdown, "### Method `a`"); + ~"impl i for int { fn a() { } }"); + assert str::contains(markdown, ~"### Method `a`"); } #[test] fn should_write_impl_method_signature() { let markdown = test::render( - "impl i for int { fn a() { } }"); - assert str::contains(markdown, "\n fn a()"); + ~"impl i for int { fn a() { } }"); + assert str::contains(markdown, ~"\n fn a()"); } fn write_type( @@ -733,41 +735,41 @@ fn write_type( #[test] fn should_write_type_header() { - let markdown = test::render("type t = int;"); - assert str::contains(markdown, "## Type `t`"); + let markdown = test::render(~"type t = int;"); + assert str::contains(markdown, ~"## Type `t`"); } #[test] fn should_write_type_desc() { let markdown = test::render( - "#[doc = \"desc\"] type t = int;"); - assert str::contains(markdown, "\n\ndesc\n\n"); + ~"#[doc = \"desc\"] type t = int;"); + assert str::contains(markdown, ~"\n\ndesc\n\n"); } #[test] fn should_write_type_signature() { - let markdown = test::render("type t = int;"); - assert str::contains(markdown, "\n\n type t = int\n\n"); + let markdown = test::render(~"type t = int;"); + assert str::contains(markdown, ~"\n\n type t = int\n\n"); } #[cfg(test)] mod test { - fn render(source: str) -> str { + fn render(source: ~str) -> ~str { let (srv, doc) = create_doc_srv(source); let markdown = write_markdown_str_srv(srv, doc); #debug("markdown: %s", markdown); markdown } - fn create_doc_srv(source: str) -> (astsrv::srv, doc::doc) { + fn create_doc_srv(source: ~str) -> (astsrv::srv, doc::doc) { do astsrv::from_str(source) |srv| { let config = { output_style: config::doc_per_crate - with config::default_config("whatever") + with config::default_config(~"whatever") }; - let doc = extract::from_srv(srv, ""); + let doc = extract::from_srv(srv, ~""); #debug("doc (extract): %?", doc); let doc = tystr_pass::mk_pass().f(srv, doc); #debug("doc (tystr): %?", doc); @@ -789,14 +791,14 @@ mod test { } } - fn create_doc(source: str) -> doc::doc { + fn create_doc(source: ~str) -> doc::doc { let (_, doc) = create_doc_srv(source); doc } fn write_markdown_str( doc: doc::doc - ) -> str { + ) -> ~str { let (writer_factory, po) = markdown_writer::future_writer_factory(); write_markdown(doc, writer_factory); ret tuple::second(comm::recv(po)); @@ -805,7 +807,7 @@ mod test { fn write_markdown_str_srv( srv: astsrv::srv, doc: doc::doc - ) -> str { + ) -> ~str { let (writer_factory, po) = markdown_writer::future_writer_factory(); let pass = mk_pass(writer_factory); pass.f(srv, doc); @@ -814,13 +816,13 @@ mod test { #[test] fn write_markdown_should_write_mod_headers() { - let markdown = render("mod moo { }"); - assert str::contains(markdown, "# Module `moo`"); + let markdown = render(~"mod moo { }"); + assert str::contains(markdown, ~"# Module `moo`"); } #[test] fn should_leave_blank_line_after_header() { - let markdown = render("mod morp { }"); - assert str::contains(markdown, "Module `morp`\n\n"); + let markdown = render(~"mod morp { }"); + assert str::contains(markdown, ~"Module `morp`\n\n"); } } diff --git a/src/rustdoc/markdown_writer.rs b/src/rustdoc/markdown_writer.rs index 6c41f0923a5..5ac9998d9ea 100644 --- a/src/rustdoc/markdown_writer.rs +++ b/src/rustdoc/markdown_writer.rs @@ -7,7 +7,7 @@ export future_writer_factory; export make_filename; enum writeinstr { - write(str), + write(~str), done } @@ -15,12 +15,12 @@ type writer = fn~(+writeinstr); type writer_factory = fn~(page: doc::page) -> writer; impl writer_util for writer { - fn write_str(str: str) { + fn write_str(str: ~str) { self(write(str)); } - fn write_line(str: str) { - self.write_str(str + "\n"); + fn write_line(str: ~str) { + self.write_str(str + ~"\n"); } fn write_done() { @@ -70,19 +70,19 @@ fn pandoc_writer( let filename = make_local_filename(config, page); let pandoc_args = ~[ - "--standalone", - "--section-divs", - "--from=markdown", - "--to=html", - "--css=rust.css", - "--output=" + filename + ~"--standalone", + ~"--section-divs", + ~"--from=markdown", + ~"--to=html", + ~"--css=rust.css", + ~"--output=" + filename ]; do generic_writer |markdown| { import io::writer_util; #debug("pandoc cmd: %s", pandoc_cmd); - #debug("pandoc args: %s", str::connect(pandoc_args, " ")); + #debug("pandoc args: %s", str::connect(pandoc_args, ~" ")); let pipe_in = os::pipe(); let pipe_out = os::pipe(); @@ -118,16 +118,16 @@ fn pandoc_writer( if status != 0 { #error("pandoc-out: %s", stdout); #error("pandoc-err: %s", stderr); - fail "pandoc failed"; + fail ~"pandoc failed"; } } } -fn readclose(fd: libc::c_int) -> str { +fn readclose(fd: libc::c_int) -> ~str { // Copied from run::program_output let file = os::fdopen(fd); let reader = io::FILE_reader(file, false); - let mut buf = ""; + let mut buf = ~""; while !reader.eof() { let bytes = reader.read_bytes(4096u); buf += str::from_bytes(bytes); @@ -136,9 +136,9 @@ fn readclose(fd: libc::c_int) -> str { ret buf; } -fn generic_writer(+process: fn~(markdown: str)) -> writer { +fn generic_writer(+process: fn~(markdown: ~str)) -> writer { let ch = do task::spawn_listener |po: comm::port<writeinstr>| { - let mut markdown = ""; + let mut markdown = ~""; let mut keep_going = true; while keep_going { alt comm::recv(po) { @@ -157,7 +157,7 @@ fn generic_writer(+process: fn~(markdown: str)) -> writer { fn make_local_filename( config: config::config, page: doc::page -) -> str { +) -> ~str { let filename = make_filename(config, page); path::connect(config.output_dir, filename) } @@ -165,77 +165,77 @@ fn make_local_filename( fn make_filename( config: config::config, page: doc::page -) -> str { +) -> ~str { let filename = { alt page { doc::cratepage(doc) { if config.output_format == config::pandoc_html && config.output_style == config::doc_per_mod { - "index" + ~"index" } else { - assert doc.topmod.name() != ""; + assert doc.topmod.name() != ~""; doc.topmod.name() } } doc::itempage(doc) { - str::connect(doc.path() + ~[doc.name()], "_") + str::connect(doc.path() + ~[doc.name()], ~"_") } } }; let ext = alt config.output_format { - config::markdown { "md" } - config::pandoc_html { "html" } + config::markdown { ~"md" } + config::pandoc_html { ~"html" } }; - filename + "." + ext + filename + ~"." + ext } #[test] fn should_use_markdown_file_name_based_off_crate() { let config = { - output_dir: "output/dir", + output_dir: ~"output/dir", output_format: config::markdown, output_style: config::doc_per_crate - with config::default_config("input/test.rc") + with config::default_config(~"input/test.rc") }; - let doc = test::mk_doc("test", ""); + let doc = test::mk_doc(~"test", ~""); let page = doc::cratepage(doc.cratedoc()); let filename = make_local_filename(config, page); - assert filename == "output/dir/test.md"; + assert filename == ~"output/dir/test.md"; } #[test] fn should_name_html_crate_file_name_index_html_when_doc_per_mod() { let config = { - output_dir: "output/dir", + output_dir: ~"output/dir", output_format: config::pandoc_html, output_style: config::doc_per_mod - with config::default_config("input/test.rc") + with config::default_config(~"input/test.rc") }; - let doc = test::mk_doc("", ""); + let doc = test::mk_doc(~"", ~""); let page = doc::cratepage(doc.cratedoc()); let filename = make_local_filename(config, page); - assert filename == "output/dir/index.html"; + assert filename == ~"output/dir/index.html"; } #[test] fn should_name_mod_file_names_by_path() { let config = { - output_dir: "output/dir", + output_dir: ~"output/dir", output_format: config::pandoc_html, output_style: config::doc_per_mod - with config::default_config("input/test.rc") + with config::default_config(~"input/test.rc") }; - let doc = test::mk_doc("", "mod a { mod b { } }"); + let doc = test::mk_doc(~"", ~"mod a { mod b { } }"); let modb = doc.cratemod().mods()[0].mods()[0]; let page = doc::itempage(doc::modtag(modb)); let filename = make_local_filename(config, page); - assert filename == "output/dir/a_b.html"; + assert filename == ~"output/dir/a_b.html"; } #[cfg(test)] mod test { - fn mk_doc(name: str, source: str) -> doc::doc { + fn mk_doc(name: ~str, source: ~str) -> doc::doc { do astsrv::from_str(source) |srv| { let doc = extract::from_srv(srv, name); let doc = path_pass::mk_pass().f(srv, doc); @@ -244,7 +244,7 @@ mod test { } } -fn write_file(path: str, s: str) { +fn write_file(path: ~str, s: ~str) { import io::writer_util; alt io::file_writer(path, ~[io::create, io::truncate]) { @@ -256,7 +256,7 @@ fn write_file(path: str, s: str) { } fn future_writer_factory( -) -> (writer_factory, comm::port<(doc::page, str)>) { +) -> (writer_factory, comm::port<(doc::page, ~str)>) { let markdown_po = comm::port(); let markdown_ch = comm::chan(markdown_po); let writer_factory = fn~(page: doc::page) -> writer { @@ -274,14 +274,14 @@ fn future_writer_factory( (writer_factory, markdown_po) } -fn future_writer() -> (writer, future::future<str>) { +fn future_writer() -> (writer, future::future<~str>) { let port = comm::port(); let chan = comm::chan(port); let writer = fn~(+instr: writeinstr) { comm::send(chan, copy instr); }; let future = do future::from_fn { - let mut res = ""; + let mut res = ~""; loop { alt comm::recv(port) { write(s) { res += s } diff --git a/src/rustdoc/page_pass.rs b/src/rustdoc/page_pass.rs index 255854df8f0..972a697202e 100644 --- a/src/rustdoc/page_pass.rs +++ b/src/rustdoc/page_pass.rs @@ -11,7 +11,7 @@ export mk_pass; fn mk_pass(output_style: config::output_style) -> pass { { - name: "page", + name: ~"page", f: fn~(srv: astsrv::srv, doc: doc::doc) -> doc::doc { run(srv, doc, output_style) } @@ -129,32 +129,32 @@ fn fold_nmod( fn should_not_split_the_doc_into_pages_for_doc_per_crate() { let doc = test::mk_doc_( config::doc_per_crate, - "mod a { } mod b { mod c { } }" + ~"mod a { } mod b { mod c { } }" ); assert doc.pages.len() == 1u; } #[test] fn should_make_a_page_for_every_mod() { - let doc = test::mk_doc("mod a { }"); - assert doc.pages.mods()[0].name() == "a"; + let doc = test::mk_doc(~"mod a { }"); + assert doc.pages.mods()[0].name() == ~"a"; } #[test] fn should_remove_mods_from_containing_mods() { - let doc = test::mk_doc("mod a { }"); + let doc = test::mk_doc(~"mod a { }"); assert vec::is_empty(doc.cratemod().mods()); } #[test] fn should_make_a_page_for_every_foreign_mod() { - let doc = test::mk_doc("extern mod a { }"); - assert doc.pages.nmods()[0].name() == "a"; + let doc = test::mk_doc(~"extern mod a { }"); + assert doc.pages.nmods()[0].name() == ~"a"; } #[test] fn should_remove_foreign_mods_from_containing_mods() { - let doc = test::mk_doc("extern mod a { }"); + let doc = test::mk_doc(~"extern mod a { }"); assert vec::is_empty(doc.cratemod().nmods()); } @@ -162,15 +162,15 @@ fn should_remove_foreign_mods_from_containing_mods() { mod test { fn mk_doc_( output_style: config::output_style, - source: str + source: ~str ) -> doc::doc { do astsrv::from_str(source) |srv| { - let doc = extract::from_srv(srv, ""); + let doc = extract::from_srv(srv, ~""); run(srv, doc, output_style) } } - fn mk_doc(source: str) -> doc::doc { + fn mk_doc(source: ~str) -> doc::doc { mk_doc_(config::doc_per_mod, source) } } diff --git a/src/rustdoc/parse.rs b/src/rustdoc/parse.rs index c327830f517..ca30e8aa8a8 100644 --- a/src/rustdoc/parse.rs +++ b/src/rustdoc/parse.rs @@ -10,26 +10,26 @@ import syntax::parse; export from_file, from_str, from_file_sess, from_str_sess; -fn from_file(file: str) -> @ast::crate { +fn from_file(file: ~str) -> @ast::crate { parse::parse_crate_from_file( file, ~[], parse::new_parse_sess(none)) } -fn from_str(source: str) -> @ast::crate { +fn from_str(source: ~str) -> @ast::crate { parse::parse_crate_from_source_str( - "-", @source, ~[], parse::new_parse_sess(none)) + ~"-", @source, ~[], parse::new_parse_sess(none)) } -fn from_file_sess(sess: session::session, file: str) -> @ast::crate { +fn from_file_sess(sess: session::session, file: ~str) -> @ast::crate { parse::parse_crate_from_file( file, cfg(sess, file_input(file)), sess.parse_sess) } -fn from_str_sess(sess: session::session, source: str) -> @ast::crate { +fn from_str_sess(sess: session::session, source: ~str) -> @ast::crate { parse::parse_crate_from_source_str( - "-", @source, cfg(sess, str_input(source)), sess.parse_sess) + ~"-", @source, cfg(sess, str_input(source)), sess.parse_sess) } fn cfg(sess: session::session, input: driver::input) -> ast::crate_cfg { - driver::default_configuration(sess, "rustdoc", input) + driver::default_configuration(sess, ~"rustdoc", input) } diff --git a/src/rustdoc/path_pass.rs b/src/rustdoc/path_pass.rs index 91330cb1192..45cd7287862 100644 --- a/src/rustdoc/path_pass.rs +++ b/src/rustdoc/path_pass.rs @@ -6,14 +6,14 @@ export mk_pass; fn mk_pass() -> pass { { - name: "path", + name: ~"path", f: run } } type ctxt = { srv: astsrv::srv, - mut path: ~[str] + mut path: ~[~str] }; #[warn(no_non_implicitly_copyable_typarams)] @@ -65,43 +65,43 @@ fn fold_nmod(fold: fold::fold<ctxt>, doc: doc::nmoddoc) -> doc::nmoddoc { #[test] fn should_record_mod_paths() { - let source = "mod a { mod b { mod c { } } mod d { mod e { } } }"; + let source = ~"mod a { mod b { mod c { } } mod d { mod e { } } }"; do astsrv::from_str(source) |srv| { - let doc = extract::from_srv(srv, ""); + let doc = extract::from_srv(srv, ~""); let doc = run(srv, doc); assert doc.cratemod().mods()[0].mods()[0].mods()[0].path() - == ~["a", "b"]; + == ~[~"a", ~"b"]; assert doc.cratemod().mods()[0].mods()[1].mods()[0].path() - == ~["a", "d"]; + == ~[~"a", ~"d"]; } } #[test] fn should_record_fn_paths() { - let source = "mod a { fn b() { } }"; + let source = ~"mod a { fn b() { } }"; do astsrv::from_str(source) |srv| { - let doc = extract::from_srv(srv, ""); + let doc = extract::from_srv(srv, ~""); let doc = run(srv, doc); - assert doc.cratemod().mods()[0].fns()[0].path() == ~["a"]; + assert doc.cratemod().mods()[0].fns()[0].path() == ~[~"a"]; } } #[test] fn should_record_foreign_mod_paths() { - let source = "mod a { extern mod b { } }"; + let source = ~"mod a { extern mod b { } }"; do astsrv::from_str(source) |srv| { - let doc = extract::from_srv(srv, ""); + let doc = extract::from_srv(srv, ~""); let doc = run(srv, doc); - assert doc.cratemod().mods()[0].nmods()[0].path() == ~["a"]; + assert doc.cratemod().mods()[0].nmods()[0].path() == ~[~"a"]; } } #[test] fn should_record_foreign_fn_paths() { - let source = "extern mod a { fn b(); }"; + let source = ~"extern mod a { fn b(); }"; do astsrv::from_str(source) |srv| { - let doc = extract::from_srv(srv, ""); + let doc = extract::from_srv(srv, ~""); let doc = run(srv, doc); - assert doc.cratemod().nmods()[0].fns[0].path() == ~["a"]; + assert doc.cratemod().nmods()[0].fns[0].path() == ~[~"a"]; } } diff --git a/src/rustdoc/prune_hidden_pass.rs b/src/rustdoc/prune_hidden_pass.rs index e121cc88dd7..f5899e29df3 100644 --- a/src/rustdoc/prune_hidden_pass.rs +++ b/src/rustdoc/prune_hidden_pass.rs @@ -5,7 +5,7 @@ export mk_pass; fn mk_pass() -> pass { { - name: "prune_hidden", + name: ~"prune_hidden", f: run } } @@ -47,15 +47,15 @@ fn is_hidden(srv: astsrv::srv, doc: doc::itemdoc) -> bool { #[test] fn should_prune_hidden_items() { - let doc = test::mk_doc("#[doc(hidden)] mod a { }"); + let doc = test::mk_doc(~"#[doc(hidden)] mod a { }"); assert vec::is_empty(doc.cratemod().mods()) } #[cfg(test)] mod test { - fn mk_doc(source: str) -> doc::doc { + fn mk_doc(source: ~str) -> doc::doc { do astsrv::from_str(source) |srv| { - let doc = extract::from_srv(srv, ""); + let doc = extract::from_srv(srv, ~""); run(srv, doc) } } diff --git a/src/rustdoc/prune_unexported_pass.rs b/src/rustdoc/prune_unexported_pass.rs index b6cafbd0ade..00173e38850 100644 --- a/src/rustdoc/prune_unexported_pass.rs +++ b/src/rustdoc/prune_unexported_pass.rs @@ -9,7 +9,7 @@ export mk_pass; fn mk_pass() -> pass { { - name: "prune_unexported", + name: ~"prune_unexported", f: run } } @@ -70,7 +70,7 @@ fn exported_items_from_mod( fn exported_items_from( srv: astsrv::srv, doc: doc::moddoc, - is_exported: fn(astsrv::srv, str) -> bool + is_exported: fn(astsrv::srv, ~str) -> bool ) -> ~[doc::itemtag] { do vec::filter_map(doc.items) |itemtag| { let itemtag = alt itemtag { @@ -95,7 +95,7 @@ fn exported_items_from( fn exported_variants_from( srv: astsrv::srv, doc: doc::enumdoc, - is_exported: fn(astsrv::srv, str) -> bool + is_exported: fn(astsrv::srv, ~str) -> bool ) -> ~[doc::variantdoc] { do vec::filter_map(doc.variants) |doc| { if is_exported(srv, doc.name) { @@ -109,7 +109,7 @@ fn exported_variants_from( fn is_exported_from_mod( srv: astsrv::srv, mod_id: doc::ast_id, - item_name: str + item_name: ~str ) -> bool { do astsrv::exec(srv) |ctxt| { alt ctxt.ast_map.get(mod_id) { @@ -119,18 +119,18 @@ fn is_exported_from_mod( ast_util::is_exported(@item_name, m) } _ { - fail "is_exported_from_mod: not a mod"; + fail ~"is_exported_from_mod: not a mod"; } } } - _ { fail "is_exported_from_mod: not an item"; } + _ { fail ~"is_exported_from_mod: not an item"; } } } } fn is_exported_from_crate( srv: astsrv::srv, - item_name: str + item_name: ~str ) -> bool { do astsrv::exec(srv) |ctxt| { ast_util::is_exported(@item_name, ctxt.ast.node.module) @@ -139,32 +139,32 @@ fn is_exported_from_crate( #[test] fn should_prune_unexported_fns() { - let doc = test::mk_doc("mod b { export a; fn a() { } fn b() { } }"); + let doc = test::mk_doc(~"mod b { export a; fn a() { } fn b() { } }"); assert vec::len(doc.cratemod().mods()[0].fns()) == 1u; } #[test] fn should_prune_unexported_fns_from_top_mod() { - let doc = test::mk_doc("export a; fn a() { } fn b() { }"); + let doc = test::mk_doc(~"export a; fn a() { } fn b() { }"); assert vec::len(doc.cratemod().fns()) == 1u; } #[test] fn should_prune_unexported_modules() { - let doc = test::mk_doc("mod a { export a; mod a { } mod b { } }"); + let doc = test::mk_doc(~"mod a { export a; mod a { } mod b { } }"); assert vec::len(doc.cratemod().mods()[0].mods()) == 1u; } #[test] fn should_prune_unexported_modules_from_top_mod() { - let doc = test::mk_doc("export a; mod a { } mod b { }"); + let doc = test::mk_doc(~"export a; mod a { } mod b { }"); assert vec::len(doc.cratemod().mods()) == 1u; } #[test] fn should_prune_unexported_consts() { let doc = test::mk_doc( - "mod a { export a; \ + ~"mod a { export a; \ const a: bool = true; \ const b: bool = true; }"); assert vec::len(doc.cratemod().mods()[0].consts()) == 1u; @@ -173,63 +173,63 @@ fn should_prune_unexported_consts() { #[test] fn should_prune_unexported_consts_from_top_mod() { let doc = test::mk_doc( - "export a; const a: bool = true; const b: bool = true;"); + ~"export a; const a: bool = true; const b: bool = true;"); assert vec::len(doc.cratemod().consts()) == 1u; } #[test] fn should_prune_unexported_enums_from_top_mod() { - let doc = test::mk_doc("export a; mod a { } enum b { c }"); + let doc = test::mk_doc(~"export a; mod a { } enum b { c }"); assert vec::len(doc.cratemod().enums()) == 0u; } #[test] fn should_prune_unexported_enums() { - let doc = test::mk_doc("mod a { export a; mod a { } enum b { c } }"); + let doc = test::mk_doc(~"mod a { export a; mod a { } enum b { c } }"); assert vec::len(doc.cratemod().mods()[0].enums()) == 0u; } #[test] fn should_prune_unexported_variants_from_top_mod() { - let doc = test::mk_doc("export b::{}; enum b { c }"); + let doc = test::mk_doc(~"export b::{}; enum b { c }"); assert vec::len(doc.cratemod().enums()[0].variants) == 0u; } #[test] fn should_prune_unexported_variants() { - let doc = test::mk_doc("mod a { export b::{}; enum b { c } }"); + let doc = test::mk_doc(~"mod a { export b::{}; enum b { c } }"); assert vec::len(doc.cratemod().mods()[0].enums()[0].variants) == 0u; } #[test] fn should_prune_unexported_traits_from_top_mod() { - let doc = test::mk_doc("export a; mod a { } iface b { fn c(); }"); + let doc = test::mk_doc(~"export a; mod a { } iface b { fn c(); }"); assert vec::is_empty(doc.cratemod().traits()); } #[test] fn should_prune_unexported_impls_from_top_mod() { let doc = test::mk_doc( - "export a; mod a { } impl b for int { fn c() { } }"); + ~"export a; mod a { } impl b for int { fn c() { } }"); assert vec::is_empty(doc.cratemod().impls()) } #[test] fn should_prune_unexported_types() { - let doc = test::mk_doc("export a; mod a { } type b = int;"); + let doc = test::mk_doc(~"export a; mod a { } type b = int;"); assert vec::is_empty(doc.cratemod().types()); } #[test] fn should_not_prune_reexports() { - fn mk_doc(source: str) -> doc::doc { + fn mk_doc(source: ~str) -> doc::doc { do astsrv::from_str(source) |srv| { - let doc = extract::from_srv(srv, ""); + let doc = extract::from_srv(srv, ~""); let doc = reexport_pass::mk_pass().f(srv, doc); run(srv, doc) } } - let doc = mk_doc("import a::b; \ + let doc = mk_doc(~"import a::b; \ export b; \ mod a { fn b() { } }"); assert vec::is_not_empty(doc.cratemod().fns()); @@ -237,9 +237,9 @@ fn should_not_prune_reexports() { #[cfg(test)] mod test { - fn mk_doc(source: str) -> doc::doc { + fn mk_doc(source: ~str) -> doc::doc { do astsrv::from_str(source) |srv| { - let doc = extract::from_srv(srv, ""); + let doc = extract::from_srv(srv, ~""); run(srv, doc) } } diff --git a/src/rustdoc/reexport_pass.rs b/src/rustdoc/reexport_pass.rs index 6a5d2b326b9..188c168d7c3 100644 --- a/src/rustdoc/reexport_pass.rs +++ b/src/rustdoc/reexport_pass.rs @@ -14,14 +14,14 @@ export mk_pass; fn mk_pass() -> pass { { - name: "reexport", + name: ~"reexport", f: run } } type def_set = map::set<ast::def_id>; type def_map = map::hashmap<ast::def_id, doc::itemtag>; -type path_map = map::hashmap<str, ~[(str, doc::itemtag)]>; +type path_map = map::hashmap<~str, ~[(~str, doc::itemtag)]>; fn run(srv: astsrv::srv, doc: doc::doc) -> doc::doc { @@ -72,8 +72,8 @@ fn from_def_assoc_list<V:copy>( } fn from_str_assoc_list<V:copy>( - list: ~[(str, V)] -) -> map::hashmap<str, V> { + list: ~[(~str, V)] +) -> map::hashmap<~str, V> { from_assoc_list(list, map::str_hash) } @@ -169,7 +169,7 @@ fn build_reexport_path_map(srv: astsrv::srv, -def_map: def_map) -> path_map { let assoc_list = do astsrv::exec(srv) |ctxt| { let def_map = from_def_assoc_list(def_assoc_list); - let path_map = map::str_hash::<~[(str,doc::itemtag)]>(); + let path_map = map::str_hash::<~[(~str,doc::itemtag)]>(); for ctxt.exp_map.each |exp_id, defs| { let path = alt check ctxt.ast_map.get(exp_id) { @@ -223,7 +223,7 @@ fn build_reexport_path_map(srv: astsrv::srv, -def_map: def_map) -> path_map { fn find_reexport_impl_docs( ctxt: astsrv::ctxt, def_map: def_map -) -> ~[(str, (str, doc::itemtag))] { +) -> ~[(~str, (~str, doc::itemtag))] { let docs = @mut ~[]; do for_each_reexported_impl(ctxt) |mod_id, i| { @@ -233,12 +233,12 @@ fn find_reexport_impl_docs( if str::is_empty(path) { *item.ident } else { - path + "::" + *item.ident + path + ~"::" + *item.ident } } _ { assert mod_id == ast::crate_node_id; - "" + ~"" } }; let ident = *i.ident; @@ -334,9 +334,9 @@ fn merge_reexports( } } - fn get_new_items(path: ~[str], path_map: path_map) -> ~[doc::itemtag] { + fn get_new_items(path: ~[~str], path_map: path_map) -> ~[doc::itemtag] { #debug("looking for reexports in path %?", path); - alt path_map.find(str::connect(path, "::")) { + alt path_map.find(str::connect(path, ~"::")) { some(name_docs) { do vec::foldl(~[], name_docs) |v, name_doc| { let (name, doc) = name_doc; @@ -347,7 +347,7 @@ fn merge_reexports( } } - fn reexport_doc(doc: doc::itemtag, name: str) -> doc::itemtag { + fn reexport_doc(doc: doc::itemtag, name: ~str) -> doc::itemtag { alt doc { doc::modtag(doc @ {item, _}) { doc::modtag({ @@ -395,7 +395,7 @@ fn merge_reexports( } } - fn reexport(doc: doc::itemdoc, name: str) -> doc::itemdoc { + fn reexport(doc: doc::itemdoc, name: ~str) -> doc::itemdoc { { name: name, reexport: true @@ -406,15 +406,15 @@ fn merge_reexports( #[test] fn should_duplicate_reexported_items() { - let source = "mod a { export b; fn b() { } } \ + let source = ~"mod a { export b; fn b() { } } \ mod c { import a::b; export b; }"; let doc = test::mk_doc(source); - assert doc.cratemod().mods()[1].fns()[0].name() == "b"; + assert doc.cratemod().mods()[1].fns()[0].name() == ~"b"; } #[test] fn should_mark_reepxorts_as_such() { - let source = "mod a { export b; fn b() { } } \ + let source = ~"mod a { export b; fn b() { } } \ mod c { import a::b; export b; }"; let doc = test::mk_doc(source); assert doc.cratemod().mods()[1].fns()[0].item.reexport == true; @@ -422,39 +422,39 @@ fn should_mark_reepxorts_as_such() { #[test] fn should_duplicate_reexported_impls() { - let source = "mod a { impl b for int { fn c() { } } } \ + let source = ~"mod a { impl b for int { fn c() { } } } \ mod d { import a::b; export b; }"; let doc = test::mk_doc(source); - assert doc.cratemod().mods()[1].impls()[0].name() == "b"; + assert doc.cratemod().mods()[1].impls()[0].name() == ~"b"; } #[test] fn should_duplicate_reexported_impls_deep() { - let source = "mod a { impl b for int { fn c() { } } } \ + let source = ~"mod a { impl b for int { fn c() { } } } \ mod d { mod e { import a::b; export b; } }"; let doc = test::mk_doc(source); - assert doc.cratemod().mods()[1].mods()[0].impls()[0].name() == "b"; + assert doc.cratemod().mods()[1].mods()[0].impls()[0].name() == ~"b"; } #[test] fn should_duplicate_reexported_impls_crate() { - let source = "import a::b; export b; \ + let source = ~"import a::b; export b; \ mod a { impl b for int { fn c() { } } }"; let doc = test::mk_doc(source); - assert doc.cratemod().impls()[0].name() == "b"; + assert doc.cratemod().impls()[0].name() == ~"b"; } #[test] fn should_duplicate_reexported_foreign_fns() { - let source = "extern mod a { fn b(); } \ + let source = ~"extern mod a { fn b(); } \ mod c { import a::b; export b; }"; let doc = test::mk_doc(source); - assert doc.cratemod().mods()[0].fns()[0].name() == "b"; + assert doc.cratemod().mods()[0].fns()[0].name() == ~"b"; } #[test] fn should_duplicate_multiple_reexported_items() { - let source = "mod a { \ + let source = ~"mod a { \ export b; export c; \ fn b() { } fn c() { } \ } \ @@ -463,46 +463,46 @@ fn should_duplicate_multiple_reexported_items() { export b; export c; \ }"; do astsrv::from_str(source) |srv| { - let doc = extract::from_srv(srv, ""); + let doc = extract::from_srv(srv, ~""); let doc = path_pass::mk_pass().f(srv, doc); let doc = run(srv, doc); // Reexports may not be in any specific order let doc = sort_item_name_pass::mk_pass().f(srv, doc); - assert doc.cratemod().mods()[1].fns()[0].name() == "b"; - assert doc.cratemod().mods()[1].fns()[1].name() == "c"; + assert doc.cratemod().mods()[1].fns()[0].name() == ~"b"; + assert doc.cratemod().mods()[1].fns()[1].name() == ~"c"; } } #[test] fn should_rename_items_reexported_with_different_names() { - let source = "mod a { export b; fn b() { } } \ + let source = ~"mod a { export b; fn b() { } } \ mod c { import x = a::b; export x; }"; let doc = test::mk_doc(source); - assert doc.cratemod().mods()[1].fns()[0].name() == "x"; + assert doc.cratemod().mods()[1].fns()[0].name() == ~"x"; } #[test] fn should_reexport_in_topmod() { - fn mk_doc(source: str) -> doc::doc { + fn mk_doc(source: ~str) -> doc::doc { do astsrv::from_str(source) |srv| { - let doc = extract::from_srv(srv, "core"); + let doc = extract::from_srv(srv, ~"core"); let doc = path_pass::mk_pass().f(srv, doc); run(srv, doc) } } - let source = "import option::{some, none}; \ + let source = ~"import option::{some, none}; \ import option = option::t; \ export option, some, none; \ mod option { \ enum t { some, none } \ }"; let doc = mk_doc(source); - assert doc.cratemod().enums()[0].name() == "option"; + assert doc.cratemod().enums()[0].name() == ~"option"; } #[test] fn should_not_reexport_multiple_times() { - let source = "import option = option::t; \ + let source = ~"import option = option::t; \ export option; \ export option; \ mod option { \ @@ -514,9 +514,9 @@ fn should_not_reexport_multiple_times() { #[cfg(test)] mod test { - fn mk_doc(source: str) -> doc::doc { + fn mk_doc(source: ~str) -> doc::doc { do astsrv::from_str(source) |srv| { - let doc = extract::from_srv(srv, ""); + let doc = extract::from_srv(srv, ~""); let doc = path_pass::mk_pass().f(srv, doc); run(srv, doc) } diff --git a/src/rustdoc/rustdoc.rs b/src/rustdoc/rustdoc.rs index 2b70ea4ea96..952539376ef 100755 --- a/src/rustdoc/rustdoc.rs +++ b/src/rustdoc/rustdoc.rs @@ -4,7 +4,7 @@ import doc::util; /// A single operation on the document model type pass = { - name: str, + name: ~str, f: fn~(srv: astsrv::srv, doc: doc::doc) -> doc::doc }; @@ -52,7 +52,7 @@ fn test_run_passes() { doc::cratepage({ topmod: { item: { - name: doc.cratemod().name() + "two" + name: doc.cratemod().name() + ~"two" with doc.cratemod().item }, items: ~[], @@ -71,7 +71,7 @@ fn test_run_passes() { doc::cratepage({ topmod: { item: { - name: doc.cratemod().name() + "three" + name: doc.cratemod().name() + ~"three" with doc.cratemod().item }, items: ~[], @@ -81,27 +81,27 @@ fn test_run_passes() { ] } } - let source = ""; + let source = ~""; do astsrv::from_str(source) |srv| { let passes = ~[ { - name: "", + name: ~"", f: pass1 }, { - name: "", + name: ~"", f: pass2 } ]; - let doc = extract::from_srv(srv, "one"); + let doc = extract::from_srv(srv, ~"one"); let doc = run_passes(srv, doc, passes); - assert doc.cratemod().name() == "onetwothree"; + assert doc.cratemod().name() == ~"onetwothree"; } } -fn main(args: ~[str]) { +fn main(args: ~[~str]) { - if vec::contains(args, "-h") { + if vec::contains(args, ~"-h") { config::usage(); ret; } @@ -117,7 +117,7 @@ fn main(args: ~[str]) { run(config); } -fn time<T>(what: str, f: fn() -> T) -> T { +fn time<T>(what: ~str, f: fn() -> T) -> T { let start = std::time::precise_time_s(); let rv = f(); let end = std::time::precise_time_s(); @@ -130,10 +130,10 @@ fn run(config: config::config) { let source_file = config.input_crate; do astsrv::from_file(source_file) |srv| { - do time("wait_ast") { + do time(~"wait_ast") { do astsrv::exec(srv) |_ctxt| { } }; - let doc = time("extract", || { + let doc = time(~"extract", || { let default_name = source_file; extract::from_srv(srv, default_name) }); diff --git a/src/rustdoc/sectionalize_pass.rs b/src/rustdoc/sectionalize_pass.rs index 0974e5da850..a6bb3574687 100644 --- a/src/rustdoc/sectionalize_pass.rs +++ b/src/rustdoc/sectionalize_pass.rs @@ -4,7 +4,7 @@ export mk_pass; fn mk_pass() -> pass { { - name: "sectionalize", + name: ~"sectionalize", f: run } } @@ -64,7 +64,7 @@ fn fold_impl(fold: fold::fold<()>, doc: doc::impldoc) -> doc::impldoc { } } -fn sectionalize(desc: option<str>) -> (option<str>, ~[doc::section]) { +fn sectionalize(desc: option<~str>) -> (option<~str>, ~[doc::section]) { /*! * Take a description of the form @@ -88,7 +88,7 @@ fn sectionalize(desc: option<str>) -> (option<str>, ~[doc::section]) { let lines = str::lines(option::get(desc)); - let mut new_desc = none::<str>; + let mut new_desc = none::<~str>; let mut current_section = none; let mut sections = ~[]; @@ -100,21 +100,21 @@ fn sectionalize(desc: option<str>) -> (option<str>, ~[doc::section]) { } current_section = some({ header: header, - body: "" + body: ~"" }); } none { alt copy current_section { some(section) { current_section = some({ - body: section.body + "\n" + line + body: section.body + ~"\n" + line with section }); } none { new_desc = alt new_desc { some(desc) { - some(desc + "\n" + line) + some(desc + ~"\n" + line) } none { some(line) @@ -133,8 +133,8 @@ fn sectionalize(desc: option<str>) -> (option<str>, ~[doc::section]) { (new_desc, sections) } -fn parse_header(line: str) -> option<str> { - if str::starts_with(line, "# ") { +fn parse_header(line: ~str) -> option<~str> { + if str::starts_with(line, ~"# ") { some(str::slice(line, 2u, str::len(line))) } else { none @@ -144,31 +144,31 @@ fn parse_header(line: str) -> option<str> { #[test] fn should_create_section_headers() { let doc = test::mk_doc( - "#[doc = \"\ + ~"#[doc = \"\ # Header\n\ Body\"]\ mod a { }"); assert str::contains( doc.cratemod().mods()[0].item.sections[0].header, - "Header"); + ~"Header"); } #[test] fn should_create_section_bodies() { let doc = test::mk_doc( - "#[doc = \"\ + ~"#[doc = \"\ # Header\n\ Body\"]\ mod a { }"); assert str::contains( doc.cratemod().mods()[0].item.sections[0].body, - "Body"); + ~"Body"); } #[test] fn should_not_create_sections_from_indented_headers() { let doc = test::mk_doc( - "#[doc = \"\n\ + ~"#[doc = \"\n\ Text\n # Header\n\ Body\"]\ mod a { }"); @@ -178,23 +178,23 @@ fn should_not_create_sections_from_indented_headers() { #[test] fn should_remove_section_text_from_main_desc() { let doc = test::mk_doc( - "#[doc = \"\ + ~"#[doc = \"\ Description\n\n\ # Header\n\ Body\"]\ mod a { }"); assert !str::contains( option::get(doc.cratemod().mods()[0].desc()), - "Header"); + ~"Header"); assert !str::contains( option::get(doc.cratemod().mods()[0].desc()), - "Body"); + ~"Body"); } #[test] fn should_eliminate_desc_if_it_is_just_whitespace() { let doc = test::mk_doc( - "#[doc = \"\ + ~"#[doc = \"\ # Header\n\ Body\"]\ mod a { }"); @@ -204,7 +204,7 @@ fn should_eliminate_desc_if_it_is_just_whitespace() { #[test] fn should_sectionalize_trait_methods() { let doc = test::mk_doc( - "iface i { + ~"iface i { #[doc = \"\ # Header\n\ Body\"]\ @@ -215,7 +215,7 @@ fn should_sectionalize_trait_methods() { #[test] fn should_sectionalize_impl_methods() { let doc = test::mk_doc( - "impl i for bool { + ~"impl i for bool { #[doc = \"\ # Header\n\ Body\"]\ @@ -225,9 +225,9 @@ fn should_sectionalize_impl_methods() { #[cfg(test)] mod test { - fn mk_doc(source: str) -> doc::doc { + fn mk_doc(source: ~str) -> doc::doc { do astsrv::from_str(source) |srv| { - let doc = extract::from_srv(srv, ""); + let doc = extract::from_srv(srv, ~""); let doc = attr_pass::mk_pass().f(srv, doc); run(srv, doc) } diff --git a/src/rustdoc/sort_item_name_pass.rs b/src/rustdoc/sort_item_name_pass.rs index 47a69fed953..daf7d97c2ea 100644 --- a/src/rustdoc/sort_item_name_pass.rs +++ b/src/rustdoc/sort_item_name_pass.rs @@ -3,18 +3,18 @@ export mk_pass; fn mk_pass() -> pass { - sort_pass::mk_pass("sort_item_name", |item1, item2| { + sort_pass::mk_pass(~"sort_item_name", |item1, item2| { str::le(item1.name(), item2.name()) }) } #[test] fn test() { - let source = "mod z { } fn y() { }"; + let source = ~"mod z { } fn y() { }"; do astsrv::from_str(source) |srv| { - let doc = extract::from_srv(srv, ""); + let doc = extract::from_srv(srv, ~""); let doc = mk_pass().f(srv, doc); - assert doc.cratemod().items[0].name() == "y"; - assert doc.cratemod().items[1].name() == "z"; + assert doc.cratemod().items[0].name() == ~"y"; + assert doc.cratemod().items[1].name() == ~"z"; } } diff --git a/src/rustdoc/sort_item_type_pass.rs b/src/rustdoc/sort_item_type_pass.rs index d8e566d0400..bc2650e590a 100644 --- a/src/rustdoc/sort_item_type_pass.rs +++ b/src/rustdoc/sort_item_type_pass.rs @@ -3,7 +3,7 @@ export mk_pass; fn mk_pass() -> pass { - do sort_pass::mk_pass("sort_item_type") |item1, item2| { + do sort_pass::mk_pass(~"sort_item_type") |item1, item2| { fn score(item: doc::itemtag) -> int { alt item { doc::consttag(_) { 0 } @@ -24,7 +24,7 @@ fn mk_pass() -> pass { #[test] fn test() { let source = - "mod imod { } \ + ~"mod imod { } \ extern mod inmod { } \ const iconst: int = 0; \ fn ifn() { } \ @@ -33,15 +33,15 @@ fn test() { impl iimpl for int { fn a() { } } \ type itype = int;"; do astsrv::from_str(source) |srv| { - let doc = extract::from_srv(srv, ""); + let doc = extract::from_srv(srv, ~""); let doc = mk_pass().f(srv, doc); - assert doc.cratemod().items[0].name() == "iconst"; - assert doc.cratemod().items[1].name() == "itype"; - assert doc.cratemod().items[2].name() == "ienum"; - assert doc.cratemod().items[3].name() == "iiface"; - assert doc.cratemod().items[4].name() == "iimpl"; - assert doc.cratemod().items[5].name() == "ifn"; - assert doc.cratemod().items[6].name() == "imod"; - assert doc.cratemod().items[7].name() == "inmod"; + assert doc.cratemod().items[0].name() == ~"iconst"; + assert doc.cratemod().items[1].name() == ~"itype"; + assert doc.cratemod().items[2].name() == ~"ienum"; + assert doc.cratemod().items[3].name() == ~"iiface"; + assert doc.cratemod().items[4].name() == ~"iimpl"; + assert doc.cratemod().items[5].name() == ~"ifn"; + assert doc.cratemod().items[6].name() == ~"imod"; + assert doc.cratemod().items[7].name() == ~"inmod"; } } diff --git a/src/rustdoc/sort_pass.rs b/src/rustdoc/sort_pass.rs index 86dc2260e7d..a95de20d1ba 100644 --- a/src/rustdoc/sort_pass.rs +++ b/src/rustdoc/sort_pass.rs @@ -6,7 +6,7 @@ export item_lteq, mk_pass; type item_lteq = fn~(doc::itemtag, doc::itemtag) -> bool; -fn mk_pass(name: str, +lteq: item_lteq) -> pass { +fn mk_pass(name: ~str, +lteq: item_lteq) -> pass { { name: name, f: fn~(srv: astsrv::srv, doc: doc::doc) -> doc::doc { @@ -46,14 +46,14 @@ fn test() { str::le(item1.name(), item2.name()) } - let source = "mod z { mod y { } fn x() { } } mod w { }"; + let source = ~"mod z { mod y { } fn x() { } } mod w { }"; do astsrv::from_str(source) |srv| { - let doc = extract::from_srv(srv, ""); - let doc = mk_pass("", name_lteq).f(srv, doc); - assert doc.cratemod().mods()[0].name() == "w"; - assert doc.cratemod().mods()[1].items[0].name() == "x"; - assert doc.cratemod().mods()[1].items[1].name() == "y"; - assert doc.cratemod().mods()[1].name() == "z"; + let doc = extract::from_srv(srv, ~""); + let doc = mk_pass(~"", name_lteq).f(srv, doc); + assert doc.cratemod().mods()[0].name() == ~"w"; + assert doc.cratemod().mods()[1].items[0].name() == ~"x"; + assert doc.cratemod().mods()[1].items[1].name() == ~"y"; + assert doc.cratemod().mods()[1].name() == ~"z"; } } @@ -63,14 +63,14 @@ fn should_be_stable() { true } - let source = "mod a { mod b { } } mod c { mod d { } }"; + let source = ~"mod a { mod b { } } mod c { mod d { } }"; do astsrv::from_str(source) |srv| { - let doc = extract::from_srv(srv, ""); - let doc = mk_pass("", always_eq).f(srv, doc); - assert doc.cratemod().mods()[0].items[0].name() == "b"; - assert doc.cratemod().mods()[1].items[0].name() == "d"; - let doc = mk_pass("", always_eq).f(srv, doc); - assert doc.cratemod().mods()[0].items[0].name() == "b"; - assert doc.cratemod().mods()[1].items[0].name() == "d"; + let doc = extract::from_srv(srv, ~""); + let doc = mk_pass(~"", always_eq).f(srv, doc); + assert doc.cratemod().mods()[0].items[0].name() == ~"b"; + assert doc.cratemod().mods()[1].items[0].name() == ~"d"; + let doc = mk_pass(~"", always_eq).f(srv, doc); + assert doc.cratemod().mods()[0].items[0].name() == ~"b"; + assert doc.cratemod().mods()[1].items[0].name() == ~"d"; } } diff --git a/src/rustdoc/text_pass.rs b/src/rustdoc/text_pass.rs index cd001e69f21..ac419c557df 100644 --- a/src/rustdoc/text_pass.rs +++ b/src/rustdoc/text_pass.rs @@ -2,7 +2,7 @@ export mk_pass; -fn mk_pass(name: str, +op: fn~(str) -> str) -> pass { +fn mk_pass(name: ~str, +op: fn~(~str) -> ~str) -> pass { { name: name, f: fn~(srv: astsrv::srv, doc: doc::doc) -> doc::doc { @@ -11,7 +11,7 @@ fn mk_pass(name: str, +op: fn~(str) -> str) -> pass { } } -type op = fn~(str) -> str; +type op = fn~(~str) -> ~str; #[warn(no_non_implicitly_copyable_typarams)] fn run( @@ -29,7 +29,7 @@ fn run( fold.fold_doc(fold, doc) } -fn maybe_apply_op(op: op, s: option<str>) -> option<str> { +fn maybe_apply_op(op: op, s: option<~str>) -> option<~str> { option::map(s, |s| op(s) ) } @@ -96,167 +96,167 @@ fn fold_impl(fold: fold::fold<op>, doc: doc::impldoc) -> doc::impldoc { #[test] fn should_execute_op_on_enum_brief() { - let doc = test::mk_doc("#[doc = \" a \"] enum a { b }"); - assert doc.cratemod().enums()[0].brief() == some("a"); + let doc = test::mk_doc(~"#[doc = \" a \"] enum a { b }"); + assert doc.cratemod().enums()[0].brief() == some(~"a"); } #[test] fn should_execute_op_on_enum_desc() { - let doc = test::mk_doc("#[doc = \" a \"] enum a { b }"); - assert doc.cratemod().enums()[0].desc() == some("a"); + let doc = test::mk_doc(~"#[doc = \" a \"] enum a { b }"); + assert doc.cratemod().enums()[0].desc() == some(~"a"); } #[test] fn should_execute_op_on_variant_desc() { - let doc = test::mk_doc("enum a { #[doc = \" a \"] b }"); - assert doc.cratemod().enums()[0].variants[0].desc == some("a"); + let doc = test::mk_doc(~"enum a { #[doc = \" a \"] b }"); + assert doc.cratemod().enums()[0].variants[0].desc == some(~"a"); } #[test] fn should_execute_op_on_trait_brief() { let doc = test::mk_doc( - "#[doc = \" a \"] iface i { fn a(); }"); - assert doc.cratemod().traits()[0].brief() == some("a"); + ~"#[doc = \" a \"] iface i { fn a(); }"); + assert doc.cratemod().traits()[0].brief() == some(~"a"); } #[test] fn should_execute_op_on_trait_desc() { let doc = test::mk_doc( - "#[doc = \" a \"] iface i { fn a(); }"); - assert doc.cratemod().traits()[0].desc() == some("a"); + ~"#[doc = \" a \"] iface i { fn a(); }"); + assert doc.cratemod().traits()[0].desc() == some(~"a"); } #[test] fn should_execute_op_on_trait_method_brief() { let doc = test::mk_doc( - "iface i { #[doc = \" a \"] fn a(); }"); - assert doc.cratemod().traits()[0].methods[0].brief == some("a"); + ~"iface i { #[doc = \" a \"] fn a(); }"); + assert doc.cratemod().traits()[0].methods[0].brief == some(~"a"); } #[test] fn should_execute_op_on_trait_method_desc() { let doc = test::mk_doc( - "iface i { #[doc = \" a \"] fn a(); }"); - assert doc.cratemod().traits()[0].methods[0].desc == some("a"); + ~"iface i { #[doc = \" a \"] fn a(); }"); + assert doc.cratemod().traits()[0].methods[0].desc == some(~"a"); } #[test] fn should_execute_op_on_impl_brief() { let doc = test::mk_doc( - "#[doc = \" a \"] impl i for int { fn a() { } }"); - assert doc.cratemod().impls()[0].brief() == some("a"); + ~"#[doc = \" a \"] impl i for int { fn a() { } }"); + assert doc.cratemod().impls()[0].brief() == some(~"a"); } #[test] fn should_execute_op_on_impl_desc() { let doc = test::mk_doc( - "#[doc = \" a \"] impl i for int { fn a() { } }"); - assert doc.cratemod().impls()[0].desc() == some("a"); + ~"#[doc = \" a \"] impl i for int { fn a() { } }"); + assert doc.cratemod().impls()[0].desc() == some(~"a"); } #[test] fn should_execute_op_on_impl_method_brief() { let doc = test::mk_doc( - "impl i for int { #[doc = \" a \"] fn a() { } }"); - assert doc.cratemod().impls()[0].methods[0].brief == some("a"); + ~"impl i for int { #[doc = \" a \"] fn a() { } }"); + assert doc.cratemod().impls()[0].methods[0].brief == some(~"a"); } #[test] fn should_execute_op_on_impl_method_desc() { let doc = test::mk_doc( - "impl i for int { #[doc = \" a \"] fn a() { } }"); - assert doc.cratemod().impls()[0].methods[0].desc == some("a"); + ~"impl i for int { #[doc = \" a \"] fn a() { } }"); + assert doc.cratemod().impls()[0].methods[0].desc == some(~"a"); } #[test] fn should_execute_op_on_type_brief() { let doc = test::mk_doc( - "#[doc = \" a \"] type t = int;"); - assert doc.cratemod().types()[0].brief() == some("a"); + ~"#[doc = \" a \"] type t = int;"); + assert doc.cratemod().types()[0].brief() == some(~"a"); } #[test] fn should_execute_op_on_type_desc() { let doc = test::mk_doc( - "#[doc = \" a \"] type t = int;"); - assert doc.cratemod().types()[0].desc() == some("a"); + ~"#[doc = \" a \"] type t = int;"); + assert doc.cratemod().types()[0].desc() == some(~"a"); } #[test] fn should_execute_on_item_section_headers() { let doc = test::mk_doc( - "#[doc = \"\ + ~"#[doc = \"\ # Header \n\ Body\"]\ fn a() { }"); - assert doc.cratemod().fns()[0].sections()[0].header == "Header"; + assert doc.cratemod().fns()[0].sections()[0].header == ~"Header"; } #[test] fn should_execute_on_item_section_bodies() { let doc = test::mk_doc( - "#[doc = \"\ + ~"#[doc = \"\ # Header\n\ Body \"]\ fn a() { }"); - assert doc.cratemod().fns()[0].sections()[0].body == "Body"; + assert doc.cratemod().fns()[0].sections()[0].body == ~"Body"; } #[test] fn should_execute_on_trait_method_section_headers() { let doc = test::mk_doc( - "iface i { + ~"iface i { #[doc = \"\ # Header \n\ Body\"]\ fn a(); }"); assert doc.cratemod().traits()[0].methods[0].sections[0].header - == "Header"; + == ~"Header"; } #[test] fn should_execute_on_trait_method_section_bodies() { let doc = test::mk_doc( - "iface i { + ~"iface i { #[doc = \"\ # Header\n\ Body \"]\ fn a(); }"); - assert doc.cratemod().traits()[0].methods[0].sections[0].body == "Body"; + assert doc.cratemod().traits()[0].methods[0].sections[0].body == ~"Body"; } #[test] fn should_execute_on_impl_method_section_headers() { let doc = test::mk_doc( - "impl i for bool { + ~"impl i for bool { #[doc = \"\ # Header \n\ Body\"]\ fn a() { } }"); assert doc.cratemod().impls()[0].methods[0].sections[0].header - == "Header"; + == ~"Header"; } #[test] fn should_execute_on_impl_method_section_bodies() { let doc = test::mk_doc( - "impl i for bool { + ~"impl i for bool { #[doc = \"\ # Header\n\ Body \"]\ fn a() { } }"); - assert doc.cratemod().impls()[0].methods[0].sections[0].body == "Body"; + assert doc.cratemod().impls()[0].methods[0].sections[0].body == ~"Body"; } #[cfg(test)] mod test { - fn mk_doc(source: str) -> doc::doc { + fn mk_doc(source: ~str) -> doc::doc { do astsrv::from_str(source) |srv| { - let doc = extract::from_srv(srv, ""); + let doc = extract::from_srv(srv, ~""); let doc = attr_pass::mk_pass().f(srv, doc); let doc = desc_to_brief_pass::mk_pass().f(srv, doc); let doc = sectionalize_pass::mk_pass().f(srv, doc); - mk_pass("", |s| str::trim(s) ).f(srv, doc) + mk_pass(~"", |s| str::trim(s) ).f(srv, doc) } } } diff --git a/src/rustdoc/trim_pass.rs b/src/rustdoc/trim_pass.rs index 3d135d8073c..1a5e96dbed4 100644 --- a/src/rustdoc/trim_pass.rs +++ b/src/rustdoc/trim_pass.rs @@ -8,21 +8,21 @@ export mk_pass; fn mk_pass() -> pass { - text_pass::mk_pass("trim", |s| str::trim(s) ) + text_pass::mk_pass(~"trim", |s| str::trim(s) ) } #[test] fn should_trim_text() { - let doc = test::mk_doc("#[doc = \" desc \"] \ + let doc = test::mk_doc(~"#[doc = \" desc \"] \ mod m { }"); - assert doc.cratemod().mods()[0].desc() == some("desc"); + assert doc.cratemod().mods()[0].desc() == some(~"desc"); } #[cfg(test)] mod test { - fn mk_doc(source: str) -> doc::doc { + fn mk_doc(source: ~str) -> doc::doc { do astsrv::from_str(source) |srv| { - let doc = extract::from_srv(srv, ""); + let doc = extract::from_srv(srv, ~""); let doc = attr_pass::mk_pass().f(srv, doc); mk_pass().f(srv, doc) } diff --git a/src/rustdoc/tystr_pass.rs b/src/rustdoc/tystr_pass.rs index 011420bdcf4..006e8bc66dc 100644 --- a/src/rustdoc/tystr_pass.rs +++ b/src/rustdoc/tystr_pass.rs @@ -9,7 +9,7 @@ export mk_pass; fn mk_pass() -> pass { { - name: "tystr", + name: ~"tystr", f: run } } @@ -43,7 +43,7 @@ fn fold_fn( } } -fn get_fn_sig(srv: astsrv::srv, fn_id: doc::ast_id) -> option<str> { +fn get_fn_sig(srv: astsrv::srv, fn_id: doc::ast_id) -> option<~str> { do astsrv::exec(srv) |ctxt| { alt check ctxt.ast_map.get(fn_id) { ast_map::node_item(@{ @@ -62,14 +62,14 @@ fn get_fn_sig(srv: astsrv::srv, fn_id: doc::ast_id) -> option<str> { #[test] fn should_add_fn_sig() { - let doc = test::mk_doc("fn a<T>() -> int { }"); - assert doc.cratemod().fns()[0].sig == some("fn a<T>() -> int"); + let doc = test::mk_doc(~"fn a<T>() -> int { }"); + assert doc.cratemod().fns()[0].sig == some(~"fn a<T>() -> int"); } #[test] fn should_add_foreign_fn_sig() { - let doc = test::mk_doc("extern mod a { fn a<T>() -> int; }"); - assert doc.cratemod().nmods()[0].fns[0].sig == some("fn a<T>() -> int"); + let doc = test::mk_doc(~"extern mod a { fn a<T>() -> int; }"); + assert doc.cratemod().nmods()[0].fns[0].sig == some(~"fn a<T>() -> int"); } fn fold_const( @@ -94,8 +94,8 @@ fn fold_const( #[test] fn should_add_const_types() { - let doc = test::mk_doc("const a: bool = true;"); - assert doc.cratemod().consts()[0].sig == some("bool"); + let doc = test::mk_doc(~"const a: bool = true;"); + assert doc.cratemod().consts()[0].sig == some(~"bool"); } fn fold_enum( @@ -133,8 +133,8 @@ fn fold_enum( #[test] fn should_add_variant_sigs() { - let doc = test::mk_doc("enum a { b(int) }"); - assert doc.cratemod().enums()[0].variants[0].sig == some("b(int)"); + let doc = test::mk_doc(~"enum a { b(int) }"); + assert doc.cratemod().enums()[0].variants[0].sig == some(~"b(int)"); } fn fold_trait( @@ -163,8 +163,8 @@ fn merge_methods( fn get_method_sig( srv: astsrv::srv, item_id: doc::ast_id, - method_name: str -) -> option<str> { + method_name: ~str +) -> option<~str> { do astsrv::exec(srv) |ctxt| { alt check ctxt.ast_map.get(item_id) { ast_map::node_item(@{ @@ -217,9 +217,9 @@ fn get_method_sig( #[test] fn should_add_trait_method_sigs() { - let doc = test::mk_doc("iface i { fn a<T>() -> int; }"); + let doc = test::mk_doc(~"iface i { fn a<T>() -> int; }"); assert doc.cratemod().traits()[0].methods[0].sig - == some("fn a<T>() -> int"); + == some(~"fn a<T>() -> int"); } fn fold_impl( @@ -239,7 +239,7 @@ fn fold_impl( }); (trait_ty, some(pprust::ty_to_str(self_ty))) } - _ { fail "expected impl" } + _ { fail ~"expected impl" } } }; @@ -253,27 +253,27 @@ fn fold_impl( #[test] fn should_add_impl_trait_ty() { - let doc = test::mk_doc("impl i of j for int { fn a<T>() { } }"); - assert doc.cratemod().impls()[0].trait_ty == some("j"); + let doc = test::mk_doc(~"impl i of j for int { fn a<T>() { } }"); + assert doc.cratemod().impls()[0].trait_ty == some(~"j"); } #[test] fn should_not_add_impl_trait_ty_if_none() { - let doc = test::mk_doc("impl i for int { fn a() { } }"); + let doc = test::mk_doc(~"impl i for int { fn a() { } }"); assert doc.cratemod().impls()[0].trait_ty == none; } #[test] fn should_add_impl_self_ty() { - let doc = test::mk_doc("impl i for int { fn a() { } }"); - assert doc.cratemod().impls()[0].self_ty == some("int"); + let doc = test::mk_doc(~"impl i for int { fn a() { } }"); + assert doc.cratemod().impls()[0].self_ty == some(~"int"); } #[test] fn should_add_impl_method_sigs() { - let doc = test::mk_doc("impl i for int { fn a<T>() -> int { fail } }"); + let doc = test::mk_doc(~"impl i for int { fn a<T>() -> int { fail } }"); assert doc.cratemod().impls()[0].methods[0].sig - == some("fn a<T>() -> int"); + == some(~"fn a<T>() -> int"); } fn fold_type( @@ -297,7 +297,7 @@ fn fold_type( pprust::ty_to_str(ty) )) } - _ { fail "expected type" } + _ { fail ~"expected type" } } } with doc @@ -306,15 +306,15 @@ fn fold_type( #[test] fn should_add_type_signatures() { - let doc = test::mk_doc("type t<T> = int;"); - assert doc.cratemod().types()[0].sig == some("type t<T> = int"); + let doc = test::mk_doc(~"type t<T> = int;"); + assert doc.cratemod().types()[0].sig == some(~"type t<T> = int"); } #[cfg(test)] mod test { - fn mk_doc(source: str) -> doc::doc { + fn mk_doc(source: ~str) -> doc::doc { do astsrv::from_str(source) |srv| { - let doc = extract::from_srv(srv, ""); + let doc = extract::from_srv(srv, ~""); run(srv, doc) } } diff --git a/src/rustdoc/unindent_pass.rs b/src/rustdoc/unindent_pass.rs index 1df8d5b8f50..52d91a7994f 100644 --- a/src/rustdoc/unindent_pass.rs +++ b/src/rustdoc/unindent_pass.rs @@ -12,10 +12,10 @@ export mk_pass; fn mk_pass() -> pass { - text_pass::mk_pass("unindent", unindent) + text_pass::mk_pass(~"unindent", unindent) } -fn unindent(s: str) -> str { +fn unindent(s: ~str) -> ~str { let lines = str::lines_any(s); let mut saw_first_line = false; let mut saw_second_line = false; @@ -70,7 +70,7 @@ fn unindent(s: str) -> str { str::slice(line, min_indent, str::len(line)) } }; - str::connect(unindented, "\n") + str::connect(unindented, ~"\n") } else { s } @@ -78,25 +78,25 @@ fn unindent(s: str) -> str { #[test] fn should_unindent() { - let s = " line1\n line2"; + let s = ~" line1\n line2"; let r = unindent(s); - assert r == "line1\nline2"; + assert r == ~"line1\nline2"; } #[test] fn should_unindent_multiple_paragraphs() { - let s = " line1\n\n line2"; + let s = ~" line1\n\n line2"; let r = unindent(s); - assert r == "line1\n\nline2"; + assert r == ~"line1\n\nline2"; } #[test] fn should_leave_multiple_indent_levels() { // Line 2 is indented another level beyond the // base indentation and should be preserved - let s = " line1\n\n line2"; + let s = ~" line1\n\n line2"; let r = unindent(s); - assert r == "line1\n\n line2"; + assert r == ~"line1\n\n line2"; } #[test] @@ -106,14 +106,14 @@ fn should_ignore_first_line_indent() { // // #[doc = "Start way over here // and continue here"] - let s = "line1\n line2"; + let s = ~"line1\n line2"; let r = unindent(s); - assert r == "line1\nline2"; + assert r == ~"line1\nline2"; } #[test] fn should_not_ignore_first_line_indent_in_a_single_line_para() { - let s = "line1\n\n line2"; + let s = ~"line1\n\n line2"; let r = unindent(s); - assert r == "line1\n\n line2"; + assert r == ~"line1\n\n line2"; } diff --git a/src/test/auxiliary/cci_class_4.rs b/src/test/auxiliary/cci_class_4.rs index ef16b540d0c..4bd1393a137 100644 --- a/src/test/auxiliary/cci_class_4.rs +++ b/src/test/auxiliary/cci_class_4.rs @@ -13,9 +13,9 @@ class cat { } let mut how_hungry : int; - let name : str; + let name : ~str; - new(in_x : uint, in_y : int, in_name: str) + new(in_x : uint, in_y : int, in_name: ~str) { self.meows = in_x; self.how_hungry = in_y; self.name = in_name; } fn speak() { self.meow(); } diff --git a/src/test/auxiliary/cci_class_cast.rs b/src/test/auxiliary/cci_class_cast.rs index 63b8426ac93..d031546c9db 100644 --- a/src/test/auxiliary/cci_class_cast.rs +++ b/src/test/auxiliary/cci_class_cast.rs @@ -16,9 +16,9 @@ class cat : to_str { } let mut how_hungry : int; - let name : str; + let name : ~str; - new(in_x : uint, in_y : int, in_name: str) + new(in_x : uint, in_y : int, in_name: ~str) { self.meows = in_x; self.how_hungry = in_y; self.name = in_name; } fn speak() { self.meow(); } @@ -35,6 +35,6 @@ class cat : to_str { } } - fn to_str() -> str { self.name } + fn to_str() -> ~str { self.name } } } diff --git a/src/test/auxiliary/crate-method-reexport-grrrrrrr2.rs b/src/test/auxiliary/crate-method-reexport-grrrrrrr2.rs index eae7bf8e7cb..97787cc8406 100644 --- a/src/test/auxiliary/crate-method-reexport-grrrrrrr2.rs +++ b/src/test/auxiliary/crate-method-reexport-grrrrrrr2.rs @@ -9,7 +9,7 @@ mod name_pool { type name_pool = (); impl methods for name_pool { - fn add(s: str) { + fn add(s: ~str) { } } } diff --git a/src/test/auxiliary/crateresolve5-1.rs b/src/test/auxiliary/crateresolve5-1.rs index 9de656e5b9c..d1a31246f5b 100644 --- a/src/test/auxiliary/crateresolve5-1.rs +++ b/src/test/auxiliary/crateresolve5-1.rs @@ -3,8 +3,8 @@ #[crate_type = "lib"]; -fn structural() -> { name: str, val: int } { - { name: "crateresolve5", val: 10 } +fn structural() -> { name: ~str, val: int } { + { name: ~"crateresolve5", val: 10 } } enum e { diff --git a/src/test/auxiliary/crateresolve5-2.rs b/src/test/auxiliary/crateresolve5-2.rs index ff884a5ba68..df28b2c25b7 100644 --- a/src/test/auxiliary/crateresolve5-2.rs +++ b/src/test/auxiliary/crateresolve5-2.rs @@ -3,8 +3,8 @@ #[crate_type = "lib"]; -fn structural() -> { name: str, val: int } { - { name: "crateresolve5", val: 10 } +fn structural() -> { name: ~str, val: int } { + { name: ~"crateresolve5", val: 10 } } enum e { diff --git a/src/test/auxiliary/foreign_lib.rs b/src/test/auxiliary/foreign_lib.rs index ff4bb5266ec..c33ced59fec 100644 --- a/src/test/auxiliary/foreign_lib.rs +++ b/src/test/auxiliary/foreign_lib.rs @@ -1,5 +1,5 @@ #[link(name="foreign_lib", vers="0.0")]; extern mod rustrt { - fn last_os_error() -> str; + fn last_os_error() -> ~str; } \ No newline at end of file diff --git a/src/test/auxiliary/issue-2414-a.rs b/src/test/auxiliary/issue-2414-a.rs index 0f4b51a8dad..01cadc92246 100644 --- a/src/test/auxiliary/issue-2414-a.rs +++ b/src/test/auxiliary/issue-2414-a.rs @@ -2,4 +2,4 @@ #[crate_type = "lib"]; type t1 = uint; -impl t2 for str { } +impl t2 for ~str { } diff --git a/src/test/auxiliary/issue-2631-a.rs b/src/test/auxiliary/issue-2631-a.rs index 049988863be..dd8ace9ee74 100644 --- a/src/test/auxiliary/issue-2631-a.rs +++ b/src/test/auxiliary/issue-2631-a.rs @@ -7,9 +7,9 @@ import dvec::*; import dvec::dvec; import std::map::hashmap; -type header_map = hashmap<str, @dvec<@str/~>>; +type header_map = hashmap<~str, @dvec<@~str>>; // the unused ty param is necessary so this gets monomorphized fn request<T: copy>(req: header_map) { - let _x = *(*req.get("METHOD"))[0u]; + let _x = *(*req.get(~"METHOD"))[0u]; } diff --git a/src/test/bench/core-std.rs b/src/test/bench/core-std.rs index 48e2b5b6a10..db7434a2139 100644 --- a/src/test/bench/core-std.rs +++ b/src/test/bench/core-std.rs @@ -8,7 +8,7 @@ import std::map::{map, hashmap}; import io::{reader, reader_util}; -fn main(argv: ~[str]) { +fn main(argv: ~[~str]) { #macro[ [#bench[id], maybe_run_test(argv, #stringify(id), id) @@ -26,12 +26,12 @@ fn main(argv: ~[str]) { #bench[vec_push_all]; } -fn maybe_run_test(argv: &[str], name: str, test: fn()) { +fn maybe_run_test(argv: &[~str], name: ~str, test: fn()) { let mut run_test = false; - if os::getenv("RUST_BENCH").is_some() { run_test = true } + if os::getenv(~"RUST_BENCH").is_some() { run_test = true } else if argv.len() > 0 { - run_test = argv.contains("all") || argv.contains(name) + run_test = argv.contains(~"all") || argv.contains(name) } if !run_test { ret } @@ -55,7 +55,7 @@ fn shift_push() { fn read_line() { let path = path::connect( #env("CFG_SRC_DIR"), - "src/test/bench/shootout-k-nucleotide.data" + ~"src/test/bench/shootout-k-nucleotide.data" ); for int::range(0, 3) |_i| { diff --git a/src/test/bench/core-uint-to-str.rs b/src/test/bench/core-uint-to-str.rs index 5dac712414d..5a6c9b9def7 100644 --- a/src/test/bench/core-uint-to-str.rs +++ b/src/test/bench/core-uint-to-str.rs @@ -1,8 +1,8 @@ -fn main(args: ~[str]) { - let args = if os::getenv("RUST_BENCH").is_some() { - ~["", "10000000"] +fn main(args: ~[~str]) { + let args = if os::getenv(~"RUST_BENCH").is_some() { + ~[~"", ~"10000000"] } else if args.len() <= 1u { - ~["", "100000"] + ~[~"", ~"100000"] } else { args }; diff --git a/src/test/bench/core-vec-append.rs b/src/test/bench/core-vec-append.rs index 7e4a327ea12..dec0c0b9f22 100644 --- a/src/test/bench/core-vec-append.rs +++ b/src/test/bench/core-vec-append.rs @@ -20,11 +20,11 @@ fn collect_dvec(num: uint) -> ~[mut uint] { ret dvec::unwrap(result); } -fn main(args: ~[str]) { - let args = if os::getenv("RUST_BENCH").is_some() { - ~["", "50000000"] +fn main(args: ~[~str]) { + let args = if os::getenv(~"RUST_BENCH").is_some() { + ~[~"", ~"50000000"] } else if args.len() <= 1u { - ~["", "100000"] + ~[~"", ~"100000"] } else { args }; diff --git a/src/test/bench/graph500-bfs.rs b/src/test/bench/graph500-bfs.rs index 5f3946e1424..bd3f2c615bf 100644 --- a/src/test/bench/graph500-bfs.rs +++ b/src/test/bench/graph500-bfs.rs @@ -196,7 +196,7 @@ fn bfs2(graph: graph, key: node_id) -> bfs_result { alt c { white { -1i64 } black(parent) { parent } - _ { fail "Found remaining gray nodes in BFS" } + _ { fail ~"Found remaining gray nodes in BFS" } } } } @@ -276,7 +276,7 @@ fn pbfs(&&graph: arc::arc<graph>, key: node_id) -> bfs_result { alt c { white { -1i64 } black(parent) { parent } - _ { fail "Found remaining gray nodes in BFS" } + _ { fail ~"Found remaining gray nodes in BFS" } } } } @@ -292,7 +292,7 @@ fn validate(edges: ~[(node_id, node_id)], // parent chains back to the root. While we do this, we also // compute the levels for each node. - log(info, "Verifying tree structure..."); + log(info, ~"Verifying tree structure..."); let mut status = true; let level = do tree.map() |parent| { @@ -324,7 +324,7 @@ fn validate(edges: ~[(node_id, node_id)], // 2. Each tree edge connects vertices whose BFS levels differ by // exactly one. - log(info, "Verifying tree edges..."); + log(info, ~"Verifying tree edges..."); let status = do tree.alli() |k, parent| { if parent != root && parent != -1i64 { @@ -340,7 +340,7 @@ fn validate(edges: ~[(node_id, node_id)], // 3. Every edge in the input list has vertices with levels that // differ by at most one or that both are not in the BFS tree. - log(info, "Verifying graph edges..."); + log(info, ~"Verifying graph edges..."); let status = do edges.all() |e| { let (u, v) = e; @@ -357,7 +357,7 @@ fn validate(edges: ~[(node_id, node_id)], // 5. A node and its parent are joined by an edge of the original // graph. - log(info, "Verifying tree and graph edges..."); + log(info, ~"Verifying tree and graph edges..."); let status = do par::alli(tree) |u, v| { let u = u as node_id; @@ -375,11 +375,11 @@ fn validate(edges: ~[(node_id, node_id)], true } -fn main(args: ~[str]) { - let args = if os::getenv("RUST_BENCH").is_some() { - ~["", "15", "48"] +fn main(args: ~[~str]) { + let args = if os::getenv(~"RUST_BENCH").is_some() { + ~[~"", ~"15", ~"48"] } else if args.len() <= 1u { - ~["", "10", "16"] + ~[~"", ~"10", ~"16"] } else { args }; @@ -413,7 +413,7 @@ fn main(args: ~[str]) { let graph_arc = arc::arc(copy graph); do gen_search_keys(graph, num_keys).map() |root| { - io::stdout().write_line(""); + io::stdout().write_line(~""); io::stdout().write_line(#fmt("Search key: %?", root)); if do_sequential { @@ -477,7 +477,7 @@ fn main(args: ~[str]) { } }; - io::stdout().write_line(""); + io::stdout().write_line(~""); io::stdout().write_line( #fmt("Total sequential: %? \t Total Parallel: %? \t Speedup: %?x", total_seq, total_par, total_seq / total_par)); diff --git a/src/test/bench/msgsend-pipes-shared.rs b/src/test/bench/msgsend-pipes-shared.rs index 6a626cff81a..4a94083b824 100644 --- a/src/test/bench/msgsend-pipes-shared.rs +++ b/src/test/bench/msgsend-pipes-shared.rs @@ -45,7 +45,7 @@ fn server(requests: port<request>, responses: pipes::chan<uint>) { //#error("server exiting"); } -fn run(args: &[str]) { +fn run(args: &[~str]) { let (to_parent, from_child) = pipes::stream(); let (to_child, from_parent) = pipes::stream(); @@ -86,11 +86,11 @@ fn run(args: &[str]) { assert result == num_bytes * size; } -fn main(args: ~[str]) { - let args = if os::getenv("RUST_BENCH").is_some() { - ~["", "1000000", "10000"] +fn main(args: ~[~str]) { + let args = if os::getenv(~"RUST_BENCH").is_some() { + ~[~"", ~"1000000", ~"10000"] } else if args.len() <= 1u { - ~["", "10000", "4"] + ~[~"", ~"10000", ~"4"] } else { copy args }; diff --git a/src/test/bench/msgsend-pipes.rs b/src/test/bench/msgsend-pipes.rs index faa20794586..78eaab47566 100644 --- a/src/test/bench/msgsend-pipes.rs +++ b/src/test/bench/msgsend-pipes.rs @@ -40,7 +40,7 @@ fn server(requests: port_set<request>, responses: pipes::chan<uint>) { //#error("server exiting"); } -fn run(args: &[str]) { +fn run(args: &[~str]) { let (to_parent, from_child) = pipes::stream(); let (to_child, from_parent_) = pipes::stream(); let from_parent = port_set(); @@ -82,11 +82,11 @@ fn run(args: &[str]) { assert result == num_bytes * size; } -fn main(args: ~[str]) { - let args = if os::getenv("RUST_BENCH").is_some() { - ~["", "1000000", "8"] +fn main(args: ~[~str]) { + let args = if os::getenv(~"RUST_BENCH").is_some() { + ~[~"", ~"1000000", ~"8"] } else if args.len() <= 1u { - ~["", "10000", "4"] + ~[~"", ~"10000", ~"4"] } else { copy args }; diff --git a/src/test/bench/msgsend-ring-pipes.rs b/src/test/bench/msgsend-ring-pipes.rs index b93f3a4bc2d..3e2e955a083 100644 --- a/src/test/bench/msgsend-ring-pipes.rs +++ b/src/test/bench/msgsend-ring-pipes.rs @@ -52,11 +52,11 @@ fn thread_ring(i: uint, }; } -fn main(args: ~[str]) { - let args = if os::getenv("RUST_BENCH").is_some() { - ~["", "100", "10000"] +fn main(args: ~[~str]) { + let args = if os::getenv(~"RUST_BENCH").is_some() { + ~[~"", ~"100", ~"10000"] } else if args.len() <= 1u { - ~["", "100", "1000"] + ~[~"", ~"100", ~"1000"] } else { copy args }; diff --git a/src/test/bench/msgsend-ring.rs b/src/test/bench/msgsend-ring.rs index fde609b5636..ceaed45f8f3 100644 --- a/src/test/bench/msgsend-ring.rs +++ b/src/test/bench/msgsend-ring.rs @@ -22,11 +22,11 @@ fn thread_ring(i: uint, }; } -fn main(args: ~[str]) { - let args = if os::getenv("RUST_BENCH").is_some() { - ~["", "100", "10000"] +fn main(args: ~[~str]) { + let args = if os::getenv(~"RUST_BENCH").is_some() { + ~[~"", ~"100", ~"10000"] } else if args.len() <= 1u { - ~["", "100", "1000"] + ~[~"", ~"100", ~"1000"] } else { args }; diff --git a/src/test/bench/msgsend.rs b/src/test/bench/msgsend.rs index 85d34c41fed..2f993d502ac 100644 --- a/src/test/bench/msgsend.rs +++ b/src/test/bench/msgsend.rs @@ -27,7 +27,7 @@ fn server(requests: comm::port<request>, responses: comm::chan<uint>) { comm::send(responses, count); } -fn run(args: ~[str]) { +fn run(args: ~[~str]) { let from_child = comm::port(); let to_parent = comm::chan(from_child); let to_child = do task::spawn_listener |po| { @@ -58,11 +58,11 @@ fn run(args: ~[str]) { io::stdout().write_str(#fmt("Throughput=%f per sec\n", thruput)); } -fn main(args: ~[str]) { - let args = if os::getenv("RUST_BENCH").is_some() { - ~["", "1000000", "10000"] +fn main(args: ~[~str]) { + let args = if os::getenv(~"RUST_BENCH").is_some() { + ~[~"", ~"1000000", ~"10000"] } else if args.len() <= 1u { - ~["", "10000", "4"] + ~[~"", ~"10000", ~"4"] } else { args }; diff --git a/src/test/bench/shootout-ackermann.rs b/src/test/bench/shootout-ackermann.rs index e1fd385957b..21d82f4daf9 100644 --- a/src/test/bench/shootout-ackermann.rs +++ b/src/test/bench/shootout-ackermann.rs @@ -12,11 +12,11 @@ fn ack(m: int, n: int) -> int { } } -fn main(args: ~[str]) { - let args = if os::getenv("RUST_BENCH").is_some() { - ~["", "12"] +fn main(args: ~[~str]) { + let args = if os::getenv(~"RUST_BENCH").is_some() { + ~[~"", ~"12"] } else if args.len() <= 1u { - ~["", "8"] + ~[~"", ~"8"] } else { args }; diff --git a/src/test/bench/shootout-binarytrees.rs b/src/test/bench/shootout-binarytrees.rs index 1098d30a7fc..f80060891c3 100644 --- a/src/test/bench/shootout-binarytrees.rs +++ b/src/test/bench/shootout-binarytrees.rs @@ -22,11 +22,11 @@ fn bottom_up_tree(arena: &a.arena::arena, item: int, depth: int) -> &a.tree { ret new(*arena) nil; } -fn main(args: ~[str]) { - let args = if os::getenv("RUST_BENCH").is_some() { - ~["", "17"] +fn main(args: ~[~str]) { + let args = if os::getenv(~"RUST_BENCH").is_some() { + ~[~"", ~"17"] } else if args.len() <= 1u { - ~["", "8"] + ~[~"", ~"8"] } else { args }; diff --git a/src/test/bench/shootout-chameneos-redux.rs b/src/test/bench/shootout-chameneos-redux.rs index e0a7a26ef86..900df13cf3f 100644 --- a/src/test/bench/shootout-chameneos-redux.rs +++ b/src/test/bench/shootout-chameneos-redux.rs @@ -11,8 +11,8 @@ fn print_complements() { let all = ~[Blue, Red, Yellow]; for vec::each(all) |aa| { for vec::each(all) |bb| { - io::println(show_color(aa) + " + " + show_color(bb) + - " -> " + show_color(transform(aa,bb))); + io::println(show_color(aa) + ~" + " + show_color(bb) + + ~" -> " + show_color(transform(aa,bb))); } } } @@ -21,41 +21,41 @@ enum color { Red, Yellow, Blue } type creature_info = { name: uint, color: color }; -fn show_color(cc: color) -> str { +fn show_color(cc: color) -> ~str { alt (cc) { - Red {"red"} - Yellow {"yellow"} - Blue {"blue"} + Red {~"red"} + Yellow {~"yellow"} + Blue {~"blue"} } } -fn show_color_list(set: ~[color]) -> str { - let mut out = ""; +fn show_color_list(set: ~[color]) -> ~str { + let mut out = ~""; for vec::eachi(set) |_ii, col| { - out += " "; + out += ~" "; out += show_color(col); } ret out; } -fn show_digit(nn: uint) -> str { +fn show_digit(nn: uint) -> ~str { alt (nn) { - 0 {"zero"} - 1 {"one"} - 2 {"two"} - 3 {"three"} - 4 {"four"} - 5 {"five"} - 6 {"six"} - 7 {"seven"} - 8 {"eight"} - 9 {"nine"} - _ {fail "expected digits from 0 to 9..."} + 0 {~"zero"} + 1 {~"one"} + 2 {~"two"} + 3 {~"three"} + 4 {~"four"} + 5 {~"five"} + 6 {~"six"} + 7 {~"seven"} + 8 {~"eight"} + 9 {~"nine"} + _ {fail ~"expected digits from 0 to 9..."} } } -fn show_number(nn: uint) -> str { - let mut out = ""; +fn show_number(nn: uint) -> ~str { + let mut out = ~""; let mut num = nn; let mut dig; @@ -64,7 +64,7 @@ fn show_number(nn: uint) -> str { while num != 0 { dig = num % 10; num = num / 10; - out = show_digit(dig) + " " + out; + out = show_digit(dig) + ~" " + out; } ret out; @@ -89,7 +89,7 @@ fn creature( color: color, from_rendezvous: comm::port<option<creature_info>>, to_rendezvous: comm::chan<creature_info>, - to_rendezvous_log: comm::chan<str> + to_rendezvous_log: comm::chan<~str> ) { let mut color = color; let mut creatures_met = 0; @@ -113,7 +113,7 @@ fn creature( } option::none { // log creatures met and evil clones of self - let report = #fmt("%u", creatures_met) + " " + + let report = #fmt("%u", creatures_met) + ~" " + show_number(evil_clones_met); comm::send(to_rendezvous_log, report); break; @@ -125,7 +125,7 @@ fn creature( fn rendezvous(nn: uint, set: ~[color]) { // these ports will allow us to hear from the creatures let from_creatures: comm::port<creature_info> = comm::port(); - let from_creatures_log: comm::port<str> = comm::port(); + let from_creatures_log: comm::port<~str> = comm::port(); // these channels will be passed to the creatures so they can talk to us let to_rendezvous = comm::chan(from_creatures); @@ -180,11 +180,11 @@ fn rendezvous(nn: uint, set: ~[color]) { io::println(show_number(creatures_met)); } -fn main(args: ~[str]) { - let args = if os::getenv("RUST_BENCH").is_some() { - ~["", "200000"] +fn main(args: ~[~str]) { + let args = if os::getenv(~"RUST_BENCH").is_some() { + ~[~"", ~"200000"] } else if args.len() <= 1u { - ~["", "600"] + ~[~"", ~"600"] } else { args }; @@ -192,10 +192,10 @@ fn main(args: ~[str]) { let nn = uint::from_str(args[1]).get(); print_complements(); - io::println(""); + io::println(~""); rendezvous(nn, ~[Blue, Red, Yellow]); - io::println(""); + io::println(~""); rendezvous(nn, ~[Blue, Red, Yellow, Red, Yellow, Blue, Red, Yellow, Red, Blue]); diff --git a/src/test/bench/shootout-fannkuchredux.rs b/src/test/bench/shootout-fannkuchredux.rs index a537a5adc1c..0e0a5333c04 100644 --- a/src/test/bench/shootout-fannkuchredux.rs +++ b/src/test/bench/shootout-fannkuchredux.rs @@ -58,11 +58,11 @@ fn fannkuch(n: int) -> int { ret flips; } -fn main(args: ~[str]) { - let args = if os::getenv("RUST_BENCH").is_some() { - ~["", "10"] +fn main(args: ~[~str]) { + let args = if os::getenv(~"RUST_BENCH").is_some() { + ~[~"", ~"10"] } else if args.len() <= 1u { - ~["", "8"] + ~[~"", ~"8"] } else { args }; diff --git a/src/test/bench/shootout-fasta.rs b/src/test/bench/shootout-fasta.rs index 919ad52fa46..ca528764b1d 100644 --- a/src/test/bench/shootout-fasta.rs +++ b/src/test/bench/shootout-fasta.rs @@ -43,30 +43,30 @@ fn select_random(r: u32, genelist: ~[aminoacids]) -> char { ret bisect(genelist, 0u, vec::len::<aminoacids>(genelist) - 1u, r); } -fn make_random_fasta(wr: io::writer, id: str, desc: str, genelist: ~[aminoacids], n: int) { - wr.write_line(">" + id + " " + desc); +fn make_random_fasta(wr: io::writer, id: ~str, desc: ~str, genelist: ~[aminoacids], n: int) { + wr.write_line(~">" + id + ~" " + desc); let rng = @{mut last: rand::rng().next()}; - let mut op: str = ""; + let mut op: ~str = ~""; for uint::range(0u, n as uint) |_i| { str::push_char(op, select_random(myrandom_next(rng, 100u32), genelist)); if str::len(op) >= LINE_LENGTH() { wr.write_line(op); - op = ""; + op = ~""; } } if str::len(op) > 0u { wr.write_line(op); } } -fn make_repeat_fasta(wr: io::writer, id: str, desc: str, s: str, n: int) unsafe { - wr.write_line(">" + id + " " + desc); - let mut op: str = ""; +fn make_repeat_fasta(wr: io::writer, id: ~str, desc: ~str, s: ~str, n: int) unsafe { + wr.write_line(~">" + id + ~" " + desc); + let mut op: ~str = ~""; let sl: uint = str::len(s); for uint::range(0u, n as uint) |i| { str::unsafe::push_byte(op, s[i % sl]); if str::len(op) >= LINE_LENGTH() { wr.write_line(op); - op = ""; + op = ~""; } } if str::len(op) > 0u { wr.write_line(op); } @@ -74,18 +74,18 @@ fn make_repeat_fasta(wr: io::writer, id: str, desc: str, s: str, n: int) unsafe fn acid(ch: char, prob: u32) -> aminoacids { ret {ch: ch, prob: prob}; } -fn main(args: ~[str]) { - let args = if os::getenv("RUST_BENCH").is_some() { +fn main(args: ~[~str]) { + let args = if os::getenv(~"RUST_BENCH").is_some() { // alioth tests k-nucleotide with this data at 25,000,000 - ~["", "5000000"] + ~[~"", ~"5000000"] } else if args.len() <= 1u { - ~["", "1000"] + ~[~"", ~"1000"] } else { args }; - let writer = if os::getenv("RUST_BENCH").is_some() { - result::get(io::file_writer("./shootout-fasta.data", ~[io::truncate, io::create])) + let writer = if os::getenv(~"RUST_BENCH").is_some() { + result::get(io::file_writer(~"./shootout-fasta.data", ~[io::truncate, io::create])) } else { io::stdout() }; @@ -101,16 +101,16 @@ fn main(args: ~[str]) { let homosapiens: ~[aminoacids] = make_cumulative(~[acid('a', 30u32), acid('c', 20u32), acid('g', 20u32), acid('t', 30u32)]); - let alu: str = - "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG" + - "GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA" + - "CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT" + - "ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA" + - "GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG" + - "AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC" + - "AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA"; - make_repeat_fasta(writer, "ONE", "Homo sapiens alu", alu, n * 2); - make_random_fasta(writer, "TWO", "IUB ambiguity codes", iub, n * 3); - make_random_fasta(writer, "THREE", - "Homo sapiens frequency", homosapiens, n * 5); + let alu: ~str = + ~"GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG" + + ~"GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA" + + ~"CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT" + + ~"ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA" + + ~"GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG" + + ~"AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC" + + ~"AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA"; + make_repeat_fasta(writer, ~"ONE", ~"Homo sapiens alu", alu, n * 2); + make_random_fasta(writer, ~"TWO", ~"IUB ambiguity codes", iub, n * 3); + make_random_fasta(writer, ~"THREE", + ~"Homo sapiens frequency", homosapiens, n * 5); } diff --git a/src/test/bench/shootout-fibo.rs b/src/test/bench/shootout-fibo.rs index dcdc92ad943..08932324ac2 100644 --- a/src/test/bench/shootout-fibo.rs +++ b/src/test/bench/shootout-fibo.rs @@ -8,11 +8,11 @@ fn fib(n: int) -> int { } } -fn main(args: ~[str]) { - let args = if os::getenv("RUST_BENCH").is_some() { - ~["", "40"] +fn main(args: ~[~str]) { + let args = if os::getenv(~"RUST_BENCH").is_some() { + ~[~"", ~"40"] } else if args.len() <= 1u { - ~["", "30"] + ~[~"", ~"30"] } else { args }; diff --git a/src/test/bench/shootout-k-nucleotide-pipes.rs b/src/test/bench/shootout-k-nucleotide-pipes.rs index d4084f43304..fbf18ab7aa4 100644 --- a/src/test/bench/shootout-k-nucleotide-pipes.rs +++ b/src/test/bench/shootout-k-nucleotide-pipes.rs @@ -12,7 +12,7 @@ import std::sort; import pipes::{stream, port, chan}; // given a map, print a sorted version of it -fn sort_and_fmt(mm: hashmap<~[u8], uint>, total: uint) -> str { +fn sort_and_fmt(mm: hashmap<~[u8], uint>, total: uint) -> ~str { fn pct(xx: uint, yy: uint) -> float { ret (xx as float) * 100f / (yy as float); } @@ -44,7 +44,7 @@ fn sort_and_fmt(mm: hashmap<~[u8], uint>, total: uint) -> str { let pairs_sorted = sortKV(pairs); - let mut buffer = ""; + let mut buffer = ~""; pairs_sorted.each(fn&(kv: (~[u8], float)) -> bool unsafe { let (k,v) = kv; @@ -56,7 +56,7 @@ fn sort_and_fmt(mm: hashmap<~[u8], uint>, total: uint) -> str { } // given a map, search for the frequency of a pattern -fn find(mm: hashmap<~[u8], uint>, key: str) -> uint { +fn find(mm: hashmap<~[u8], uint>, key: ~str) -> uint { alt mm.find(str::bytes(str::to_lower(key))) { option::none { ret 0u; } option::some(num) { ret num; } @@ -90,7 +90,7 @@ fn windows_with_carry(bb: ~[const u8], nn: uint, } fn make_sequence_processor(sz: uint, from_parent: pipes::port<~[u8]>, - to_parent: pipes::chan<str>) { + to_parent: pipes::chan<~str>) { let freqs: hashmap<~[u8], uint> = map::bytes_hash(); let mut carry: ~[u8] = ~[]; @@ -112,12 +112,12 @@ fn make_sequence_processor(sz: uint, from_parent: pipes::port<~[u8]>, let buffer = alt sz { 1u { sort_and_fmt(freqs, total) } 2u { sort_and_fmt(freqs, total) } - 3u { #fmt["%u\t%s", find(freqs, "GGT"), "GGT"] } - 4u { #fmt["%u\t%s", find(freqs, "GGTA"), "GGTA"] } - 6u { #fmt["%u\t%s", find(freqs, "GGTATT"), "GGTATT"] } - 12u { #fmt["%u\t%s", find(freqs, "GGTATTTTAATT"), "GGTATTTTAATT"] } - 18u { #fmt["%u\t%s", find(freqs, "GGTATTTTAATTTATAGT"), "GGTATTTTAATTTATAGT"] } - _ { "" } + 3u { #fmt["%u\t%s", find(freqs, ~"GGT"), ~"GGT"] } + 4u { #fmt["%u\t%s", find(freqs, ~"GGTA"), ~"GGTA"] } + 6u { #fmt["%u\t%s", find(freqs, ~"GGTATT"), ~"GGTATT"] } + 12u { #fmt["%u\t%s", find(freqs, ~"GGTATTTTAATT"), ~"GGTATTTTAATT"] } + 18u { #fmt["%u\t%s", find(freqs, ~"GGTATTTTAATTTATAGT"), ~"GGTATTTTAATTTATAGT"] } + _ { ~"" } }; //comm::send(to_parent, #fmt["yay{%u}", sz]); @@ -125,13 +125,13 @@ fn make_sequence_processor(sz: uint, from_parent: pipes::port<~[u8]>, } // given a FASTA file on stdin, process sequence THREE -fn main(args: ~[str]) { - let rdr = if os::getenv("RUST_BENCH").is_some() { +fn main(args: ~[~str]) { + let rdr = if os::getenv(~"RUST_BENCH").is_some() { // FIXME: Using this compile-time env variable is a crummy way to // get to this massive data set, but #include_bin chokes on it (#2598) let path = path::connect( #env("CFG_SRC_DIR"), - "src/test/bench/shootout-k-nucleotide.data" + ~"src/test/bench/shootout-k-nucleotide.data" ); result::get(io::file_reader(path)) } else { @@ -167,7 +167,7 @@ fn main(args: ~[str]) { let mut proc_mode = false; while !rdr.eof() { - let line: str = rdr.read_line(); + let line: ~str = rdr.read_line(); if str::len(line) == 0u { again; } @@ -175,7 +175,7 @@ fn main(args: ~[str]) { // start processing if this is the one ('>' as u8, false) { - alt str::find_str_from(line, "THREE", 1u) { + alt str::find_str_from(line, ~"THREE", 1u) { option::some(_) { proc_mode = true; } option::none { } } diff --git a/src/test/bench/shootout-k-nucleotide.rs b/src/test/bench/shootout-k-nucleotide.rs index c19b7199197..db6c1b67174 100644 --- a/src/test/bench/shootout-k-nucleotide.rs +++ b/src/test/bench/shootout-k-nucleotide.rs @@ -10,7 +10,7 @@ import std::map::hashmap; import std::sort; // given a map, print a sorted version of it -fn sort_and_fmt(mm: hashmap<~[u8], uint>, total: uint) -> str { +fn sort_and_fmt(mm: hashmap<~[u8], uint>, total: uint) -> ~str { fn pct(xx: uint, yy: uint) -> float { ret (xx as float) * 100f / (yy as float); } @@ -42,7 +42,7 @@ fn sort_and_fmt(mm: hashmap<~[u8], uint>, total: uint) -> str { let pairs_sorted = sortKV(pairs); - let mut buffer = ""; + let mut buffer = ~""; pairs_sorted.each(fn&(kv: (~[u8], float)) -> bool unsafe { let (k,v) = kv; @@ -54,7 +54,7 @@ fn sort_and_fmt(mm: hashmap<~[u8], uint>, total: uint) -> str { } // given a map, search for the frequency of a pattern -fn find(mm: hashmap<~[u8], uint>, key: str) -> uint { +fn find(mm: hashmap<~[u8], uint>, key: ~str) -> uint { alt mm.find(str::bytes(str::to_lower(key))) { option::none { ret 0u; } option::some(num) { ret num; } @@ -88,7 +88,7 @@ fn windows_with_carry(bb: ~[const u8], nn: uint, } fn make_sequence_processor(sz: uint, from_parent: comm::port<~[u8]>, - to_parent: comm::chan<str>) { + to_parent: comm::chan<~str>) { let freqs: hashmap<~[u8], uint> = map::bytes_hash(); let mut carry: ~[u8] = ~[]; @@ -110,12 +110,12 @@ fn make_sequence_processor(sz: uint, from_parent: comm::port<~[u8]>, let buffer = alt sz { 1u { sort_and_fmt(freqs, total) } 2u { sort_and_fmt(freqs, total) } - 3u { #fmt["%u\t%s", find(freqs, "GGT"), "GGT"] } - 4u { #fmt["%u\t%s", find(freqs, "GGTA"), "GGTA"] } - 6u { #fmt["%u\t%s", find(freqs, "GGTATT"), "GGTATT"] } - 12u { #fmt["%u\t%s", find(freqs, "GGTATTTTAATT"), "GGTATTTTAATT"] } - 18u { #fmt["%u\t%s", find(freqs, "GGTATTTTAATTTATAGT"), "GGTATTTTAATTTATAGT"] } - _ { "" } + 3u { #fmt["%u\t%s", find(freqs, ~"GGT"), ~"GGT"] } + 4u { #fmt["%u\t%s", find(freqs, ~"GGTA"), ~"GGTA"] } + 6u { #fmt["%u\t%s", find(freqs, ~"GGTATT"), ~"GGTATT"] } + 12u { #fmt["%u\t%s", find(freqs, ~"GGTATTTTAATT"), ~"GGTATTTTAATT"] } + 18u { #fmt["%u\t%s", find(freqs, ~"GGTATTTTAATTTATAGT"), ~"GGTATTTTAATTTATAGT"] } + _ { ~"" } }; //comm::send(to_parent, #fmt["yay{%u}", sz]); @@ -123,13 +123,13 @@ fn make_sequence_processor(sz: uint, from_parent: comm::port<~[u8]>, } // given a FASTA file on stdin, process sequence THREE -fn main(args: ~[str]) { - let rdr = if os::getenv("RUST_BENCH").is_some() { +fn main(args: ~[~str]) { + let rdr = if os::getenv(~"RUST_BENCH").is_some() { // FIXME: Using this compile-time env variable is a crummy way to // get to this massive data set, but #include_bin chokes on it (#2598) let path = path::connect( #env("CFG_SRC_DIR"), - "src/test/bench/shootout-k-nucleotide.data" + ~"src/test/bench/shootout-k-nucleotide.data" ); result::get(io::file_reader(path)) } else { @@ -154,7 +154,7 @@ fn main(args: ~[str]) { let mut proc_mode = false; while !rdr.eof() { - let line: str = rdr.read_line(); + let line: ~str = rdr.read_line(); if str::len(line) == 0u { again; } @@ -162,7 +162,7 @@ fn main(args: ~[str]) { // start processing if this is the one ('>' as u8, false) { - alt str::find_str_from(line, "THREE", 1u) { + alt str::find_str_from(line, ~"THREE", 1u) { option::some(_) { proc_mode = true; } option::none { } } diff --git a/src/test/bench/shootout-mandelbrot.rs b/src/test/bench/shootout-mandelbrot.rs index 27a3d993cd4..aa6377633c2 100644 --- a/src/test/bench/shootout-mandelbrot.rs +++ b/src/test/bench/shootout-mandelbrot.rs @@ -85,16 +85,16 @@ impl of io::writer for devnull { fn flush() -> int {0} } -fn writer(path: str, writech: comm::chan<comm::chan<line>>, size: uint) +fn writer(path: ~str, writech: comm::chan<comm::chan<line>>, size: uint) { let p: comm::port<line> = comm::port(); let ch = comm::chan(p); comm::send(writech, ch); let cout: io::writer = alt path { - "" { + ~"" { {dn: 0} as io::writer } - "-" { + ~"-" { io::stdout() } _ { @@ -103,7 +103,7 @@ fn writer(path: str, writech: comm::chan<comm::chan<line>>, size: uint) ~[io::create, io::truncate])) } }; - cout.write_line("P4"); + cout.write_line(~"P4"); cout.write_line(#fmt("%u %u", size, size)); let lines = std::map::uint_hash(); let mut done = 0_u; @@ -139,14 +139,14 @@ fn writer(path: str, writech: comm::chan<comm::chan<line>>, size: uint) } } -fn main(args: ~[str]) { - let args = if os::getenv("RUST_BENCH").is_some() { - ~["", "4000", "10"] +fn main(args: ~[~str]) { + let args = if os::getenv(~"RUST_BENCH").is_some() { + ~[~"", ~"4000", ~"10"] } else { args }; - let path = if vec::len(args) < 4_u { "" } + let path = if vec::len(args) < 4_u { ~"" } else { args[3] }; let yieldevery = if vec::len(args) < 3_u { 10_u } diff --git a/src/test/bench/shootout-nbody.rs b/src/test/bench/shootout-nbody.rs index 56b01325b24..8c2c4426934 100644 --- a/src/test/bench/shootout-nbody.rs +++ b/src/test/bench/shootout-nbody.rs @@ -13,11 +13,11 @@ extern mod libc { fn sqrt(n: float) -> float; } -fn main(args: ~[str]) { - let args = if os::getenv("RUST_BENCH").is_some() { - ~["", "4000000"] +fn main(args: ~[~str]) { + let args = if os::getenv(~"RUST_BENCH").is_some() { + ~[~"", ~"4000000"] } else if args.len() <= 1u { - ~["", "100000"] + ~[~"", ~"100000"] } else { args }; diff --git a/src/test/bench/shootout-pfib.rs b/src/test/bench/shootout-pfib.rs index 8ce91865b04..41d2bdeb71b 100644 --- a/src/test/bench/shootout-pfib.rs +++ b/src/test/bench/shootout-pfib.rs @@ -46,14 +46,14 @@ fn fib(n: int) -> int { type config = {stress: bool}; -fn parse_opts(argv: ~[str]) -> config { - let opts = ~[getopts::optflag("stress")]; +fn parse_opts(argv: ~[~str]) -> config { + let opts = ~[getopts::optflag(~"stress")]; let opt_args = vec::slice(argv, 1u, vec::len(argv)); alt getopts::getopts(opt_args, opts) { - ok(m) { ret {stress: getopts::opt_present(m, "stress")} } + ok(m) { ret {stress: getopts::opt_present(m, ~"stress")} } err(_) { fail; } } } @@ -78,11 +78,11 @@ fn stress(num_tasks: int) { for results.each |r| { future::get(r); } } -fn main(args: ~[str]) { - let args = if os::getenv("RUST_BENCH").is_some() { - ~["", "20"] +fn main(args: ~[~str]) { + let args = if os::getenv(~"RUST_BENCH").is_some() { + ~[~"", ~"20"] } else if args.len() <= 1u { - ~["", "8"] + ~[~"", ~"8"] } else { args }; diff --git a/src/test/bench/shootout-spectralnorm.rs b/src/test/bench/shootout-spectralnorm.rs index c5a952aab8d..983efce1f50 100644 --- a/src/test/bench/shootout-spectralnorm.rs +++ b/src/test/bench/shootout-spectralnorm.rs @@ -40,11 +40,11 @@ fn eval_AtA_times_u(u: ~[const float], AtAu: ~[mut float]) { eval_At_times_u(v, AtAu); } -fn main(args: ~[str]) { - let args = if os::getenv("RUST_BENCH").is_some() { - ~["", "2000"] +fn main(args: ~[~str]) { + let args = if os::getenv(~"RUST_BENCH").is_some() { + ~[~"", ~"2000"] } else if args.len() <= 1u { - ~["", "1000"] + ~[~"", ~"1000"] } else { args }; diff --git a/src/test/bench/shootout-threadring.rs b/src/test/bench/shootout-threadring.rs index be2e1fc3ad8..e064c9481f2 100644 --- a/src/test/bench/shootout-threadring.rs +++ b/src/test/bench/shootout-threadring.rs @@ -37,11 +37,11 @@ fn roundtrip(id: int, p: comm::port<int>, ch: comm::chan<int>) { } } -fn main(args: ~[str]) { - let args = if os::getenv("RUST_BENCH").is_some() { - ~["", "2000000"] +fn main(args: ~[~str]) { + let args = if os::getenv(~"RUST_BENCH").is_some() { + ~[~"", ~"2000000"] } else if args.len() <= 1u { - ~["", "1000"] + ~[~"", ~"1000"] } else { args }; diff --git a/src/test/bench/std-smallintmap.rs b/src/test/bench/std-smallintmap.rs index 4a712e2d995..865385d81b0 100644 --- a/src/test/bench/std-smallintmap.rs +++ b/src/test/bench/std-smallintmap.rs @@ -17,11 +17,11 @@ fn check_sequential(min: uint, max: uint, map: smallintmap<uint>) { } } -fn main(args: ~[str]) { - let args = if os::getenv("RUST_BENCH").is_some() { - ~["", "100000", "100"] +fn main(args: ~[~str]) { + let args = if os::getenv(~"RUST_BENCH").is_some() { + ~[~"", ~"100000", ~"100"] } else if args.len() <= 1u { - ~["", "10000", "50"] + ~[~"", ~"10000", ~"50"] } else { args }; diff --git a/src/test/bench/sudoku.rs b/src/test/bench/sudoku.rs index 61055b49c5d..3eeb16f9379 100644 --- a/src/test/bench/sudoku.rs +++ b/src/test/bench/sudoku.rs @@ -29,7 +29,7 @@ enum grid_t { grid_ctor(grid), } // read a sudoku problem from file f fn read_grid(f: io::reader) -> grid_t { - assert f.read_line() == "9,9"; /* assert first line is exactly "9,9" */ + assert f.read_line() == ~"9,9"; /* assert first line is exactly "9,9" */ let g = vec::from_fn(10u, {|_i| vec::to_mut(vec::from_elem(10u, 0 as u8)) @@ -110,7 +110,7 @@ fn solve_grid(g: grid_t) { ptr = ptr + 1u; } else { // no: redo this field aft recoloring pred; unless there is none - if ptr == 0u { fail "No solution found for this sudoku"; } + if ptr == 0u { fail ~"No solution found for this sudoku"; } ptr = ptr - 1u; } } @@ -126,7 +126,7 @@ fn write_grid(f: io::writer, g: grid_t) { } } -fn main(args: ~[str]) { +fn main(args: ~[~str]) { let grid = if vec::len(args) == 1u { // FIXME create sudoku inline since nested vec consts dont work yet // (#571) diff --git a/src/test/bench/task-perf-alloc-unwind.rs b/src/test/bench/task-perf-alloc-unwind.rs index 194c78e250d..240febf8f25 100644 --- a/src/test/bench/task-perf-alloc-unwind.rs +++ b/src/test/bench/task-perf-alloc-unwind.rs @@ -7,7 +7,7 @@ import std::list::{list, cons, nil}; import std::time::precise_time_s; fn main() { - let (repeat, depth) = if os::getenv("RUST_BENCH").is_some() { + let (repeat, depth) = if os::getenv(~"RUST_BENCH").is_some() { (50, 1000) } else { (10, 10) diff --git a/src/test/bench/task-perf-one-million.rs b/src/test/bench/task-perf-one-million.rs index 6992162fc5c..adb5e1a0799 100644 --- a/src/test/bench/task-perf-one-million.rs +++ b/src/test/bench/task-perf-one-million.rs @@ -45,11 +45,11 @@ fn calc(children: uint, parent_ch: comm::chan<msg>) { comm::send(parent_ch, done(sum + 1)); } -fn main(args: ~[str]) { - let args = if os::getenv("RUST_BENCH").is_some() { - ~["", "100000"] +fn main(args: ~[~str]) { + let args = if os::getenv(~"RUST_BENCH").is_some() { + ~[~"", ~"100000"] } else if args.len() <= 1u { - ~["", "100"] + ~[~"", ~"100"] } else { args }; diff --git a/src/test/bench/task-perf-spawnalot.rs b/src/test/bench/task-perf-spawnalot.rs index 7cc9446250e..32e701498b0 100644 --- a/src/test/bench/task-perf-spawnalot.rs +++ b/src/test/bench/task-perf-spawnalot.rs @@ -8,11 +8,11 @@ fn f(&&n: uint) { fn g() { } -fn main(args: ~[str]) { - let args = if os::getenv("RUST_BENCH").is_some() { - ~["", "400"] +fn main(args: ~[~str]) { + let args = if os::getenv(~"RUST_BENCH").is_some() { + ~[~"", ~"400"] } else if args.len() <= 1u { - ~["", "10"] + ~[~"", ~"10"] } else { args }; diff --git a/src/test/bench/task-perf-word-count-generic.rs b/src/test/bench/task-perf-word-count-generic.rs index 85e92602dcc..62aa4d75f20 100644 --- a/src/test/bench/task-perf-word-count-generic.rs +++ b/src/test/bench/task-perf-word-count-generic.rs @@ -38,7 +38,7 @@ macro_rules! move { } trait word_reader { - fn read_word() -> option<str>; + fn read_word() -> option<~str>; } trait hash_key { @@ -52,9 +52,9 @@ fn mk_hash<K: const hash_key, V: copy>() -> map::hashmap<K, V> { map::hashmap(hashfn::<K>, |x, y| x.eq(y)) } -impl of hash_key for str { +impl of hash_key for ~str { fn hash() -> uint { str::hash(self) } - fn eq(&&x: str) -> bool { str::eq(self, x) } + fn eq(&&x: ~str) -> bool { str::eq(self, x) } } // These used to be in task, but they disappeard. @@ -74,17 +74,17 @@ fn join(t: joinable_task) { } impl of word_reader for io::reader { - fn read_word() -> option<str> { read_word(self) } + fn read_word() -> option<~str> { read_word(self) } } -fn file_word_reader(filename: str) -> word_reader { +fn file_word_reader(filename: ~str) -> word_reader { alt io::file_reader(filename) { result::ok(f) { f as word_reader } result::err(e) { fail #fmt("%?", e) } } } -fn map(f: fn~() -> word_reader, emit: map_reduce::putter<str, int>) { +fn map(f: fn~() -> word_reader, emit: map_reduce::putter<~str, int>) { let f = f(); loop { alt f.read_word() { @@ -94,7 +94,7 @@ fn map(f: fn~() -> word_reader, emit: map_reduce::putter<str, int>) { } } -fn reduce(&&word: str, get: map_reduce::getter<int>) { +fn reduce(&&word: ~str, get: map_reduce::getter<int>) { let mut count = 0; loop { alt get() { some(_) { count += 1; } none { break; } } } @@ -299,8 +299,8 @@ mod map_reduce { } } -fn main(argv: ~[str]) { - if vec::len(argv) < 2u && !os::getenv("RUST_BENCH").is_some() { +fn main(argv: ~[~str]) { + if vec::len(argv) < 2u && !os::getenv(~"RUST_BENCH").is_some() { let out = io::stdout(); out.write_line(#fmt["Usage: %s <filename> ...", argv[0]]); @@ -330,19 +330,19 @@ fn main(argv: ~[str]) { let elapsed = (stop - start) / 1000000u64; - log(error, "MapReduce completed in " - + u64::str(elapsed) + "ms"); + log(error, ~"MapReduce completed in " + + u64::str(elapsed) + ~"ms"); } -fn read_word(r: io::reader) -> option<str> { - let mut w = ""; +fn read_word(r: io::reader) -> option<~str> { + let mut w = ~""; while !r.eof() { let c = r.read_char(); if is_word_char(c) { w += str::from_char(c); - } else { if w != "" { ret some(w); } } + } else { if w != ~"" { ret some(w); } } } ret none; } @@ -359,7 +359,7 @@ class random_word_reader: word_reader { self.rng = rand::rng(); } - fn read_word() -> option<str> { + fn read_word() -> option<~str> { if self.remaining > 0 { self.remaining -= 1; let len = self.rng.gen_uint_range(1, 4); diff --git a/src/test/bench/task-perf-word-count.rs b/src/test/bench/task-perf-word-count.rs index 83c0eb53d99..055da76b159 100644 --- a/src/test/bench/task-perf-word-count.rs +++ b/src/test/bench/task-perf-word-count.rs @@ -21,7 +21,7 @@ import comm::port; import comm::recv; import comm::send; -fn map(input: str, emit: map_reduce::putter) { +fn map(input: ~str, emit: map_reduce::putter) { let f = io::str_reader(input); @@ -30,7 +30,7 @@ fn map(input: str, emit: map_reduce::putter) { } } -fn reduce(_word: str, get: map_reduce::getter) { +fn reduce(_word: ~str, get: map_reduce::getter) { let mut count = 0; loop { alt get() { some(_) { count += 1; } none { break; } } } @@ -43,22 +43,22 @@ mod map_reduce { export reducer; export map_reduce; - type putter = fn@(str, int); + type putter = fn@(~str, int); - type mapper = fn@(str, putter); + type mapper = fn@(~str, putter); type getter = fn@() -> option<int>; - type reducer = fn@(str, getter); + type reducer = fn@(~str, getter); enum ctrl_proto { - find_reducer(str, chan<chan<reduce_proto>>), + find_reducer(~str, chan<chan<reduce_proto>>), mapper_done, } enum reduce_proto { emit_val(int), done, ref, release, } - fn start_mappers(ctrl: chan<ctrl_proto>, -inputs: ~[str]) -> + fn start_mappers(ctrl: chan<ctrl_proto>, -inputs: ~[~str]) -> ~[future::future<task::task_result>] { let mut results = ~[]; for inputs.each |i| { @@ -69,12 +69,12 @@ mod map_reduce { ret results; } - fn map_task(ctrl: chan<ctrl_proto>, input: str) { + fn map_task(ctrl: chan<ctrl_proto>, input: ~str) { // log(error, "map_task " + input); let intermediates = map::str_hash(); - fn emit(im: map::hashmap<str, chan<reduce_proto>>, - ctrl: chan<ctrl_proto>, key: str, val: int) { + fn emit(im: map::hashmap<~str, chan<reduce_proto>>, + ctrl: chan<ctrl_proto>, key: ~str, val: int) { let mut c; alt im.find(key) { some(_c) { @@ -98,7 +98,7 @@ mod map_reduce { send(ctrl, mapper_done); } - fn reduce_task(key: str, out: chan<chan<reduce_proto>>) { + fn reduce_task(key: ~str, out: chan<chan<reduce_proto>>) { let p = port(); send(out, chan(p)); @@ -128,13 +128,13 @@ mod map_reduce { reduce(key, || get(p, state) ); } - fn map_reduce(-inputs: ~[str]) { + fn map_reduce(-inputs: ~[~str]) { let ctrl = port::<ctrl_proto>(); // This task becomes the master control task. It task::_spawns // to do the rest. - let mut reducers: map::hashmap<str, chan<reduce_proto>>; + let mut reducers: map::hashmap<~str, chan<reduce_proto>>; reducers = map::str_hash(); @@ -178,7 +178,7 @@ mod map_reduce { } } -fn main(argv: ~[str]) { +fn main(argv: ~[~str]) { let inputs = if vec::len(argv) < 2u { ~[input1(), input2(), input3()] } else { @@ -194,19 +194,19 @@ fn main(argv: ~[str]) { let mut elapsed = stop - start; elapsed /= 1000000u64; - log(error, "MapReduce completed in " - + u64::str(elapsed) + "ms"); + log(error, ~"MapReduce completed in " + + u64::str(elapsed) + ~"ms"); } -fn read_word(r: io::reader) -> option<str> { - let mut w = ""; +fn read_word(r: io::reader) -> option<~str> { + let mut w = ~""; while !r.eof() { let c = r.read_char(); if is_word_char(c) { w += str::from_char(c); - } else { if w != "" { ret some(w); } } + } else { if w != ~"" { ret some(w); } } } ret none; } @@ -297,7 +297,7 @@ fn is_word_char(c: char) -> bool { is_alpha(c) || is_digit(c) || c == '_' } -fn input1() -> str { " Lorem ipsum dolor sit amet, consectetur +fn input1() -> ~str { ~" Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vestibulum tempor erat a dui commodo congue. Proin ac imperdiet est. Nunc volutpat placerat justo, ac euismod nisl elementum et. Nam a eros eleifend dolor porttitor auctor a a felis. Maecenas dui @@ -337,7 +337,7 @@ laoreet nec. Curabitur non urna a augue rhoncus pulvinar. Integer placerat vehicula nisl sed egestas. Morbi iaculis diam at erat sollicitudin nec interdum libero tristique. " } -fn input2() -> str { " Lorem ipsum dolor sit amet, consectetur +fn input2() -> ~str { ~" Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin enim nibh, scelerisque faucibus accumsan id, feugiat id ipsum. In luctus mauris a massa consequat dignissim. Donec sit amet sem urna. Nullam pellentesque accumsan mi, at convallis arcu @@ -397,7 +397,7 @@ ullamcorper. Nullam blandit, diam quis sollicitudin tincidunt, elit justo varius lacus, aliquet luctus neque nibh quis turpis. Etiam massa sapien, tristique ut consectetur eu, elementum vel orci. " } -fn input3() -> str { " Lorem ipsum dolor sit amet, consectetur +fn input3() -> ~str { ~" Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque bibendum sapien ut magna fringilla mollis. Vivamus in neque non metus faucibus accumsan eu pretium nunc. Ut erat augue, pulvinar eget blandit nec, cursus quis diff --git a/src/test/compile-fail/estr-subtyping.rs b/src/test/compile-fail/estr-subtyping.rs index e5f963733dc..7e3e29f2b8f 100644 --- a/src/test/compile-fail/estr-subtyping.rs +++ b/src/test/compile-fail/estr-subtyping.rs @@ -1,14 +1,14 @@ -fn wants_box(x: str/@) { } -fn wants_uniq(x: str/~) { } +fn wants_box(x: @str) { } +fn wants_uniq(x: ~str) { } fn wants_three(x: str/3) { } -fn has_box(x: str/@) { +fn has_box(x: @str) { wants_box(x); wants_uniq(x); //~ ERROR str storage differs: expected ~ but found @ wants_three(x); //~ ERROR str storage differs: expected 3 but found @ } -fn has_uniq(x: str/~) { +fn has_uniq(x: ~str) { wants_box(x); //~ ERROR str storage differs: expected @ but found ~ wants_uniq(x); wants_three(x); //~ ERROR str storage differs: expected 3 but found ~ diff --git a/src/test/compile-fail/unsendable-class.rs b/src/test/compile-fail/unsendable-class.rs index 11384408ad8..35b81cdecb1 100644 --- a/src/test/compile-fail/unsendable-class.rs +++ b/src/test/compile-fail/unsendable-class.rs @@ -3,8 +3,8 @@ class foo { let i: int; - let j: @str/~; - new(i:int, j: @str/~) { self.i = i; self.j = j; } + let j: @~str; + new(i:int, j: @~str) { self.i = i; self.j = j; } } fn main() { diff --git a/src/test/run-fail/alt-bot-fail.rs b/src/test/run-fail/alt-bot-fail.rs index dcca16590a5..88c6688b766 100644 --- a/src/test/run-fail/alt-bot-fail.rs +++ b/src/test/run-fail/alt-bot-fail.rs @@ -1,6 +1,6 @@ // error-pattern:explicit failure -fn foo(s: str) { } +fn foo(s: ~str) { } fn main() { let i = diff --git a/src/test/run-fail/alt-disc-bot.rs b/src/test/run-fail/alt-disc-bot.rs index 2ac519e6419..09770179ebf 100644 --- a/src/test/run-fail/alt-disc-bot.rs +++ b/src/test/run-fail/alt-disc-bot.rs @@ -1,4 +1,4 @@ // error-pattern:quux -fn f() -> ! { fail "quux" } +fn f() -> ! { fail ~"quux" } fn g() -> int { alt f() { true { 1 } false { 0 } } } fn main() { g(); } diff --git a/src/test/run-fail/alt-wildcards.rs b/src/test/run-fail/alt-wildcards.rs index a3426e3a921..4a428f3cdb1 100644 --- a/src/test/run-fail/alt-wildcards.rs +++ b/src/test/run-fail/alt-wildcards.rs @@ -1,7 +1,7 @@ // error-pattern:squirrelcupcake fn cmp() -> int { alt check (option::some('a'), option::none::<char>) { - (option::some(_), _) { fail "squirrelcupcake"; } + (option::some(_), _) { fail ~"squirrelcupcake"; } (_, option::some(_)) { fail; } } } diff --git a/src/test/run-fail/args-fail.rs b/src/test/run-fail/args-fail.rs index afdaa553ba6..a28762aa9c2 100644 --- a/src/test/run-fail/args-fail.rs +++ b/src/test/run-fail/args-fail.rs @@ -1,4 +1,4 @@ // error-pattern:meep -fn f(a: int, b: int, c: @int) { fail "moop"; } +fn f(a: int, b: int, c: @int) { fail ~"moop"; } -fn main() { f(1, fail "meep", @42); } +fn main() { f(1, fail ~"meep", @42); } diff --git a/src/test/run-fail/binop-fail-2.rs b/src/test/run-fail/binop-fail-2.rs index adef5da4d0e..feb657efe0c 100644 --- a/src/test/run-fail/binop-fail-2.rs +++ b/src/test/run-fail/binop-fail-2.rs @@ -1,3 +1,3 @@ // error-pattern:quux -fn my_err(s: str) -> ! { log(error, s); fail "quux"; } -fn main() { 3u == my_err("bye"); } +fn my_err(s: ~str) -> ! { log(error, s); fail ~"quux"; } +fn main() { 3u == my_err(~"bye"); } diff --git a/src/test/run-fail/binop-fail.rs b/src/test/run-fail/binop-fail.rs index 83368cd1a07..a4aa1200316 100644 --- a/src/test/run-fail/binop-fail.rs +++ b/src/test/run-fail/binop-fail.rs @@ -1,3 +1,3 @@ // error-pattern:quux -fn my_err(s: str) -> ! { log(error, s); fail "quux"; } -fn main() { my_err("bye") == 3u; } +fn my_err(s: ~str) -> ! { log(error, s); fail ~"quux"; } +fn main() { my_err(~"bye") == 3u; } diff --git a/src/test/run-fail/bug-811.rs b/src/test/run-fail/bug-811.rs index a7d360ff8fc..e1b9187e0fb 100644 --- a/src/test/run-fail/bug-811.rs +++ b/src/test/run-fail/bug-811.rs @@ -8,4 +8,4 @@ enum chan_t<T: send> = {task: task_id, port: port_id}; fn send<T: send>(ch: chan_t<T>, -data: T) { fail; } -fn main() { fail "quux"; } +fn main() { fail ~"quux"; } diff --git a/src/test/run-fail/explicit-fail-msg.rs b/src/test/run-fail/explicit-fail-msg.rs index 8014ee75c15..f3927f122ed 100644 --- a/src/test/run-fail/explicit-fail-msg.rs +++ b/src/test/run-fail/explicit-fail-msg.rs @@ -1,4 +1,4 @@ // error-pattern:wooooo fn main() { - let mut a = 1; if 1 == 1 { a = 2; } fail "woooo" + "o"; + let mut a = 1; if 1 == 1 { a = 2; } fail ~"woooo" + ~"o"; } diff --git a/src/test/run-fail/fail-arg.rs b/src/test/run-fail/fail-arg.rs index a5d14f14303..5d1e83d6203 100644 --- a/src/test/run-fail/fail-arg.rs +++ b/src/test/run-fail/fail-arg.rs @@ -1,4 +1,4 @@ // error-pattern:woe fn f(a: int) { log(debug, a); } -fn main() { f(fail "woe"); } +fn main() { f(fail ~"woe"); } diff --git a/src/test/run-fail/fail-main.rs b/src/test/run-fail/fail-main.rs index 5df6d09896e..77918112209 100644 --- a/src/test/run-fail/fail-main.rs +++ b/src/test/run-fail/fail-main.rs @@ -1,4 +1,4 @@ // error-pattern:moop use std; import uint; -fn main() { fail "moop"; } +fn main() { fail ~"moop"; } diff --git a/src/test/run-fail/fmt-fail.rs b/src/test/run-fail/fmt-fail.rs index 5ca0ab74147..3950495e9c4 100644 --- a/src/test/run-fail/fmt-fail.rs +++ b/src/test/run-fail/fmt-fail.rs @@ -1,4 +1,4 @@ // error-pattern:meh use std; -fn main() { let str_var: str = "meh"; fail #fmt["%s", str_var]; } +fn main() { let str_var: ~str = ~"meh"; fail #fmt["%s", str_var]; } diff --git a/src/test/run-fail/fn-constraint-claim.rs b/src/test/run-fail/fn-constraint-claim.rs index 5a5fa5ea81c..e209a3de489 100644 --- a/src/test/run-fail/fn-constraint-claim.rs +++ b/src/test/run-fail/fn-constraint-claim.rs @@ -2,6 +2,6 @@ use std; import uint::*; -fn nop(a: uint, b: uint) : le(a, b) { fail "quux"; } +fn nop(a: uint, b: uint) : le(a, b) { fail ~"quux"; } fn main() { let a: uint = 5u; let b: uint = 4u; claim (le(a, b)); nop(a, b); } diff --git a/src/test/run-fail/for-each-loop-fail.rs b/src/test/run-fail/for-each-loop-fail.rs index a52b75f6cad..847be695222 100644 --- a/src/test/run-fail/for-each-loop-fail.rs +++ b/src/test/run-fail/for-each-loop-fail.rs @@ -1,4 +1,4 @@ // error-pattern:moop use std; import uint; -fn main() { for uint::range(0u, 10u) |_i| { fail "moop"; } } +fn main() { for uint::range(0u, 10u) |_i| { fail ~"moop"; } } diff --git a/src/test/run-fail/if-check-fail.rs b/src/test/run-fail/if-check-fail.rs index 31e95d5c385..3aa87f04e2d 100644 --- a/src/test/run-fail/if-check-fail.rs +++ b/src/test/run-fail/if-check-fail.rs @@ -9,7 +9,7 @@ fn foo(x: uint) { if check even(x) { log(debug, x); } else { - fail "Number is odd"; + fail ~"Number is odd"; } } diff --git a/src/test/run-fail/if-cond-bot.rs b/src/test/run-fail/if-cond-bot.rs index 71b7323240d..0a11fc35fca 100644 --- a/src/test/run-fail/if-cond-bot.rs +++ b/src/test/run-fail/if-cond-bot.rs @@ -1,3 +1,3 @@ // error-pattern:quux -fn my_err(s: str) -> ! { log(error, s); fail "quux"; } -fn main() { if my_err("bye") { } } +fn my_err(s: ~str) -> ! { log(error, s); fail ~"quux"; } +fn main() { if my_err(~"bye") { } } diff --git a/src/test/run-fail/issue-1459.rs b/src/test/run-fail/issue-1459.rs index 0fc6d8f697a..0039c5b0358 100644 --- a/src/test/run-fail/issue-1459.rs +++ b/src/test/run-fail/issue-1459.rs @@ -1,4 +1,4 @@ // error-pattern:roflcopter fn main() { - log (fail "roflcopter", 2); + log (fail ~"roflcopter", 2); } diff --git a/src/test/run-fail/issue-2156.rs b/src/test/run-fail/issue-2156.rs index 921842a32d2..1e8fea9d111 100644 --- a/src/test/run-fail/issue-2156.rs +++ b/src/test/run-fail/issue-2156.rs @@ -4,7 +4,7 @@ use std; import io::{reader, reader_util}; fn main() { - do io::with_str_reader("") |rdr| { + do io::with_str_reader(~"") |rdr| { alt rdr.read_char() { '=' { } _ { fail } } } } diff --git a/src/test/run-fail/issue-948.rs b/src/test/run-fail/issue-948.rs index 205d9d9466d..abc67f7c4aa 100644 --- a/src/test/run-fail/issue-948.rs +++ b/src/test/run-fail/issue-948.rs @@ -1,5 +1,5 @@ // error-pattern:beep boop fn main() { let origin = {x: 0, y: 0}; - let f: {x:int,y:int} = {x: (fail "beep boop") with origin}; + let f: {x:int,y:int} = {x: (fail ~"beep boop") with origin}; } diff --git a/src/test/run-fail/linked-failure3.rs b/src/test/run-fail/linked-failure3.rs index 22f6661716c..926317c7836 100644 --- a/src/test/run-fail/linked-failure3.rs +++ b/src/test/run-fail/linked-failure3.rs @@ -6,7 +6,7 @@ import task; import comm::port; import comm::recv; -fn grandchild() { fail "grandchild dies"; } +fn grandchild() { fail ~"grandchild dies"; } fn child() { let p = port::<int>(); diff --git a/src/test/run-fail/morestack2.rs b/src/test/run-fail/morestack2.rs index 7a7fd5daa96..649d00dc1f4 100644 --- a/src/test/run-fail/morestack2.rs +++ b/src/test/run-fail/morestack2.rs @@ -8,7 +8,7 @@ use std; extern mod rustrt { - fn last_os_error() -> str; + fn last_os_error() -> ~str; } fn getbig_call_c_and_fail(i: int) { diff --git a/src/test/run-fail/port-type.rs b/src/test/run-fail/port-type.rs index 3c7ebf8c18c..e33130df83c 100644 --- a/src/test/run-fail/port-type.rs +++ b/src/test/run-fail/port-type.rs @@ -15,4 +15,4 @@ fn echo<T: send>(c: chan<T>, oc: chan<chan<T>>) { send(c, x); } -fn main() { fail "meep"; } +fn main() { fail ~"meep"; } diff --git a/src/test/run-fail/result-get-fail.rs b/src/test/run-fail/result-get-fail.rs index 5a32f7d0ba4..41da3a6b55c 100644 --- a/src/test/run-fail/result-get-fail.rs +++ b/src/test/run-fail/result-get-fail.rs @@ -1,4 +1,4 @@ // error-pattern:get called on error result: ~"kitty" fn main() { - log(error, result::get(result::err::<int,str>("kitty"))); + log(error, result::get(result::err::<int,~str>(~"kitty"))); } diff --git a/src/test/run-fail/rhs-type.rs b/src/test/run-fail/rhs-type.rs index 461b2c65b44..c58f396f2eb 100644 --- a/src/test/run-fail/rhs-type.rs +++ b/src/test/run-fail/rhs-type.rs @@ -1,4 +1,4 @@ // Tests that trans treats the rhs of pth's decl // as a _|_-typed thing, not a str-typed thing // error-pattern:bye -fn main() { let pth = fail "bye"; let rs: {t: str} = {t: pth}; } +fn main() { let pth = fail ~"bye"; let rs: {t: ~str} = {t: pth}; } diff --git a/src/test/run-fail/rt-log-trunc.rs b/src/test/run-fail/rt-log-trunc.rs index 9ee2ecbcad3..a74cde84558 100644 --- a/src/test/run-fail/rt-log-trunc.rs +++ b/src/test/run-fail/rt-log-trunc.rs @@ -2,7 +2,7 @@ // error-pattern:[...] fn main() { - fail "\ + fail ~"\ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\ diff --git a/src/test/run-fail/rt-set-exit-status-fail.rs b/src/test/run-fail/rt-set-exit-status-fail.rs index 52f152895ad..32388eb0992 100644 --- a/src/test/run-fail/rt-set-exit-status-fail.rs +++ b/src/test/run-fail/rt-set-exit-status-fail.rs @@ -1,7 +1,7 @@ // error-pattern:whatever fn main() { - log(error, "whatever"); + log(error, ~"whatever"); // Setting the exit status only works when the scheduler terminates // normally. In this case we're going to fail, so instead of of // returning 50 the process will return the typical rt failure code. diff --git a/src/test/run-fail/rt-set-exit-status-fail2.rs b/src/test/run-fail/rt-set-exit-status-fail2.rs index 4f8e357bfd8..1cd6784cf42 100644 --- a/src/test/run-fail/rt-set-exit-status-fail2.rs +++ b/src/test/run-fail/rt-set-exit-status-fail2.rs @@ -12,7 +12,7 @@ class r { } fn main() { - log(error, "whatever"); + log(error, ~"whatever"); do task::spawn { let i = r(5); }; diff --git a/src/test/run-fail/rt-set-exit-status.rs b/src/test/run-fail/rt-set-exit-status.rs index 6b83256036b..c4e86715980 100644 --- a/src/test/run-fail/rt-set-exit-status.rs +++ b/src/test/run-fail/rt-set-exit-status.rs @@ -1,7 +1,7 @@ // error-pattern:whatever fn main() { - log(error, "whatever"); + log(error, ~"whatever"); // 101 is the code the runtime uses on task failure and the value // compiletest expects run-fail tests to return. os::set_exit_status(101); diff --git a/src/test/run-fail/run-unexported-tests.rs b/src/test/run-fail/run-unexported-tests.rs index c0512a4e213..3275e30eb5b 100644 --- a/src/test/run-fail/run-unexported-tests.rs +++ b/src/test/run-fail/run-unexported-tests.rs @@ -9,5 +9,5 @@ mod m { fn exported() { } #[test] - fn unexported() { fail "runned an unexported test"; } + fn unexported() { fail ~"runned an unexported test"; } } diff --git a/src/test/run-fail/str-overrun.rs b/src/test/run-fail/str-overrun.rs index 31346964d4c..b8bccfe82d4 100644 --- a/src/test/run-fail/str-overrun.rs +++ b/src/test/run-fail/str-overrun.rs @@ -2,7 +2,7 @@ // error-pattern:bounds check fn main() { - let s: str = "hello"; + let s: ~str = ~"hello"; // Bounds-check failure. assert (s[5] == 0x0 as u8); diff --git a/src/test/run-fail/task-comm-recv-block.rs b/src/test/run-fail/task-comm-recv-block.rs index 1e703bc47f9..f55758d7196 100644 --- a/src/test/run-fail/task-comm-recv-block.rs +++ b/src/test/run-fail/task-comm-recv-block.rs @@ -6,7 +6,7 @@ import comm; fn goodfail() { task::yield(); - fail "goodfail"; + fail ~"goodfail"; } fn main() { @@ -15,5 +15,5 @@ fn main() { // We shouldn't be able to get past this recv since there's no // message available let i: int = comm::recv(po); - fail "badfail"; + fail ~"badfail"; } diff --git a/src/test/run-fail/task-spawn-barefn.rs b/src/test/run-fail/task-spawn-barefn.rs index fe1b926160a..e9a20e81324 100644 --- a/src/test/run-fail/task-spawn-barefn.rs +++ b/src/test/run-fail/task-spawn-barefn.rs @@ -7,5 +7,5 @@ fn main() { } fn startfn() { - assert str::is_empty("Ensure that the child task runs by failing"); + assert str::is_empty(~"Ensure that the child task runs by failing"); } diff --git a/src/test/run-fail/too-much-recursion.rs b/src/test/run-fail/too-much-recursion.rs index 6939670ff0b..36dd47c373b 100644 --- a/src/test/run-fail/too-much-recursion.rs +++ b/src/test/run-fail/too-much-recursion.rs @@ -3,6 +3,6 @@ // Test that the task fails after hiting the recursion limit fn main() { - log(debug, "don't optimize me out"); + log(debug, ~"don't optimize me out"); main(); } \ No newline at end of file diff --git a/src/test/run-fail/unwind-alt.rs b/src/test/run-fail/unwind-alt.rs index 1cd512cfc41..751dc722fc8 100644 --- a/src/test/run-fail/unwind-alt.rs +++ b/src/test/run-fail/unwind-alt.rs @@ -4,8 +4,8 @@ fn test_box() { @0; } fn test_str() { - let res = alt check false { true { "happy" } }; - assert res == "happy"; + let res = alt check false { true { ~"happy" } }; + assert res == ~"happy"; } fn main() { test_box(); diff --git a/src/test/run-fail/unwind-box-str.rs b/src/test/run-fail/unwind-box-str.rs index 8da8043c854..fa28160d812 100644 --- a/src/test/run-fail/unwind-box-str.rs +++ b/src/test/run-fail/unwind-box-str.rs @@ -5,7 +5,7 @@ fn failfn() { } fn main() { - let x = @"hi"/~; + let x = @~"hi"; failfn(); log(error, x); } \ No newline at end of file diff --git a/src/test/run-fail/unwind-lambda.rs b/src/test/run-fail/unwind-lambda.rs index f76d710d502..d97c66b4b9b 100644 --- a/src/test/run-fail/unwind-lambda.rs +++ b/src/test/run-fail/unwind-lambda.rs @@ -1,16 +1,16 @@ // error-pattern:fail fn main() { - let cheese = "roquefort"; - let carrots = @"crunchy"/~; + let cheese = ~"roquefort"; + let carrots = @~"crunchy"; - fn@(tasties: @str/~, macerate: fn(str)) { + fn@(tasties: @~str, macerate: fn(~str)) { macerate(*tasties); } (carrots, |food| { let mush = food + cheese; let f = fn@() { let chew = mush + cheese; - fail "so yummy" + fail ~"so yummy" }; f(); }); diff --git a/src/test/run-fail/unwind-misc-1.rs b/src/test/run-fail/unwind-misc-1.rs index 72b176e80c5..7a0324a0f16 100644 --- a/src/test/run-fail/unwind-misc-1.rs +++ b/src/test/run-fail/unwind-misc-1.rs @@ -7,19 +7,19 @@ import uint; fn main() { let count = @mut 0u; - fn hash(&&s: ~[@str/~]) -> uint { - if (vec::len(s) > 0u && str::eq(*s[0], "boom")) { fail; } + fn hash(&&s: ~[@~str]) -> uint { + if (vec::len(s) > 0u && str::eq(*s[0], ~"boom")) { fail; } ret 10u; } - fn eq(&&s: ~[@str/~], &&t: ~[@str/~]) -> bool { + fn eq(&&s: ~[@~str], &&t: ~[@~str]) -> bool { ret s == t; } let map = map::hashmap(hash, eq); let mut arr = ~[]; for uint::range(0u, 10u) |i| { - arr += ~[@"key stuff"/~]; - map.insert(arr, arr + ~[@"value stuff"/~]); + arr += ~[@~"key stuff"]; + map.insert(arr, arr + ~[@~"value stuff"]); } - map.insert(~[@"boom"/~], ~[]); + map.insert(~[@~"boom"], ~[]); } diff --git a/src/test/run-fail/while-body-fails.rs b/src/test/run-fail/while-body-fails.rs index da241afe8a3..4e422fc095e 100644 --- a/src/test/run-fail/while-body-fails.rs +++ b/src/test/run-fail/while-body-fails.rs @@ -1,2 +1,2 @@ // error-pattern:quux -fn main() { let x: int = { while true { fail "quux"; } ; 8 } ; } +fn main() { let x: int = { while true { fail ~"quux"; } ; 8 } ; } diff --git a/src/test/run-fail/while-fail.rs b/src/test/run-fail/while-fail.rs index 3f1f9f3e655..8dc923ab60e 100644 --- a/src/test/run-fail/while-fail.rs +++ b/src/test/run-fail/while-fail.rs @@ -1,4 +1,4 @@ // error-pattern:giraffe fn main() { - fail { while true { fail "giraffe"}; "clandestine" }; + fail { while true { fail ~"giraffe"}; ~"clandestine" }; } diff --git a/src/test/run-fail/zip-different-lengths.rs b/src/test/run-fail/zip-different-lengths.rs index 91f9827a676..ae98291777a 100644 --- a/src/test/run-fail/zip-different-lengths.rs +++ b/src/test/run-fail/zip-different-lengths.rs @@ -32,5 +32,5 @@ fn main() { check (same_length(chars, ints)); let ps = zip(chars, ints); - fail "the impossible happened"; + fail ~"the impossible happened"; } diff --git a/src/test/run-pass-fulldeps/qquote.rs b/src/test/run-pass-fulldeps/qquote.rs index ecd9ee45034..171531c5fb8 100644 --- a/src/test/run-pass-fulldeps/qquote.rs +++ b/src/test/run-pass-fulldeps/qquote.rs @@ -32,65 +32,65 @@ fn main() { let ext_cx = mk_ctxt(); let abc = #ast{23}; - check_pp(abc, pprust::print_expr, "23"); + check_pp(abc, pprust::print_expr, ~"23"); let expr3 = #ast{2 - $(abc) + 7}; - check_pp(expr3, pprust::print_expr, "2 - 23 + 7"); + check_pp(expr3, pprust::print_expr, ~"2 - 23 + 7"); let expr4 = #ast{2 - $(#ast{3}) + 9}; - check_pp(expr4, pprust::print_expr, "2 - 3 + 9"); + check_pp(expr4, pprust::print_expr, ~"2 - 3 + 9"); let ty = #ast(ty){int}; - check_pp(ty, pprust::print_type, "int"); + check_pp(ty, pprust::print_type, ~"int"); let ty2 = #ast(ty){option<$(ty)>}; - check_pp(ty2, pprust::print_type, "option<int>"); + check_pp(ty2, pprust::print_type, ~"option<int>"); let item = #ast(item){const x : int = 10;}; - check_pp(item, pprust::print_item, "const x: int = 10;"); + check_pp(item, pprust::print_item, ~"const x: int = 10;"); let item2: @ast::item = #ast(item){const x : int = $(abc);}; - check_pp(item2, pprust::print_item, "const x: int = 23;"); + check_pp(item2, pprust::print_item, ~"const x: int = 23;"); let stmt = #ast(stmt){let x = 20;}; - check_pp(*stmt, pprust::print_stmt, "let x = 20;"); + check_pp(*stmt, pprust::print_stmt, ~"let x = 20;"); let stmt2 = #ast(stmt){let x : $(ty) = $(abc);}; - check_pp(*stmt2, pprust::print_stmt, "let x: int = 23;"); + check_pp(*stmt2, pprust::print_stmt, ~"let x: int = 23;"); let pat = #ast(pat){some(_)}; - check_pp(pat, pprust::print_pat, "some(_)"); + check_pp(pat, pprust::print_pat, ~"some(_)"); // issue #1785 let x = #ast{1}; let test1 = #ast{1+$(x)}; - check_pp(test1, pprust::print_expr, "1 + 1"); + check_pp(test1, pprust::print_expr, ~"1 + 1"); let test2 = #ast{$(x)+1}; - check_pp(test2, pprust::print_expr, "1 + 1"); + check_pp(test2, pprust::print_expr, ~"1 + 1"); let y = #ast{2}; let test3 = #ast{$(x) + $(y)}; - check_pp(test3, pprust::print_expr, "1 + 2"); + check_pp(test3, pprust::print_expr, ~"1 + 2"); let crate = #ast(crate) { fn a() { } }; - check_pp(crate, pprust::print_crate_, "fn a() { }\n"); + check_pp(crate, pprust::print_crate_, ~"fn a() { }\n"); // issue #1926 let s = #ast(expr){__s}; let e = #ast(expr){__e}; let call = #ast(expr){$(s).foo(|__e| $(e) )}; - check_pp(call, pprust::print_expr, "__s.foo(|__e| __e)") + check_pp(call, pprust::print_expr, ~"__s.foo(|__e| __e)") } -fn check_pp<T>(expr: T, f: fn(pprust::ps, T), expect: str) { +fn check_pp<T>(expr: T, f: fn(pprust::ps, T), expect: ~str) { let buf = mem_buffer(); let pp = pprust::rust_printer(buf as io::writer); f(pp, expr); pp::eof(pp.s); let str = mem_buffer_str(buf); stdout().write_line(str); - if expect != "" { + if expect != ~"" { #error("expect: '%s', got: '%s'", expect, str); assert str == expect; } diff --git a/src/test/run-pass/alias-uninit-value.rs b/src/test/run-pass/alias-uninit-value.rs index 0679022d37a..866ed58f842 100644 --- a/src/test/run-pass/alias-uninit-value.rs +++ b/src/test/run-pass/alias-uninit-value.rs @@ -7,10 +7,10 @@ import option::none; enum sty { ty_nil, } -type raw_t = {struct: sty, cname: option<str>, hash: uint}; +type raw_t = {struct: sty, cname: option<~str>, hash: uint}; -fn mk_raw_ty(st: sty, cname: option<str>) -> raw_t { +fn mk_raw_ty(st: sty, cname: option<~str>) -> raw_t { ret {struct: st, cname: cname, hash: 0u}; } -fn main() { mk_raw_ty(ty_nil, none::<str>); } +fn main() { mk_raw_ty(ty_nil, none::<~str>); } diff --git a/src/test/run-pass/alt-range.rs b/src/test/run-pass/alt-range.rs index e85a82a2fd4..29bbc452d47 100644 --- a/src/test/run-pass/alt-range.rs +++ b/src/test/run-pass/alt-range.rs @@ -1,30 +1,30 @@ fn main() { alt 5u { 1u to 5u {} - _ { fail "should match range"; } + _ { fail ~"should match range"; } } alt 5u { - 6u to 7u { fail "shouldn't match range"; } + 6u to 7u { fail ~"shouldn't match range"; } _ {} } alt check 5u { - 1u { fail "should match non-first range"; } + 1u { fail ~"should match non-first range"; } 2u to 6u {} } alt 'c' { 'a' to 'z' {} - _ { fail "should suppport char ranges"; } + _ { fail ~"should suppport char ranges"; } } alt -3 { -7 to 5 {} - _ { fail "should match signed range"; } + _ { fail ~"should match signed range"; } } alt 3.0 { 1.0 to 5.0 {} - _ { fail "should match float range"; } + _ { fail ~"should match float range"; } } alt -1.5 { -3.6 to 3.6 {} - _ { fail "should match negative float range"; } + _ { fail ~"should match negative float range"; } } } diff --git a/src/test/run-pass/alt-str.rs b/src/test/run-pass/alt-str.rs index c0a096cc2c9..708932b2e1a 100644 --- a/src/test/run-pass/alt-str.rs +++ b/src/test/run-pass/alt-str.rs @@ -1,21 +1,21 @@ // Issue #53 fn main() { - alt check "test" { "not-test" { fail; } "test" { } _ { fail; } } + alt check ~"test" { ~"not-test" { fail; } ~"test" { } _ { fail; } } - enum t { tag1(str), tag2, } + enum t { tag1(~str), tag2, } - alt tag1("test") { + alt tag1(~"test") { tag2 { fail; } - tag1("not-test") { fail; } - tag1("test") { } + tag1(~"not-test") { fail; } + tag1(~"test") { } _ { fail; } } - let x = alt check "a" { "a" { 1 } "b" { 2 } }; + let x = alt check ~"a" { ~"a" { 1 } ~"b" { 2 } }; assert (x == 1); - alt check "a" { "a" { } "b" { } } + alt check ~"a" { ~"a" { } ~"b" { } } } diff --git a/src/test/run-pass/alt-with-ret-arm.rs b/src/test/run-pass/alt-with-ret-arm.rs index 20fe17d4847..b12841dd229 100644 --- a/src/test/run-pass/alt-with-ret-arm.rs +++ b/src/test/run-pass/alt-with-ret-arm.rs @@ -2,7 +2,7 @@ fn main() { // sometimes we have had trouble finding // the right type for f, as we unified // bot and u32 here - let f = alt uint::from_str("1234") { + let f = alt uint::from_str(~"1234") { none { ret () } some(num) { num as u32 } }; diff --git a/src/test/run-pass/argv.rs b/src/test/run-pass/argv.rs index fa2a05365e9..79d7e4e5b0f 100644 --- a/src/test/run-pass/argv.rs +++ b/src/test/run-pass/argv.rs @@ -1,5 +1,5 @@ -fn main(args: ~[str]) { - let vs: ~[str] = ~["hi", "there", "this", "is", "a", "vec"]; - let vvs: ~[~[str]] = ~[args, vs]; +fn main(args: ~[~str]) { + let vs: ~[~str] = ~[~"hi", ~"there", ~"this", ~"is", ~"a", ~"vec"]; + let vvs: ~[~[~str]] = ~[args, vs]; for vvs.each |vs| { for vs.each |s| { log(debug, s); } } } diff --git a/src/test/run-pass/auto_serialize.rs b/src/test/run-pass/auto_serialize.rs index 5e9c22d0509..1f1c2a6c707 100644 --- a/src/test/run-pass/auto_serialize.rs +++ b/src/test/run-pass/auto_serialize.rs @@ -11,7 +11,7 @@ import std::ebml::deserializer; import std::serialization::{serialize_uint, deserialize_uint}; fn test_ser_and_deser<A>(a1: A, - expected: str, + expected: ~str, ebml_ser_fn: fn(ebml::writer, A), ebml_deser_fn: fn(ebml::ebml_deserializer) -> A, io_ser_fn: fn(io::writer, A)) { @@ -28,11 +28,11 @@ fn test_ser_and_deser<A>(a1: A, ebml_ser_fn(w, a1); let d = ebml::doc(@io::mem_buffer_buf(buf)); let a2 = ebml_deser_fn(ebml::ebml_deserializer(d)); - io::print("\na1 = "); + io::print(~"\na1 = "); io_ser_fn(io::stdout(), a1); - io::print("\na2 = "); + io::print(~"\na2 = "); io_ser_fn(io::stdout(), a2); - io::print("\n"); + io::print(~"\n"); assert a1 == a2; } @@ -79,56 +79,56 @@ fn main() { test_ser_and_deser(plus(@minus(@val(3u), @val(10u)), @plus(@val(22u), @val(5u))), - "plus(@minus(@val(3u), @val(10u)), \ + ~"plus(@minus(@val(3u), @val(10u)), \ @plus(@val(22u), @val(5u)))", serialize_expr, deserialize_expr, serialize_expr); test_ser_and_deser({lo: 0u, hi: 5u, node: 22u}, - "{lo: 0u, hi: 5u, node: 22u}", + ~"{lo: 0u, hi: 5u, node: 22u}", serialize_spanned_uint, deserialize_spanned_uint, serialize_spanned_uint); test_ser_and_deser(an_enum({v: ~[1u, 2u, 3u]}), - "an_enum({v: [1u, 2u, 3u]})", + ~"an_enum({v: [1u, 2u, 3u]})", serialize_an_enum, deserialize_an_enum, serialize_an_enum); test_ser_and_deser({x: 3u, y: 5u}, - "{x: 3u, y: 5u}", + ~"{x: 3u, y: 5u}", serialize_point, deserialize_point, serialize_point); test_ser_and_deser(~[1u, 2u, 3u], - "[1u, 2u, 3u]", + ~"[1u, 2u, 3u]", serialize_uint_vec, deserialize_uint_vec, serialize_uint_vec); test_ser_and_deser(top(22u), - "top(22u)", + ~"top(22u)", serialize_uint_quark, deserialize_uint_quark, serialize_uint_quark); test_ser_and_deser(bottom(222u), - "bottom(222u)", + ~"bottom(222u)", serialize_uint_quark, deserialize_uint_quark, serialize_uint_quark); test_ser_and_deser(a, - "a", + ~"a", serialize_c_like, deserialize_c_like, serialize_c_like); test_ser_and_deser(b, - "b", + ~"b", serialize_c_like, deserialize_c_like, serialize_c_like); diff --git a/src/test/run-pass/autobind.rs b/src/test/run-pass/autobind.rs index 1a50b3ba3e6..4b8f33e45bb 100644 --- a/src/test/run-pass/autobind.rs +++ b/src/test/run-pass/autobind.rs @@ -4,6 +4,6 @@ fn g(act: fn(~[int]) -> int) -> int { ret act(~[1, 2, 3]); } fn main() { assert (g(f) == 1); - let f1: fn(~[str]) -> str = f; - assert (f1(~["x", "y", "z"]) == "x"); + let f1: fn(~[~str]) -> ~str = f; + assert (f1(~[~"x", ~"y", ~"z"]) == ~"x"); } diff --git a/src/test/run-pass/basic.rs b/src/test/run-pass/basic.rs index 9c2b4311b90..b0fa0e3576e 100644 --- a/src/test/run-pass/basic.rs +++ b/src/test/run-pass/basic.rs @@ -20,7 +20,7 @@ fn a(c: chan<int>) { fn k(x: int) -> int { ret 15; } -fn g(x: int, y: str) -> int { +fn g(x: int, y: ~str) -> int { log(debug, x); log(debug, y); let z: int = k(1); @@ -29,7 +29,7 @@ fn g(x: int, y: str) -> int { fn main() { let mut n: int = 2 + 3 * 7; - let s: str = "hello there"; + let s: ~str = ~"hello there"; let p = comm::port(); let ch = comm::chan(p); task::spawn(|| a(ch) ); diff --git a/src/test/run-pass/block-arg.rs b/src/test/run-pass/block-arg.rs index 2bcdcfccdfd..cebafd03f00 100644 --- a/src/test/run-pass/block-arg.rs +++ b/src/test/run-pass/block-arg.rs @@ -25,14 +25,14 @@ fn main() { assert false; } alt do vec::all(v) |e| { float::is_negative(e) } { - true { fail "incorrect answer."; } + true { fail ~"incorrect answer."; } false { } } alt 3 { _ if do vec::any(v) |e| { float::is_negative(e) } { } _ { - fail "wrong answer."; + fail ~"wrong answer."; } } diff --git a/src/test/run-pass/block-explicit-types.rs b/src/test/run-pass/block-explicit-types.rs index ca6fe9b659d..3e87bbbe659 100644 --- a/src/test/run-pass/block-explicit-types.rs +++ b/src/test/run-pass/block-explicit-types.rs @@ -1,4 +1,4 @@ fn main() { - fn as_buf<T>(s: str, f: fn(str) -> T) -> T { f(s) } - as_buf("foo", |foo: str| -> () log(error, foo) ); + fn as_buf<T>(s: ~str, f: fn(~str) -> T) -> T { f(s) } + as_buf(~"foo", |foo: ~str| -> () log(error, foo) ); } diff --git a/src/test/run-pass/box-compare.rs b/src/test/run-pass/box-compare.rs index 3102166b390..5cfb4e0009e 100644 --- a/src/test/run-pass/box-compare.rs +++ b/src/test/run-pass/box-compare.rs @@ -2,6 +2,6 @@ fn main() { assert (@1 < @3); - assert (@@"hello "/~ > @@"hello"/~); - assert (@@@"hello"/~ != @@@"there"/~); + assert (@@~"hello " > @@~"hello"); + assert (@@@~"hello" != @@@~"there"); } diff --git a/src/test/run-pass/c-stack-returning-int64.rs b/src/test/run-pass/c-stack-returning-int64.rs index 4c7c2af982b..8af9f6d2599 100644 --- a/src/test/run-pass/c-stack-returning-int64.rs +++ b/src/test/run-pass/c-stack-returning-int64.rs @@ -8,16 +8,16 @@ extern mod libc { fn atoll(x: *u8) -> i64; } -fn atol(s: str) -> int { +fn atol(s: ~str) -> int { ret str::as_buf(s, { |x| libc::atol(x) }); } -fn atoll(s: str) -> i64 { +fn atoll(s: ~str) -> i64 { ret str::as_buf(s, { |x| libc::atoll(x) }); } fn main() { - assert atol("1024") * 10 == atol("10240"); - assert (atoll("11111111111111111") * 10i64) - == atoll("111111111111111110"); + assert atol(~"1024") * 10 == atol(~"10240"); + assert (atoll(~"11111111111111111") * 10i64) + == atoll(~"111111111111111110"); } diff --git a/src/test/run-pass/cci_nested_exe.rs b/src/test/run-pass/cci_nested_exe.rs index cf75dd6c57b..de1d6e69fcb 100644 --- a/src/test/run-pass/cci_nested_exe.rs +++ b/src/test/run-pass/cci_nested_exe.rs @@ -6,14 +6,14 @@ import cci_nested_lib::*; fn main() { let lst = new_int_alist(); - alist_add(lst, 22, "hi"); - alist_add(lst, 44, "ho"); - assert alist_get(lst, 22) == "hi"; - assert alist_get(lst, 44) == "ho"; + alist_add(lst, 22, ~"hi"); + alist_add(lst, 44, ~"ho"); + assert alist_get(lst, 22) == ~"hi"; + assert alist_get(lst, 44) == ~"ho"; let lst = new_int_alist_2(); - alist_add(lst, 22, "hi"); - alist_add(lst, 44, "ho"); - assert alist_get(lst, 22) == "hi"; - assert alist_get(lst, 44) == "ho"; + alist_add(lst, 22, ~"hi"); + alist_add(lst, 44, ~"ho"); + assert alist_get(lst, 22) == ~"hi"; + assert alist_get(lst, 44) == ~"ho"; } diff --git a/src/test/run-pass/check-pattern-bound.rs b/src/test/run-pass/check-pattern-bound.rs index fe8a650afe2..936947701ad 100644 --- a/src/test/run-pass/check-pattern-bound.rs +++ b/src/test/run-pass/check-pattern-bound.rs @@ -5,5 +5,5 @@ pure fn p(x: int) -> bool { true } fn f(x: int) : p(x) { } fn main() { - alt some(5) { some(y) { check (p(y)); f(y); } _ { fail "yuck"; } } + alt some(5) { some(y) { check (p(y)); f(y); } _ { fail ~"yuck"; } } } diff --git a/src/test/run-pass/child-outlives-parent.rs b/src/test/run-pass/child-outlives-parent.rs index 1c3ad872477..4342d40262c 100644 --- a/src/test/run-pass/child-outlives-parent.rs +++ b/src/test/run-pass/child-outlives-parent.rs @@ -3,6 +3,6 @@ use std; import task; -fn child2(&&s: str) { } +fn child2(&&s: ~str) { } -fn main() { let x = task::spawn(|| child2("hi") ); } +fn main() { let x = task::spawn(|| child2(~"hi") ); } diff --git a/src/test/run-pass/class-cast-to-iface-cross-crate-2.rs b/src/test/run-pass/class-cast-to-iface-cross-crate-2.rs index 2e4dc4f32b3..0afe1cedfaa 100644 --- a/src/test/run-pass/class-cast-to-iface-cross-crate-2.rs +++ b/src/test/run-pass/class-cast-to-iface-cross-crate-2.rs @@ -4,14 +4,14 @@ use cci_class_cast; import to_str::to_str; import cci_class_cast::kitty::*; -fn print_out<T: to_str>(thing: T, expected: str) { +fn print_out<T: to_str>(thing: T, expected: ~str) { let actual = thing.to_str(); #debug("%s", actual); assert(actual == expected); } fn main() { - let nyan : to_str = cat(0u, 2, "nyan") as to_str; - print_out(nyan, "nyan"); + let nyan : to_str = cat(0u, 2, ~"nyan") as to_str; + print_out(nyan, ~"nyan"); } diff --git a/src/test/run-pass/class-cast-to-iface-multiple-types.rs b/src/test/run-pass/class-cast-to-iface-multiple-types.rs index 89f5e656a68..23d0a203a70 100644 --- a/src/test/run-pass/class-cast-to-iface-multiple-types.rs +++ b/src/test/run-pass/class-cast-to-iface-multiple-types.rs @@ -40,9 +40,9 @@ class cat : noisy { } let how_hungry : @mut int; - let name : str; + let name : ~str; - new(in_x : uint, in_y : int, in_name: str) + new(in_x : uint, in_y : int, in_name: ~str) { self.meows = @mut in_x; self.how_hungry = @mut in_y; self.name = in_name; } @@ -55,7 +55,7 @@ fn annoy_neighbors<T: noisy>(critter: T) { } fn main() { - let nyan : cat = cat(0u, 2, "nyan"); + let nyan : cat = cat(0u, 2, ~"nyan"); let whitefang : dog = dog(); annoy_neighbors(nyan as noisy); annoy_neighbors(whitefang as noisy); diff --git a/src/test/run-pass/class-cast-to-iface.rs b/src/test/run-pass/class-cast-to-iface.rs index 10222acc45a..e35152bd1d9 100644 --- a/src/test/run-pass/class-cast-to-iface.rs +++ b/src/test/run-pass/class-cast-to-iface.rs @@ -15,9 +15,9 @@ class cat : noisy { } let mut how_hungry : int; - let name : str; + let name : ~str; - new(in_x : uint, in_y : int, in_name: str) + new(in_x : uint, in_y : int, in_name: ~str) { self.meows = in_x; self.how_hungry = in_y; self.name = in_name; } fn speak() { self.meow(); } @@ -36,6 +36,6 @@ class cat : noisy { } fn main() { - let nyan : noisy = cat(0u, 2, "nyan") as noisy; + let nyan : noisy = cat(0u, 2, ~"nyan") as noisy; nyan.speak(); } \ No newline at end of file diff --git a/src/test/run-pass/class-exports.rs b/src/test/run-pass/class-exports.rs index 8753553d8de..b9f99f2076d 100644 --- a/src/test/run-pass/class-exports.rs +++ b/src/test/run-pass/class-exports.rs @@ -7,13 +7,13 @@ mod kitty { export cat; class cat { let meows: uint; - let name: str; + let name: ~str; - fn get_name() -> str { self.name } - new(in_name: str) { self.name = in_name; self.meows = 0u; } + fn get_name() -> ~str { self.name } + new(in_name: ~str) { self.name = in_name; self.meows = 0u; } } } fn main() { - assert(cat("Spreckles").get_name() == "Spreckles"); + assert(cat(~"Spreckles").get_name() == ~"Spreckles"); } \ No newline at end of file diff --git a/src/test/run-pass/class-impl-very-parameterized-iface.rs b/src/test/run-pass/class-impl-very-parameterized-iface.rs index 8d710d0e6b4..425364945f0 100644 --- a/src/test/run-pass/class-impl-very-parameterized-iface.rs +++ b/src/test/run-pass/class-impl-very-parameterized-iface.rs @@ -49,7 +49,7 @@ class cat<T: copy> : map<int, T> { fn get(&&k:int) -> T { alt self.find(k) { some(v) { v } - none { fail "epic fail"; } + none { fail ~"epic fail"; } } } fn [](&&k:int) -> T { self.get(k) } @@ -87,9 +87,9 @@ class cat<T: copy> : map<int, T> { fn main() { - let nyan : cat<str> = cat(0, 2, "nyan"); + let nyan : cat<~str> = cat(0, 2, ~"nyan"); for uint::range(1u, 5u) |_i| { nyan.speak(); } - assert(nyan.find(1) == some("nyan")); + assert(nyan.find(1) == some(~"nyan")); assert(nyan.find(10) == none); let spotty : cat<cat_type> = cat(2, 57, tuxedo); for uint::range(0u, 6u) |_i| { spotty.speak(); } diff --git a/src/test/run-pass/class-implement-iface-cross-crate.rs b/src/test/run-pass/class-implement-iface-cross-crate.rs index 5a778217b5f..a8a22f44447 100644 --- a/src/test/run-pass/class-implement-iface-cross-crate.rs +++ b/src/test/run-pass/class-implement-iface-cross-crate.rs @@ -16,9 +16,9 @@ class cat : noisy { } let mut how_hungry : int; - let name : str; + let name : ~str; - new(in_x : uint, in_y : int, in_name: str) + new(in_x : uint, in_y : int, in_name: ~str) { self.meows = in_x; self.how_hungry = in_y; self.name = in_name; } fn speak() { self.meow(); } @@ -37,7 +37,7 @@ class cat : noisy { } fn main() { - let nyan = cat(0u, 2, "nyan"); + let nyan = cat(0u, 2, ~"nyan"); nyan.eat(); assert(!nyan.eat()); for uint::range(1u, 10u) |_i| { nyan.speak(); }; diff --git a/src/test/run-pass/class-implement-ifaces.rs b/src/test/run-pass/class-implement-ifaces.rs index 1f592323488..c506e031c98 100644 --- a/src/test/run-pass/class-implement-ifaces.rs +++ b/src/test/run-pass/class-implement-ifaces.rs @@ -15,9 +15,9 @@ class cat : noisy { } let mut how_hungry : int; - let name : str; + let name : ~str; - new(in_x : uint, in_y : int, in_name: str) + new(in_x : uint, in_y : int, in_name: ~str) { self.meows = in_x; self.how_hungry = in_y; self.name = in_name; } fn speak() { self.meow(); } @@ -40,7 +40,7 @@ fn make_speak<C: noisy>(c: C) { } fn main() { - let nyan = cat(0u, 2, "nyan"); + let nyan = cat(0u, 2, ~"nyan"); nyan.eat(); assert(!nyan.eat()); for uint::range(1u, 10u) |_i| { make_speak(nyan); }; diff --git a/src/test/run-pass/class-poly-methods-cross-crate.rs b/src/test/run-pass/class-poly-methods-cross-crate.rs index 1703ad035c8..8789489336d 100644 --- a/src/test/run-pass/class-poly-methods-cross-crate.rs +++ b/src/test/run-pass/class-poly-methods-cross-crate.rs @@ -5,11 +5,11 @@ import cci_class_6::kitties::*; fn main() { let nyan : cat<char> = cat::<char>(52u, 99, ~['p']); - let kitty = cat(1000u, 2, ~["tabby"]); + let kitty = cat(1000u, 2, ~[~"tabby"]); assert(nyan.how_hungry == 99); assert(kitty.how_hungry == 2); nyan.speak(~[1u,2u,3u]); assert(nyan.meow_count() == 55u); - kitty.speak(~["meow", "mew", "purr", "chirp"]); + kitty.speak(~[~"meow", ~"mew", ~"purr", ~"chirp"]); assert(kitty.meow_count() == 1004u); } diff --git a/src/test/run-pass/class-poly-methods.rs b/src/test/run-pass/class-poly-methods.rs index d40e2441b69..5808b0789d1 100644 --- a/src/test/run-pass/class-poly-methods.rs +++ b/src/test/run-pass/class-poly-methods.rs @@ -18,11 +18,11 @@ class cat<U> { fn main() { let nyan : cat<int> = cat::<int>(52u, 99, ~[9]); - let kitty = cat(1000u, 2, ~["tabby"]); + let kitty = cat(1000u, 2, ~[~"tabby"]); assert(nyan.how_hungry == 99); assert(kitty.how_hungry == 2); nyan.speak(~[1,2,3]); assert(nyan.meow_count() == 55u); - kitty.speak(~["meow", "mew", "purr", "chirp"]); + kitty.speak(~[~"meow", ~"mew", ~"purr", ~"chirp"]); assert(kitty.meow_count() == 1004u); } diff --git a/src/test/run-pass/class-separate-impl.rs b/src/test/run-pass/class-separate-impl.rs index 905ac9626f6..82f46c74874 100644 --- a/src/test/run-pass/class-separate-impl.rs +++ b/src/test/run-pass/class-separate-impl.rs @@ -15,9 +15,9 @@ class cat { } let mut how_hungry : int; - let name : str; + let name : ~str; - new(in_x : uint, in_y : int, in_name: str) + new(in_x : uint, in_y : int, in_name: ~str) { self.meows = in_x; self.how_hungry = in_y; self.name = in_name; } fn speak() { self.meow(); } @@ -36,16 +36,16 @@ class cat { } impl of to_str for cat { - fn to_str() -> str { self.name } + fn to_str() -> ~str { self.name } } -fn print_out<T: to_str>(thing: T, expected: str) { +fn print_out<T: to_str>(thing: T, expected: ~str) { let actual = thing.to_str(); #debug("%s", actual); assert(actual == expected); } fn main() { - let nyan : to_str = cat(0u, 2, "nyan") as to_str; - print_out(nyan, "nyan"); + let nyan : to_str = cat(0u, 2, ~"nyan") as to_str; + print_out(nyan, ~"nyan"); } diff --git a/src/test/run-pass/class-str-field.rs b/src/test/run-pass/class-str-field.rs index fab99f25910..e0f7441db85 100644 --- a/src/test/run-pass/class-str-field.rs +++ b/src/test/run-pass/class-str-field.rs @@ -1,11 +1,11 @@ class cat { - let name : str; + let name : ~str; - new(in_name: str) + new(in_name: ~str) { self.name = in_name; } } fn main() { - let nyan = cat("nyan"); + let nyan = cat(~"nyan"); } \ No newline at end of file diff --git a/src/test/run-pass/classes-cross-crate.rs b/src/test/run-pass/classes-cross-crate.rs index 5e454368e47..1f71c240590 100644 --- a/src/test/run-pass/classes-cross-crate.rs +++ b/src/test/run-pass/classes-cross-crate.rs @@ -4,7 +4,7 @@ use cci_class_4; import cci_class_4::kitties::*; fn main() { - let nyan = cat(0u, 2, "nyan"); + let nyan = cat(0u, 2, ~"nyan"); nyan.eat(); assert(!nyan.eat()); for uint::range(1u, 10u) |_i| { nyan.speak(); }; diff --git a/src/test/run-pass/classes.rs b/src/test/run-pass/classes.rs index d7aaf6e3b04..697b4c79676 100644 --- a/src/test/run-pass/classes.rs +++ b/src/test/run-pass/classes.rs @@ -11,9 +11,9 @@ class cat { } let mut how_hungry : int; - let name : str; + let name : ~str; - new(in_x : uint, in_y : int, in_name: str) + new(in_x : uint, in_y : int, in_name: ~str) { self.meows = in_x; self.how_hungry = in_y; self.name = in_name; } fn speak() { self.meow(); } @@ -32,7 +32,7 @@ class cat { } fn main() { - let nyan = cat(0u, 2, "nyan"); + let nyan = cat(0u, 2, ~"nyan"); nyan.eat(); assert(!nyan.eat()); for uint::range(1u, 10u) |_i| { nyan.speak(); }; diff --git a/src/test/run-pass/command-line-args.rs b/src/test/run-pass/command-line-args.rs index 0bffb268762..16e0951d238 100644 --- a/src/test/run-pass/command-line-args.rs +++ b/src/test/run-pass/command-line-args.rs @@ -1,3 +1,3 @@ -fn main(args: ~[str]) { log(debug, args[0]); } +fn main(args: ~[~str]) { log(debug, args[0]); } diff --git a/src/test/run-pass/companionmod-src/b/x.rs b/src/test/run-pass/companionmod-src/b/x.rs index 413b834fb11..d81ff2ba9a5 100644 --- a/src/test/run-pass/companionmod-src/b/x.rs +++ b/src/test/run-pass/companionmod-src/b/x.rs @@ -1 +1 @@ -fn f() -> str { "ralph" } \ No newline at end of file +fn f() -> ~str { ~"ralph" } \ No newline at end of file diff --git a/src/test/run-pass/companionmod-src/d/x.rs b/src/test/run-pass/companionmod-src/d/x.rs index 94f006f9a1f..b27e39327f1 100644 --- a/src/test/run-pass/companionmod-src/d/x.rs +++ b/src/test/run-pass/companionmod-src/d/x.rs @@ -1 +1 @@ -fn f() -> str { "nelson" } \ No newline at end of file +fn f() -> ~str { ~"nelson" } \ No newline at end of file diff --git a/src/test/run-pass/companionmod.rs b/src/test/run-pass/companionmod.rs index 9b9d1a00f0f..99c21e06d3a 100644 --- a/src/test/run-pass/companionmod.rs +++ b/src/test/run-pass/companionmod.rs @@ -2,6 +2,6 @@ // xfail-test fn main() { - assert a::b::g() == "ralph"; - assert a::c::g() == "nelson"; + assert a::b::g() == ~"ralph"; + assert a::c::g() == ~"nelson"; } \ No newline at end of file diff --git a/src/test/run-pass/complex.rs b/src/test/run-pass/complex.rs index c715f3b677b..3ac0c75da11 100644 --- a/src/test/run-pass/complex.rs +++ b/src/test/run-pass/complex.rs @@ -6,18 +6,18 @@ type t = int; fn nothing() { } -fn putstr(s: str) { } +fn putstr(s: ~str) { } fn putint(i: int) { let mut i: int = 33; - while i < 36 { putstr("hi"); i = i + 1; } + while i < 36 { putstr(~"hi"); i = i + 1; } } fn zerg(i: int) -> int { ret i; } fn foo(x: int) -> int { let mut y: t = x + 2; - putstr("hello"); + putstr(~"hello"); while y < 10 { putint(y); if y * 3 == 4 { y = y + 2; nothing(); } } let mut z: t; z = 0x55; diff --git a/src/test/run-pass/const-bound.rs b/src/test/run-pass/const-bound.rs index 36ca25cd1bb..e5e60f184f2 100644 --- a/src/test/run-pass/const-bound.rs +++ b/src/test/run-pass/const-bound.rs @@ -6,7 +6,7 @@ fn foo<T: copy const>(x: T) -> T { x } fn main() { foo(1); - foo("hi"); + foo(~"hi"); foo(~[1, 2, 3]); foo({field: 42}); foo((1, 2u)); diff --git a/src/test/run-pass/crate-method-reexport-grrrrrrr.rs b/src/test/run-pass/crate-method-reexport-grrrrrrr.rs index 3325b36bc3f..8d5260290b4 100644 --- a/src/test/run-pass/crate-method-reexport-grrrrrrr.rs +++ b/src/test/run-pass/crate-method-reexport-grrrrrrr.rs @@ -12,5 +12,5 @@ fn main() { let x = @(); x.cx(); let y = (); - y.add("hi"); + y.add(~"hi"); } diff --git a/src/test/run-pass/drop-on-ret.rs b/src/test/run-pass/drop-on-ret.rs index 821601baae8..16722714bc3 100644 --- a/src/test/run-pass/drop-on-ret.rs +++ b/src/test/run-pass/drop-on-ret.rs @@ -2,6 +2,6 @@ // -*- rust -*- -fn f() -> int { if true { let s: str = "should not leak"; ret 1; } ret 0; } +fn f() -> int { if true { let s: ~str = ~"should not leak"; ret 1; } ret 0; } fn main() { f(); } diff --git a/src/test/run-pass/enum-disr-val-pretty.rs b/src/test/run-pass/enum-disr-val-pretty.rs index b050b4d2b86..89c916b6c72 100644 --- a/src/test/run-pass/enum-disr-val-pretty.rs +++ b/src/test/run-pass/enum-disr-val-pretty.rs @@ -3,13 +3,13 @@ enum color { red = 1, green, blue, imaginary = -1, } fn main() { - test_color(red, 1, "red"); - test_color(green, 2, "green"); - test_color(blue, 3, "blue"); - test_color(imaginary, -1, "imaginary"); + test_color(red, 1, ~"red"); + test_color(green, 2, ~"green"); + test_color(blue, 3, ~"blue"); + test_color(imaginary, -1, ~"imaginary"); } -fn test_color(color: color, val: int, name: str) { +fn test_color(color: color, val: int, name: ~str) { assert color as int == val; assert color as float == val as float; } diff --git a/src/test/run-pass/estr-shared.rs b/src/test/run-pass/estr-shared.rs index 6fc0f296d8d..b853d855030 100644 --- a/src/test/run-pass/estr-shared.rs +++ b/src/test/run-pass/estr-shared.rs @@ -1,4 +1,4 @@ // xfail-test fn main() { - let x : str/@ = "hello"/@; + let x : @str = @"hello"; } diff --git a/src/test/run-pass/estr-slice.rs b/src/test/run-pass/estr-slice.rs index af31e546c6a..6af1dee8926 100644 --- a/src/test/run-pass/estr-slice.rs +++ b/src/test/run-pass/estr-slice.rs @@ -1,8 +1,8 @@ fn main() { - let x = "hello"/&; - let v = "hello"/&; - let mut y : str/& = "there"/&; + let x = &"hello"; + let v = &"hello"; + let mut y : &str = &"there"; log(debug, x); log(debug, y); @@ -10,14 +10,14 @@ fn main() { assert x[0] == 'h' as u8; assert x[4] == 'o' as u8; - let z : str/& = "thing"/&; + let z : &str = &"thing"; assert v == x; assert x != z; - let a = "aaaa"/&; - let b = "bbbb"/&; - let c = "cccc"/&; - let cc = "ccccc"/&; + let a = &"aaaa"; + let b = &"bbbb"; + let c = &"cccc"; + let cc = &"ccccc"; log(debug, a); diff --git a/src/test/run-pass/estr-uniq.rs b/src/test/run-pass/estr-uniq.rs index 07b7fcf58d6..bd6641a93de 100644 --- a/src/test/run-pass/estr-uniq.rs +++ b/src/test/run-pass/estr-uniq.rs @@ -1,7 +1,7 @@ fn main() { - let x : str/~ = "hello"/~; - let _y : str/~ = "there"/~; - let mut z = "thing"/~; + let x : ~str = ~"hello"; + let _y : ~str = ~"there"; + let mut z = ~"thing"; z = x; assert z[0] == ('h' as u8); assert z[4] == ('o' as u8); diff --git a/src/test/run-pass/exec-env.rs b/src/test/run-pass/exec-env.rs index cddcd4987e5..86960fbad1f 100644 --- a/src/test/run-pass/exec-env.rs +++ b/src/test/run-pass/exec-env.rs @@ -2,5 +2,5 @@ // exec-env:TEST_EXEC_ENV=22 fn main() { - assert os::getenv("TEST_EXEC_ENV") == some("22"); + assert os::getenv(~"TEST_EXEC_ENV") == some(~"22"); } diff --git a/src/test/run-pass/expr-alt-box.rs b/src/test/run-pass/expr-alt-box.rs index 93a65d62977..9953838b274 100644 --- a/src/test/run-pass/expr-alt-box.rs +++ b/src/test/run-pass/expr-alt-box.rs @@ -10,8 +10,8 @@ fn test_box() { } fn test_str() { - let res = alt check true { true { "happy" } }; - assert (res == "happy"); + let res = alt check true { true { ~"happy" } }; + assert (res == ~"happy"); } fn main() { test_box(); test_str(); } diff --git a/src/test/run-pass/expr-if-box.rs b/src/test/run-pass/expr-if-box.rs index 7d9e2320e93..d5352851516 100644 --- a/src/test/run-pass/expr-if-box.rs +++ b/src/test/run-pass/expr-if-box.rs @@ -10,8 +10,8 @@ fn test_box() { } fn test_str() { - let rs = if true { "happy" } else { "sad" }; - assert (rs == "happy"); + let rs = if true { ~"happy" } else { ~"sad" }; + assert (rs == ~"happy"); } fn main() { test_box(); test_str(); } diff --git a/src/test/run-pass/fixed_length_vec_glue.rs b/src/test/run-pass/fixed_length_vec_glue.rs index b8d894bef7d..017a17684ec 100644 --- a/src/test/run-pass/fixed_length_vec_glue.rs +++ b/src/test/run-pass/fixed_length_vec_glue.rs @@ -2,5 +2,5 @@ fn main() { let arr = [1,2,3]/3; let struct = {a: 13u8, b: arr, c: 42}; let s = sys::log_str(struct); - assert(s == "(13, [1, 2, 3]/3, 42)"); + assert(s == ~"(13, [1, 2, 3]/3, 42)"); } diff --git a/src/test/run-pass/for-loop-fail.rs b/src/test/run-pass/for-loop-fail.rs index 82551bbc6ff..6edebcbabd6 100644 --- a/src/test/run-pass/for-loop-fail.rs +++ b/src/test/run-pass/for-loop-fail.rs @@ -1 +1 @@ -fn main() { let x: ~[int] = ~[]; for x.each |_i| { fail "moop"; } } +fn main() { let x: ~[int] = ~[]; for x.each |_i| { fail ~"moop"; } } diff --git a/src/test/run-pass/foreign-dupe.rs b/src/test/run-pass/foreign-dupe.rs index ab6a7320e45..b780e95f544 100644 --- a/src/test/run-pass/foreign-dupe.rs +++ b/src/test/run-pass/foreign-dupe.rs @@ -4,13 +4,13 @@ #[abi = "cdecl"] #[link_name = "rustrt"] extern mod rustrt1 { - fn last_os_error() -> str; + fn last_os_error() -> ~str; } #[abi = "cdecl"] #[link_name = "rustrt"] extern mod rustrt2 { - fn last_os_error() -> str; + fn last_os_error() -> ~str; } fn main() { diff --git a/src/test/run-pass/foreign-fn-linkname.rs b/src/test/run-pass/foreign-fn-linkname.rs index 46fa8cf97cd..010df0158ed 100644 --- a/src/test/run-pass/foreign-fn-linkname.rs +++ b/src/test/run-pass/foreign-fn-linkname.rs @@ -10,13 +10,13 @@ extern mod libc { fn my_strlen(str: *u8) -> uint; } -fn strlen(str: str) -> uint unsafe { +fn strlen(str: ~str) -> uint unsafe { // C string is terminated with a zero let bytes = str::bytes(str) + ~[0u8]; ret libc::my_strlen(vec::unsafe::to_ptr(bytes)); } fn main() { - let len = strlen("Rust"); + let len = strlen(~"Rust"); assert(len == 4u); } diff --git a/src/test/run-pass/foreign2.rs b/src/test/run-pass/foreign2.rs index b801051d4f6..7af41e8dc41 100644 --- a/src/test/run-pass/foreign2.rs +++ b/src/test/run-pass/foreign2.rs @@ -24,4 +24,4 @@ extern mod libc { #[nolink] extern mod baz { } -fn main(args: ~[str]) { } +fn main(args: ~[~str]) { } diff --git a/src/test/run-pass/generic-tag-corruption.rs b/src/test/run-pass/generic-tag-corruption.rs index f1313f8cb6b..6e1985d2a6f 100644 --- a/src/test/run-pass/generic-tag-corruption.rs +++ b/src/test/run-pass/generic-tag-corruption.rs @@ -4,4 +4,4 @@ // This causes memory corruption in stage0. enum thing<K> { some(K), } -fn main() { let x = some("hi"); } +fn main() { let x = some(~"hi"); } diff --git a/src/test/run-pass/hashmap-memory.rs b/src/test/run-pass/hashmap-memory.rs index 212a6febef5..a29fd7afc1d 100644 --- a/src/test/run-pass/hashmap-memory.rs +++ b/src/test/run-pass/hashmap-memory.rs @@ -20,30 +20,30 @@ import comm::send; import comm::recv; import comm; -fn map(filename: str, emit: map_reduce::putter) { emit(filename, "1"); } +fn map(filename: ~str, emit: map_reduce::putter) { emit(filename, ~"1"); } mod map_reduce { export putter; export mapper; export map_reduce; - type putter = fn@(str, str); + type putter = fn@(~str, ~str); - type mapper = extern fn(str, putter); + type mapper = extern fn(~str, putter); enum ctrl_proto { find_reducer(~[u8], chan<int>), mapper_done, } - fn start_mappers(ctrl: chan<ctrl_proto>, inputs: ~[str]) { + fn start_mappers(ctrl: chan<ctrl_proto>, inputs: ~[~str]) { for inputs.each |i| { task::spawn(|| map_task(ctrl, i) ); } } - fn map_task(ctrl: chan<ctrl_proto>, input: str) { + fn map_task(ctrl: chan<ctrl_proto>, input: ~str) { let intermediates = map::str_hash(); - fn emit(im: map::hashmap<str, int>, ctrl: chan<ctrl_proto>, key: str, - val: str) { + fn emit(im: map::hashmap<~str, int>, ctrl: chan<ctrl_proto>, key: ~str, + val: ~str) { let mut c; alt im.find(key) { some(_c) { c = _c } @@ -63,13 +63,13 @@ mod map_reduce { send(ctrl, mapper_done); } - fn map_reduce(inputs: ~[str]) { + fn map_reduce(inputs: ~[~str]) { let ctrl = port(); // This task becomes the master control task. It spawns others // to do the rest. - let mut reducers: map::hashmap<str, int>; + let mut reducers: map::hashmap<~str, int>; reducers = map::str_hash(); @@ -94,5 +94,5 @@ mod map_reduce { } fn main() { - map_reduce::map_reduce(~["../src/test/run-pass/hashmap-memory.rs"]); + map_reduce::map_reduce(~[~"../src/test/run-pass/hashmap-memory.rs"]); } diff --git a/src/test/run-pass/iface-cast.rs b/src/test/run-pass/iface-cast.rs index 1377bb2a279..b53a4c06ee9 100644 --- a/src/test/run-pass/iface-cast.rs +++ b/src/test/run-pass/iface-cast.rs @@ -8,31 +8,31 @@ type TreeR = @{ }; iface to_str { - fn to_str() -> str; + fn to_str() -> ~str; } impl <T: to_str> of to_str for option<T> { - fn to_str() -> str { + fn to_str() -> ~str { alt self { - none { "none" } - some(t) { "some(" + t.to_str() + ")" } + none { ~"none" } + some(t) { ~"some(" + t.to_str() + ~")" } } } } impl of to_str for int { - fn to_str() -> str { int::str(self) } + fn to_str() -> ~str { int::str(self) } } impl of to_str for Tree { - fn to_str() -> str { + fn to_str() -> ~str { let l = self.left, r = self.right; #fmt["[%s, %s, %s]", self.val.to_str(), l.to_str(), r.to_str()] } } -fn foo<T: to_str>(x: T) -> str { x.to_str() } +fn foo<T: to_str>(x: T) -> ~str { x.to_str() } fn main() { let t1 = Tree(@{mut left: none, @@ -41,7 +41,7 @@ fn main() { let t2 = Tree(@{mut left: some(t1), mut right: some(t1), val: 2 as to_str }); - let expected = "[2, some([1, none, none]), some([1, none, none])]"; + let expected = ~"[2, some([1, none, none]), some([1, none, none])]"; assert t2.to_str() == expected; assert foo(t2 as to_str) == expected; t1.left = some(t2); // create cycle diff --git a/src/test/run-pass/iface-generic.rs b/src/test/run-pass/iface-generic.rs index 13be78d8616..f60dd6e1f18 100644 --- a/src/test/run-pass/iface-generic.rs +++ b/src/test/run-pass/iface-generic.rs @@ -1,14 +1,14 @@ iface to_str { - fn to_str() -> str; + fn to_str() -> ~str; } impl of to_str for int { - fn to_str() -> str { int::str(self) } + fn to_str() -> ~str { int::str(self) } } -impl of to_str for str { - fn to_str() -> str { self } +impl of to_str for ~str { + fn to_str() -> ~str { self } } impl of to_str for () { - fn to_str() -> str { "()" } + fn to_str() -> ~str { ~"()" } } iface map<T> { @@ -22,16 +22,16 @@ impl <T> of map<T> for ~[T] { } } -fn foo<U, T: map<U>>(x: T) -> ~[str] { - x.map(|_e| "hi" ) +fn foo<U, T: map<U>>(x: T) -> ~[~str] { + x.map(|_e| ~"hi" ) } -fn bar<U: to_str, T: map<U>>(x: T) -> ~[str] { +fn bar<U: to_str, T: map<U>>(x: T) -> ~[~str] { x.map(|_e| _e.to_str() ) } fn main() { - assert foo(~[1]) == ~["hi"]; - assert bar::<int, ~[int]>(~[4, 5]) == ~["4", "5"]; - assert bar::<str, ~[str]>(~["x", "y"]) == ~["x", "y"]; - assert bar::<(), ~[()]>(~[()]) == ~["()"]; + assert foo(~[1]) == ~[~"hi"]; + assert bar::<int, ~[int]>(~[4, 5]) == ~[~"4", ~"5"]; + assert bar::<~str, ~[~str]>(~[~"x", ~"y"]) == ~[~"x", ~"y"]; + assert bar::<(), ~[()]>(~[()]) == ~[~"()"]; } diff --git a/src/test/run-pass/iface-to-str.rs b/src/test/run-pass/iface-to-str.rs index a3d5b535371..71d25b4efd5 100644 --- a/src/test/run-pass/iface-to-str.rs +++ b/src/test/run-pass/iface-to-str.rs @@ -1,28 +1,28 @@ iface to_str { - fn to_str() -> str; + fn to_str() -> ~str; } impl of to_str for int { - fn to_str() -> str { int::str(self) } + fn to_str() -> ~str { int::str(self) } } impl <T: to_str> of to_str for ~[T] { - fn to_str() -> str { - "[" + str::connect(vec::map(self, |e| e.to_str() ), ", ") + "]" + fn to_str() -> ~str { + ~"[" + str::connect(vec::map(self, |e| e.to_str() ), ~", ") + ~"]" } } fn main() { - assert 1.to_str() == "1"; - assert (~[2, 3, 4]).to_str() == "[2, 3, 4]"; + assert 1.to_str() == ~"1"; + assert (~[2, 3, 4]).to_str() == ~"[2, 3, 4]"; - fn indirect<T: to_str>(x: T) -> str { - x.to_str() + "!" + fn indirect<T: to_str>(x: T) -> ~str { + x.to_str() + ~"!" } - assert indirect(~[10, 20]) == "[10, 20]!"; + assert indirect(~[10, 20]) == ~"[10, 20]!"; - fn indirect2<T: to_str>(x: T) -> str { + fn indirect2<T: to_str>(x: T) -> ~str { indirect(x) } - assert indirect2(~[1]) == "[1]!"; + assert indirect2(~[1]) == ~"[1]!"; } diff --git a/src/test/run-pass/import4.rs b/src/test/run-pass/import4.rs index 9f3207f6b6f..f6d2a9c9b5b 100644 --- a/src/test/run-pass/import4.rs +++ b/src/test/run-pass/import4.rs @@ -5,4 +5,4 @@ mod zed { fn bar() { #debug("bar"); } } -fn main(args: ~[str]) { let zed = 42; bar(); } +fn main(args: ~[~str]) { let zed = 42; bar(); } diff --git a/src/test/run-pass/import5.rs b/src/test/run-pass/import5.rs index f389dc61e53..ef8df1b9399 100644 --- a/src/test/run-pass/import5.rs +++ b/src/test/run-pass/import5.rs @@ -7,4 +7,4 @@ mod foo { } } -fn main(args: ~[str]) { bar(); } +fn main(args: ~[~str]) { bar(); } diff --git a/src/test/run-pass/import7.rs b/src/test/run-pass/import7.rs index b76ec2ccb4f..eeb8484e574 100644 --- a/src/test/run-pass/import7.rs +++ b/src/test/run-pass/import7.rs @@ -12,4 +12,4 @@ mod bar { mod zed { } } } -fn main(args: ~[str]) { baz(); } +fn main(args: ~[~str]) { baz(); } diff --git a/src/test/run-pass/inferred-suffix-in-pattern-range.rs b/src/test/run-pass/inferred-suffix-in-pattern-range.rs index d0647dd1ec9..eadb3503bda 100644 --- a/src/test/run-pass/inferred-suffix-in-pattern-range.rs +++ b/src/test/run-pass/inferred-suffix-in-pattern-range.rs @@ -1,22 +1,22 @@ fn main() { let x = 2; let x_message = alt x { - 0 to 1 { "not many" } - _ { "lots" } + 0 to 1 { ~"not many" } + _ { ~"lots" } }; - assert x_message == "lots"; + assert x_message == ~"lots"; let y = 2i; let y_message = alt y { - 0 to 1 { "not many" } - _ { "lots" } + 0 to 1 { ~"not many" } + _ { ~"lots" } }; - assert y_message == "lots"; + assert y_message == ~"lots"; let z = 1u64; let z_message = alt z { - 0 to 1 { "not many" } - _ { "lots" } + 0 to 1 { ~"not many" } + _ { ~"lots" } }; - assert z_message == "not many"; + assert z_message == ~"not many"; } diff --git a/src/test/run-pass/integral-indexing.rs b/src/test/run-pass/integral-indexing.rs index 222e63d4928..f6fbd20c732 100644 --- a/src/test/run-pass/integral-indexing.rs +++ b/src/test/run-pass/integral-indexing.rs @@ -4,7 +4,7 @@ // This is a testcase for issue #94. fn main() { let v: ~[int] = ~[0, 1, 2, 3, 4, 5]; - let s: str = "abcdef"; + let s: ~str = ~"abcdef"; assert (v[3u] == 3); assert (v[3u8] == 3); assert (v[3i8] == 3); diff --git a/src/test/run-pass/issue-1257.rs b/src/test/run-pass/issue-1257.rs index 870d4aec403..7471f7ab8ad 100644 --- a/src/test/run-pass/issue-1257.rs +++ b/src/test/run-pass/issue-1257.rs @@ -1,8 +1,8 @@ fn main () { - let mut line = ""; + let mut line = ~""; let mut i = 0; - while line != "exit" { - line = if i == 9 { "exit" } else { "notexit" }; + while line != ~"exit" { + line = if i == 9 { ~"exit" } else { ~"notexit" }; i += 1; } } diff --git a/src/test/run-pass/issue-1466.rs b/src/test/run-pass/issue-1466.rs index a40de7d4413..a9a665a0a7f 100644 --- a/src/test/run-pass/issue-1466.rs +++ b/src/test/run-pass/issue-1466.rs @@ -1,6 +1,6 @@ // exec-env:RUST_CC_ZEAL=1 fn main() { - #error["%?", os::getenv("RUST_CC_ZEAL")]; + #error["%?", os::getenv(~"RUST_CC_ZEAL")]; let _x = @{a: @10, b: ~true}; } diff --git a/src/test/run-pass/issue-1696.rs b/src/test/run-pass/issue-1696.rs index ab142a895e5..615c7be6241 100644 --- a/src/test/run-pass/issue-1696.rs +++ b/src/test/run-pass/issue-1696.rs @@ -4,6 +4,6 @@ import std::map::hashmap; fn main() { let m = map::bytes_hash(); - m.insert(str::bytes("foo"), str::bytes("bar")); + m.insert(str::bytes(~"foo"), str::bytes(~"bar")); log(error, m); } diff --git a/src/test/run-pass/issue-1701.rs b/src/test/run-pass/issue-1701.rs index b3b364c8090..f550c98d337 100644 --- a/src/test/run-pass/issue-1701.rs +++ b/src/test/run-pass/issue-1701.rs @@ -1,21 +1,21 @@ enum pattern { tabby, tortoiseshell, calico } enum breed { beagle, rottweiler, pug } -type name = str; +type name = ~str; enum ear_kind { lop, upright } enum animal { cat(pattern), dog(breed), rabbit(name, ear_kind), tiger } -fn noise(a: animal) -> option<str> { +fn noise(a: animal) -> option<~str> { alt a { - cat(*) { some("meow") } - dog(*) { some("woof") } + cat(*) { some(~"meow") } + dog(*) { some(~"woof") } rabbit(*) { none } - tiger(*) { some("roar") } + tiger(*) { some(~"roar") } } } fn main() { - assert noise(cat(tabby)) == some("meow"); - assert noise(dog(pug)) == some("woof"); - assert noise(rabbit("Hilbert", upright)) == none; - assert noise(tiger) == some("roar"); + assert noise(cat(tabby)) == some(~"meow"); + assert noise(dog(pug)) == some(~"woof"); + assert noise(rabbit(~"Hilbert", upright)) == none; + assert noise(tiger) == some(~"roar"); } \ No newline at end of file diff --git a/src/test/run-pass/issue-1974.rs b/src/test/run-pass/issue-1974.rs index ba84ad967c5..e8d27aa5e5c 100644 --- a/src/test/run-pass/issue-1974.rs +++ b/src/test/run-pass/issue-1974.rs @@ -1,8 +1,8 @@ // Issue 1974 // Don't double free the condition allocation fn main() { - let s = "hej"; - while s != "" { + let s = ~"hej"; + while s != ~"" { ret; } } \ No newline at end of file diff --git a/src/test/run-pass/issue-2631-b.rs b/src/test/run-pass/issue-2631-b.rs index 6a3025be697..41006ba3d65 100644 --- a/src/test/run-pass/issue-2631-b.rs +++ b/src/test/run-pass/issue-2631-b.rs @@ -10,8 +10,8 @@ import std::map::str_hash; import dvec; fn main() { - let v = ~[mut @"hi"/~]; + let v = ~[mut @~"hi"]; let m: req::header_map = str_hash(); - m.insert("METHOD", @dvec::from_vec(v)); + m.insert(~"METHOD", @dvec::from_vec(v)); request::<int>(m); } diff --git a/src/test/run-pass/issue-2718.rs b/src/test/run-pass/issue-2718.rs index 96e8af30ed4..412bcb5b66a 100644 --- a/src/test/run-pass/issue-2718.rs +++ b/src/test/run-pass/issue-2718.rs @@ -65,7 +65,7 @@ mod pipes { // The receiver will eventually clean this up. unsafe { forget(p); } } - full { fail "duplicate send" } + full { fail ~"duplicate send" } blocked { // The receiver will eventually clean this up. @@ -108,7 +108,7 @@ mod pipes { } full { // This is impossible - fail "you dun goofed" + fail ~"you dun goofed" } terminated { // I have to clean up, use drop_glue @@ -125,7 +125,7 @@ mod pipes { } blocked { // this shouldn't happen. - fail "terminating a blocked packet" + fail ~"terminating a blocked packet" } terminated | full { // I have to clean up, use drop_glue @@ -213,7 +213,7 @@ mod pingpong { fn do_pong(-c: pong) -> (ping, ()) { let packet = pipes::recv(c); if packet == none { - fail "sender closed the connection" + fail ~"sender closed the connection" } (liberate_pong(option::unwrap(packet)), ()) } @@ -226,7 +226,7 @@ mod pingpong { fn do_ping(-c: ping) -> (pong, ()) { let packet = pipes::recv(c); if packet == none { - fail "sender closed the connection" + fail ~"sender closed the connection" } (liberate_ping(option::unwrap(packet)), ()) } @@ -241,16 +241,16 @@ mod pingpong { fn client(-chan: pingpong::client::ping) { let chan = pingpong::client::do_ping(chan); - log(error, "Sent ping"); + log(error, ~"Sent ping"); let (chan, _data) = pingpong::client::do_pong(chan); - log(error, "Received pong"); + log(error, ~"Received pong"); } fn server(-chan: pingpong::server::ping) { let (chan, _data) = pingpong::server::do_ping(chan); - log(error, "Received ping"); + log(error, ~"Received ping"); let chan = pingpong::server::do_pong(chan); - log(error, "Sent pong"); + log(error, ~"Sent pong"); } fn main() { diff --git a/src/test/run-pass/issue-2734.rs b/src/test/run-pass/issue-2734.rs index 25f23bdf384..63bc1dc7d6f 100644 --- a/src/test/run-pass/issue-2734.rs +++ b/src/test/run-pass/issue-2734.rs @@ -6,7 +6,7 @@ fn perform_hax<T>(x: @T) -> hax { } fn deadcode() { - perform_hax(@"deadcode"/~); + perform_hax(@~"deadcode"); } fn main() { diff --git a/src/test/run-pass/issue-2735.rs b/src/test/run-pass/issue-2735.rs index 6c2f28c88b6..4ba77e0266c 100644 --- a/src/test/run-pass/issue-2735.rs +++ b/src/test/run-pass/issue-2735.rs @@ -6,7 +6,7 @@ fn perform_hax<T>(x: @T) -> hax { } fn deadcode() { - perform_hax(@"deadcode"/~); + perform_hax(@~"deadcode"); } fn main() { diff --git a/src/test/run-pass/issue-2804-2.rs b/src/test/run-pass/issue-2804-2.rs index 245d0d0ab24..4ac9ea0eb6e 100644 --- a/src/test/run-pass/issue-2804-2.rs +++ b/src/test/run-pass/issue-2804-2.rs @@ -3,8 +3,8 @@ use std; import std::map::hashmap; -fn add_interfaces(managed_ip: str, device: std::map::hashmap<str, int>) { - #error["%s, %?", managed_ip, device["interfaces"]]; +fn add_interfaces(managed_ip: ~str, device: std::map::hashmap<~str, int>) { + #error["%s, %?", managed_ip, device[~"interfaces"]]; } fn main() {} diff --git a/src/test/run-pass/issue-2804.rs b/src/test/run-pass/issue-2804.rs index ae63e1ab22e..926a8086cc2 100644 --- a/src/test/run-pass/issue-2804.rs +++ b/src/test/run-pass/issue-2804.rs @@ -9,7 +9,7 @@ enum object int_value(i64), } -fn lookup(table: std::map::hashmap<str, std::json::json>, key: str, default: str) -> str +fn lookup(table: std::map::hashmap<~str, std::json::json>, key: ~str, default: ~str) -> ~str { alt table.find(key) { @@ -29,13 +29,13 @@ fn lookup(table: std::map::hashmap<str, std::json::json>, key: str, default: str } } -fn add_interface(store: int, managed_ip: str, data: std::json::json) -> (str, object) +fn add_interface(store: int, managed_ip: ~str, data: std::json::json) -> (~str, object) { alt data { std::json::dict(interface) { - let name = lookup(interface, "ifDescr", ""); + let name = lookup(interface, ~"ifDescr", ~""); let label = #fmt["%s-%s", managed_ip, name]; (label, bool_value(false)) @@ -43,14 +43,14 @@ fn add_interface(store: int, managed_ip: str, data: std::json::json) -> (str, ob _ { #error["Expected dict for %s interfaces but found %?", managed_ip, data]; - ("gnos:missing-interface", bool_value(true)) + (~"gnos:missing-interface", bool_value(true)) } } } -fn add_interfaces(store: int, managed_ip: str, device: std::map::hashmap<str, std::json::json>) -> [(str, object)]/~ +fn add_interfaces(store: int, managed_ip: ~str, device: std::map::hashmap<~str, std::json::json>) -> ~[(~str, object)] { - alt device["interfaces"] + alt device[~"interfaces"] { std::json::list(interfaces) { @@ -60,8 +60,8 @@ fn add_interfaces(store: int, managed_ip: str, device: std::map::hashmap<str, st } _ { - #error["Expected list for %s interfaces but found %?", managed_ip, device["interfaces"]]; - []/~ + #error["Expected list for %s interfaces but found %?", managed_ip, device[~"interfaces"]]; + ~[] } } } diff --git a/src/test/run-pass/istr.rs b/src/test/run-pass/istr.rs index af6b55934eb..c9e1c2886ea 100644 --- a/src/test/run-pass/istr.rs +++ b/src/test/run-pass/istr.rs @@ -1,53 +1,53 @@ fn test_stack_assign() { - let s: str = "a"; + let s: ~str = ~"a"; log(debug, s); - let t: str = "a"; + let t: ~str = ~"a"; assert (s == t); - let u: str = "b"; + let u: ~str = ~"b"; assert (s != u); } -fn test_heap_lit() { "a big string"; } +fn test_heap_lit() { ~"a big string"; } fn test_heap_assign() { - let s: str = "a big ol' string"; - let t: str = "a big ol' string"; + let s: ~str = ~"a big ol' string"; + let t: ~str = ~"a big ol' string"; assert (s == t); - let u: str = "a bad ol' string"; + let u: ~str = ~"a bad ol' string"; assert (s != u); } -fn test_heap_log() { let s = "a big ol' string"; log(debug, s); } +fn test_heap_log() { let s = ~"a big ol' string"; log(debug, s); } fn test_stack_add() { - assert ("a" + "b" == "ab"); - let s: str = "a"; - assert (s + s == "aa"); - assert ("" + "" == ""); + assert (~"a" + ~"b" == ~"ab"); + let s: ~str = ~"a"; + assert (s + s == ~"aa"); + assert (~"" + ~"" == ~""); } -fn test_stack_heap_add() { assert ("a" + "bracadabra" == "abracadabra"); } +fn test_stack_heap_add() { assert (~"a" + ~"bracadabra" == ~"abracadabra"); } fn test_heap_add() { - assert ("this should" + " totally work" == "this should totally work"); + assert (~"this should" + ~" totally work" == ~"this should totally work"); } fn test_append() { - let mut s = ""; - s += "a"; - assert (s == "a"); + let mut s = ~""; + s += ~"a"; + assert (s == ~"a"); - let mut s = "a"; - s += "b"; + let mut s = ~"a"; + s += ~"b"; log(debug, s); - assert (s == "ab"); + assert (s == ~"ab"); - let mut s = "c"; - s += "offee"; - assert (s == "coffee"); + let mut s = ~"c"; + s += ~"offee"; + assert (s == ~"coffee"); - s += "&tea"; - assert (s == "coffee&tea"); + s += ~"&tea"; + assert (s == ~"coffee&tea"); } fn main() { diff --git a/src/test/run-pass/item-attributes.rs b/src/test/run-pass/item-attributes.rs index bcb70aba648..1e6aff673ed 100644 --- a/src/test/run-pass/item-attributes.rs +++ b/src/test/run-pass/item-attributes.rs @@ -143,7 +143,7 @@ mod test_distinguish_syntax_ext { use std; fn f() { - #fmt["test%s", "s"]; + #fmt["test%s", ~"s"]; #[attr = "val"] fn g() { } } diff --git a/src/test/run-pass/last-use-in-block.rs b/src/test/run-pass/last-use-in-block.rs index a9e367a89d4..745fc345dc0 100644 --- a/src/test/run-pass/last-use-in-block.rs +++ b/src/test/run-pass/last-use-in-block.rs @@ -1,6 +1,6 @@ // Issue #1818 -fn lp<T>(s: str, f: fn(str) -> T) -> T { +fn lp<T>(s: ~str, f: fn(~str) -> T) -> T { while false { let r = f(s); ret r; @@ -8,8 +8,8 @@ fn lp<T>(s: str, f: fn(str) -> T) -> T { fail; } -fn apply<T>(s: str, f: fn(str) -> T) -> T { - fn g<T>(s: str, f: fn(str) -> T) -> T {f(s)} +fn apply<T>(s: ~str, f: fn(~str) -> T) -> T { + fn g<T>(s: ~str, f: fn(~str) -> T) -> T {f(s)} g(s, |v| { let r = f(v); r }) } diff --git a/src/test/run-pass/linear-for-loop.rs b/src/test/run-pass/linear-for-loop.rs index 7bb9c3060cf..5091020508d 100644 --- a/src/test/run-pass/linear-for-loop.rs +++ b/src/test/run-pass/linear-for-loop.rs @@ -6,7 +6,7 @@ fn main() { for x.each |i| { log(debug, i); y += i; } log(debug, y); assert (y == 6); - let s = "hello there"; + let s = ~"hello there"; let mut i: int = 0; for str::each(s) |c| { if i == 0 { assert (c == 'h' as u8); } diff --git a/src/test/run-pass/log-err-phi.rs b/src/test/run-pass/log-err-phi.rs index 5b4ae8799c8..0c96279e707 100644 --- a/src/test/run-pass/log-err-phi.rs +++ b/src/test/run-pass/log-err-phi.rs @@ -1,3 +1,3 @@ -fn main() { if false { log(error, "foo" + "bar"); } } +fn main() { if false { log(error, ~"foo" + ~"bar"); } } diff --git a/src/test/run-pass/log-knows-the-names-of-variants-in-std.rs b/src/test/run-pass/log-knows-the-names-of-variants-in-std.rs index c099375cb7c..57542570860 100644 --- a/src/test/run-pass/log-knows-the-names-of-variants-in-std.rs +++ b/src/test/run-pass/log-knows-the-names-of-variants-in-std.rs @@ -3,16 +3,16 @@ import std::list; enum foo { a(uint), - b(str), + b(~str), } -fn check_log<T>(exp: str, v: T) { +fn check_log<T>(exp: ~str, v: T) { assert exp == #fmt["%?", v]; } fn main() { - let x = list::from_vec(~[a(22u), b("hi")]); - let exp = "@cons(a(22), @cons(b(~\"hi\"), @nil))"; + let x = list::from_vec(~[a(22u), b(~"hi")]); + let exp = ~"@cons(a(22), @cons(b(~\"hi\"), @nil))"; assert #fmt["%?", x] == exp; check_log(exp, x); } diff --git a/src/test/run-pass/log-knows-the-names-of-variants.rs b/src/test/run-pass/log-knows-the-names-of-variants.rs index 4df6d588209..f2d066277d4 100644 --- a/src/test/run-pass/log-knows-the-names-of-variants.rs +++ b/src/test/run-pass/log-knows-the-names-of-variants.rs @@ -1,11 +1,11 @@ enum foo { a(uint), - b(str), + b(~str), c, } fn main() { - assert "a(22)" == #fmt["%?", a(22u)]; - assert "b(~\"hi\")" == #fmt["%?", b("hi")]; - assert "c" == #fmt["%?", c]; + assert ~"a(22)" == #fmt["%?", a(22u)]; + assert ~"b(~\"hi\")" == #fmt["%?", b(~"hi")]; + assert ~"c" == #fmt["%?", c]; } diff --git a/src/test/run-pass/log-str.rs b/src/test/run-pass/log-str.rs index 7f424bf69f7..5f406d5fbbf 100644 --- a/src/test/run-pass/log-str.rs +++ b/src/test/run-pass/log-str.rs @@ -1,4 +1,4 @@ fn main() { - assert "~[1, 2, 3]" == sys::log_str(~[1, 2, 3]); - assert #fmt["%?/%6?", [1, 2, 3]/~, "hi"] == "~[1, 2, 3]/ ~\"hi\""; + assert ~"~[1, 2, 3]" == sys::log_str(~[1, 2, 3]); + assert #fmt["%?/%6?", ~[1, 2, 3], ~"hi"] == ~"~[1, 2, 3]/ ~\"hi\""; } diff --git a/src/test/run-pass/loop-break-cont.rs b/src/test/run-pass/loop-break-cont.rs index 2fa706e5777..7cdfddc5d7f 100644 --- a/src/test/run-pass/loop-break-cont.rs +++ b/src/test/run-pass/loop-break-cont.rs @@ -1,7 +1,7 @@ fn main() { let mut i = 0u; loop { - log(error, "a"); + log(error, ~"a"); i += 1u; if i == 10u { break; @@ -13,7 +13,7 @@ fn main() { if i == 21u { break; } - log(error, "b"); + log(error, ~"b"); is_even = false; i += 1u; if i % 2u != 0u { @@ -23,7 +23,7 @@ fn main() { } assert !is_even; loop { - log(error, "c"); + log(error, ~"c"); if i == 22u { break; } diff --git a/src/test/run-pass/main-ivec.rs b/src/test/run-pass/main-ivec.rs index a62147f286f..2cd454a1ccf 100644 --- a/src/test/run-pass/main-ivec.rs +++ b/src/test/run-pass/main-ivec.rs @@ -1 +1 @@ -fn main(args: ~[str]) { for args.each |s| { log(debug, s); } } +fn main(args: ~[~str]) { for args.each |s| { log(debug, s); } } diff --git a/src/test/run-pass/module-polymorphism4-files/cat.rs b/src/test/run-pass/module-polymorphism4-files/cat.rs index 9bcb03f611c..1f186036e13 100644 --- a/src/test/run-pass/module-polymorphism4-files/cat.rs +++ b/src/test/run-pass/module-polymorphism4-files/cat.rs @@ -5,10 +5,10 @@ enum cat { meowlycat } -fn animal() -> str { "cat" } -fn talk(c: cat) -> str { +fn animal() -> ~str { ~"cat" } +fn talk(c: cat) -> ~str { alt c { - howlycat { "howl" } - meowlycat { "meow" } + howlycat { ~"howl" } + meowlycat { ~"meow" } } } diff --git a/src/test/run-pass/module-polymorphism4-files/dog.rs b/src/test/run-pass/module-polymorphism4-files/dog.rs index 4826f48b6f3..4fd212deb8d 100644 --- a/src/test/run-pass/module-polymorphism4-files/dog.rs +++ b/src/test/run-pass/module-polymorphism4-files/dog.rs @@ -4,6 +4,6 @@ enum dog { dog } -fn animal() -> str { "dog" } -fn talk(_d: dog) -> str { "woof" } +fn animal() -> ~str { ~"dog" } +fn talk(_d: dog) -> ~str { ~"woof" } diff --git a/src/test/run-pass/module-polymorphism4-files/trait.rs b/src/test/run-pass/module-polymorphism4-files/trait.rs index 79296359d77..e5762d156a0 100644 --- a/src/test/run-pass/module-polymorphism4-files/trait.rs +++ b/src/test/run-pass/module-polymorphism4-files/trait.rs @@ -2,8 +2,8 @@ impl talky for T { // 'animal' and 'talk' functions are implemented by the module // instantiating the talky trait. They are 'abstract' - fn says() -> str { - animal() + " says '" + talk(self) + "'" + fn says() -> ~str { + animal() + ~" says '" + talk(self) + ~"'" } } diff --git a/src/test/run-pass/module-polymorphism4.rs b/src/test/run-pass/module-polymorphism4.rs index 074a9272a97..5c061c4d3b5 100644 --- a/src/test/run-pass/module-polymorphism4.rs +++ b/src/test/run-pass/module-polymorphism4.rs @@ -8,7 +8,7 @@ fn main() { let cat1 = cat::inst::meowlycat; let cat2 = cat::inst::howlycat; let dog = dog::inst::dog; - assert cat1.says() == "cat says 'meow'"; - assert cat2.says() == "cat says 'howl'"; - assert dog.says() == "dog says 'woof'"; + assert cat1.says() == ~"cat says 'meow'"; + assert cat2.says() == ~"cat says 'howl'"; + assert dog.says() == ~"dog says 'woof'"; } \ No newline at end of file diff --git a/src/test/run-pass/monad.rs b/src/test/run-pass/monad.rs index 674460a6a80..a1e52d44e6b 100644 --- a/src/test/run-pass/monad.rs +++ b/src/test/run-pass/monad.rs @@ -15,13 +15,13 @@ impl monad<A> for option<A> { } } -fn transform(x: option<int>) -> option<str> { +fn transform(x: option<int>) -> option<~str> { x.bind(|n| some(n + 1) ).bind(|n| some(int::str(n)) ) } fn main() { - assert transform(some(10)) == some("11"); + assert transform(some(10)) == some(~"11"); assert transform(none) == none; - assert (~["hi"]).bind(|x| ~[x, x + "!"] ).bind(|x| ~[x, x + "?"] ) == - ~["hi", "hi?", "hi!", "hi!?"]; + assert (~[~"hi"]).bind(|x| ~[x, x + ~"!"] ).bind(|x| ~[x, x + ~"?"] ) == + ~[~"hi", ~"hi?", ~"hi!", ~"hi!?"]; } diff --git a/src/test/run-pass/morestack6.rs b/src/test/run-pass/morestack6.rs index 69a904e00cd..62b73cd6a76 100644 --- a/src/test/run-pass/morestack6.rs +++ b/src/test/run-pass/morestack6.rs @@ -9,8 +9,8 @@ extern mod rustrt { fn debug_get_stk_seg() -> *u8; fn unsupervise(); - fn last_os_error() -> str; - fn rust_getcwd() -> str; + fn last_os_error() -> ~str; + fn rust_getcwd() -> ~str; fn get_task_id(); fn sched_threads(); fn rust_get_task(); diff --git a/src/test/run-pass/move-arg-2-unique.rs b/src/test/run-pass/move-arg-2-unique.rs index 10dc7937be9..e312d2afb4b 100644 --- a/src/test/run-pass/move-arg-2-unique.rs +++ b/src/test/run-pass/move-arg-2-unique.rs @@ -1,10 +1,10 @@ -fn test(-foo: ~[int]/~) { assert (foo[0] == 10); } +fn test(-foo: ~~[int]) { assert (foo[0] == 10); } fn main() { - let x = ~[10]/~; + let x = ~~[10]; // Test forgetting a local by move-in test(x); // Test forgetting a temporary by move-in. - test(~[10]/~); + test(~~[10]); } diff --git a/src/test/run-pass/option-ext.rs b/src/test/run-pass/option-ext.rs index 12c0feac891..0dbe60aca2e 100644 --- a/src/test/run-pass/option-ext.rs +++ b/src/test/run-pass/option-ext.rs @@ -1,8 +1,8 @@ -fn main(args: ~[str]) { - let thing = "{{ f }}"; - let f = str::find_str(thing, "{{"); +fn main(args: ~[~str]) { + let thing = ~"{{ f }}"; + let f = str::find_str(thing, ~"{{"); if f.is_none() { - io::println("None!"); + io::println(~"None!"); } } \ No newline at end of file diff --git a/src/test/run-pass/path.rs b/src/test/run-pass/path.rs index 6bccf726921..345f93f760d 100644 --- a/src/test/run-pass/path.rs +++ b/src/test/run-pass/path.rs @@ -4,4 +4,4 @@ mod foo { fn bar(offset: uint) { } } -fn main(args: ~[str]) { foo::bar(0u); } +fn main(args: ~[~str]) { foo::bar(0u); } diff --git a/src/test/run-pass/pipe-bank-proto.rs b/src/test/run-pass/pipe-bank-proto.rs index 8c3f1c00c70..72bdfff9f42 100644 --- a/src/test/run-pass/pipe-bank-proto.rs +++ b/src/test/run-pass/pipe-bank-proto.rs @@ -6,8 +6,8 @@ import pipes::try_recv; -type username = str; -type password = str; +type username = ~str; +type password = ~str; type money = float; type amount = float; @@ -42,26 +42,26 @@ fn macros() { fn bank_client(+bank: bank::client::login) { import bank::*; - let bank = client::login(bank, "theincredibleholk", "1234"); + let bank = client::login(bank, ~"theincredibleholk", ~"1234"); let bank = alt try_recv(bank) { some(ok(connected)) { #move(connected) } - some(invalid(_)) { fail "login unsuccessful" } - none { fail "bank closed the connection" } + some(invalid(_)) { fail ~"login unsuccessful" } + none { fail ~"bank closed the connection" } }; let bank = client::deposit(bank, 100.00); let bank = client::withdrawal(bank, 50.00); alt try_recv(bank) { some(money(m, _)) { - io::println("Yay! I got money!"); + io::println(~"Yay! I got money!"); } some(insufficient_funds(_)) { - fail "someone stole my money" + fail ~"someone stole my money" } none { - fail "bank closed the connection" + fail ~"bank closed the connection" } } } diff --git a/src/test/run-pass/pipe-pingpong-proto.rs b/src/test/run-pass/pipe-pingpong-proto.rs index d0ea4a9a877..f5eaf26f4a8 100644 --- a/src/test/run-pass/pipe-pingpong-proto.rs +++ b/src/test/run-pass/pipe-pingpong-proto.rs @@ -20,18 +20,18 @@ mod test { import pingpong::client; let chan = client::ping(chan); - log(error, "Sent ping"); + log(error, ~"Sent ping"); let pong(_chan) = recv(chan); - log(error, "Received pong"); + log(error, ~"Received pong"); } fn server(-chan: pingpong::server::ping) { import pingpong::server; let ping(chan) = recv(chan); - log(error, "Received ping"); + log(error, ~"Received ping"); let _chan = server::pong(chan); - log(error, "Sent pong"); + log(error, ~"Sent pong"); } } diff --git a/src/test/run-pass/rec-align-u32.rs b/src/test/run-pass/rec-align-u32.rs index 3f109d78e52..81f11395e04 100644 --- a/src/test/run-pass/rec-align-u32.rs +++ b/src/test/run-pass/rec-align-u32.rs @@ -50,5 +50,5 @@ fn main() { // because `inner`s alignment was 4. assert sys::size_of::<outer>() == m::size(); - assert y == "(22, (44))"; + assert y == ~"(22, (44))"; } diff --git a/src/test/run-pass/rec-align-u64.rs b/src/test/run-pass/rec-align-u64.rs index 2476cf7d818..433ca581ab3 100644 --- a/src/test/run-pass/rec-align-u64.rs +++ b/src/test/run-pass/rec-align-u64.rs @@ -64,5 +64,5 @@ fn main() { // because `inner`s alignment was 4. assert sys::size_of::<outer>() == m::m::size(); - assert y == "(22, (44))"; + assert y == ~"(22, (44))"; } diff --git a/src/test/run-pass/rec-auto.rs b/src/test/run-pass/rec-auto.rs index 8b2274817f7..0bb521c9dfb 100644 --- a/src/test/run-pass/rec-auto.rs +++ b/src/test/run-pass/rec-auto.rs @@ -5,7 +5,7 @@ // Issue #50. fn main() { - let x = {foo: "hello", bar: "world"}; + let x = {foo: ~"hello", bar: ~"world"}; log(debug, x.foo); log(debug, x.bar); } diff --git a/src/test/run-pass/reflect-visit-data.rs b/src/test/run-pass/reflect-visit-data.rs index c3e7709cf00..b654cf9bd19 100644 --- a/src/test/run-pass/reflect-visit-data.rs +++ b/src/test/run-pass/reflect-visit-data.rs @@ -172,30 +172,30 @@ impl ptr_visitor<V: ty_visitor movable_ptr> } fn visit_str() -> bool { - self.align_to::<str>(); + self.align_to::<~str>(); if ! self.inner.visit_str() { ret false; } - self.bump_past::<str>(); + self.bump_past::<~str>(); true } fn visit_estr_box() -> bool { - self.align_to::<str/@>(); + self.align_to::<@str>(); if ! self.inner.visit_estr_box() { ret false; } - self.bump_past::<str/@>(); + self.bump_past::<@str>(); true } fn visit_estr_uniq() -> bool { - self.align_to::<str/~>(); + self.align_to::<~str>(); if ! self.inner.visit_estr_uniq() { ret false; } - self.bump_past::<str/~>(); + self.bump_past::<~str>(); true } fn visit_estr_slice() -> bool { - self.align_to::<str/&static>(); + self.align_to::<&static/str>(); if ! self.inner.visit_estr_slice() { ret false; } - self.bump_past::<str/&static>(); + self.bump_past::<&static/str>(); true } @@ -289,7 +289,7 @@ impl ptr_visitor<V: ty_visitor movable_ptr> true } - fn visit_rec_field(i: uint, name: str/&, + fn visit_rec_field(i: uint, name: &str, mtbl: uint, inner: *tydesc) -> bool { if ! self.inner.visit_rec_field(i, name, mtbl, inner) { ret false; } true @@ -308,7 +308,7 @@ impl ptr_visitor<V: ty_visitor movable_ptr> true } - fn visit_class_field(i: uint, name: str/&, + fn visit_class_field(i: uint, name: &str, mtbl: uint, inner: *tydesc) -> bool { if ! self.inner.visit_class_field(i, name, mtbl, inner) { ret false; @@ -374,7 +374,7 @@ impl ptr_visitor<V: ty_visitor movable_ptr> fn visit_enter_enum_variant(variant: uint, disr_val: int, n_fields: uint, - name: str/&) -> bool { + name: &str) -> bool { if ! self.inner.visit_enter_enum_variant(variant, disr_val, n_fields, name) { ret false; @@ -390,7 +390,7 @@ impl ptr_visitor<V: ty_visitor movable_ptr> fn visit_leave_enum_variant(variant: uint, disr_val: int, n_fields: uint, - name: str/&) -> bool { + name: &str) -> bool { if ! self.inner.visit_leave_enum_variant(variant, disr_val, n_fields, name) { ret false; @@ -460,7 +460,7 @@ impl ptr_visitor<V: ty_visitor movable_ptr> enum my_visitor = @{ mut ptr1: *c_void, mut ptr2: *c_void, - mut vals: ~[str] + mut vals: ~[~str] }; impl extra_methods for my_visitor { @@ -540,7 +540,7 @@ impl of ty_visitor for my_visitor { fn visit_enter_rec(_n_fields: uint, _sz: uint, _align: uint) -> bool { true } - fn visit_rec_field(_i: uint, _name: str/&, + fn visit_rec_field(_i: uint, _name: &str, _mtbl: uint, inner: *tydesc) -> bool { #error("rec field!"); self.visit_inner(inner) @@ -550,7 +550,7 @@ impl of ty_visitor for my_visitor { fn visit_enter_class(_n_fields: uint, _sz: uint, _align: uint) -> bool { true } - fn visit_class_field(_i: uint, _name: str/&, + fn visit_class_field(_i: uint, _name: &str, _mtbl: uint, inner: *tydesc) -> bool { self.visit_inner(inner) } @@ -574,14 +574,14 @@ impl of ty_visitor for my_visitor { fn visit_enter_enum_variant(_variant: uint, _disr_val: int, _n_fields: uint, - _name: str/&) -> bool { true } + _name: &str) -> bool { true } fn visit_enum_variant_field(_i: uint, inner: *tydesc) -> bool { self.visit_inner(inner) } fn visit_leave_enum_variant(_variant: uint, _disr_val: int, _n_fields: uint, - _name: str/&) -> bool { true } + _name: &str) -> bool { true } fn visit_leave_enum(_n_variants: uint, _sz: uint, _align: uint) -> bool { true } @@ -625,5 +625,5 @@ fn main() { io::println(#fmt("val: %s", s)); } #error("%?", copy u.vals); - assert u.vals == ~["1", "2", "3", "true", "false", "5", "4", "3"]; + assert u.vals == ~[~"1", ~"2", ~"3", ~"true", ~"false", ~"5", ~"4", ~"3"]; } diff --git a/src/test/run-pass/reflect-visit-type.rs b/src/test/run-pass/reflect-visit-type.rs index 0ba4bf0730c..2d9227e22ef 100644 --- a/src/test/run-pass/reflect-visit-type.rs +++ b/src/test/run-pass/reflect-visit-type.rs @@ -77,14 +77,14 @@ impl of ty_visitor for my_visitor { fn visit_enter_rec(_n_fields: uint, _sz: uint, _align: uint) -> bool { true } - fn visit_rec_field(_i: uint, _name: str/&, + fn visit_rec_field(_i: uint, _name: &str, _mtbl: uint, _inner: *tydesc) -> bool { true } fn visit_leave_rec(_n_fields: uint, _sz: uint, _align: uint) -> bool { true } fn visit_enter_class(_n_fields: uint, _sz: uint, _align: uint) -> bool { true } - fn visit_class_field(_i: uint, _name: str/&, + fn visit_class_field(_i: uint, _name: &str, _mtbl: uint, _inner: *tydesc) -> bool { true } fn visit_leave_class(_n_fields: uint, _sz: uint, _align: uint) -> bool { true } @@ -100,12 +100,12 @@ impl of ty_visitor for my_visitor { fn visit_enter_enum_variant(_variant: uint, _disr_val: int, _n_fields: uint, - _name: str/&) -> bool { true } + _name: &str) -> bool { true } fn visit_enum_variant_field(_i: uint, _inner: *tydesc) -> bool { true } fn visit_leave_enum_variant(_variant: uint, _disr_val: int, _n_fields: uint, - _name: str/&) -> bool { true } + _name: &str) -> bool { true } fn visit_leave_enum(_n_variants: uint, _sz: uint, _align: uint) -> bool { true } diff --git a/src/test/run-pass/regions-borrow-estr-uniq.rs b/src/test/run-pass/regions-borrow-estr-uniq.rs index f118b96bb41..dbbdcc9fc34 100644 --- a/src/test/run-pass/regions-borrow-estr-uniq.rs +++ b/src/test/run-pass/regions-borrow-estr-uniq.rs @@ -1,13 +1,13 @@ -fn foo(x: str/&) -> u8 { +fn foo(x: &str) -> u8 { x[0] } fn main() { - let p = "hello"/~; + let p = ~"hello"; let r = foo(p); assert r == 'h' as u8; - let p = "hello"; + let p = ~"hello"; let r = foo(p); assert r == 'h' as u8; } diff --git a/src/test/run-pass/resource-destruct.rs b/src/test/run-pass/resource-destruct.rs index 0ae85a5af0b..3ccf15c9daf 100644 --- a/src/test/run-pass/resource-destruct.rs +++ b/src/test/run-pass/resource-destruct.rs @@ -2,7 +2,7 @@ class shrinky_pointer { let i: @@mut int; fn look_at() -> int { ret **(self.i); } new(i: @@mut int) { self.i = i; } - drop { log(error, "Hello!"); **(self.i) -= 1; } + drop { log(error, ~"Hello!"); **(self.i) -= 1; } } fn main() { diff --git a/src/test/run-pass/ret-bang.rs b/src/test/run-pass/ret-bang.rs index db8b86fe4a4..122188643de 100644 --- a/src/test/run-pass/ret-bang.rs +++ b/src/test/run-pass/ret-bang.rs @@ -2,10 +2,10 @@ // -*- rust -*- -fn my_err(s: str) -> ! { log(error, s); fail; } +fn my_err(s: ~str) -> ! { log(error, s); fail; } fn okay(i: uint) -> int { - if i == 3u { my_err("I don't like three"); } else { ret 42; } + if i == 3u { my_err(~"I don't like three"); } else { ret 42; } } fn main() { okay(4u); } diff --git a/src/test/run-pass/ret-break-cont-in-block.rs b/src/test/run-pass/ret-break-cont-in-block.rs index c94f0640180..5dc448a3e6c 100644 --- a/src/test/run-pass/ret-break-cont-in-block.rs +++ b/src/test/run-pass/ret-break-cont-in-block.rs @@ -26,13 +26,13 @@ fn bail_deep(x: ~[~[bool]]) { assert !seen; } -fn ret_deep() -> str { +fn ret_deep() -> ~str { for iter(~[1, 2]) |e| { for iter(~[3, 4]) |x| { - if e + x > 4 { ret "hi"; } + if e + x > 4 { ret ~"hi"; } } } - ret "bye"; + ret ~"bye"; } fn main() { @@ -47,11 +47,11 @@ fn main() { assert find_pos(1, ~[0, 1, 2, 3]) == some(1u); assert find_pos(1, ~[0, 4, 2, 3]) == none; - assert find_pos("hi", ~["foo", "bar", "baz", "hi"]) == some(3u); + assert find_pos(~"hi", ~[~"foo", ~"bar", ~"baz", ~"hi"]) == some(3u); bail_deep(~[~[false, false], ~[true, true], ~[false, true]]); bail_deep(~[~[true]]); bail_deep(~[~[false, false, false]]); - assert ret_deep() == "hi"; + assert ret_deep() == ~"hi"; } diff --git a/src/test/run-pass/sendfn-generic-fn.rs b/src/test/run-pass/sendfn-generic-fn.rs index bc8ecd7047a..2a4d675c321 100644 --- a/src/test/run-pass/sendfn-generic-fn.rs +++ b/src/test/run-pass/sendfn-generic-fn.rs @@ -11,16 +11,16 @@ fn make_generic_record<A: copy, B: copy>(a: A, b: B) -> pair<A,B> { ret {a: a, b: b}; } -fn test05_start(&&f: fn~(&&float, &&str) -> pair<float, str>) { - let p = f(22.22f, "Hi"); +fn test05_start(&&f: fn~(&&float, &&~str) -> pair<float, ~str>) { + let p = f(22.22f, ~"Hi"); log(debug, p); assert p.a == 22.22f; - assert p.b == "Hi"; + assert p.b == ~"Hi"; - let q = f(44.44f, "Ho"); + let q = f(44.44f, ~"Ho"); log(debug, q); assert q.a == 44.44f; - assert q.b == "Ho"; + assert q.b == ~"Ho"; } fn spawn<A: copy, B: copy>(f: extern fn(fn~(A,B)->pair<A,B>)) { @@ -31,5 +31,5 @@ fn spawn<A: copy, B: copy>(f: extern fn(fn~(A,B)->pair<A,B>)) { } fn test05() { - spawn::<float,str>(test05_start); + spawn::<float,~str>(test05_start); } diff --git a/src/test/run-pass/seq-compare.rs b/src/test/run-pass/seq-compare.rs index 00ddcbd9a65..e310184c6c8 100644 --- a/src/test/run-pass/seq-compare.rs +++ b/src/test/run-pass/seq-compare.rs @@ -1,9 +1,9 @@ fn main() { - assert ("hello" < "hellr"); - assert ("hello " > "hello"); - assert ("hello" != "there"); + assert (~"hello" < ~"hellr"); + assert (~"hello " > ~"hello"); + assert (~"hello" != ~"there"); assert (~[1, 2, 3, 4] > ~[1, 2, 3]); assert (~[1, 2, 3] < ~[1, 2, 3, 4]); assert (~[1, 2, 4, 4] > ~[1, 2, 3, 4]); diff --git a/src/test/run-pass/shape_intrinsic_tag_then_rec.rs b/src/test/run-pass/shape_intrinsic_tag_then_rec.rs index 151d6b123c7..6e050704e1f 100644 --- a/src/test/run-pass/shape_intrinsic_tag_then_rec.rs +++ b/src/test/run-pass/shape_intrinsic_tag_then_rec.rs @@ -16,14 +16,14 @@ enum opt_span { type span = {lo: uint, hi: uint, expanded_from: opt_span}; type spanned<T> = { data: T, span: span }; type ty_ = uint; -type path_ = { global: bool, idents: ~[str], types: ~[@ty] }; +type path_ = { global: bool, idents: ~[~str], types: ~[@ty] }; type path = spanned<path_>; type ty = spanned<ty_>; fn main() { let sp: span = {lo: 57451u, hi: 57542u, expanded_from: os_none}; let t: @ty = @{ data: 3u, span: sp }; - let p_: path_ = { global: true, idents: ~["hi"], types: ~[t] }; + let p_: path_ = { global: true, idents: ~[~"hi"], types: ~[t] }; let p: path = { data: p_, span: sp }; let x = { sp: sp, path: p }; log(error, x.path); diff --git a/src/test/run-pass/shebang.rs b/src/test/run-pass/shebang.rs index 5354dde7410..462546e24b8 100644 --- a/src/test/run-pass/shebang.rs +++ b/src/test/run-pass/shebang.rs @@ -3,4 +3,4 @@ import io::println; -fn main() { io::println("Hello World"); } +fn main() { io::println(~"Hello World"); } diff --git a/src/test/run-pass/spawn-fn.rs b/src/test/run-pass/spawn-fn.rs index 502b62e3a52..2f749ca8275 100644 --- a/src/test/run-pass/spawn-fn.rs +++ b/src/test/run-pass/spawn-fn.rs @@ -4,15 +4,15 @@ use std; import task::yield; import task; -fn x(s: str, n: int) { +fn x(s: ~str, n: int) { log(debug, s); log(debug, n); } fn main() { - task::spawn(|| x("hello from first spawned fn", 65) ); - task::spawn(|| x("hello from second spawned fn", 66) ); - task::spawn(|| x("hello from third spawned fn", 67) ); + task::spawn(|| x(~"hello from first spawned fn", 65) ); + task::spawn(|| x(~"hello from second spawned fn", 66) ); + task::spawn(|| x(~"hello from third spawned fn", 67) ); let mut i: int = 30; while i > 0 { i = i - 1; #debug("parent sleeping"); yield(); } } diff --git a/src/test/run-pass/spawn-types.rs b/src/test/run-pass/spawn-types.rs index 420d6793a44..58229d0e5da 100644 --- a/src/test/run-pass/spawn-types.rs +++ b/src/test/run-pass/spawn-types.rs @@ -12,12 +12,12 @@ import task; type ctx = comm::chan<int>; -fn iotask(cx: ctx, ip: str) { - assert (str::eq(ip, "localhost")); +fn iotask(cx: ctx, ip: ~str) { + assert (str::eq(ip, ~"localhost")); } fn main() { let p = comm::port::<int>(); let ch = comm::chan(p); - task::spawn(|| iotask(ch, "localhost") ); + task::spawn(|| iotask(ch, ~"localhost") ); } diff --git a/src/test/run-pass/static-impl.rs b/src/test/run-pass/static-impl.rs index fe083872792..468002e0d5b 100644 --- a/src/test/run-pass/static-impl.rs +++ b/src/test/run-pass/static-impl.rs @@ -6,11 +6,11 @@ mod a { } mod b { - impl baz for str { fn plus() -> int { 200 } } + impl baz for ~str { fn plus() -> int { 200 } } } impl util for uint { - fn str() -> str { uint::str(self) } + fn str() -> ~str { uint::str(self) } fn multi(f: fn(uint)) { let mut c = 0u; while c < self { f(c); c += 1u; } @@ -31,9 +31,9 @@ fn main() { impl foo for int { fn plus() -> int { self + 10 } } assert 10.plus() == 20; assert 10u.plus() == 30; - assert "hi".plus() == 200; + assert (~"hi").plus() == 200; - assert (~[1]).length_().str() == "1"; + assert (~[1]).length_().str() == ~"1"; assert (~[3, 4]).map_(|a| a + 4 )[0] == 7; assert (~[3, 4]).map_::<uint>(|a| a as uint + 4u )[0] == 7u; let mut x = 0u; diff --git a/src/test/run-pass/str-append.rs b/src/test/run-pass/str-append.rs index 03cda225bf6..b460c63fe43 100644 --- a/src/test/run-pass/str-append.rs +++ b/src/test/run-pass/str-append.rs @@ -5,8 +5,8 @@ use std; import str; fn test1() { - let mut s: str = "hello"; - s += "world"; + let mut s: ~str = ~"hello"; + s += ~"world"; log(debug, s); assert (s[9] == 'd' as u8); } @@ -14,13 +14,13 @@ fn test1() { fn test2() { // This tests for issue #163 - let ff: str = "abc"; - let a: str = ff + "ABC" + ff; - let b: str = "ABC" + ff + "ABC"; + let ff: ~str = ~"abc"; + let a: ~str = ff + ~"ABC" + ff; + let b: ~str = ~"ABC" + ff + ~"ABC"; log(debug, a); log(debug, b); - assert (str::eq(a, "abcABCabc")); - assert (str::eq(b, "ABCabcABC")); + assert (str::eq(a, ~"abcABCabc")); + assert (str::eq(b, ~"ABCabcABC")); } fn main() { test1(); test2(); } diff --git a/src/test/run-pass/str-concat.rs b/src/test/run-pass/str-concat.rs index 69d26469677..daba08e7378 100644 --- a/src/test/run-pass/str-concat.rs +++ b/src/test/run-pass/str-concat.rs @@ -3,9 +3,9 @@ // -*- rust -*- fn main() { - let a: str = "hello"; - let b: str = "world"; - let s: str = a + b; + let a: ~str = ~"hello"; + let b: ~str = ~"world"; + let s: ~str = a + b; log(debug, s); assert (s[9] == 'd' as u8); } diff --git a/src/test/run-pass/str-growth.rs b/src/test/run-pass/str-growth.rs index eca411a35aa..fb17ef212b7 100644 --- a/src/test/run-pass/str-growth.rs +++ b/src/test/run-pass/str-growth.rs @@ -1,12 +1,12 @@ fn main() { - let mut s = "a"; - s += "b"; + let mut s = ~"a"; + s += ~"b"; assert (s[0] == 'a' as u8); assert (s[1] == 'b' as u8); - s += "c"; - s += "d"; + s += ~"c"; + s += ~"d"; assert (s[0] == 'a' as u8); assert (s[1] == 'b' as u8); assert (s[2] == 'c' as u8); diff --git a/src/test/run-pass/str-idx.rs b/src/test/run-pass/str-idx.rs index ef7e2c71eaa..5b81123ac94 100644 --- a/src/test/run-pass/str-idx.rs +++ b/src/test/run-pass/str-idx.rs @@ -1,7 +1,7 @@ fn main() { - let s = "hello"; + let s = ~"hello"; let c: u8 = s[4]; log(debug, c); assert (c == 0x6f as u8); diff --git a/src/test/run-pass/str-multiline.rs b/src/test/run-pass/str-multiline.rs index 6523ce47df3..e9f27b23deb 100644 --- a/src/test/run-pass/str-multiline.rs +++ b/src/test/run-pass/str-multiline.rs @@ -5,13 +5,13 @@ use std; import str; fn main() { - let a: str = "this \ + let a: ~str = ~"this \ is a test"; - let b: str = - "this \ + let b: ~str = + ~"this \ is \ another \ test"; - assert (str::eq(a, "this is a test")); - assert (str::eq(b, "this is another test")); + assert (str::eq(a, ~"this is a test")); + assert (str::eq(b, ~"this is another test")); } diff --git a/src/test/run-pass/string-self-append.rs b/src/test/run-pass/string-self-append.rs index c293c8741e2..1c360bea3da 100644 --- a/src/test/run-pass/string-self-append.rs +++ b/src/test/run-pass/string-self-append.rs @@ -3,7 +3,7 @@ import str; fn main() { // Make sure we properly handle repeated self-appends. - let mut a: str = "A"; + let mut a: ~str = ~"A"; let mut i = 20; let mut expected_len = 1u; while i > 0 { diff --git a/src/test/run-pass/syntax-extension-fmt.rs b/src/test/run-pass/syntax-extension-fmt.rs index 141523609a2..eee76140ede 100644 --- a/src/test/run-pass/syntax-extension-fmt.rs +++ b/src/test/run-pass/syntax-extension-fmt.rs @@ -1,17 +1,17 @@ use std; import str; -fn test(actual: str, expected: str) { +fn test(actual: ~str, expected: ~str) { log(debug, actual); log(debug, expected); assert (str::eq(actual, expected)); } fn main() { - test(#fmt["hello %d friends and %s things", 10, "formatted"], - "hello 10 friends and formatted things"); + test(#fmt["hello %d friends and %s things", 10, ~"formatted"], + ~"hello 10 friends and formatted things"); - test(#fmt["test"], "test"); + test(#fmt["test"], ~"test"); // a quadratic optimization in LLVM (jump-threading) makes this test a // bit slow to compile unless we break it up @@ -28,224 +28,224 @@ fn main() { fn part1() { // Simple tests for types - test(#fmt["%d", 1], "1"); - test(#fmt["%i", 2], "2"); - test(#fmt["%i", -1], "-1"); - test(#fmt["%u", 10u], "10"); - test(#fmt["%s", "test"], "test"); - test(#fmt["%b", true], "true"); - test(#fmt["%b", false], "false"); - test(#fmt["%c", 'A'], "A"); - test(#fmt["%x", 0xff_u], "ff"); - test(#fmt["%X", 0x12ab_u], "12AB"); - test(#fmt["%o", 10u], "12"); - test(#fmt["%t", 0b11010101_u], "11010101"); - test(#fmt["%f", 5.82], "5.82"); + test(#fmt["%d", 1], ~"1"); + test(#fmt["%i", 2], ~"2"); + test(#fmt["%i", -1], ~"-1"); + test(#fmt["%u", 10u], ~"10"); + test(#fmt["%s", ~"test"], ~"test"); + test(#fmt["%b", true], ~"true"); + test(#fmt["%b", false], ~"false"); + test(#fmt["%c", 'A'], ~"A"); + test(#fmt["%x", 0xff_u], ~"ff"); + test(#fmt["%X", 0x12ab_u], ~"12AB"); + test(#fmt["%o", 10u], ~"12"); + test(#fmt["%t", 0b11010101_u], ~"11010101"); + test(#fmt["%f", 5.82], ~"5.82"); // 32-bit limits - test(#fmt["%i", -2147483648], "-2147483648"); - test(#fmt["%i", 2147483647], "2147483647"); - test(#fmt["%u", 4294967295u], "4294967295"); - test(#fmt["%x", 0xffffffff_u], "ffffffff"); - test(#fmt["%o", 0xffffffff_u], "37777777777"); - test(#fmt["%t", 0xffffffff_u], "11111111111111111111111111111111"); + test(#fmt["%i", -2147483648], ~"-2147483648"); + test(#fmt["%i", 2147483647], ~"2147483647"); + test(#fmt["%u", 4294967295u], ~"4294967295"); + test(#fmt["%x", 0xffffffff_u], ~"ffffffff"); + test(#fmt["%o", 0xffffffff_u], ~"37777777777"); + test(#fmt["%t", 0xffffffff_u], ~"11111111111111111111111111111111"); } fn part2() { // Widths - test(#fmt["%1d", 500], "500"); - test(#fmt["%10d", 500], " 500"); - test(#fmt["%10d", -500], " -500"); - test(#fmt["%10u", 500u], " 500"); - test(#fmt["%10s", "test"], " test"); - test(#fmt["%10b", true], " true"); - test(#fmt["%10x", 0xff_u], " ff"); - test(#fmt["%10X", 0xff_u], " FF"); - test(#fmt["%10o", 10u], " 12"); - test(#fmt["%10t", 0xff_u], " 11111111"); - test(#fmt["%10c", 'A'], " A"); - test(#fmt["%10f", 5.82], " 5.82"); + test(#fmt["%1d", 500], ~"500"); + test(#fmt["%10d", 500], ~" 500"); + test(#fmt["%10d", -500], ~" -500"); + test(#fmt["%10u", 500u], ~" 500"); + test(#fmt["%10s", ~"test"], ~" test"); + test(#fmt["%10b", true], ~" true"); + test(#fmt["%10x", 0xff_u], ~" ff"); + test(#fmt["%10X", 0xff_u], ~" FF"); + test(#fmt["%10o", 10u], ~" 12"); + test(#fmt["%10t", 0xff_u], ~" 11111111"); + test(#fmt["%10c", 'A'], ~" A"); + test(#fmt["%10f", 5.82], ~" 5.82"); // Left justify - test(#fmt["%-10d", 500], "500 "); - test(#fmt["%-10d", -500], "-500 "); - test(#fmt["%-10u", 500u], "500 "); - test(#fmt["%-10s", "test"], "test "); - test(#fmt["%-10b", true], "true "); - test(#fmt["%-10x", 0xff_u], "ff "); - test(#fmt["%-10X", 0xff_u], "FF "); - test(#fmt["%-10o", 10u], "12 "); - test(#fmt["%-10t", 0xff_u], "11111111 "); - test(#fmt["%-10c", 'A'], "A "); - test(#fmt["%-10f", 5.82], "5.82 "); + test(#fmt["%-10d", 500], ~"500 "); + test(#fmt["%-10d", -500], ~"-500 "); + test(#fmt["%-10u", 500u], ~"500 "); + test(#fmt["%-10s", ~"test"], ~"test "); + test(#fmt["%-10b", true], ~"true "); + test(#fmt["%-10x", 0xff_u], ~"ff "); + test(#fmt["%-10X", 0xff_u], ~"FF "); + test(#fmt["%-10o", 10u], ~"12 "); + test(#fmt["%-10t", 0xff_u], ~"11111111 "); + test(#fmt["%-10c", 'A'], ~"A "); + test(#fmt["%-10f", 5.82], ~"5.82 "); } fn part3() { // Precision - test(#fmt["%.d", 0], ""); - test(#fmt["%.u", 0u], ""); - test(#fmt["%.x", 0u], ""); - test(#fmt["%.t", 0u], ""); - test(#fmt["%.d", 10], "10"); - test(#fmt["%.d", -10], "-10"); - test(#fmt["%.u", 10u], "10"); - test(#fmt["%.s", "test"], ""); - test(#fmt["%.x", 127u], "7f"); - test(#fmt["%.o", 10u], "12"); - test(#fmt["%.t", 3u], "11"); - test(#fmt["%.c", 'A'], "A"); - test(#fmt["%.f", 5.82], "6"); - test(#fmt["%.0d", 0], ""); - test(#fmt["%.0u", 0u], ""); - test(#fmt["%.0x", 0u], ""); - test(#fmt["%.0t", 0u], ""); - test(#fmt["%.0d", 10], "10"); - test(#fmt["%.0d", -10], "-10"); - test(#fmt["%.0u", 10u], "10"); - test(#fmt["%.0s", "test"], ""); - test(#fmt["%.0x", 127u], "7f"); - test(#fmt["%.0o", 10u], "12"); - test(#fmt["%.0t", 3u], "11"); - test(#fmt["%.0c", 'A'], "A"); - test(#fmt["%.0f", 5.892], "6"); - test(#fmt["%.1d", 0], "0"); - test(#fmt["%.1u", 0u], "0"); - test(#fmt["%.1x", 0u], "0"); - test(#fmt["%.1t", 0u], "0"); - test(#fmt["%.1d", 10], "10"); - test(#fmt["%.1d", -10], "-10"); - test(#fmt["%.1u", 10u], "10"); - test(#fmt["%.1s", "test"], "t"); - test(#fmt["%.1x", 127u], "7f"); - test(#fmt["%.1o", 10u], "12"); - test(#fmt["%.1t", 3u], "11"); - test(#fmt["%.1c", 'A'], "A"); - test(#fmt["%.1f", 5.82], "5.8"); + test(#fmt["%.d", 0], ~""); + test(#fmt["%.u", 0u], ~""); + test(#fmt["%.x", 0u], ~""); + test(#fmt["%.t", 0u], ~""); + test(#fmt["%.d", 10], ~"10"); + test(#fmt["%.d", -10], ~"-10"); + test(#fmt["%.u", 10u], ~"10"); + test(#fmt["%.s", ~"test"], ~""); + test(#fmt["%.x", 127u], ~"7f"); + test(#fmt["%.o", 10u], ~"12"); + test(#fmt["%.t", 3u], ~"11"); + test(#fmt["%.c", 'A'], ~"A"); + test(#fmt["%.f", 5.82], ~"6"); + test(#fmt["%.0d", 0], ~""); + test(#fmt["%.0u", 0u], ~""); + test(#fmt["%.0x", 0u], ~""); + test(#fmt["%.0t", 0u], ~""); + test(#fmt["%.0d", 10], ~"10"); + test(#fmt["%.0d", -10], ~"-10"); + test(#fmt["%.0u", 10u], ~"10"); + test(#fmt["%.0s", ~"test"], ~""); + test(#fmt["%.0x", 127u], ~"7f"); + test(#fmt["%.0o", 10u], ~"12"); + test(#fmt["%.0t", 3u], ~"11"); + test(#fmt["%.0c", 'A'], ~"A"); + test(#fmt["%.0f", 5.892], ~"6"); + test(#fmt["%.1d", 0], ~"0"); + test(#fmt["%.1u", 0u], ~"0"); + test(#fmt["%.1x", 0u], ~"0"); + test(#fmt["%.1t", 0u], ~"0"); + test(#fmt["%.1d", 10], ~"10"); + test(#fmt["%.1d", -10], ~"-10"); + test(#fmt["%.1u", 10u], ~"10"); + test(#fmt["%.1s", ~"test"], ~"t"); + test(#fmt["%.1x", 127u], ~"7f"); + test(#fmt["%.1o", 10u], ~"12"); + test(#fmt["%.1t", 3u], ~"11"); + test(#fmt["%.1c", 'A'], ~"A"); + test(#fmt["%.1f", 5.82], ~"5.8"); } fn part4() { - test(#fmt["%.5d", 0], "00000"); - test(#fmt["%.5u", 0u], "00000"); - test(#fmt["%.5x", 0u], "00000"); - test(#fmt["%.5t", 0u], "00000"); - test(#fmt["%.5d", 10], "00010"); - test(#fmt["%.5d", -10], "-00010"); - test(#fmt["%.5u", 10u], "00010"); - test(#fmt["%.5s", "test"], "test"); - test(#fmt["%.5x", 127u], "0007f"); - test(#fmt["%.5o", 10u], "00012"); - test(#fmt["%.5t", 3u], "00011"); - test(#fmt["%.5c", 'A'], "A"); - test(#fmt["%.5f", 5.82], "5.82000"); - test(#fmt["%.5f", 5.0], "5.00000"); + test(#fmt["%.5d", 0], ~"00000"); + test(#fmt["%.5u", 0u], ~"00000"); + test(#fmt["%.5x", 0u], ~"00000"); + test(#fmt["%.5t", 0u], ~"00000"); + test(#fmt["%.5d", 10], ~"00010"); + test(#fmt["%.5d", -10], ~"-00010"); + test(#fmt["%.5u", 10u], ~"00010"); + test(#fmt["%.5s", ~"test"], ~"test"); + test(#fmt["%.5x", 127u], ~"0007f"); + test(#fmt["%.5o", 10u], ~"00012"); + test(#fmt["%.5t", 3u], ~"00011"); + test(#fmt["%.5c", 'A'], ~"A"); + test(#fmt["%.5f", 5.82], ~"5.82000"); + test(#fmt["%.5f", 5.0], ~"5.00000"); // Bool precision. I'm not sure if it's good or bad to have bool // conversions support precision - it's not standard printf so we // can do whatever. For now I'm making it behave the same as string // conversions. - test(#fmt["%.b", true], ""); - test(#fmt["%.0b", true], ""); - test(#fmt["%.1b", true], "t"); + test(#fmt["%.b", true], ~""); + test(#fmt["%.0b", true], ~""); + test(#fmt["%.1b", true], ~"t"); } fn part5() { // Explicit + sign. Only for signed conversions - test(#fmt["%+d", 0], "+0"); - test(#fmt["%+d", 1], "+1"); - test(#fmt["%+d", -1], "-1"); - test(#fmt["%+f", 0.0], "+0"); + test(#fmt["%+d", 0], ~"+0"); + test(#fmt["%+d", 1], ~"+1"); + test(#fmt["%+d", -1], ~"-1"); + test(#fmt["%+f", 0.0], ~"+0"); // Leave space for sign - test(#fmt["% d", 0], " 0"); - test(#fmt["% d", 1], " 1"); - test(#fmt["% d", -1], "-1"); - test(#fmt["% f", 0.0], " 0"); + test(#fmt["% d", 0], ~" 0"); + test(#fmt["% d", 1], ~" 1"); + test(#fmt["% d", -1], ~"-1"); + test(#fmt["% f", 0.0], ~" 0"); // Plus overrides space - test(#fmt["% +d", 0], "+0"); - test(#fmt["%+ d", 0], "+0"); - test(#fmt["% +f", 0.0], "+0"); - test(#fmt["%+ f", 0.0], "+0"); + test(#fmt["% +d", 0], ~"+0"); + test(#fmt["%+ d", 0], ~"+0"); + test(#fmt["% +f", 0.0], ~"+0"); + test(#fmt["%+ f", 0.0], ~"+0"); // 0-padding - test(#fmt["%05d", 0], "00000"); - test(#fmt["%05d", 1], "00001"); - test(#fmt["%05d", -1], "-0001"); - test(#fmt["%05u", 1u], "00001"); - test(#fmt["%05x", 127u], "0007f"); - test(#fmt["%05X", 127u], "0007F"); - test(#fmt["%05o", 10u], "00012"); - test(#fmt["%05t", 3u], "00011"); - test(#fmt["%05f", 5.82], "05.82"); + test(#fmt["%05d", 0], ~"00000"); + test(#fmt["%05d", 1], ~"00001"); + test(#fmt["%05d", -1], ~"-0001"); + test(#fmt["%05u", 1u], ~"00001"); + test(#fmt["%05x", 127u], ~"0007f"); + test(#fmt["%05X", 127u], ~"0007F"); + test(#fmt["%05o", 10u], ~"00012"); + test(#fmt["%05t", 3u], ~"00011"); + test(#fmt["%05f", 5.82], ~"05.82"); // 0-padding a string is undefined but glibc does this: - test(#fmt["%05s", "test"], " test"); - test(#fmt["%05c", 'A'], " A"); - test(#fmt["%05b", true], " true"); + test(#fmt["%05s", ~"test"], ~" test"); + test(#fmt["%05c", 'A'], ~" A"); + test(#fmt["%05b", true], ~" true"); // Left-justify overrides 0-padding - test(#fmt["%-05d", 0], "0 "); - test(#fmt["%-05d", 1], "1 "); - test(#fmt["%-05d", -1], "-1 "); - test(#fmt["%-05u", 1u], "1 "); - test(#fmt["%-05x", 127u], "7f "); - test(#fmt["%-05X", 127u], "7F "); - test(#fmt["%-05o", 10u], "12 "); - test(#fmt["%-05t", 3u], "11 "); - test(#fmt["%-05s", "test"], "test "); - test(#fmt["%-05c", 'A'], "A "); - test(#fmt["%-05b", true], "true "); - test(#fmt["%-05f", 5.82], "5.82 "); + test(#fmt["%-05d", 0], ~"0 "); + test(#fmt["%-05d", 1], ~"1 "); + test(#fmt["%-05d", -1], ~"-1 "); + test(#fmt["%-05u", 1u], ~"1 "); + test(#fmt["%-05x", 127u], ~"7f "); + test(#fmt["%-05X", 127u], ~"7F "); + test(#fmt["%-05o", 10u], ~"12 "); + test(#fmt["%-05t", 3u], ~"11 "); + test(#fmt["%-05s", ~"test"], ~"test "); + test(#fmt["%-05c", 'A'], ~"A "); + test(#fmt["%-05b", true], ~"true "); + test(#fmt["%-05f", 5.82], ~"5.82 "); } fn part6() { // Precision overrides 0-padding // FIXME #2481: Recent gcc's report some of these as warnings - test(#fmt["%06.5d", 0], " 00000"); - test(#fmt["%06.5u", 0u], " 00000"); - test(#fmt["%06.5x", 0u], " 00000"); - test(#fmt["%06.5d", 10], " 00010"); - test(#fmt["%06.5d", -10], "-00010"); - test(#fmt["%06.5u", 10u], " 00010"); - test(#fmt["%06.5s", "test"], " test"); - test(#fmt["%06.5c", 'A'], " A"); - test(#fmt["%06.5x", 127u], " 0007f"); - test(#fmt["%06.5X", 127u], " 0007F"); - test(#fmt["%06.5o", 10u], " 00012"); + test(#fmt["%06.5d", 0], ~" 00000"); + test(#fmt["%06.5u", 0u], ~" 00000"); + test(#fmt["%06.5x", 0u], ~" 00000"); + test(#fmt["%06.5d", 10], ~" 00010"); + test(#fmt["%06.5d", -10], ~"-00010"); + test(#fmt["%06.5u", 10u], ~" 00010"); + test(#fmt["%06.5s", ~"test"], ~" test"); + test(#fmt["%06.5c", 'A'], ~" A"); + test(#fmt["%06.5x", 127u], ~" 0007f"); + test(#fmt["%06.5X", 127u], ~" 0007F"); + test(#fmt["%06.5o", 10u], ~" 00012"); // Precision does not override zero-padding for floats - test(#fmt["%08.5f", 5.82], "05.82000"); + test(#fmt["%08.5f", 5.82], ~"05.82000"); // Signed combinations - test(#fmt["% 5d", 1], " 1"); - test(#fmt["% 5d", -1], " -1"); - test(#fmt["%+5d", 1], " +1"); - test(#fmt["%+5d", -1], " -1"); - test(#fmt["% 05d", 1], " 0001"); - test(#fmt["% 05d", -1], "-0001"); - test(#fmt["%+05d", 1], "+0001"); - test(#fmt["%+05d", -1], "-0001"); - test(#fmt["%- 5d", 1], " 1 "); - test(#fmt["%- 5d", -1], "-1 "); - test(#fmt["%-+5d", 1], "+1 "); - test(#fmt["%-+5d", -1], "-1 "); - test(#fmt["%- 05d", 1], " 1 "); - test(#fmt["%- 05d", -1], "-1 "); - test(#fmt["%-+05d", 1], "+1 "); - test(#fmt["%-+05d", -1], "-1 "); + test(#fmt["% 5d", 1], ~" 1"); + test(#fmt["% 5d", -1], ~" -1"); + test(#fmt["%+5d", 1], ~" +1"); + test(#fmt["%+5d", -1], ~" -1"); + test(#fmt["% 05d", 1], ~" 0001"); + test(#fmt["% 05d", -1], ~"-0001"); + test(#fmt["%+05d", 1], ~"+0001"); + test(#fmt["%+05d", -1], ~"-0001"); + test(#fmt["%- 5d", 1], ~" 1 "); + test(#fmt["%- 5d", -1], ~"-1 "); + test(#fmt["%-+5d", 1], ~"+1 "); + test(#fmt["%-+5d", -1], ~"-1 "); + test(#fmt["%- 05d", 1], ~" 1 "); + test(#fmt["%- 05d", -1], ~"-1 "); + test(#fmt["%-+05d", 1], ~"+1 "); + test(#fmt["%-+05d", -1], ~"-1 "); } fn percent() { let s = #fmt["ab%%cd"]; - assert(s == "ab%cd"); + assert(s == ~"ab%cd"); } fn more_floats() { - assert "3.1416" == #fmt["%.4f", 3.14159]; - assert "3" == #fmt["%.0f", 3.14159]; - assert "99" == #fmt["%.0f", 98.5]; - assert "7.0000" == #fmt["%.4f", 6.999999999]; - assert "3.141590000" == #fmt["%.9f", 3.14159]; + assert ~"3.1416" == #fmt["%.4f", 3.14159]; + assert ~"3" == #fmt["%.0f", 3.14159]; + assert ~"99" == #fmt["%.0f", 98.5]; + assert ~"7.0000" == #fmt["%.4f", 6.999999999]; + assert ~"3.141590000" == #fmt["%.9f", 3.14159]; } \ No newline at end of file diff --git a/src/test/run-pass/syntax-extension-minor.rs b/src/test/run-pass/syntax-extension-minor.rs index 50939997523..346a85ada0e 100644 --- a/src/test/run-pass/syntax-extension-minor.rs +++ b/src/test/run-pass/syntax-extension-minor.rs @@ -1,8 +1,8 @@ fn main() { - let asdf_fdsa = "<.<"; - assert (#concat_idents[asd, f_f, dsa] == "<.<"); + let asdf_fdsa = ~"<.<"; + assert (#concat_idents[asd, f_f, dsa] == ~"<.<"); assert (#ident_to_str[use_mention_distinction] == - "use_mention_distinction"); + ~"use_mention_distinction"); } diff --git a/src/test/run-pass/syntax-extension-source-utils-files/includeme.fragment b/src/test/run-pass/syntax-extension-source-utils-files/includeme.fragment index 5db5b0f6ff5..0d355518bfb 100644 --- a/src/test/run-pass/syntax-extension-source-utils-files/includeme.fragment +++ b/src/test/run-pass/syntax-extension-source-utils-files/includeme.fragment @@ -1,7 +1,7 @@ /* this is for run-pass/syntax-extension-source-utils.rs */ { - assert(#file[].ends_with("utils-files/includeme.fragment")); + assert(#file[].ends_with(~"utils-files/includeme.fragment")); assert(#line[] == 5u); #fmt["victory robot %u", #line[]] -} \ No newline at end of file +} diff --git a/src/test/run-pass/syntax-extension-source-utils.rs b/src/test/run-pass/syntax-extension-source-utils.rs index 29bd6e65f4f..1ed41491fc3 100644 --- a/src/test/run-pass/syntax-extension-source-utils.rs +++ b/src/test/run-pass/syntax-extension-source-utils.rs @@ -3,24 +3,24 @@ mod m1 { mod m2 { - fn where_am_i() -> str { #mod[] } + fn where_am_i() -> ~str { #mod[] } } } fn main() { assert(#line[] == 11u); assert(#col[] == 11u); - assert(#file[].ends_with("syntax-extension-source-utils.rs")); - assert(#stringify[(2*3) + 5] == "2 * 3 + 5"); + assert(#file[].ends_with(~"syntax-extension-source-utils.rs")); + assert(#stringify[(2*3) + 5] == ~"2 * 3 + 5"); assert(#include["syntax-extension-source-utils-files/includeme.fragment"] - == "victory robot 6"); + == ~"victory robot 6"); + assert( #include_str["syntax-extension-source-utils-files/includeme.fragment"] - .starts_with("/* this is for ")); + .starts_with(~"/* this is for ")); assert( #include_bin["syntax-extension-source-utils-files/includeme.fragment"] [1] == (42 as u8)); // '*' // The Windows tests are wrapped in an extra module for some reason - assert(m1::m2::where_am_i().ends_with("m1::m2")); - + assert(m1::m2::where_am_i().ends_with(~"m1::m2")); } diff --git a/src/test/run-pass/tag-in-block.rs b/src/test/run-pass/tag-in-block.rs index 9107249b2b0..f529a8d96ae 100644 --- a/src/test/run-pass/tag-in-block.rs +++ b/src/test/run-pass/tag-in-block.rs @@ -6,4 +6,4 @@ fn foo() { fn baz() { zed(nil); } } -fn main(args: ~[str]) { } +fn main(args: ~[~str]) { } diff --git a/src/test/run-pass/tag-variant-disr-val.rs b/src/test/run-pass/tag-variant-disr-val.rs index c33b167128a..45c2c2ef94d 100644 --- a/src/test/run-pass/tag-variant-disr-val.rs +++ b/src/test/run-pass/tag-variant-disr-val.rs @@ -10,17 +10,17 @@ enum color { } fn main() { - test_color(red, 0xff0000, "red"); - test_color(green, 0x00ff00, "green"); - test_color(blue, 0x0000ff, "blue"); - test_color(black, 0x000000, "black"); - test_color(white, 0xFFFFFF, "white"); - test_color(imaginary, -1, "imaginary"); - test_color(purple, 2, "purple"); - test_color(orange, 4, "orange"); + test_color(red, 0xff0000, ~"red"); + test_color(green, 0x00ff00, ~"green"); + test_color(blue, 0x0000ff, ~"blue"); + test_color(black, 0x000000, ~"black"); + test_color(white, 0xFFFFFF, ~"white"); + test_color(imaginary, -1, ~"imaginary"); + test_color(purple, 2, ~"purple"); + test_color(orange, 4, ~"orange"); } -fn test_color(color: color, val: int, name: str) unsafe { +fn test_color(color: color, val: int, name: ~str) unsafe { //assert unsafe::reinterpret_cast(color) == val; assert color as int == val; assert color as float == val as float; @@ -28,29 +28,29 @@ fn test_color(color: color, val: int, name: str) unsafe { assert get_color_if(color) == name; } -fn get_color_alt(color: color) -> str { +fn get_color_alt(color: color) -> ~str { alt color { - red {"red"} - green {"green"} - blue {"blue"} - black {"black"} - white {"white"} - imaginary {"imaginary"} - purple {"purple"} - orange {"orange"} + red {~"red"} + green {~"green"} + blue {~"blue"} + black {~"black"} + white {~"white"} + imaginary {~"imaginary"} + purple {~"purple"} + orange {~"orange"} } } -fn get_color_if(color: color) -> str { - if color == red {"red"} - else if color == green {"green"} - else if color == blue {"blue"} - else if color == black {"black"} - else if color == white {"white"} - else if color == imaginary {"imaginary"} - else if color == purple {"purple"} - else if color == orange {"orange"} - else {"unknown"} +fn get_color_if(color: color) -> ~str { + if color == red {~"red"} + else if color == green {~"green"} + else if color == blue {~"blue"} + else if color == black {~"black"} + else if color == white {~"white"} + else if color == imaginary {~"imaginary"} + else if color == purple {~"purple"} + else if color == orange {~"orange"} + else {~"unknown"} } diff --git a/src/test/run-pass/tail-call-arg-leak.rs b/src/test/run-pass/tail-call-arg-leak.rs index 269fa53211d..9b9631867e2 100644 --- a/src/test/run-pass/tail-call-arg-leak.rs +++ b/src/test/run-pass/tail-call-arg-leak.rs @@ -2,6 +2,6 @@ // use of tail calls causes arg slot leaks, issue #160. -fn inner(dummy: str, b: bool) { if b { ret inner(dummy, false); } } +fn inner(dummy: ~str, b: bool) { if b { ret inner(dummy, false); } } -fn main() { inner("hi", true); } +fn main() { inner(~"hi", true); } diff --git a/src/test/run-pass/task-comm-10.rs b/src/test/run-pass/task-comm-10.rs index 90ad3563152..1d0963a29dc 100644 --- a/src/test/run-pass/task-comm-10.rs +++ b/src/test/run-pass/task-comm-10.rs @@ -2,17 +2,17 @@ use std; import task; import comm; -fn start(c: comm::chan<comm::chan<str>>) { +fn start(c: comm::chan<comm::chan<~str>>) { let p = comm::port(); comm::send(c, comm::chan(p)); let mut a; let mut b; a = comm::recv(p); - assert a == "A"; + assert a == ~"A"; log(error, a); b = comm::recv(p); - assert b == "B"; + assert b == ~"B"; log(error, b); } @@ -22,7 +22,7 @@ fn main() { let child = task::spawn(|| start(ch) ); let c = comm::recv(p); - comm::send(c, "A"); - comm::send(c, "B"); + comm::send(c, ~"A"); + comm::send(c, ~"B"); task::yield(); } diff --git a/src/test/run-pass/task-comm-16.rs b/src/test/run-pass/task-comm-16.rs index 009661acedb..bc46de64cd7 100644 --- a/src/test/run-pass/task-comm-16.rs +++ b/src/test/run-pass/task-comm-16.rs @@ -36,7 +36,7 @@ fn test_vec() { fn test_str() { let po = port(); let ch = chan(po); - let s0 = "test"; + let s0 = ~"test"; send(ch, s0); let s1 = recv(po); assert (s1[0] == 't' as u8); diff --git a/src/test/run-pass/task-comm-chan-cleanup.rs b/src/test/run-pass/task-comm-chan-cleanup.rs index 32756ce494b..39c3eefd774 100644 --- a/src/test/run-pass/task-comm-chan-cleanup.rs +++ b/src/test/run-pass/task-comm-chan-cleanup.rs @@ -4,5 +4,5 @@ import comm; fn main() { let p = comm::port(); let c = comm::chan(p); - comm::send(c, "coffee"); + comm::send(c, ~"coffee"); } \ No newline at end of file diff --git a/src/test/run-pass/task-comm-chan-cleanup3.rs b/src/test/run-pass/task-comm-chan-cleanup3.rs index 79c32e5f1fd..a153d4a8e5d 100644 --- a/src/test/run-pass/task-comm-chan-cleanup3.rs +++ b/src/test/run-pass/task-comm-chan-cleanup3.rs @@ -6,5 +6,5 @@ fn main() { let p = comm::port(); comm::chan(p) }; - comm::send(c, "coffee"); + comm::send(c, ~"coffee"); } \ No newline at end of file diff --git a/src/test/run-pass/task-comm-chan-cleanup4.rs b/src/test/run-pass/task-comm-chan-cleanup4.rs index 65c6ab79ce8..e5e6ed08fc7 100644 --- a/src/test/run-pass/task-comm-chan-cleanup4.rs +++ b/src/test/run-pass/task-comm-chan-cleanup4.rs @@ -6,9 +6,9 @@ import task; // We're trying to trigger a race between send and port destruction that // results in the string not being freed -fn starship(&&ch: comm::chan<str>) { +fn starship(&&ch: comm::chan<~str>) { for int::range(0, 10) |_i| { - comm::send(ch, "pew pew"); + comm::send(ch, ~"pew pew"); } } diff --git a/src/test/run-pass/task-life-0.rs b/src/test/run-pass/task-life-0.rs index 2232bff1bc7..12fddc294dc 100644 --- a/src/test/run-pass/task-life-0.rs +++ b/src/test/run-pass/task-life-0.rs @@ -1,9 +1,9 @@ use std; import task; fn main() { - task::spawn(|| child("Hello") ); + task::spawn(|| child(~"Hello") ); } -fn child(&&s: str) { +fn child(&&s: ~str) { } diff --git a/src/test/run-pass/test-ignore-cfg.rs b/src/test/run-pass/test-ignore-cfg.rs index 0aad5bd13d3..49fc6e88ec4 100644 --- a/src/test/run-pass/test-ignore-cfg.rs +++ b/src/test/run-pass/test-ignore-cfg.rs @@ -22,10 +22,10 @@ fn checktests() { let tests = __test::tests(); let shouldignore = option::get( - vec::find(tests, |t| t.name == "shouldignore" )); + vec::find(tests, |t| t.name == ~"shouldignore" )); assert shouldignore.ignore == true; let shouldnotignore = option::get( - vec::find(tests, |t| t.name == "shouldnotignore" )); + vec::find(tests, |t| t.name == ~"shouldnotignore" )); assert shouldnotignore.ignore == false; } \ No newline at end of file diff --git a/src/test/run-pass/type-param.rs b/src/test/run-pass/type-param.rs index a2afde8d73f..525891fc1c3 100644 --- a/src/test/run-pass/type-param.rs +++ b/src/test/run-pass/type-param.rs @@ -2,4 +2,4 @@ type lteq<T> = extern fn(T) -> bool; -fn main(args: ~[str]) { } +fn main(args: ~[~str]) { } diff --git a/src/test/run-pass/type-ptr.rs b/src/test/run-pass/type-ptr.rs index f469ebd3dd0..dd572d8655c 100644 --- a/src/test/run-pass/type-ptr.rs +++ b/src/test/run-pass/type-ptr.rs @@ -2,4 +2,4 @@ fn f(a: *int) -> *int { ret a; } fn g(a: *int) -> *int { let b = f(a); ret b; } -fn main(args: ~[str]) { ret; } +fn main(args: ~[~str]) { ret; } diff --git a/src/test/run-pass/uniq-cc-generic.rs b/src/test/run-pass/uniq-cc-generic.rs index cd05e217546..d72c8f82cba 100644 --- a/src/test/run-pass/uniq-cc-generic.rs +++ b/src/test/run-pass/uniq-cc-generic.rs @@ -15,7 +15,7 @@ fn make_uniq_closure<A:send copy>(a: A) -> fn~() -> uint { fn empty_pointy() -> @pointy { ret @{ mut a : none, - d : make_uniq_closure("hi") + d : make_uniq_closure(~"hi") } } diff --git a/src/test/run-pass/unique-autoderef-index.rs b/src/test/run-pass/unique-autoderef-index.rs index 43d894ed3ac..4ed8aba8447 100644 --- a/src/test/run-pass/unique-autoderef-index.rs +++ b/src/test/run-pass/unique-autoderef-index.rs @@ -1,4 +1,4 @@ fn main() { - let i = ~[100]/~; + let i = ~~[100]; assert i[0] == 100; -} \ No newline at end of file +} diff --git a/src/test/run-pass/unique-drop-complex.rs b/src/test/run-pass/unique-drop-complex.rs index 6ae3224ccfc..72a09f5ddde 100644 --- a/src/test/run-pass/unique-drop-complex.rs +++ b/src/test/run-pass/unique-drop-complex.rs @@ -1,3 +1,3 @@ fn main() { - let x = ~[0,0,0,0,0]/~; -} \ No newline at end of file + let x = ~~[0,0,0,0,0]; +} diff --git a/src/test/run-pass/utf8.rs b/src/test/run-pass/utf8.rs index c18133f7051..5b81e84fe12 100644 --- a/src/test/run-pass/utf8.rs +++ b/src/test/run-pass/utf8.rs @@ -14,22 +14,22 @@ fn main() { assert (pi as int == '\u03a0' as int); assert ('\x0a' as int == '\n' as int); - let bhutan: str = "འབྲུག་ཡུལ།"; - let japan: str = "日本"; - let uzbekistan: str = "Ўзбекистон"; - let austria: str = "Österreich"; + let bhutan: ~str = ~"འབྲུག་ཡུལ།"; + let japan: ~str = ~"日本"; + let uzbekistan: ~str = ~"Ўзбекистон"; + let austria: ~str = ~"Österreich"; - let bhutan_e: str = - "\u0f60\u0f56\u0fb2\u0f74\u0f42\u0f0b\u0f61\u0f74\u0f63\u0f0d"; - let japan_e: str = "\u65e5\u672c"; - let uzbekistan_e: str = - "\u040e\u0437\u0431\u0435\u043a\u0438\u0441\u0442\u043e\u043d"; - let austria_e: str = "\u00d6sterreich"; + let bhutan_e: ~str = + ~"\u0f60\u0f56\u0fb2\u0f74\u0f42\u0f0b\u0f61\u0f74\u0f63\u0f0d"; + let japan_e: ~str = ~"\u65e5\u672c"; + let uzbekistan_e: ~str = + ~"\u040e\u0437\u0431\u0435\u043a\u0438\u0441\u0442\u043e\u043d"; + let austria_e: ~str = ~"\u00d6sterreich"; let oo: char = 'Ö'; assert (oo as int == 0xd6); - fn check_str_eq(a: str, b: str) { + fn check_str_eq(a: ~str, b: ~str) { let mut i: int = 0; for str::each(a) |ab| { log(debug, i); diff --git a/src/test/run-pass/utf8_chars.rs b/src/test/run-pass/utf8_chars.rs index ad7bc8fe2dc..fa89765c9d9 100644 --- a/src/test/run-pass/utf8_chars.rs +++ b/src/test/run-pass/utf8_chars.rs @@ -5,7 +5,7 @@ import vec; fn main() { // Chars of 1, 2, 3, and 4 bytes let chs: ~[char] = ~['e', 'é', '€', 0x10000 as char]; - let s: str = str::from_chars(chs); + let s: ~str = str::from_chars(chs); assert (str::len(s) == 10u); assert (str::char_len(s) == 4u); @@ -19,13 +19,13 @@ fn main() { assert (!str::is_utf8(~[0xc0_u8])); assert (!str::is_utf8(~[0xc0_u8, 0x10_u8])); - let mut stack = "a×c€"; + let mut stack = ~"a×c€"; assert (str::pop_char(stack) == '€'); assert (str::pop_char(stack) == 'c'); str::push_char(stack, 'u'); - assert (str::eq(stack, "a×u")); + assert (str::eq(stack, ~"a×u")); assert (str::shift_char(stack) == 'a'); assert (str::shift_char(stack) == '×'); str::unshift_char(stack, 'ß'); - assert (str::eq(stack, "ßu")); + assert (str::eq(stack, ~"ßu")); } diff --git a/src/test/run-pass/variant-attributes.rs b/src/test/run-pass/variant-attributes.rs index 45d79c83532..cbdf650d60e 100644 --- a/src/test/run-pass/variant-attributes.rs +++ b/src/test/run-pass/variant-attributes.rs @@ -24,6 +24,6 @@ enum crew_of_enterprise_d { geordi_la_forge, } -fn boldly_go(_crew_member: crew_of_enterprise_d, _where: str) { } +fn boldly_go(_crew_member: crew_of_enterprise_d, _where: ~str) { } -fn main() { boldly_go(worf, "where no one has gone before"); } +fn main() { boldly_go(worf, ~"where no one has gone before"); } diff --git a/src/test/run-pass/while-prelude-drop.rs b/src/test/run-pass/while-prelude-drop.rs index 9e4a2a170b7..dcc19b8ca20 100644 --- a/src/test/run-pass/while-prelude-drop.rs +++ b/src/test/run-pass/while-prelude-drop.rs @@ -1,12 +1,12 @@ -enum t { a, b(str), } +enum t { a, b(~str), } fn make(i: int) -> t { if i > 10 { ret a; } - let mut s = "hello"; + let mut s = ~"hello"; // Ensure s is non-const. - s += "there"; + s += ~"there"; ret b(s); } |